DIRECTORY Basics, BasicTime, BcdDefs, CommandTool, Convert, DFUtilities, FileSets, FileSetsPrivate, FS, FSPseudoServers, FSRemoteFile, IO, Process, RedBlackTree, Rope, STP, STPConnectionCache, Tempus, TextFind, TextReplace, VersionMap, ViewerClasses, ViewerTools;

FileSetsImpl: CEDAR PROGRAM
IMPORTS BasicTime, CommandTool, Convert, DFUtilities, FS, FSPseudoServers, FSRemoteFile, IO, Process, RedBlackTree, Rope, STP, STPConnectionCache, Tempus, TextFind, TextReplace, VersionMap
EXPORTS FileSets, FileSetsPrivate

={OPEN FileSets, FileSetsPrivate;

Error: PUBLIC ERROR [message: ROPE] = CODE;
Warning: PUBLIC SIGNAL [message: ROPE] = CODE;
Miss: PUBLIC SIGNAL [name: ROPE, created: GMT] = CODE;
GetCreated: PUBLIC PROC [fn: FileNote] RETURNS [created: GMT] = {
IF (created _ fn.created) # noGMT THEN RETURN;
IF NOT fn.createTried THEN {
ok: BOOL _ TRUE;
ct: GMT _ noGMT;
fn.createTried _ TRUE;
[created: ct] _ FS.FileInfo[name: fn.id.name, remoteCheck: FALSE !FS.Error => {ok _ FALSE; CONTINUE}];
IF ok THEN fn.created _ created _ ct};
};

GetAccounting: PUBLIC PROC [fn: FileNote] RETURNS [read, write: GMT, author: ROPE] = {
h: STPConnectionCache.Handle;
full, hostName, rest: ROPE;
cp: FS.ComponentPositions;
IF fn.readTried THEN RETURN [fn.read, fn.write, fn.author];
fn.readTried _ TRUE;
[full, cp] _ FS.ExpandName[fn.fsName];
hostName _ full.Substr[start: cp.server.start, len: cp.server.length];
IF hostName.Length[] = 0 THEN {--try for a remote attachment--
attachedTo: ROPE;
[attachedTo: attachedTo] _ FS.FileInfo[full];
IF attachedTo # NIL THEN {
[full, cp] _ FS.ExpandName[attachedTo];
hostName _ full.Substr[start: cp.server.start, len: cp.server.length];
};
};
rest _ full.Substr[start: cp.dir.start-1];
IF rest.Fetch[0] # '< THEN ERROR;
IF hostName.Length[] # 0 THEN {
servers: LOR _ FSPseudoServers.TranslateForRead[hostName];
found: BOOL _ FALSE;
FOR servers _ servers, servers.rest WHILE servers # NIL AND NOT found DO
server: ROPE _ servers.first;
h _ STPConnectionCache.Get[server, "FileSetsImpl.GetAccounting" !STP.Error => IF code IN STP.ConnectionErrors THEN LOOP];
{ENABLE UNWIND => h.Release[stpTimeout];
PerMatch: PROC [file: ROPE] RETURNS [continue: STP.Continue] = {
fi: STP.FileInfo _ h.stpHandle.GetFileInfo[];
fn.read _ FSRemoteFile.FTPTimeToGMT[fi.read];
fn.write _ FSRemoteFile.FTPTimeToGMT[fi.write];
fn.author _ fi.author;
found _ TRUE;
RETURN [yes]};
h.stpHandle.Enumerate[rest, PerMatch !
STP.Error => IF code = noSuchFile THEN CONTINUE];
};
h.Release[stpTimeout];
ENDLOOP;
found _ found;
};
RETURN [fn.read, fn.write, fn.author];
};

stpTimeout: INT--seconds-- _ 15;
NewFileSet: PUBLIC PROC [ids: IdentificationScheme _ []] RETURNS [fs: FileSet] = {
fs _ NEW [FileSetRep _ [
elts: RedBlackTree.Create[Id, IF ids.askFS OR ids.create THEN CompareFullFileNotes ELSE CompareFileNotesByName],
ids: ids,
summary: NIL]];
};

Id: PROC [data: REF ANY] RETURNS [key: REF ANY] --RedBlackTree.GetKey-- =
{key _ data};

CompareFileNotesByName: PROC [k, data: REF ANY] RETURNS [c: Basics.Comparison] --RedBlackTree.Compare-- = {
fn1: FileNote _ NARROW[k];
fn2: FileNote _ NARROW[data];
c _ fn1.id.name.Compare[fn2.id.name, FALSE]};

CompareFullFileNotes: PROC [k, data: REF ANY] RETURNS [c: Basics.Comparison] --RedBlackTree.Compare-- = {
fn1: FileNote _ NARROW[k];
fn2: FileNote _ NARROW[data];
IF (c _ fn1.id.name.Compare[fn2.id.name, FALSE]) = equal THEN {
c _ SELECT BasicTime.Period[from: fn1.id.created, to: fn2.id.created] FROM
<0 => less,
=0 => equal,
>0 => greater,
ENDCASE => ERROR;
};
};

EnumSet: PUBLIC PROC [fs: FileSet, to: FileConsumer] = {
FOR fn: FileNote _ NARROW[fs.elts.LookupSmallest[]], NARROW[fs.elts.LookupNextLarger[fn]] WHILE fn # NIL DO
Process.CheckForAbort[];
to[fn];
ENDLOOP;
fs _ fs};

First: PUBLIC PROC [fs: FileSet] RETURNS [fn: FileNote] =
{fn _ NARROW[fs.elts.LookupSmallest[]]};

Next: PUBLIC PROC [fs: FileSet, fn: FileNote] RETURNS [next: FileNote] =
{next _ NARROW[fs.elts.LookupNextLarger[fn]]};

Lookup: PUBLIC PROC [fs: FileSet, fn: FileNote] RETURNS [found: FileNote] =
{found _ NARROW[fs.elts.Lookup[fn]]};

Delete: PUBLIC PROC [fs: FileSet, fn: FileNote] RETURNS [found: FileNote] = {
node: RedBlackTree.Node _ fs.elts.Delete[fn];
found _ IF node # NIL THEN NARROW[node.data] ELSE NIL;
};

Insert: PUBLIC PROC [fs: FileSet, fn: FileNote] RETURNS [news: BOOL] = {
prevFN: FileNote _ Lookup[fs, fn];
SELECT (news _ prevFN = NIL) FROM
TRUE => fs.elts.Insert[fn, fn];
FALSE => NULL;
ENDCASE => ERROR;
};

Size: PUBLIC PROC [fs: FileSet] RETURNS [numberOfFiles: INT] =
{numberOfFiles _ fs.elts.Size[]};

MapNames: PUBLIC PROC [fs: FileSet, map: RopeMap, mapIDName, mapFSName: BOOL _ TRUE] RETURNS [mfs: FileSet] = {
TranslateFile: PROC [fn: FileNote] = {
newFN: FileNote _ NEW [FileNoteRep _ fn^];
IF mapIDName THEN newFN.id.name _ MapName[newFN.id.name, mfs.ids];
IF mapFSName THEN newFN.fsName _ MapName[newFN.fsName, fullID];
IF NOT Insert[mfs, newFN] THEN ERROR;
};
MapName: PROC [pn: ROPE, ids: IdentificationScheme] RETURNS [rn: ROPE] = {
full: ROPE;
cp: FS.ComponentPositions;
rn _ map.Apply[pn];
[full, cp] _ FS.ExpandName[rn];
rn _ TrimNameByIDS[full, cp, ids];
};
mfs _ NewFileSet[fs.ids];
EnumSet[fs, TranslateFile];
mfs.summary _ Convert.RopeFromInt[Size[mfs]].Cat[":(MapNames ", fs.summary, ")"];
};

fullID: IdentificationScheme = [server: TRUE, directory: TRUE, version: TRUE, create: TRUE, askFS: FALSE];

ReIdentify: PUBLIC PROC [fs: FileSet, ids: IdentificationScheme _ []] RETURNS [mfs: FileSet] = {
Mapit: PROC [fn: FileNote] = {
newFN: FileNote = CreateNote[fn.id.name, fn.id.created, ids];
IF newFN # NIL THEN [] _ Insert[mfs, newFN];
};
mfs _ NewFileSet[ids];
EnumSet[fs, Mapit];
mfs.summary _ Convert.RopeFromInt[Size[mfs]].Cat[":(ReIdentify ", fs.summary, ")"];
};

MapNameAndLookup: PUBLIC PROC [fs: FileSet, map: RopeMap, ids: IdentificationScheme _ []] RETURNS [mfs: FileSet] = {
TranslateFile: PROC [fn: FileNote] = {
newName: ROPE = map.Apply[fn.id.name];
newFN: FileNote = CreateNote[newName, noGMT, ids];
IF newFN # NIL THEN [] _ Insert[mfs, newFN];
};
mfs _ NewFileSet[ids];
EnumSet[fs, TranslateFile];
mfs.summary _ Convert.RopeFromInt[Size[mfs]].Cat[":(MapNameAndLookup ", fs.summary, ")"];
};

pseudoServerToRead: PUBLIC RopeMap _ NEW [TextReplace.RopeMapRep _ [
MapPseudoServerToRead]];

MapPseudoServerToRead: PROC [data: REF ANY, pn: ROPE] RETURNS [rn: ROPE] = {
full: ROPE;
cp: FS.ComponentPositions;
IF pn.Length[] = 0 THEN RETURN [pn];
[full, cp] _ FS.ExpandName[pn];
rn _ FS.ConstructFName[[
server: FSPseudoServers.TranslateForRead[full.Substr[cp.server.start, cp.server.length]].first,
dir: full.Substr[cp.dir.start, cp.dir.length],
subDirs: full.Substr[cp.subDirs.start, cp.subDirs.length],
base: full.Substr[cp.base.start, cp.base.length],
ext: full.Substr[cp.ext.start, cp.ext.length],
ver: full.Substr[cp.ver.start, cp.ver.length]
]];
};

Direction: TYPE = {normal, reverse};

HasRelative: PROC [fn: FileNote, fs: FileSet, fr: FileRelation, direction: Direction] RETURNS [has: BOOL] = {
NoteRelative: PROC [rfn: FileNote] = {has _ TRUE; Enuf};
has _ FALSE;
EnumerateRelatives[fn, fs, fr, direction, NoteRelative !Enuf => CONTINUE];
has _ has;
};

Enuf: ERROR = CODE;

EnumerateRelatives: PROC [fn: FileNote, fs: FileSet, fr: FileRelation, direction: Direction, NoteRelative: PROC [FileNote]] = {
fir: FileIDRange = SELECT direction FROM
normal => fr.LeftToRight[fr.data, fn.id],
reverse => fr.RightToLeft[fr.data, fn.id],
ENDCASE => ERROR;
Relates: PROC [fn2: FileNote] RETURNS [b: BOOL] = {
b _ SELECT direction FROM
normal => fr.Test[fr.data, fn.id, fn2.id],
reverse => fr.Test[fr.data, fn2.id, fn.id],
ENDCASE => ERROR;
};
test: FileNote = NEW [FileNoteRep _ [
id: LowEnd[fir]
]];
highID: FileID = HighEnd[fir];
found: FileNote _ NARROW[fs.elts.Lookup[test]];
IF found # NIL AND Relates[found] THEN NoteRelative[found];
FOR found _ NARROW[fs.elts.LookupNextLarger[test]], NARROW[fs.elts.LookupNextLarger[found]] WHILE found # NIL AND LessOrEqual[found.id, highID] DO
IF Relates[found] THEN NoteRelative[found];
ENDLOOP;
found _ found;
};

LowEnd: PROC [fir: FileIDRange] RETURNS [fid: FileID] = {
fid _ [
name: fir.lowName,
created: IF fir.earlyCreated = noGMT THEN BasicTime.earliestGMT ELSE fir.earlyCreated
];
};

HighEnd: PROC [fir: FileIDRange] RETURNS [fid: FileID] = {
fid _ [
name: fir.highName,
created: IF fir.lateCreated = noGMT THEN BasicTime.latestGMT ELSE fir.lateCreated
];
};

LessOrEqual: PROC [fid1, fid2: FileID] RETURNS [leq: BOOL] = {
leq _ SELECT fid1.name.Compare[fid2.name, FALSE] FROM
less => TRUE,
equal => BasicTime.Period[from: fid1.created, to: fid2.created] <= 0,
greater => FALSE,
ENDCASE => ERROR;
};

OpWork: PROC [fsl: FileSetList, head: ROPE, combine: PROC [sofar, this: FileSet] RETURNS [sum: FileSet]] RETURNS [fs: FileSet] = {
summary: ROPE _ head;
fs _ NIL;
IF fsl = NIL THEN ERROR Error["NIL FileSetList given --- that's a no-no"];
FOR fsl _ fsl, fsl.rest WHILE fsl # NIL DO
IF fs # NIL AND fs.ids # fsl.first.ids THEN ERROR;
fs _ combine[fs, fsl.first];
summary _ summary.Cat[" ", Convert.RopeFromInt[Size[fsl.first]]];
ENDLOOP;
IF fs = NIL THEN ERROR;
fs.summary _ Convert.RopeFromInt[Size[fs]].Cat[":", summary, ")"];
};

Union: PUBLIC PROC [fsl: FileSetList, fr: FileRelation _ NIL] RETURNS [fs: FileSet] = {
UnionCombine: PROC [sofar, this: FileSet] RETURNS [sum: FileSet] = {
Add: PROC [fn: FileNote] --FileConsumer-- = {[] _ Insert[sum, fn]};
AddIfNotRelated: PROC [fn: FileNote] --FileConsumer-- = {
related: BOOL = HasRelative[fn, sum, fr, reverse];
IF NOT related THEN [] _ Insert[sum, fn];
};
sum _ sofar;
IF sum = NIL THEN sum _ NewFileSet[this.ids];
EnumSet[this, IF fr = NIL THEN Add ELSE AddIfNotRelated];
};
fs _ OpWork[fsl, "(union", UnionCombine];
};

Difference: PUBLIC PROC [fsl: FileSetList, fr: FileRelation _ NIL] RETURNS [fs: FileSet] = {
DiffCombine: PROC [sofar, this: FileSet] RETURNS [sum: FileSet] = {
IF sofar = NIL
THEN {
Add: PROC [fn: FileNote] --FileConsumer-- = {[] _ Insert[sum, fn]};
sum _ NewFileSet[this.ids];
EnumSet[this, Add];
}
ELSE {
Subtract: PROC [fn: FileNote] --FileConsumer-- = {[] _ Delete[sum, fn]};
SubtractRelatives: PROC [fn: FileNote] --FileConsumer-- = {
EnumerateRelatives[fn, sum, fr, reverse, Subtract];
};
sum _ sofar;
EnumSet[this, IF fr = NIL THEN Subtract ELSE SubtractRelatives];
};
};
fs _ OpWork[fsl, "(diff", DiffCombine];
};

SymmetricDifference: PUBLIC PROC [fsl: FileSetList, fr: FileRelation _ NIL] RETURNS [fs: FileSet] = {
SDiffCombine: PROC [sofar, this: FileSet] RETURNS [sum: FileSet] = {
IF sofar = NIL
THEN {
Add: PROC [fn: FileNote] --FileConsumer-- = {[] _ Insert[sum, fn]};
sum _ NewFileSet[this.ids];
EnumSet[this, Add];
}
ELSE {
SimpleSDiffit: PROC [fn: FileNote] --FileConsumer-- = {
SELECT Lookup[sum, fn] FROM
=NIL => [] _ Insert[sum, fn];
#NIL => [] _ Delete[sum, fn];
ENDCASE => ERROR;
};
GeneralSDiffit: PROC [fn: FileNote] --FileConsumer-- = {
related: BOOL _ FALSE;
SeeLeftee: PROC [fn: FileNote] --FileConsumer-- = {
[] _ Delete[sum, fn];
related _ TRUE;
};
EnumerateRelatives[fn, sum, fr, reverse, SeeLeftee];
IF NOT related THEN [] _ Insert[sum, fn];
};
sum _ sofar;
EnumSet[this, IF fr = NIL THEN SimpleSDiffit ELSE GeneralSDiffit];
};
};
fs _ OpWork[fsl, "(sdiff", SDiffCombine];
};

Intersection: PUBLIC PROC [fsl: FileSetList, fr: FileRelation _ NIL] RETURNS [fs: FileSet] = {
IntersectionCombine: PROC [sofar, this: FileSet] RETURNS [sum: FileSet] = {
IF sofar = NIL
THEN {
Add: PROC [fn: FileNote] --FileConsumer-- = {[] _ Insert[sum, fn]};
sum _ NewFileSet[this.ids];
EnumSet[this, Add];
}
ELSE {
SimpleIntersect: PROC [fn: FileNote] --FileConsumer-- = {
IF Lookup[this, fn] = NIL THEN [] _ Delete[sum, fn];
};
GeneralIntersect: PROC [fn: FileNote] --FileConsumer-- = {
IF NOT HasRelative[fn, this, fr, normal] THEN [] _ Delete[sum, fn];
};
sum _ sofar;
EnumSet[sum, IF fr = NIL THEN SimpleIntersect ELSE GeneralIntersect];
};
};
fs _ OpWork[fsl, "(intersect", IntersectionCombine];
};

equality: PUBLIC FileRelation _ NEW [FileRelationPrivate _ [
TestEquality, PointRange, PointRange]];

TestEquality: PROC [data: REF ANY, left, right: FileID] RETURNS [b: BOOL] = {
b _
left.name.Equal[right.name, FALSE]
AND left.created = right.created;
};

PointRange: PROC [data: REF ANY, fid: FileID] RETURNS [fir: FileIDRange] = {
fir _ [
lowName: fid.name,
highName: fid.name,
earlyCreated: fid.created,
lateCreated: fid.created
];
};

ReverseFileRelation: PUBLIC PROC [fr: FileRelation] RETURNS [frr: FileRelation] = {
frr _ NEW [FileRelationPrivate _ [
TestReverse, ReverseLeftToRight, ReverseRightToLeft, fr]];
};

TestReverse: PROC [data: REF ANY, left, right: FileID] RETURNS [b: BOOL] = {
fr: FileRelation = NARROW[data];
b _ fr.Test[fr.data, right, left];
};

ReverseLeftToRight: PROC [data: REF ANY, fid: FileID] RETURNS [fir: FileIDRange] = {
fr: FileRelation = NARROW[data];
fir _ fr.RightToLeft[fr.data, fid];
};

ReverseRightToLeft: PROC [data: REF ANY, fid: FileID] RETURNS [fir: FileIDRange] = {
fr: FileRelation = NARROW[data];
fir _ fr.LeftToRight[fr.data, fid];
};

FilterFileSet: PUBLIC PROC [subject: FileSet, filter: Filter] RETURNS [filtered: FileSet] = {
DoFilter: PROC [fn: FileNote] =
{IF filter.Eval[fn, filter.data] THEN [] _ Insert[filtered, fn]};
filtered _ NewFileSet[subject.ids];
EnumSet[subject, DoFilter];
filtered.summary _ Convert.RopeFromInt[Size[filtered]].Cat[":(filter ", subject.summary, ")"];
};

And: PUBLIC PROC [fl: FilterList] RETURNS [f: Filter] = {
f _ NEW [FilterRep _ [AndFilters, fl]];
};

AndFilters: PROC [fn: FileNote, data: REF ANY] RETURNS [BOOL] = {
fl: FilterList _ NARROW[data];
FOR fl _ fl, fl.rest WHILE fl # NIL DO
IF NOT fl.first.Eval[fn, fl.first.data] THEN RETURN [FALSE];
ENDLOOP;
RETURN [TRUE];
};

Or: PUBLIC PROC [fl: FilterList] RETURNS [f: Filter] = {
f _ NEW [FilterRep _ [OrFilters, fl]];
};

OrFilters: PROC [fn: FileNote, data: REF ANY] RETURNS [BOOL] = {
fl: FilterList _ NARROW[data];
FOR fl _ fl, fl.rest WHILE fl # NIL DO
IF fl.first.Eval[fn, fl.first.data] THEN RETURN [TRUE];
ENDLOOP;
RETURN [FALSE];
};

Not: PUBLIC PROC [f: Filter] RETURNS [nf: Filter] = {
nf _ NEW [FilterRep _ [NegateFilter, f]]};

NegateFilter: PROC [fn: FileNote, data: REF ANY] RETURNS [BOOL] = {
f: Filter _ NARROW[data];
RETURN [NOT f.Eval[fn, f.data]];
};

IfCreated: PUBLIC PROC [reln: TimeReln, when: GMT] RETURNS [f: Filter] = {
f _ NEW [FilterRep _ [TestTime, NEW [TimeFilterRep _ [created, reln, when]]]];
};

IfRead: PUBLIC PROC [reln: TimeReln, when: GMT] RETURNS [f: Filter] = {
f _ NEW [FilterRep _ [TestTime, NEW [TimeFilterRep _ [read, reln, when]]]];
};

TimeFilter: TYPE = REF TimeFilterRep;
TimeFilterRep: TYPE = RECORD [
which: WhichTime,
reln: TimeReln,
when: GMT];
WhichTime: TYPE = {created, read};

TestTime: PROC [fn: FileNote, data: REF ANY] RETURNS [BOOL] = {
tf: TimeFilter _ NARROW[data];
time: GMT _ SELECT tf.which FROM
read => GetAccounting[fn].read,
created => GetCreated[fn],
ENDCASE => ERROR;
IF time = noGMT THEN RETURN [FALSE];
RETURN [BasicTime.Period[from: tf.when, to: time] * (SELECT tf.reln FROM before => -1, after => 1, ENDCASE => ERROR) > 0];
};

NameMatches: PUBLIC PROC [pattern: ROPE, literal, word, ignoreCase, addBounds: BOOL _ FALSE] RETURNS [f: Filter] = {
f _ NEW [FilterRep _ [TestName, TextFind.CreateFromRope[pattern: pattern, literal: literal, word: word, ignoreCase: ignoreCase, addBounds: addBounds] ]];
};

TestName: PROC [fn: FileNote, data: REF ANY] RETURNS [BOOL] = {
finder: TextFind.Finder _ NARROW[data];
RETURN [TextFind.SearchRope[finder, fn.fsName].found];
};

isOnline: PUBLIC Filter _ NEW [FilterRep _ [TestOnline, NIL]];

TestOnline: PROC [fn: FileNote, data: REF ANY] RETURNS [BOOL] = {
exists: BOOL _ TRUE;
[] _ FS.FileInfo[name: fn.fsName, wantedCreatedTime: GetCreated[fn] !FS.Error => {exists _ FALSE; CONTINUE}];
RETURN [exists];
};

DFContentsFilter: TYPE = REF DFContentsFilterRec;
DFContentsFilterRec: TYPE = RECORD [
filter: Filter,
dfFilter: DFUtilities.Filter,
allowableExceptions: NAT,
ids: IdentificationScheme
];

ContentsPass: PUBLIC PROC [filter: Filter, dfFilter: DFUtilities.Filter, allowableExceptions: NAT _ 0, ids: IdentificationScheme] RETURNS [f: Filter--applicable only to DF files--] = {
f _ NEW [FilterRep _ [TestDFContents, NEW [DFContentsFilterRec _ [filter, dfFilter, allowableExceptions]] ]];
};

TestDFContents: PROC [fn: FileNote, data: REF ANY] RETURNS [BOOL] = {
dfcf: DFContentsFilter _ NARROW[data];
exceptions: NAT _ 0;
TestContent: PROC [fn: FileNote] = {
IF NOT dfcf.filter.Eval[fn, dfcf.filter.data] THEN exceptions _ exceptions + 1;
};
created: GMT _ GetCreated[fn];
EnumDF[
dfName: fn.fsName,
date: IF created # noGMT THEN [explicit, created] ELSE [],
to: TestContent,
filter: dfcf.dfFilter,
which: remote,
ids: dfcf.ids];
RETURN [exceptions <= dfcf.allowableExceptions];
};
CreateNote: PUBLIC PROC [fileName: ROPE, created: GMT, ids: IdentificationScheme] RETURNS [fn: FileNote] = {
createTried: BOOL _ FALSE;
fsName: ROPE _ NIL;
realCreated: GMT _ created;
SELECT ids.askFS FROM
TRUE => {
ok: BOOL _ TRUE;
createTried _ TRUE;
[fullFName: fileName, created: created] _ FS.FileInfo[name: fileName, wantedCreatedTime: created, remoteCheck: FALSE !FS.Error => {ok _ FALSE; CONTINUE}];
IF NOT ok THEN {
SIGNAL Miss[fileName, created];
RETURN [NIL]};
fsName _ fileName;
realCreated _ created;
createTried _ TRUE;
};
FALSE => {
cp: FS.ComponentPositions;
needInfo: BOOL _ FALSE;
[fileName, cp] _ FS.ExpandName[fileName];
IF (ids.version AND cp.ver.length = 0) OR (ids.create AND created = noGMT) THEN {
ok: BOOL _ TRUE;
[fullFName: fileName, created: created] _ FS.FileInfo[name: fileName, wantedCreatedTime: created, remoteCheck: FALSE !FS.Error => {ok _ FALSE; CONTINUE}];
IF NOT ok THEN {
SIGNAL Miss[fileName, created];
RETURN [NIL]};
[fileName, cp] _ FS.ExpandName[fileName];
realCreated _ created;
createTried _ TRUE;
};
fsName _ fileName;
fileName _ TrimNameByIDS[fileName, cp, ids];
IF NOT ids.create THEN created _ noGMT;
};
ENDCASE => ERROR;
fn _ NEW [FileNoteRep _ [id: [name: fileName, created: created], fsName: fsName, created: realCreated, createTried: createTried]];
};

TrimNameByIDS: PROC [full: ROPE, cp: FS.ComponentPositions, ids: IdentificationScheme] RETURNS [fileName: ROPE] = {
fileName _ full;
IF NOT ids.version THEN fileName _ fileName.Substr[len: cp.ext.start + cp.ext.length];
IF NOT ids.directory THEN fileName _ fileName.Substr[start: cp.base.start]
ELSE IF NOT ids.server THEN fileName _ fileName.Substr[start: cp.dir.start-1];
};

FromFS: PUBLIC PROC [pattern: ROPE, ids: IdentificationScheme _ []] RETURNS [fs: FileSet] = {
Add: PROC [fn: FileNote] --FileConsumer-- = {[] _ Insert[fs, fn]};
fs _ NewFileSet[ids];
EnumFSMatches[pattern, Add, ids];
fs.summary _ Convert.RopeFromInt[Size[fs]];
};

EnumFSMatches: PUBLIC PROC [pattern: ROPE, to: FileConsumer, ids: IdentificationScheme _ []] = {
PerMatch: PROC [fullFName: ROPE, created: GMT, primaryVolume, backupVolume: ROPE] = {
fn: FileNote _ CreateNote[fullFName, created, ids];
IF primaryVolume # NIL OR backupVolume # NIL THEN ERROR;
IF fn # NIL THEN to[fn];
};
HashEnumerate[pattern, FSEnumerate, PerMatch];
};

FSEnumerate: PROC [pattern: ROPE, Consume: Consumer] = {
PerFile: PROC [
fullFName, attachedTo: ROPE, created: BasicTime.GMT, bytes: INT, keep: CARDINAL] RETURNS [continue: BOOL] = {
Consume[fullFName, created, NIL, NIL];
continue _ TRUE};
FS.EnumerateForInfo[pattern: pattern, proc: PerFile];
};

FromVersionMapsByShortName: PUBLIC PROC [vml: VersionMapList, pattern: ROPE, ids: IdentificationScheme _ []] RETURNS [fs: FileSet] = {
Add: PROC [fn: FileNote] --FileConsumer-- = {[] _ Insert[fs, fn]};
fs _ NewFileSet[ids];
EnumVersionMapsByShortName[vml, pattern, Add, ids];
fs.summary _ Convert.RopeFromInt[Size[fs]];
};

EnumVersionMapsByShortName: PUBLIC PROC [vml: VersionMapList, pattern: ROPE, to: FileConsumer, ids: IdentificationScheme _ []] = {
VMEnumerate: PROC [pattern: ROPE, Consume: Consumer] = {EnumVMsByShort[vml, pattern, Consume]};
PerMatch: PROC [fullFName: ROPE, created: GMT, primaryVolume, backupVolume: ROPE] = {
fn: FileNote _ CreateNote[fullFName, created, ids];
IF primaryVolume # NIL OR backupVolume # NIL THEN ERROR;
IF fn # NIL THEN to[fn];
};
HashEnumerate[pattern, VMEnumerate, PerMatch];
};

EnumVMsByShort: PROC [vml: VersionMapList, pattern: ROPE, Consume: Consumer] = {
size: INT = Rope.Length[pattern];
starPos: INT = pattern.Index[0, "*"];
match: BOOL = starPos # size;
prefix: ROPE = Rope.Flatten[pattern, 0, starPos];
prefixLen: INT = Rope.Length[prefix];
rangeList: VersionMap.RangeList _ VersionMap.ShortNameToRanges[vml, prefix];
IF size = 0 THEN RETURN;
WHILE rangeList # NIL DO
range: VersionMap.Range _ rangeList.first;
map: VersionMap.Map = range.map;
rangeList _ rangeList.rest;
Process.CheckForAbort[];
IF match
THEN {
entries: CARDINAL = VersionMap.Length[map];
IF range.first >= entries THEN LOOP;
range.len _ entries - range.first;
WHILE range.len # 0 DO
fullName: ROPE;
stamp: BcdDefs.VersionStamp;
thisShort: ROPE;
created: BasicTime.GMT;
[fullName, stamp, created, range] _ VersionMap.RangeToEntry[range];
thisShort _ ShortName[fullName];
IF Rope.Run[prefix, 0, thisShort, 0, FALSE] # prefixLen THEN EXIT;
IF Rope.Match[pattern, thisShort, FALSE] THEN {
Consume[fullName, created, NIL, NIL];
};
ENDLOOP;
}
ELSE {
WHILE range.len # 0 DO
fullName: ROPE;
stamp: BcdDefs.VersionStamp;
created: BasicTime.GMT;
[fullName, stamp, created, range] _ VersionMap.RangeToEntry[range];
Consume[fullName, created, NIL, NIL];
ENDLOOP;
};
ENDLOOP;
};

ShortName: PROC [r: ROPE] RETURNS [ROPE] = {
first: INT _ 0; 
last: INT _ Rope.Length[r];
FOR i: INT DECREASING IN [0..last) DO
c: CHAR _ r.Fetch[i];
SELECT c FROM
'>, '/ => {first _ i+1; EXIT};
'! => last _ i
ENDCASE; 
ENDLOOP;
RETURN [r.Substr[first, last - first]]
};

FromVersionMapsByCreateDate: PUBLIC PROC [vml: VersionMapList, range: TimeRange, ids: IdentificationScheme _ []] RETURNS [fs: FileSet] = {
Add: PROC [fn: FileNote] --FileConsumer-- = {[] _ Insert[fs, fn]};
fs _ NewFileSet[ids];
EnumVersionMapsByCreateDate[vml, range, Add, ids];
fs.summary _ IO.PutFR["%g:(versionMapFilesCreated \"%g\" \"%g\")", [integer[Size[fs]]], [time[range.from]], [time[range.to]]];
};

EnumVersionMapsByCreateDate: PUBLIC PROC [vml: VersionMapList, range: TimeRange, to: FileConsumer, ids: IdentificationScheme _ []] = {
FOR vml _ vml, vml.rest WHILE vml # NIL DO
map: VersionMap.Map = vml.first;
Process.CheckForAbort[];
FOR i: INT IN [0 .. map.Length[]) DO
created: GMT = map.FetchCreated[i];
IF InRange[created, range] THEN {
fn: FileNote = CreateNote[VersionMap.FetchName[map, i], created, ids];
IF fn # NIL THEN to[fn];
};
ENDLOOP;
ENDLOOP;
};

InRange: PROC [time: GMT, range: TimeRange] RETURNS [in: BOOL] = INLINE {
in _ BasicTime.Period[range.from, time] >= 0 AND BasicTime.Period[time, range.to] >= 0;
};

HashEnumerate: PUBLIC PROC [pattern: ROPE, Enumerate: Enumerator, Consume: Consumer] = {
fsPattern: ROPE _ pattern;
matchPattern: ROPE _ pattern;
filteringNeeded: BOOL _ FALSE;
nChecks: INT _ 0;
checks: LOR _ NIL;
finder: TextFind.Finder _ NIL;
NoteFile: PROC [fullFName: ROPE, created: GMT, primaryVolume, backupVolume: ROPE] = {
IF filteringNeeded THEN {
found: BOOL _ TextFind.SearchRope[finder, fullFName].found;
rm: TextReplace.RopeMap _ TextReplace.MapNamedSubfieldToMatch[finder, fullFName];
IF NOT found THEN {
SIGNAL Warning[IO.PutFR["FileSets Enumeration/directory filter bug: couldn't match %g against %g", IO.refAny[matchPattern], IO.refAny[fullFName]]];
RETURN;
};
FOR cl: LOR _ checks, cl.rest WHILE cl # NIL DO
IF rm.Apply[cl.first].Find[">"] # -1 THEN RETURN;
ENDLOOP;
};
Consume[fullFName, created, primaryVolume, backupVolume];
};
FOR i: INT _ fsPattern.Find["#"], fsPattern.Find["#"] WHILE i >= 0 DO
filteringNeeded _ TRUE;
fsPattern _ fsPattern.Substr[len: i].Cat["*", fsPattern.Substr[start: i+1]];
ENDLOOP;
IF filteringNeeded THEN {
IF matchPattern.Find["/"] # -1 THEN ERROR Error[IO.PutFR["FileSets can't enumerate a pattern in slashy format with a # in it (%g)", IO.refAny[matchPattern]]];
SELECT matchPattern.Fetch[0] FROM
'[, '< => NULL;
IN ['A .. 'Z], IN ['a .. 'z], IN ['0 .. '9], '., '!, '*, '# => {
cwd: ROPE _ GetCWD[];
matchPattern _ cwd.Cat[matchPattern];
fsPattern _ cwd.Cat[fsPattern];
};
ENDCASE => ERROR Error[IO.PutFR["FileSets thinks file name pattern %g is bogus", IO.refAny[matchPattern]]];
matchPattern _ TextReplace.Apply[quoteMetas, matchPattern];
matchPattern _ matchPattern.Substr[len: Rope.Index[s1: matchPattern, s2: "!"]].Concat["!*"];
FOR i: INT _ matchPattern.Find["#"], matchPattern.Find["#"] WHILE i >= 0 DO
checks _ CONS[IO.PutFR["ck%g", IO.int[nChecks _ nChecks + 1]], checks];
matchPattern _ matchPattern.Substr[len: i].Cat["<", checks.first, ":*>", matchPattern.Substr[start: i+1]];
ENDLOOP;
finder _ TextFind.CreateFromRope[pattern: matchPattern, ignoreCase: TRUE];
};
Enumerate[fsPattern, NoteFile];
};

quoteMetas: TextReplace.RopeMap _ TextReplace.RopeMapFromPairs[LIST[["<", "'<", TRUE], [">", "'>", TRUE]]];

GetCWD: PROC RETURNS [cwd: ROPE--in brackety format--] = {
cwd _ FS.ExpandName["x!3", CommandTool.CurrentWorkingDirectory[]].fullFName;
cwd _ cwd.Substr[len: cwd.Length[]-3];
};

FromDF: PUBLIC PROC [dfName: ROPE, date: DFUtilities.Date _ [], filter: DFUtilities.Filter, which: DFWhich, ids: IdentificationScheme _ []] RETURNS [fs: FileSet] = {
Add: PROC [fn: FileNote] --FileConsumer-- = {[] _ Insert[fs, fn]};
fs _ NewFileSet[ids];
EnumDF[dfName, date, Add, filter, which, ids];
fs.summary _ Convert.RopeFromInt[Size[fs]];
};

FromDFs: PUBLIC PROC [dfs: FileSet, filter: DFUtilities.Filter, which: DFWhich, ids: IdentificationScheme _ []] RETURNS [fs: FileSet] = {
Add: PROC [fn: FileNote] --FileConsumer-- = {[] _ Insert[fs, fn]};
PerDF: PROC [fn: FileNote] --FileConsumer-- = {
created: GMT _ GetCreated[fn];
dfDate: DFUtilities.Date _ IF created # noGMT THEN [explicit, created] ELSE [];
EnumDF[fn.fsName, dfDate, Add, filter, which, ids];
};
fs _ NewFileSet[ids];
EnumSet[dfs, PerDF];
fs.summary _ Convert.RopeFromInt[Size[fs]].Cat[":(fromDFS ", dfs.summary, ")"];
};

EnumDF: PUBLIC PROC [dfName: ROPE, date: DFUtilities.Date _ [], to: FileConsumer, filter: DFUtilities.Filter, which: DFWhich, ids: IdentificationScheme _ []] = {
dir: ROPE _ "?";
readOnly: BOOL _ FALSE;
PerItem: PROC [item: REF ANY] RETURNS [stop: BOOL _ FALSE] = {
Process.CheckForAbort[];
WITH item SELECT FROM
di: REF DFUtilities.DirectoryItem => {dir _ di.path1; readOnly _ di.readOnly};
fi: REF DFUtilities.FileItem => {
useDir: ROPE _ SELECT which FROM remote => dir, local => NIL, ENDCASE => ERROR;
fiName: ROPE;
fiCP: FS.ComponentPositions;
fn: FileNote;
[fiName, fiCP, ] _ FS.ExpandName[fi.name, useDir];
IF (fn _ SELECT which FROM
remote => CreateNote[fiName, fi.date.gmt, ids],
local => CreateNote[DFUtilities.RemoveVersionNumber[fiName], noGMT, ids],
ENDCASE => ERROR) # NIL THEN to[fn];
};
ii: REF DFUtilities.ImportsItem => {
subFilter: DFUtilities.Filter _ [
comments: filter.comments,
filterA: filter.filterA,
filterB: IF ii.form = $exports THEN $public ELSE filter.filterB,
filterC: $all,
list: IF ii.form = $list THEN ii.list ELSE filter.list
];
EnumDF[ii.path1, ii.date, to, subFilter, which, ids];
};
ii: REF DFUtilities.IncludeItem => EnumDF[ii.path1, ii.date, to, filter, which, ids];
ci: REF DFUtilities.CommentItem => NULL;
wi: REF DFUtilities.WhiteSpaceItem => NULL;
ENDCASE => ERROR;
};
file: FS.OpenFile _ FS.nullOpenFile;
from: STREAM;
file _ FS.Open[
name: dfName,
wantedCreatedTime: SELECT date.format FROM
explicit => date.gmt,
omitted, greaterThan, notEqual => BasicTime.nullGMT,
ENDCASE => ERROR
!FS.Error => {
SIGNAL Warning[IO.PutFR["FS.Error[%g, %g]; assumed empty", IO.atom[error.code], IO.rope[error.explanation]]];
file _ FS.nullOpenFile;
CONTINUE
}];
IF file = FS.nullOpenFile THEN RETURN;
from _ FS.StreamFromOpenFile[file];
DFUtilities.ParseFromStream[in: from, proc: PerItem, filter: filter !DFUtilities.SyntaxError => {SIGNAL Warning[IO.PutFR["Syntax error near [%g] in DF-file %g: %g", IO.int[from.GetIndex[]], IO.rope[dfName], IO.rope[reason]]]; CONTINUE}];
from.Close[];
};

MentionedDFs: PUBLIC PROC [dfName: ROPE, filter: DFUtilities.Filter _ [], ids: IdentificationScheme _ []] RETURNS [fs: FileSet] = {
Add: PROC [fn: FileNote] = {[] _ Insert[fs, fn]};
fs _ NewFileSet[ids];
EnumMentionedDFs[dfName, filter, Add, ids];
fs.summary _ Convert.RopeFromInt[Size[fs]];
};

EnumMentionedDFs: PUBLIC PROC [dfName: ROPE, filter: DFUtilities.Filter _ [], to: FileConsumer, ids: IdentificationScheme _ []] = {
ProcessDFFile: PROC [fullDFName: ROPE, filter: DFUtilities.Filter] = {
in: IO.STREAM = FS.StreamOpen[fullDFName];
ProcessItem: PROC [item: REF ANY] RETURNS [stop: BOOL _ FALSE] --DFUtilities.ProcessItemProc-- = {
WITH item SELECT FROM
di: REF DFUtilities.DirectoryItem => NULL;
fi: REF DFUtilities.FileItem => NULL;
ii: REF DFUtilities.ImportsItem => {
fn: FileNote = CreateNote[ii.path1, ii.date.gmt, ids];
to[fn];
};
ii: REF DFUtilities.IncludeItem => {
fn: FileNote = CreateNote[ii.path1, ii.date.gmt, ids];
to[fn];
ProcessDFFile[ii.path1, filter];
};
ci: REF DFUtilities.CommentItem => NULL;
wi: REF DFUtilities.WhiteSpaceItem => NULL;
ENDCASE => ERROR;
};
DFUtilities.ParseFromStream[in, ProcessItem, filter];
in.Close[];
};
ProcessDFFile[dfName, filter];
};

FromRope: PUBLIC PROC [rope: ROPE, ids: IdentificationScheme _ []] RETURNS [fs: FileSet] = {
s: STREAM _ IO.RIS[rope];
fs _ FromStream[s, ids];
s.Close[];
};

FromFile: PUBLIC PROC [fileName: ROPE, ids: IdentificationScheme _ []] RETURNS [fs: FileSet] = {
s: STREAM _ FS.StreamOpen[fileName];
fs _ FromStream[s, ids];
s.Close[];
};

CRBreak: PROC [char: CHAR] RETURNS [cc: IO.CharClass] --IO.BreakProc-- = {
cc _ SELECT char FROM
'\n => break,
IN ['\000 .. ' ] => sepr,
ENDCASE => other;
};

FromStream: PUBLIC PROC [from: STREAM, ids: IdentificationScheme _ []] RETURNS [fs: FileSet] = {
fs _ NewFileSet[ids];
FOR i: INT _ from.SkipWhitespace[], from.SkipWhitespace[] WHILE NOT from.EndOf[] DO
fileName: ROPE _ from.GetTokenRope[CRBreak].token;
fn: FileNote;
created: GMT _ noGMT;
GetToke: PROC RETURNS [toke: ROPE] =
{toke _ IF from.EndOf[] THEN "\n" ELSE from.GetTokenRope[CRBreak].token};
FOR toke: ROPE _ GetToke[], GetToke[] UNTIL toke.Equal["\n"] DO
SELECT TRUE FROM
toke.Equal["Of", FALSE] => {
createdRope: ROPE _ from.GetLineRope[];
[created] _ Tempus.Parse[rope: createdRope, search: FALSE];
EXIT;
};
ENDCASE => ERROR;
ENDLOOP;
fn _ CreateNote[fileName, created, ids];
IF fn # NIL THEN [] _ Insert[fs, fn];
ENDLOOP;
fs.summary _ Convert.RopeFromInt[Size[fs]];
};

ToRope: PUBLIC PROC [fs: FileSet] RETURNS [rope: ROPE] = {
s: IO.STREAM _ IO.ROS[];
ToStream[fs, s];
rope _ s.RopeFromROS[];
};

ToFile: PUBLIC PROC [fs: FileSet, fileName: ROPE] = {
s: IO.STREAM _ FS.StreamOpen[fileName, create];
ToStream[fs, s];
s.Close[];
};

ToStream: PUBLIC PROC [fs: FileSet, to: IO.STREAM] = {
PerNote: PROC [fn: FileNote] --FileConsumer-- = {
created: GMT _ GetCreated[fn];
to.PutRope[fn.fsName];
IF created # noGMT THEN to.PutF[" Of %g", IO.time[created]];
to.PutChar['\n];
};
EnumSet[fs, PerNote];
};
}.

~FileSetsImpl.Mesa
Copyright c 1984 by Xerox Corporation.  All rights reserved.
Last Edited by: Spreitzer, April 7, 1986 5:18:53 pm PST
Basics:
For syntax errors and such.
For syntax errors and such.
Informational signal: Couldn't identify.
FileNote Operations:
FileSet Operations:
Primitive Enumerations:
make a long name into a short one
assumes a valid long name, of course
Κ%œ˜
code™Kšœ
Οm
œ1™<K™7—K˜KšΟk	œ[žœ!žœžœ\˜‡K˜KšΠbxœžœ
ž˜Kšžœ/žœ!žœžœ?˜Ό
Kšžœ˜!K˜Kšœžœ˜!K˜
head™š	œžœ
žœžœžœ
˜+K™—š	œ	žœ
žœžœžœ
˜.K™—šœžœ
žœžœžœžœ
˜6K™(——™š
Οn
œžœ
žœžœžœ˜AKšžœ žœ
žœ
˜.šžœ
žœžœ˜Kšœžœžœ
˜Kšœžœ	˜Kšœžœ
˜Kšœžœ)žœžœžœžœ˜fKšžœžœ˜&—Kš
œ˜—K˜š 
œžœ
žœžœžœ
žœ˜VKš
œ˜Kšœžœ
˜Kšœžœ˜Kšžœžœ
žœ ˜;Kšœžœ
˜Kšœ
žœ˜&Kš
œF˜FšžœžœΟc˜>Kšœžœ
˜Kšœžœ˜-šžœžœ
žœ˜Kšœ
žœ˜'Kš
œF˜FK˜—K˜—K˜*Kšžœžœ
žœ
˜!šžœžœ˜Kšœ	žœ.˜:Kšœžœžœ
˜šžœ!žœžœ
žœ
žœž˜HKšœžœ˜š
œAžœ
žœžœ
žœžœ
žœ˜yKšœ
žœ
žœ˜(š
 œžœžœžœžœ˜@Kšœžœ&˜-Kš
œ-˜-Kš
œ/˜/K˜Kšœžœ
˜
Kšžœ˜—š
œ&˜&Kšžœ
žœžœ
žœ˜1—K˜—Kš
œ˜Kšžœ
˜—Kš
œ˜K˜—Kšžœ ˜&K˜—K˜Kšœž‘œ˜ —™š 
œžœ
žœ"žœ˜Ršœžœ˜Kš	œžœžœžœžœ˜pK˜	Kšœ	žœ˜—K˜K˜š œžœžœ
žœžœžœ
žœ‘œ˜IKš
œ
˜
—K˜š œžœžœ
žœžœ‘œ˜kKšœžœ˜Kšœžœ˜Kšœ%žœ˜-—K˜š œžœžœ
žœžœ‘œ˜iKšœžœ˜Kšœžœ˜šžœ'žœžœ˜?šœžœ<ž˜JK˜K˜K˜Kšžœžœ
˜—Kš
œ˜—K˜——K˜š œžœ
žœ$˜8šžœžœžœžœžœ
ž˜kK˜Kš
œ˜Kšžœ
˜—K˜	—K˜š œžœ
žœžœ˜9Kšœžœ˜(—K˜š œžœ
žœžœ˜HKšœžœ ˜.—K˜š œžœ
žœžœ˜KKšœ	žœ˜%—K˜š œžœ
žœžœ˜MKš
œ-˜-Kš
œžœžœ
žœ
žœžœ
žœ
˜6K˜—K˜š
 œžœ
žœžœžœ˜HKš
œ"˜"šžœžœž˜!Kšžœ˜Kšžœžœ
˜Kšžœžœ
˜—K˜—K˜š
 œžœ
žœžœžœ˜>Kš
œ!˜!—K˜š œžœ
žœ3žœžœžœ˜oš 
œžœ˜&Kšœžœ˜*Kšžœžœ1˜BKšžœžœ.˜?Kšžœ
žœžœ
žœ
˜%K˜—š
 œžœžœžœžœ˜JKšœžœ
˜Kšœžœ˜K˜Kšœ
žœ˜K˜"K˜—K˜Kš
œ˜Kš
œQ˜QK˜—K˜Kšœ(žœ
žœžœ
žœ	žœ˜jK˜š 
œžœ
žœ/žœ˜`š œžœ˜Kš
œ=˜=Jšžœ	žœ
žœ˜,K˜—K˜Kš
œ˜Kš
œS˜SK˜—K˜š œžœ
žœ=žœ˜tš 
œžœ˜&Kšœ	žœ˜&Kš
œ2˜2Jšžœ	žœ
žœ˜,K˜—K˜Kš
œ˜Kš
œY˜YK˜—K˜šœžœžœ˜DKš
œ˜—K˜š œžœžœ
žœžœžœžœ˜LKšœžœ
˜Kšœžœ˜Kšžœžœ
žœ˜$Kšœ
žœ˜šœžœ˜Kš
œ_˜_K˜.K˜:K˜1K˜.K˜-K˜—K˜—K˜Kšœžœ˜$K˜š œžœEžœžœ˜mKš œžœžœ˜8Kšœžœ
˜Kšœ@žœ˜JK˜
K˜—K˜Kšœžœžœ
˜K˜š œžœE œžœ˜šœžœž˜(K˜)K˜*Kšžœžœ
˜—š œžœžœžœ˜3šœžœž˜K˜*K˜+Kšžœžœ
˜—K˜—šœžœ˜%K˜K˜—K˜Kšœžœ˜/Kšžœ	žœ
žœžœ˜;š
žœ	žœ"žœ"žœ	žœ
žœž˜’
Kšžœžœ˜+Kšžœ
˜—Kš
œ˜K˜—K˜š œžœžœ˜9˜K˜Kšœ	žœžœžœ˜UK˜—K˜—K˜š œžœžœ˜:˜K˜Kšœ	žœžœžœ˜QK˜—K˜—K˜š œžœžœžœ˜>šœžœžœž˜5Kšœžœ
˜
Kš
œE˜EKšœžœ
˜Kšžœžœ
˜—K˜—K˜š œžœžœžœžœžœ˜‚
Kšœ	žœ˜Kšœžœ
˜	Kšžœžœ
žœ
žœ3˜Jšžœžœžœ
ž˜*Kš
žœžœ
žœžœ
žœ
˜2Kš
œ˜Kš
œA˜AKšžœ
˜—Kšžœžœ
žœ
žœ
˜Kš
œB˜BK˜—K˜š
 œžœ
žœ'žœžœ˜Wš œžœžœ˜DKš œžœ‘œ˜Cš œžœ‘œ˜9Kšœ	žœ%˜2Kšžœ
žœ	žœ˜)K˜—K˜Kšžœžœ
žœ˜-Kš	œžœžœ
žœžœ˜9K˜—Kš
œ)˜)Kš
œ˜—K˜š
 
œžœ
žœ'žœžœ˜\š œžœžœ˜Cšžœ	ž˜šžœ˜Kš œžœ‘œ˜CK˜Kš
œ˜K˜
—šžœ˜Kš œžœ‘œ˜Hš œžœ‘œ˜;Kš
œ3˜3K˜—K˜Kš	œžœžœ
žœ
žœ˜@K˜——K˜—Kš
œ'˜'Kš
œ˜—K˜š
 œžœ
žœ'žœžœ˜eš œžœžœ˜Dšžœ	ž˜šžœ˜Kš œžœ‘œ˜CK˜Kš
œ˜K˜
—šžœ˜š 
œžœ‘œ˜7šžœž˜Kšœ
žœ˜Kšœ
žœ˜Kšžœžœ
˜—Kš
œ˜—š œžœ‘œ˜8Kšœ	žœžœ
˜š 	œžœ‘œ˜3K˜Kšœ
žœ
˜K˜—Kš
œ4˜4Kšžœ
žœ	žœ˜)Kš
œ˜—K˜Kš	œžœžœ
žœžœ˜BK˜——K˜—Kš
œ)˜)Kš
œ˜—K˜š
 œžœ
žœ'žœžœ˜^š œžœžœ˜Kšžœ	ž˜šžœ˜Kš œžœ‘œ˜CK˜Kš
œ˜K˜
—šžœ˜š œžœ‘œ˜9Kšžœžœ
žœ˜4Kš
œ˜—š œžœ‘œ˜:Kšžœ
žœ#žœ˜CKš
œ˜—K˜Kš	œ
žœžœ
žœžœ˜EK˜——K˜—Kš
œ4˜4Kš
œ˜—K˜šœ
žœžœ˜<K˜'—K˜š œžœžœ
žœžœžœ˜M˜Kšœžœ
˜"Kšžœ˜!—K˜—K˜š
 
œžœžœ
žœžœ˜L˜K˜K˜K˜K˜K˜—K˜—K˜š œžœ
žœžœ˜Sšœžœ˜"K˜:—K˜—K˜š œžœžœ
žœžœžœ˜LKšœžœ˜ K˜"K˜—K˜š
 œžœžœ
žœžœ˜TKšœžœ˜ Kš
œ#˜#K˜—K˜š
 œžœžœ
žœžœ˜TKšœžœ˜ Kš
œ#˜#K˜—K˜š 
œžœ
žœ$žœ˜]š œžœ˜Kšœ
žœžœ˜A—Kš
œ#˜#Kš
œ˜Kš
œ^˜^K˜—K˜š œžœ
žœžœ˜9Kšœžœ ˜'K˜—K˜š 
œžœžœ
žœžœžœ˜AKšœžœ˜šžœžœžœ
ž˜&Kš
žœ
žœ"žœ
žœžœ˜<Kšžœ
˜—Kšžœžœ˜K˜—K˜š 
œžœ
žœžœ˜8Kšœžœ˜&K˜—K˜š 	œžœžœ
žœžœžœ˜@Kšœžœ˜šžœžœžœ
ž˜&Kšžœ"žœ
žœžœ˜7Kšžœ
˜—Kšžœžœ˜K˜—K˜š œžœ
žœ
žœ˜5Kšœžœ"˜*—K˜š œžœžœ
žœžœžœ˜CKšœžœ˜Kšžœžœ˜ K˜—K˜š
 	œžœ
žœžœžœ˜JKšœžœžœ+˜NK˜—K˜š
 œžœ
žœžœžœ˜GKšœžœžœ(˜KK˜—K˜Kšœžœžœ˜%šœžœžœ˜K˜K˜Kšœžœ˜—Kšœžœ˜"K˜š œžœžœ
žœžœžœ˜?Kšœžœ˜šœžœžœ
ž˜ K˜K˜Kšžœžœ
˜—Kšžœžœ
žœžœ˜$Kš
žœ/žœ	žœžœžœ˜zK˜—K˜š œžœ
žœžœ(žœžœžœ˜tKšœžœ’
˜™
K˜—K˜š œžœžœ
žœžœžœ˜?Kšœžœ˜'Kšžœ0˜6K˜—K˜Kšœ
žœ
žœžœ˜>K˜š 
œžœžœ
žœžœžœ˜AKšœžœžœ
˜Kš	œžœ>žœžœžœ˜mKšžœ
˜K˜—K˜Kšœžœžœ˜1šœžœžœ˜$Kš
œ˜Kš
œ˜Kšœžœ
˜K˜K˜—K˜š œžœ
žœEžœ!žœ‘œ˜Έ
KšœžœžœD˜mK˜—K˜š œžœžœ
žœžœžœ˜EKšœžœ˜&Kšœžœ˜š œžœ˜$Kšžœ
žœ(žœ˜OK˜—Kšœ	žœ˜š
œ˜K˜Kšœžœžœžœ˜:K˜K˜K˜K˜—Kšžœ*˜0K˜——™š 
œžœ
žœžœžœžœ˜lKšœ
žœžœ
˜Kšœžœžœ
˜Kšœ
žœ˜šžœž˜šžœ˜	Kšœžœžœ
˜Kšœžœ
˜Kšœ*žœCžœžœžœžœ˜š
šžœ
žœžœ˜Kšžœ˜Kšžœžœ˜—Kš
œ˜Kš
œ˜Kšœžœ
˜K˜—šžœ˜
Kšœžœ˜Kšœ
žœžœ
˜Kšœžœ˜)š
žœžœžœ
žœžœ˜QKšœžœžœ
˜Kšœ*žœCžœžœžœžœ˜š
šžœ
žœžœ˜Kšžœ˜Kšžœžœ˜—Kšœžœ˜)Kš
œ˜Kšœžœ
˜K˜—Kš
œ˜Kš
œ,˜,Kšžœ
žœžœ˜'K˜—Kšžœžœ
˜—Kšœžœz˜‚
K˜—K˜š 
œžœžœžœ0žœžœ˜sK˜Kšžœ
žœ
žœ?˜VKšžœ
žœžœ1˜JKšžœ
žœ
žœžœ3˜NK˜—K˜š
 œžœ
žœžœ"žœ˜]Kš œžœ‘œ˜BK˜Kš
œ!˜!Kš
œ+˜+K˜—K˜š 
œžœ
žœžœ7˜`š
 œžœ
žœžœžœ˜UK˜3Kšžœžœ
žœžœ
žœ
žœ
˜8Kšžœžœ
žœ˜K˜—Kš
œ.˜.K˜—K˜š œžœžœ œ˜8š œžœžœžœ	žœžœžœžœ˜}Kšœžœžœ˜&Kšœžœ˜—Kšžœ3˜5K˜—K˜š
 œžœ
žœ žœ"žœ˜†
Kš œžœ‘œ˜BK˜Kš
œ3˜3Kš
œ+˜+K˜—K˜š œžœ
žœ žœ7˜‚
Kš œžœžœ œ6˜_š
 œžœ
žœžœžœ˜UK˜3Kšžœžœ
žœžœ
žœ
žœ
˜8Kšžœžœ
žœ˜K˜—Kš
œ.˜.K˜—K˜š œžœ žœ œ˜PKšœžœ˜!Kšœ	žœ˜%Kšœžœ˜Kšœžœ%˜1Kšœžœ˜%Kš
œL˜LKšžœ
žœ
žœ
˜šžœ
žœ
ž˜Kš
œ*˜*Kš
œ ˜ Kš
œ˜K˜šžœ˜šžœ˜Kšœ	žœ˜+Kšžœžœ
žœ
˜$Kš
œ"˜"šžœž˜Kšœ
žœ
˜Kš
œ˜Kšœžœ
˜Kšœžœ
˜Kš
œC˜CKš
œ ˜ Kšžœ#žœžœ
žœ
˜Bšžœ žœžœ˜/Kšœžœžœ˜%K˜—Kšžœ
˜—K˜
—šžœ˜šžœž˜Kšœ
žœ
˜Kš
œ˜Kšœžœ
˜Kš
œC˜CKšœžœžœ˜%Kš
ž˜—K˜——Kšžœ
˜—K˜—K˜š
 	œžœžœžœžœ˜,Kš
œ!™!Kš
œ$™$Kšœžœ˜Kšœžœ˜š	žœžœ
ž
œ
žœž˜%Kšœžœ˜šžœž˜
Kšœžœ˜K˜Kšžœ˜	—Kšžœ
˜—Kšžœ ˜&K˜—K˜š œžœ
žœIžœ˜Š
Kš œžœ‘œ˜BK˜Kš
œ2˜2Kšœ
žœo˜~K˜—K˜š œžœ
žœ^˜†
šžœžœžœ
ž˜*K˜ K˜šžœžœ
žœž˜$Kšœ	žœ˜#šžœžœ˜!Kš
œF˜FKšžœžœ
žœ˜K˜—Kšžœ
˜—Kšžœ
˜—K˜—K˜š œžœžœžœžœžœ˜IKšœ-žœ'˜WK˜—K˜š 
œžœ
žœžœ/˜XKšœžœ˜Kšœžœ˜Kšœžœžœ
˜Kšœ	žœ˜Kšœžœžœ
˜Kšœžœ
˜š
 œžœ
žœžœžœ˜Ušžœžœ˜Kšœžœ0˜;Kš
œQ˜Qšžœ
žœžœ˜Kšžœ	žœRžœžœ˜“
Kšžœ
˜K˜—š	žœžœžœžœ
ž˜/Kšžœ#žœ
žœ
˜1Kšžœ
˜—K˜—Kš
œ9˜9K˜—šžœžœ,žœž˜EKšœžœ
˜K˜LKšžœ
˜—šžœžœ˜Kš
žœžœ
žœžœRžœ˜ž
šžœž˜!Kšœ
žœ
˜šžœ
žœ
žœ ˜@Kšœžœ˜Kš
œ%˜%Kš
œ˜K˜—Kšžœžœžœ8žœ˜k—Kš
œ;˜;Kš
œ\˜\šžœžœ2žœž˜KKšœ	žœ
žœžœ&˜GKš
œj˜jKšžœ
˜—KšœDžœ˜JKš
œ˜—Kš
œ˜K˜—K˜Kšœ?žœ
žœžœ˜kK˜š	 œžœ
žœž‘œ˜:KšœžœD˜LK˜&K˜—K˜š
 œžœ
žœ
žœkžœ˜₯
Kš œžœ‘œ˜BK˜Kš
œ.˜.Kš
œ+˜+K˜—K˜š œžœ
žœ\žœ˜‰
Kš œžœ‘œ˜Bš œžœ‘œ˜/Kšœ	žœ˜Kšœžœžœžœ˜OKš
œ3˜3K˜—K˜Kš
œ˜Kš
œO˜OK˜—K˜š œžœ
žœ
žœ€
˜‘
Kšœžœ˜Kšœ
žœžœ
˜š œžœžœ
žœžœžœžœ˜>K˜šžœžœ
ž˜KšœžœG˜Nšœžœ˜!Kš
œžœžœžœžœžœžœ
˜OKšœžœ
˜
Kšœžœ˜K˜
Kšœžœ˜2šžœžœž˜Kš
œ/˜/Kš
œI˜IKšžœžœžœ
žœ˜$—K˜—šœžœ˜$˜!Kš
œ˜Kš
œ˜Kšœ	žœžœ	žœ˜@Jš
œ˜Jšœžœžœ	žœ˜6J˜—Kš
œ5˜5K˜—KšœžœN˜UKšœžœžœ
˜(Kšœžœžœ
˜+Kšžœžœ
˜—K˜—Kšœžœžœ˜$Kšœžœ
˜
šœžœ˜Kš
œ
˜
šœžœ
ž˜*K˜Kš
œ4˜4Kšžœž˜—šœ
žœ˜Kšžœ	žœ*žœžœ˜mKšœžœ˜Kš
ž˜Kš
œ˜——Kšžœžœžœ
žœ
˜&Kšœžœ˜#Kš
œažœ	žœ3žœžœžœžœ˜ν
K˜
K˜—K˜š
 œžœ
žœ
žœCžœ˜ƒ
Kš œžœ(˜1Kš
œ˜Kš
œ+˜+Kš
œ+˜+K˜—K˜š œžœ
žœ
žœX˜ƒ
š 
œžœžœ!˜FKšœžœ
žœžœ˜*š œžœžœ
žœžœžœžœ‘œ˜bšžœžœ
ž˜Kšœžœžœ
˜*Kšœžœžœ
˜%šœžœ˜$K˜6K˜K˜—šœžœ˜$K˜6K˜Kš
œ ˜ K˜—Kšœžœžœ
˜(Kšœžœžœ
˜+Kšžœžœ
˜—K˜—K˜5K˜K˜—Kš
œ˜K˜—K˜š
 œžœ
žœžœ"žœ˜\Kšœžœžœ
žœ˜Kš
œ˜K˜
K˜—K˜š
 œžœ
žœžœ"žœ˜`Kšœžœžœ˜$Kš
œ˜K˜
K˜—K˜š œžœžœžœžœ‘œ˜Jšœžœž˜Kš
œ
˜
Kšžœ˜Kšžœ
˜—K˜—K˜š
 
œžœ
žœžœ"žœ˜`K˜š	žœžœ0žœ
žœž˜SKšœ
žœ$˜2K˜
Kšœ	žœ	˜š œžœ
žœžœ˜$Kšœžœžœžœ#˜I—šžœžœžœž˜?šžœ
žœ
ž˜šœžœ˜Kšœ
žœ˜'Kšœ4žœ˜;Kšžœ
˜K˜—Kšžœžœ
˜—Kšžœ
˜—Kš
œ(˜(Kšžœžœ
žœ˜%Kšžœ
˜—Kš
œ+˜+K˜—K˜š
 œžœ
žœžœžœ˜:Kš	œžœ
žœžœ
žœ˜K˜K˜K˜—K˜š œžœ
žœžœ˜5Kšœžœ
žœžœ˜/K˜K˜
K˜—K˜š
 œžœ
žœžœ
žœ˜6š œžœ‘œ˜1Kšœ	žœ˜K˜Kšžœžœžœ˜<K˜K˜—Kš
œ˜K˜——K˜—…—yn ˆ