DIRECTORY Atom, BasicTime, CommandTool, ExtendADotOut, FS, IO, MakeDo, MakeDoGrossHack, MakeDoParsers, MakeDoPorting, MakeDoPrivate, MobDefs, Mobery, MobListerUtils, PBasics, PFS, PFSNames, RefTab, Rope, SimpleFeedback, UserProfile;

CcDeps: CEDAR MONITOR
IMPORTS Atom, BasicTime, CommandTool, FS, IO, MakeDo, MakeDoParsers, MakeDoPorting, MakeDoPrivate, Mobery, MobListerUtils, PBasics, PFS, PFSNames, RefTab, Rope, SimpleFeedback, UserProfile
EXPORTS MakeDoGrossHack

= BEGIN OPEN MakeDo, MDPs:MakeDoParsers;

ShouldNotHappen: ERROR = CODE;

ROPE: TYPE = Rope.ROPE;

StampTableRef: TYPE = REF StampTableRep; StampTableRep: TYPE = RECORD [
created: BasicTime.GMT,
depInfo: ExtendADotOut.DependencyInfo,
stampTable: Mobery.StampTable,
depInfoValid: BOOL _ FALSE,
stampTableValid: BOOL _ FALSE];
SourceData: TYPE = REF SourceDataRep; SourceDataRep: TYPE = RECORD [
switchesPath: PFS.PATH, --absolute
oName: ROPE, --absolute, unspecified format
baseName: ROPE, --working directory in FS format
subName: ROPE, --output subdirectory (eg, sun4/); may be NIL
shortName: ROPE, --the part after last directory delim and before .c2c.o
sourceType: MDPs.SourceType _ Unknown,
genesis: Genesis,
supports: RefTab.Ref, --node => $T
mesaNode, cedarNode, configNode, switchesNode, oNode, cNode: Node _ NIL,
bschemeNode: Node _ NIL,
boot: BOOL _ FALSE,
depInfo: ExtendADotOut.DependencyInfo _ NIL,
stampTable: Mobery.StampTable _ NIL,
oCreateTime: BasicTime.GMT,
oReadable: BOOL,
useAltSwitches: BOOL, --GROSS HACK!
supportsInvalid: BOOL _ FALSE,
cmd: ROPE _ NIL
];

Genesis: TYPE ~ {C, Cedar, Scheme};

installDir: ROPE ~ CommandTool.CurrentWorkingDirectory[];
installed, badInstall: BOOL _ FALSE;

dolog: BOOL _ FALSE;
myRouterName: ATOM ~ Atom.MakeAtom["MakeDo.CcDeps"];

findAltSwitches: BOOL _ FALSE;

c2cTail: ROPE = ".c2c";
sxTail: ROPE = ".sx";
c2coTail: ROPE = Rope.Cat[c2cTail, ".o"];
c2coTailLength: INT = c2coTail.Length[];
sxoTail: ROPE = Rope.Cat[sxTail, ".o"];
sxoTailLength: INT = sxoTail.Length[];
c2ccTail: ROPE = Rope.Cat[c2cTail, ".c"];
sxcTail: ROPE = Rope.Cat[sxTail, ".c"];
mobExt: ROPE = "mob";
mobTail: ROPE = Rope.Cat[".", mobExt];
mesaTail: ROPE = ".mesa";
cedarTail: ROPE = ".cedar";
configTail: ROPE = ".config";
schemeTail: ROPE = ".scheme";
bschemeTail: ROPE = ".bscheme";
clusterTail: ROPE = ".cluster";
switchesTail: ROPE = ".switches";
libTail: ROPE = ".a";
libTailLen: INT ~ libTail.Length[];
oTail: ROPE = ".o";
oTailLen: INT ~ oTail.Length[];
cTail: ROPE = ".c";

DirAndClass: TYPE = RECORD [
dir: ROPE, -- the directory name --
class: ROPE, -- the corresponding machine class --
switches: ROPE, -- the default switches --
altSwitches: ROPE _ NIL --the alternate switches  GROSS HACK
];

knownLocalDirs: LIST OF DirAndClass = LIST[
DirAndClass[dir: "sun3", class: "sun3", switches: "-c -g"],
DirAndClass[dir: "sun4", class: "sun4", switches: "-c -g"],
DirAndClass[dir: "sun4-o3", class: "sun4", switches: "-c -O3", altSwitches: "-c -O2"],
DirAndClass[dir: "sun4o3", class: "sun4", switches: "-c -O3", altSwitches: "-c -O2"],
DirAndClass[dir: "29k", class: "amd29000", switches: "-c -g"],
DirAndClass[dir: "sun4-profiled", class: "sun4", switches: "-c -p"],
DirAndClass[dir: "sun4-gprof", class: "sparc", switches: "-c -pg"],
DirAndClass[dir: "rs6000", class: "rs6000", switches: "-c -g"],
DirAndClass[dir: "rs6000o", class: "rs6000", switches: "-c -O", altSwitches: "-c -O"],
DirAndClass[dir: "rs6000-o", class: "rs6000", switches: "-c -O", altSwitches: "-c -O"],
DirAndClass[dir: "mipsl", class: "mipsl", switches: "-c -g", altSwitches: "-c -g"],
DirAndClass[dir: "mipsl-o", class: "mipsl", switches: "-c -O", altSwitches: "-c -O"],
DirAndClass[dir: "mips", class: "mips", switches: "-c -g", altSwitches: "-c -g"],
DirAndClass[dir: "mips-o", class: "mips", switches: "-c -O", altSwitches: "-c -O"]
]; -- if in these directories, we issue this -mach  --

CcClass: ActionClass _ NEW [ActionClassRep _ [
CheckConsistency: CheckConsistency,
Rederive: RederiveSource,
ClearCaches: ClearCaches
]];

ClearCaches: PROC [ac: ActionClass] ~ {
MDPs.FlushCache[];
installed _ badInstall _ FALSE;
};

SetOLevel: PUBLIC PROC [high: BOOL] ~ {findAltSwitches _ NOT high};

SourceFind: PROC [resultName: ROPE, finderData: REF ANY] RETURNS [found: BOOLEAN, sought: Node, makes, cmdFrom: NodeList, from: From, cmd: ROPE, class: ActionClass, foundData: REF ANY] -- FinderProc -- ~ {

shortName: ROPE; -- the part after last directory delim and before .c2c.o
middleName: ROPE; --either .c2c, .sx, or null
subName: ROPE _ NIL; --output subdirectory (eg, sun4/); may be NIL
localDir: PFS.PATH; --output subdirectory (eg, sun4/); may be null
baseDir: PFS.PATH; --full expanded name, up to, but not including, the sun3 directory part
baseName, oName, cName, switchesName: ROPE;
oExpanded: PFS.PATH;
oSteps: INTEGER;
oNode, cNode: Node;
genesis: Genesis;
md: SourceData;
resNameLen: INT ~ resultName.Length[];
found _ NOT badInstall;
IF NOT found THEN RETURN;
found _ resNameLen > oTailLen AND resultName.EqualSubstrs[start1: resNameLen-oTailLen, s2: oTail, case: FALSE];
IF NOT found THEN RETURN;
IF NOT installed THEN InstallMe[];
found _ NOT badInstall;
IF NOT found THEN RETURN;
oExpanded _ PFS.AbsoluteName[PFS.PathFromRope[resultName !PFS.Error => {found _ FALSE; CONTINUE}]];
IF NOT found THEN RETURN;
oSteps _ oExpanded.ComponentCount[];
IF resNameLen >= c2coTailLength AND resultName.EqualSubstrs[start1: resNameLen - c2coTailLength, s2: c2coTail, case: FALSE] THEN {genesis _ Cedar; middleName _ c2cTail}
ELSE IF resNameLen >= sxoTailLength AND resultName.EqualSubstrs[start1: resNameLen - sxoTailLength, s2: sxoTail, case: FALSE] THEN {genesis _ Scheme; middleName _ sxTail}
ELSE {genesis _ C; middleName _ NIL};
IF oSteps > 1 AND genesis#Scheme THEN {
localDir _ oExpanded.SubName[oSteps-2, 1, FALSE, TRUE];
subName _ PFS.RopeFromPath[localDir];
IF RemoteMachClassAndSwitches[subName, knownLocalDirs, findAltSwitches].mach = NIL
THEN {localDir _ oExpanded.SubName[oSteps-2, 0]; subName _ NIL};
}
ELSE localDir _ oExpanded.SubName[0, 0];
baseDir _ oExpanded.SubName[0, oSteps-1-localDir.ComponentCount[], TRUE, TRUE];
{shortComp: PFSNames.Component _ oExpanded.ShortName[];
shortComp.name.len _ shortComp.name.len - middleName.Length[] - oTailLen;
shortName _ shortComp.ComponentRope[]};
{bpn: ROPE ~ PFS.RopeFromPath[baseDir];
oName _ bpn.Cat[subName, shortName, middleName, oTail];
baseName _ FS.ExpandName[bpn].fullFName};
cName _ baseName.Cat[shortName, middleName, cTail];
switchesName _ oName.Concat[switchesTail];
oNode _ GetNode[oName, fileClass];
cNode _ GetNode[cName, fileClass];
foundData _ md _ NEW [SourceDataRep _ [
switchesPath: PFS.PathFromRope[switchesName],
oName: oName,
baseName: baseName,
subName: subName,
shortName: shortName,
genesis: genesis,
supports: RefTab.Create[],
switchesNode: GetNode[switchesName, fileClass],
oNode: oNode,
cNode: cNode,
oReadable: genesis#Cedar,
oCreateTime: MakeDo.notExistTime,
useAltSwitches: findAltSwitches
]];
SELECT genesis FROM
C => cmdFrom _ LIST[md.cNode, md.switchesNode];
Cedar => {
md.mesaNode _ GetNode[Rope.Cat[baseName, shortName, mesaTail], fileClass];
md.cedarNode _ GetNode[Rope.Cat[baseName, shortName, cedarTail], fileClass];
md.configNode _ GetNode[Rope.Cat[baseName, shortName, configTail], fileClass];
cmdFrom _ LIST[md.cedarNode, md.mesaNode, md.configNode, md.switchesNode]};
Scheme => {
md.mesaNode _ GetNode[Rope.Cat[baseName, shortName, schemeTail], fileClass];
md.bschemeNode _ GetNode[Rope.Cat[baseName, shortName, bschemeTail], fileClass];
md.configNode _ GetNode[Rope.Cat[baseName, shortName, clusterTail], fileClass];
cmdFrom _ LIST[md.mesaNode, md.bschemeNode, md.configNode]};
ENDCASE => ERROR;
sought _ md.oNode;
class _ CcClass;
[from, cmd] _ RederiveWork[md];
makes _ LIST[md.oNode];
RETURN};

GetSwitches: PROC [sp: PFS.PATH] RETURNS [switches: ROPE _ NIL] = {
ss: IO.STREAM _ NIL;
ss _ PFS.StreamOpen[sp !PFS.Error => CONTINUE];
IF ss # NIL THEN {
[] _ ss.SkipWhitespace[];
IF NOT ss.EndOf[] THEN switches _ IO.GetLineRope[ss]; 
ss.Close[]};
RETURN};

MesafySwitches: PROC [switches, defaultMsw: ROPE] RETURNS [ROPE] = {
IF switches.Length = 0 THEN switches _ IO.PutFR["-mSw \"%q\"", [rope[defaultMsw]] ]
ELSE IF switches.Fetch[0] = '; THEN switches _ IO.PutFR["-mSw \"%q\" %g", [rope[defaultMsw]], [rope[switches.Substr[1]]] ]
ELSE switches _ IO.PutFR["-mSw \"%q\"", [rope[switches]] ];
RETURN [switches]};

SupportIsLoaded: PROC [] RETURNS [BOOL] ~ {
moberies, moblisteries, pfs: BOOL;
moberies _ PBasics.IsBound[LOOPHOLE[Mobery.ReadStampTable]] AND PBasics.IsBound[LOOPHOLE[Mobery.StampTableSubset]];
moblisteries _ PBasics.IsBound[LOOPHOLE[MobListerUtils.PrintVersion]];
pfs _ PBasics.IsBound[LOOPHOLE[PFS.PathFromRope]] AND PBasics.IsBound[LOOPHOLE[PFS.AbsoluteName]];
RETURN [moberies AND moblisteries AND pfs];
};

InstallMe: PROC ~ {
foundFile, failed: BOOL;
IF SupportIsLoaded[] THEN {
installed _ TRUE;
RETURN;
};
[foundFile, failed] _ MakeDoPrivate.MDInstall[installDir, "CcDepsSupport"];
badInstall _ failed OR NOT foundFile;
installed _ TRUE;
IF NOT foundFile THEN Warning[Rope.Cat["Couldn't install CcDeps support because couldn't find ", installDir, "CcDepsSupport.Install (see ", MakeDoPorting.logPath, "CcDepsSupport.InstallLog); proceeding without knowledge of Cc"]]
ELSE IF failed THEN Warning[Rope.Cat["Couldn't install CcDeps support because of error in install file (", installDir, "CcDepsSupport.Install) (see ", MakeDoPorting.logPath, "CcDepsSupport.InstallLog); proceeding without knowledge of Cc"]];
RETURN};

CheckConsistency: PROC [a: Action, result: Node] RETURNS [consistent: BOOL, reason: ROPE] --ConsistencyChecker-- =
BEGIN
md: SourceData = NARROW[a.PublicPartsOfAction[].foundData];
switchesCreate: BasicTime.GMT = InnerGetCreated[md.switchesNode];
curCTime: Time = InnerGetCreated[md.cNode] ; -- Creation time of the C node --
resultExists: BOOL;
supportFound: BOOL _ FALSE;
CheckSupport: PROC [key, val: REF ANY] RETURNS [stop: BOOL _ FALSE]  --RefTab.EachPairAction-- ~ {
sn: Node = MakeDo.NarrowToNode[key];
thisTime: Time = InnerGetCreated[sn];
thisName: ROPE ~ sn.PublicPartsOfNode[].name;
thisIsLib: BOOL ~ IsLibName[thisName];
thisDepInfo: ExtendADotOut.DependencyInfo;
thisStampTable: Mobery.StampTable;

IF thisTime = MakeDo.notExistTime THEN RETURN [FALSE];
supportFound _ TRUE;
IF NOT resultExists THEN RETURN [supportFound];
IF BasicTime.Period[thisTime, md.oCreateTime] < 0 THEN {
consistent _ FALSE;
reason _ IO.PutFR[".o file created at %g but %g was created at %g", [time[md.oCreateTime]], [rope[thisName]], [time[thisTime]] ];
RETURN [TRUE];
};

IF thisIsLib OR md.genesis#Cedar THEN RETURN [FALSE];
thisDepInfo _ CurDepInfo[node: sn];
IF thisDepInfo # NIL AND ContainsDepInfo[md.depInfo]
THEN {
StampInDepInfo: PROC [name: ROPE, depInfo: ExtendADotOut.DependencyInfo] RETURNS [stamp: MobDefs.VersionStamp _ MobDefs.NullVersion] ~ {
FOR list: LIST OF ExtendADotOut.ObjectID _ depInfo.dependList, list.rest WHILE list # NIL DO
id: ExtendADotOut.ObjectID ~ list.first;
IF Rope.Equal[s1: id.name, s2: name] THEN RETURN [id.stamp];
ENDLOOP;
};
stampUsed: MobDefs.VersionStamp ~ StampInDepInfo[thisName, md.depInfo];
IF thisDepInfo.self.stamp # stampUsed THEN {
out: IO.STREAM _ IO.ROS[];
out.PutF["Version stamp of %g (", IO.rope[thisName]];
TRUSTED {MobListerUtils.PrintVersion[thisDepInfo.self.stamp, out, TRUE]};
out.PutF[") is different from the version stamp used to create %g (", IO.rope[md.oName]];
TRUSTED {MobListerUtils.PrintVersion[stampUsed, out, TRUE]};
out.PutF[")"];
consistent _ FALSE;
reason _ out.RopeFromROS[];
RETURN [TRUE];
};
}
ELSE {
diff: ROPE _ NIL;
NoteDiff: PROC [name, stampClass: ROPE, stamp: MobDefs.VersionStamp] RETURNS [BOOL] --Mobery.EnumerateStampProc-- ~ {
elt: ROPE ~ IO.PutFR["%g: %g!%08x%08x", [rope[stampClass]], [rope[name]], [cardinal[stamp[0]]], [cardinal[stamp[1]]] ];
IF diff=NIL THEN diff _ elt ELSE diff _ diff.Cat[", ", elt];
RETURN [FALSE]};
IF md.stampTable = NIL
THEN md.stampTable _ CurStampTab[node: md.oNode];
thisStampTable _ CurStampTab[node: sn];
Mobery.EnumerateStampTableDifference[thisStampTable, md.stampTable, NoteDiff];
IF diff#NIL THEN {
consistent _ FALSE;
reason _ IO.PutFR["Some stamps (%g) in %g are not in %g", [rope[diff]], [rope[thisName]], [rope[md.oName]] ];
RETURN [TRUE];
};
}
};
Log["check consistency for %g\n", IO.rope[md.oName]];
UpdateSupport[md];
resultExists _ md.oCreateTime # MakeDo.notExistTime;
SELECT md.sourceType FROM
Mesa, Config, PlainC, Scheme, Cluster => NULL;
Unknown => RETURN [TRUE, "No source is known for this result"];
ENDCASE => ERROR ShouldNotHappen;

IF resultExists AND NOT md.oReadable THEN RETURN [FALSE, ".o file not readable"];
IF switchesCreate # MakeDo.notExistTime THEN {
supportFound _ TRUE;
IF resultExists AND BasicTime.Period[md.oCreateTime, switchesCreate] > 0
THEN RETURN [FALSE, "switches file created later than result"]};
consistent _ TRUE;
reason _ "all version stamps match";
[] _ md.supports.Pairs[CheckSupport];
IF NOT supportFound THEN RETURN [TRUE, "no inputs exist to indicate inconsistency"];
IF NOT resultExists THEN RETURN [FALSE, "some inputs but no result exists"];
END;

UpdateSupport: PROC [md: SourceData] = {

oldO: Time = md.oCreateTime;
oLength: INT;
[md.oCreateTime, oLength]_ InnerGetInfo[md.oNode];
IF oLength=0 THEN md.oCreateTime _ MakeDo.notExistTime;
IF md.oCreateTime = MakeDo.notExistTime THEN RETURN;
IF oldO = md.oCreateTime AND NOT md.supportsInvalid THEN RETURN;

IF md.genesis=Cedar THEN {
md.depInfo _ CurDepInfo[node: md.oNode];
IF NOT ContainsDepInfo[md.depInfo] THEN 
md.stampTable _ CurStampTab[node: md.oNode];
md.oReadable _ md.depInfo # NIL OR md.stampTable # NIL;
};
md.supportsInvalid _ FALSE;

};

CurStampTab: ENTRY PROC [node: Node] RETURNS [stampTable: Mobery.StampTable] ~ {
ENABLE UNWIND => {};
sr: StampTableRef _ NARROW[node.GetProp[$StampTable]];
created: BasicTime.GMT _ InnerGetCreated[node];
fileName: ROPE ~ node.PublicPartsOfNode[].name;
GetIt: PROC [] RETURNS [stampTable: Mobery.StampTable] ~ INLINE {
Log["ReadStampTable for %g\n", IO.rope[fileName]];
stampTable _ Mobery.ReadStampTable[fileName !FS.Error => {stampTable _ NIL; CONTINUE}];
Log[".. %g\n", IO.rope[IF stampTable = NIL THEN "F" ELSE "S"]];
RETURN [stampTable];
};
IF sr = NIL THEN node.SetProp[
prop: $StampTable,
val: sr _ NEW [StampTableRep _ [
created: notExistTime,
depInfo: NIL,
stampTable: NIL]]
];
IF created = MakeDo.notExistTime
THEN {
sr.stampTable _ NIL;
sr.depInfo _ NIL;
sr.stampTableValid _ sr.depInfoValid _ TRUE;
RETURN [stampTable: sr.stampTable]; -- cached value --
};
IF created = sr.created THEN {
IF NOT sr.stampTableValid THEN {
sr.stampTableValid _ TRUE;
sr.stampTable _ GetIt[];
};
RETURN [stampTable: sr.stampTable]; -- cached value --
};
sr.created _ created;
sr.stampTableValid _ TRUE;
sr.depInfoValid _ FALSE;
sr.stampTable _ GetIt[];
stampTable _ sr.stampTable;
RETURN [stampTable: stampTable]
};

ContainsDepInfo: PROC [depInfo: ExtendADotOut.DependencyInfo] RETURNS [BOOL] ~ INLINE {
IF depInfo = NIL THEN RETURN [FALSE];
RETURN [depInfo.action.class # null];
};

CurDepInfo: ENTRY PROC [node: Node] RETURNS [depInfo: ExtendADotOut.DependencyInfo] ~ {
ENABLE UNWIND => {};
sr: StampTableRef _ NARROW[node.GetProp[$StampTable]];
created: BasicTime.GMT _ InnerGetCreated[node];
fileName: ROPE ~ node.PublicPartsOfNode[].name;
len: INT ~ Rope.Length[fileName];
ExpandNamesInDepInfo: PROC [depInfo: ExtendADotOut.DependencyInfo, fileName: ROPE] RETURNS [newInfo: ExtendADotOut.DependencyInfo] ~ {
FromSlash: PROC [old: CHAR] RETURNS [CHAR] ~ {
IF old = '/ THEN RETURN ['>];
RETURN [old];
};
base: ROPE;
selfName: ROPE ~ depInfo.self.name;
selfConverted: ROPE;
IF selfName.Fetch[0] = '/
THEN {
selfConverted _ FS.ExpandName[selfName].fullFName;
depInfo.self.name _ selfConverted;
base _ NIL;
}
ELSE {
tailPos: INT;
selfConverted _ Rope.Translate[base: selfName, translator: FromSlash];
tailPos _ fileName.FindBackward[s2: selfConverted, case: TRUE];
IF tailPos = -1 THEN RETURN [NIL];
base _ fileName.Substr[len: tailPos]; 
depInfo.self.name _ FS.ExpandName[name: selfConverted, wDir: base].fullFName;
};
FOR list: LIST OF ExtendADotOut.ObjectID _ depInfo.dependList, list.rest WHILE list # NIL DO
id: ExtendADotOut.ObjectID _ list.first;
IF id.name.Fetch[0] # '/
THEN IF base = NIL
THEN RETURN [NIL]
ELSE {
tailConverted: ROPE ~ Rope.Translate[base: id.name, translator: FromSlash];
newName: ROPE ~ FS.ExpandName[name: tailConverted, wDir: base].fullFName;
list.first.name _ newName;
};
ENDLOOP;
RETURN [depInfo];
};
<<GetFromFileName: PROC [] RETURNS [depInfo: ExtendADotOut.DependencyInfo] ~ {
depInfo _ NEW [ExtendADotOut.DependencyInfoRep _ [
self: [name: fileName, class: ExtendADotOut.ObjectClassFromFileName[fileName], stamp: ExtendADotOut.VersionStampFromTime[created]],
action: [name: NIL, class: null, stamp: MobDefs.NullVersion],
dependList: NIL
]];
};>>
GetIt: PROC [] RETURNS [depInfo: ExtendADotOut.DependencyInfo _ NIL] ~ {
<<SELECT TRUE FROM
NOT PBasics.IsBound[LOOPHOLE[ExtendADotOut.GetDependencyInfo]] => RETURN [NIL];
len >= 2 AND Rope.EqualSubstrs[s1: fileName, start1: len-2, s2: ".c"] => {
Log["DepInfo from create time for %g\n", IO.rope[fileName]];
depInfo _ GetFromFileName[];
};
len >= 2 AND Rope.EqualSubstrs[s1: fileName, start1: len-2, s2: ".h"] => {
Log["DepInfo from create time for %g\n", IO.rope[fileName]];
depInfo _ GetFromFileName[];
};
ENDCASE => {
Log["GetDependencyInfo for %g", IO.rope[fileName]];
depInfo _ ExtendADotOut.GetDependencyInfo[fileName ! ExtendADotOut.Fail => {depInfo _ GetFromFileName[] ; CONTINUE }];
depInfo _ ExpandNamesInDepInfo[depInfo, fileName];
};>>
RETURN [depInfo];
};
IF sr = NIL THEN node.SetProp[
prop: $StampTable,
val: sr _ NEW [StampTableRep _ [
created: notExistTime,
depInfo: NIL,
stampTable: NIL]]
];
IF created = MakeDo.notExistTime
THEN {
sr.stampTable _ NIL;
sr.depInfo _ NIL;
sr.stampTableValid _ sr.depInfoValid _ TRUE;
RETURN [depInfo: sr.depInfo]; -- cached value --
};
IF created = sr.created THEN {
IF NOT sr.depInfoValid THEN {
sr.depInfoValid _ TRUE;
sr.depInfo _ GetIt[];
};
RETURN [depInfo: sr.depInfo]; -- cached value --
};
sr.created _ created;
sr.stampTableValid _ FALSE;
sr.depInfoValid _ TRUE;
sr.depInfo _ GetIt[];
depInfo _ sr.depInfo;
RETURN [depInfo: sr.depInfo]; -- cached value --
};

RederiveSource: PROC [a: Action] RETURNS [from: From, cmd: ROPE] --RederiveProc-- = {
md: SourceData ~ NARROW[a.PublicPartsOfAction[].foundData];
RETURN RederiveWork[md]};

RemoteMachClassAndSwitches: PROC [subName: ROPE, known: LIST OF DirAndClass, useAlt: BOOL] RETURNS [mach: ROPE, switches: ROPE] ~ {
dir: ROPE;
IF subName = NIL THEN RETURN [NIL, NIL];
dir _ Rope.Substr[subName, 0, subName.Length[]-1];
FOR list: LIST OF DirAndClass _ known, list.rest WHILE list # NIL DO
pair: DirAndClass = list.first;
IF Rope.Equal[pair.dir, dir, FALSE] THEN RETURN [mach: pair.class, switches: IF useAlt AND pair.altSwitches#NIL THEN pair.altSwitches ELSE pair.switches];
ENDLOOP;
RETURN [NIL, NIL]
};

RederiveWork: PROC [md: SourceData] RETURNS [from: From, cmd: ROPE] ~ {
NoteDep: PROC [fileName: ROPE] ~ {
n: Node; p: PFS.PATH; fn: ROPE;
p _ PFS.PathFromRope[fileName !PFS.Error => {MakeDo.Warning[IO.PutFR["PFS.Error[%g, %g] while processing dependency on %g of %g", [atom[error.code]], [rope[error.explanation]], [rope[fileName]], [rope[md.oName]] ]]; GOTO Skip}];
p _ PFS.AbsoluteName[p];
fn _ PFS.RopeFromPath[p];
n _ GetNode[fn, fileClass];
[] _ md.supports.Insert[n, $T];
from.mustHave _ CONS[n, from.mustHave];
RETURN;
EXITS Skip => NULL};
userSwitches: ROPE;
mimosaSwitches: ROPE;
dirSw: ROPE = IF md.subName # NIL THEN Rope.Cat[" -dir ", md.subName] ELSE NIL;
machClass, uSwitches, midSwitches, mmSwitches, machClassSw: ROPE;
[mach: machClass, switches: uSwitches] _ RemoteMachClassAndSwitches[md.subName, knownLocalDirs, md.useAltSwitches];
machClassSw _ IF machClass # NIL THEN Rope.Cat[" -class ", machClass] ELSE NIL;
md.supports.Erase[];
SELECT md.genesis FROM
Cedar => {
from _ [mustHave: LIST[md.cNode], optional: LIST[md.switchesNode]];
IF NOT md.supports.Insert[md.cNode, $T] THEN ERROR;
IF EnumerateDependancies[md.mesaNode, Mesa, NIL, md, NIL]
OR EnumerateDependancies[md.cedarNode, Mesa, NIL, md, NIL]
OR EnumerateDependancies[md.configNode, Config, NoteDep, md, md.subName] THEN NULL};
C => {
from _ [mustHave: LIST[md.cNode], optional: LIST[md.switchesNode]];
IF NOT md.supports.Insert[md.cNode, $T] THEN ERROR;
[] _  EnumerateDependancies[md.cNode, PlainC, NoteDep, md, NIL]};
Scheme => {
from _ [NIL, NIL];
IF EnumerateDependancies[md.mesaNode, Scheme, NIL, md, NIL]
OR EnumerateDependancies[md.bschemeNode, Scheme, NIL, md, NIL, TRUE]
OR EnumerateDependancies[md.configNode, Cluster, NoteDep, md, NIL] THEN NULL;
{srcNode: Node ~ SELECT md.sourceType FROM
Scheme => IF md.boot THEN md.bschemeNode ELSE md.mesaNode,
Cluster => md.configNode,
Unknown => NIL,
ENDCASE => ERROR;
IF srcNode#NIL THEN {
IF NOT md.supports.Insert[srcNode, $T] THEN ERROR;
from.mustHave _ CONS[srcNode, from.mustHave]};
}};
ENDCASE => ERROR;
md.supportsInvalid _ TRUE;
UpdateSupport[md];
midSwitches _ GetSwitches[md.switchesPath];
mmSwitches _ MesafySwitches[midSwitches, uSwitches];
SELECT md.sourceType FROM
PlainC => {
cmd _ Rope.Cat["MMCCC ", machClassSw, " -name ", md.shortName, dirSw];
cmd _ cmd.Cat[" ", mmSwitches];
cmd _ cmd.Cat[" -aux ", NodeToAllButOne[target: md.cNode, nodeList: from.mustHave] ];
};
Mesa => {
cmd _ Rope.Cat["MMCCMesa ", machClassSw, " -name ", md.shortName, dirSw];
cmd _ cmd.Cat[" ", mmSwitches];
};
Config => {
cmd _ Rope.Cat["MMCCConfig ", machClassSw, " -name ", md.shortName, dirSw];
cmd _ cmd.Cat[" ", mmSwitches];
cmd _ cmd.Cat[" -raux ",
NodeToOnlyObjs[md.baseName, from.mustHave, oTail],
NodeToOnlyObjs[md.baseName, from.mustHave, libTail]
];
};
Scheme => cmd _ IO.PutFR[IF md.boot
THEN "Gambit -m %g %g.bscheme"
ELSE "Gambit %g %g.scheme",
[rope[midSwitches]], [rope[md.shortName]] ];
Cluster => cmd _ Rope.Cat["Cluster ", midSwitches, " ", md.shortName, ".cluster"];
Unknown => cmd _ Rope.Cat[
SELECT md.genesis FROM
C => "MMCCC ",
Cedar => "(MMCCMesa or MMCCConfig) ",
Scheme => "(Gambit or Cluster) ",
ENDCASE => ERROR,
md.shortName];
ENDCASE => ERROR ShouldNotHappen;
md.cmd _ cmd;
RETURN};

NodeToOnlyObjs: PROC [baseName: ROPE, nodeList: NodeList, objTail: ROPE] RETURNS [aRope: ROPE] ~ -- Results are ordered as they appear in argument-- {
baseLen: INT ~ baseName.Length[];
tailLen: INT ~ objTail.Length[];
ObjNameOrNIL: PROC [aNode: Node] RETURNS [shortName: ROPE _ NIL] ~ {
nodeName: ROPE;
nnLen: INT;
[name: nodeName] _ MakeDo.PublicPartsOfNode[aNode];
nnLen _ nodeName.Length[];
IF nnLen<tailLen OR NOT nodeName.EqualSubstrs[start1: nnLen-tailLen, s2: objTail] THEN RETURN [NIL];
IF baseName.EqualSubstrs[s2: nodeName, len2: baseLen] THEN {
shortName _ nodeName.Substr[start: baseLen];
IF Rope.IsPrefix["<", shortName] THEN shortName _ shortName.Substr[start: 1];
RETURN};
RETURN [nodeName]};
aRope _ NIL;
FOR list: NodeList _ nodeList, list.rest WHILE list # NIL DO
nameToAdd: ROPE _ ObjNameOrNIL[list.first];
IF nameToAdd#NIL THEN aRope _ Rope.Cat[aRope, " ", nameToAdd];
ENDLOOP;
RETURN};

IsLibName: PROC [name: ROPE] RETURNS [BOOL] ~ {
len: INT ~ name.Length[];
RETURN [len>=libTailLen AND name.EqualSubstrs[start1: len-libTailLen, s2: libTail]]};

NodeToAllButOne: PROC [target: Node, nodeList: NodeList] RETURNS [aRope: ROPE] ~ {
ShortName: PROC [aNode: Node] RETURNS [shortName: ROPE] ~ {
nodeName, fullName: ROPE;
nameCP: FS.ComponentPositions;
[name: nodeName] _ MakeDo.PublicPartsOfNode[aNode];
[fullFName: fullName, cp: nameCP] _ FS.ExpandName[nodeName];
shortName _ fullName.Substr[start: nameCP.base.start, len: nameCP.ext.start + nameCP.ext.length - nameCP.base.start];
};
aRope _ NIL;
FOR list: NodeList _ nodeList, list.rest WHILE list # NIL DO
IF list.first # target THEN aRope _ Rope.Cat[aRope, " ", ShortName[list.first]];
ENDLOOP;
RETURN [aRope: aRope];
};

EnumerateDependancies: PROC [sourceNode: Node, sourceType: MDPs.SourceType, consume: PROC [fileName: ROPE], md: SourceData, subDir: ROPE, boot: BOOL _ FALSE] RETURNS [BOOLEAN] ~ {
Pass: PROC [fileName: ROPE] ~ {
c0: CHAR ~ IF fileName.Length[]>0 THEN fileName.Fetch[0] ELSE 'x;
IF c0#'[ AND c0#'/ THEN fileName _ subDir.Concat[fileName];
consume[fileName]};
pd: MDPs.ParseData ~ MDPs.GetParseData[sourceNode, sourceType];
IF pd=NIL THEN RETURN [FALSE];
IF consume#NIL THEN {
To: PROC [fileName: ROPE] ~ IF subDir.Length[]#0 THEN Pass ELSE consume;
MDPs.EnumerateWithSuffix[pd.refdModules, ".c2c.o", To];
FOR rl: RopeList _ pd.refdFileSeq, rl.rest WHILE rl#NIL DO To[rl.first] ENDLOOP;
sourceNode _ sourceNode};
md.sourceType _ pd.sourceType;
md.boot _ boot;
RETURN [TRUE]};

Log: PROC [fmt: ROPE, val: IO.Value] ~ {
IF NOT dolog THEN RETURN;
SimpleFeedback.PutF[myRouterName, oneLiner, $Log, fmt, val];
RETURN};

OnProfileChange: UserProfile.ProfileChangedProc ~ {
dolog _ UserProfile.Boolean[key: "CcDeps.Talk", default: FALSE];
<<ExtendADotOut.SetSwitch[debug, dolog];>>
RETURN};

AddFinder[["Cc", SourceFind], front];
UserProfile.CallWhenProfileChanges[OnProfileChange];

END.

΄
CcDeps.Mesa
Copyright Σ 1988, 1990 by Xerox Corporation.  All rights reserved.
Eduardo Pelegri-Llopart, January 18, 1990 2:23:40 pm PST
After ConfigAndMesaDeps.mesa
Deals with (user-created and Mimosa & Cinder-created) C files.  Output files are .o
JKF March 14, 1989 10:28:07 am PST
Last tweaked by Mike Spreitzer on October 5, 1992 12:33 pm PDT
Bill Jackson (bj) January 16, 1989 1:31:39 pm PST
Mna, May 3, 1992 2:13 pm PDT

INVARIANT
StampRef in node props
The stamp table and when the file was created.  Used for caching information.

Maintains information that MakeDo "knows" about and does not have to re-compute.
if the ".o" file has been extended, this information is acurate and easy to extract
stampTable is the desired collection of stamp encoded in the O file.
For Cedar-generated files, can we read some dependency info?
For C and Scheme files, always TRUE.
Constants
A FinderProc looks for an action that will make an object with name resultName.  It returns an indication of whether it found it, a pointer to the node describing the object, and a list of the nodes produced by the action.  cmdFrom is a list of the determiners, while from is a list of all the nodes needed by the action to be runnable, discriminating between mandatory and optional nodes. FoundData is a record holding all the useful information that may be needed later.
The action found by this finder is "Cc", details depend on the source of the C file
We only know what to do with .o files.
Only accept the local directories that make sense
LOOPHOLE only needed for PrincOps
Is an action a consistent with a current result?  The action is derived from the current determiners and result is in Makes of the action. 
We know that the only valid result is the ONode.
What to check depends on what we have available.
It can be either the source creation time, or the encoded-in-O-file stamp, or the collection of mob-version stamps.
Update the information that may have changed since last time.
Extract information (Stamps and Create times) from the O that currently exist.  It does not change the contents of md.support, which is done in RederiveWork[].
nothing has changed --
Get the current Stamp Table of a node.  Information is cached.
Get the current dependency or Stamp Table of a node.  Information is cached.
fileName is in FS format; all the file names in the DependencyInfo are in / format.
This actually shouldn't happen.
This shouldn't happen
Returns a "something" or NIL, depending on whether we know about the subName or not.
RederiveWork determines which of a collection of actions implied by md is currently favored by the state of the system.  It returns the action and the list of all the nodes needed for this action to be startable.
Collect one more dependency into the from set;  also reconstructs md.support.
Elements of from.mustHave appear in the reverse of the EnumerateDependancies order.
NodeToAllButOne: PROC [target: Node, nodeList: NodeList] RETURNS [aRope: ROPE] ~ {
ExplodeTarget: PROC [target: Node] RETURNS [targetShortName: ROPE, targetDirLen: INT] ~ {
targetName: ROPE ~ MakeDo.PublicPartsOfNode[target].name;
targetFullFName: ROPE;
targetCP: FS.ComponentPositions;
[fullFName: targetFullFName, cp: targetCP] _ FS.ExpandName[targetName];
targetShortName _ targetFullFName.Substr[start: targetCP.base.start];
RETURN [targetShortName: targetShortName, targetDirLen: targetCP.base.start];
};
targetShortName: ROPE;
targetDirLen: INT;
ShortName: PROC [aNode: Node] RETURNS [shortName: ROPE] ~ {
nodeName, fullName: ROPE;
[name: nodeName] _ MakeDo.PublicPartsOfNode[aNode];
fullName _ FS.ExpandName[nodeName].fullFName;
shortName _ fullName.Substr[start: targetDirLen];
};
[targetShortName: targetShortName, targetDirLen: targetDirLen] _ ExplodeTarget[target];
aRope _ NIL;
FOR list: NodeList _ nodeList, list.rest WHILE list # NIL DO
newName: ROPE = ShortName[list.first];
IF NOT Rope.Equal[s1: newName, s2: targetShortName, case: FALSE] THEN
aRope _ Rope.Cat[aRope, " ", newName];
ENDLOOP;
RETURN [aRope: aRope];
};

NodeToAllButOne: PROC [target: ROPE, nodeList: NodeList] RETURNS [aRope: ROPE] ~ {
ShortName: PROC [aNode: Node] RETURNS [shortName: ROPE] ~ {
nodeName, fullName: ROPE;
nameCP: FS.ComponentPositions;
[name: nodeName] _ MakeDo.PublicPartsOfNode[aNode];
[fullFName: fullName, cp: nameCP] _ FS.ExpandName[nodeName];
shortName _ fullName.Substr[start: nameCP.base.start, len: nameCP.ext.start + nameCP.ext.length - nameCP.base.start];
};
aRope _ NIL;
FOR list: NodeList _ nodeList, list.rest WHILE list # NIL DO
newName: ROPE = ShortName[list.first];
IF NOT Rope.Equal[s1: newName, s2: target, case: FALSE] THEN
aRope _ Rope.Cat[aRope, " ", newName];
ENDLOOP;
RETURN [aRope: aRope];
};

If sourceNode exists, then callback to consume with all the fileNames that are required to be present by the semantics of sourceType and the contents of sourceNode. Caching is done. 
JKF October 7, 1988 10:51:46 am PDT
Just changed -lcedarc to -lxrc

JKF March 14, 1989 10:27:47 am PST
Added a class for profiled code.

Κρ–

"cedar" style•NewlineDelimiter

™
code™K™BKš
œ8™8K™K™SK™"K™>K™1K™K™—KšΟk	œ.œœrœ6˜θ
K˜šΡbnxœœ
˜KšœœœXœ5˜Ό
Kšœ˜š
	™	Kš
œ™——K˜Kšœœ
œ	Οnœ˜(K˜KšŸœœœ
˜K˜Kšœœœ
˜K˜š	œœœœœ˜GKšœœ
˜K˜&Kš
œ˜Kšœœœ
˜šœœœ˜K™MK™——š	œœœœœ˜DK™PKšœœ
œΟc
˜"Kšœœ ˜+Kšœ
œ  ˜0Kšœ	œ -˜<Kšœœ 7˜HK˜&K˜Kšœ ˜"KšœDœ
˜HKšœœ
˜Kšœœœ
˜šœ(œ
˜,K™S—šœ œ
˜$Kš
œD™D—Kšœœ
˜šœœ
˜K™<K™$—Kšœœ 
˜#Kšœœœ
˜Kšœœ˜K˜—K˜Kšœ	œ˜#K˜Kšœœ)˜9Kšœœœ
˜$K˜Kšœœœ
˜Kšœœ"˜4K˜Kšœœœ
˜K˜
head™	Kšœ	œ
˜Kšœœ	˜Kšœ
œ˜)Kšœœ˜(Kšœ	œ˜'Kšœœ˜&Kšœ
œ˜)Kšœ	œ˜'Kšœœ	˜Kšœ	œ˜&Kšœ
œ˜Kšœœ˜Kšœœ
˜Kšœœ
˜Kšœ
œ˜Kšœ
œ˜Kšœœ˜!Kšœ	œ˜Kšœœ˜#Kšœœ˜Kšœ
œ˜Kšœœ˜K˜—šœ
œœ˜Kšœœ ˜#Kšœœ %˜2Kšœ
œ ˜*Kšœ
œœ
 %˜=K˜K˜—šœœ
œœ
˜+Kš
œ;˜;Kš
œ;˜;Kš
œV˜VKš
œU˜UKš
œ>˜>Kš
œD˜DKš
œC˜CKš
œ?˜?Kš
œV˜VKš
œW˜WKš
œS˜SKš
œU˜UKš
œQ˜QKš
œR˜RKšœ 3˜6—K˜šŸœœ˜.KšŸœ˜#KšŸœ˜KšŸœ
˜K˜—K˜šŸœœ˜'Kš
œ˜Kšœœ
˜K˜—K˜Kš
Ÿ	œœ
œœœ˜CK˜šŸ
œœœœ
œœ	œ;œ!œ
œ œ˜Ν
Kš	œ+Οeœ‘
œ
‘œ%‘œΘ
™ΨK™SK˜Kšœœ 8˜IKšœœ ˜-Kšœ	œœ -˜BKšœ
œ
œ .˜BKšœ	œ
œ G˜ZKšœ&œ
˜+Kšœœ
œ
˜Kšœœ
˜Kš
œ˜K˜K˜Kšœœ˜&Kšœœ˜Kšœ
œœ
œ
˜šœœGœ˜oKš
Ρjls&™&—Kšœ
œœ
œ
˜Kšœ
œœ
˜"Kšœœ˜Kšœ
œœ
œ
˜Kšœœœœœœ˜cKšœ
œœ
œ
˜K˜$KšœœRœœ(˜¨
Kš
œ
œœPœœ(˜ͺ
Kšœœ˜%šœœœ˜'Kšœ*œœ˜7Kšœ
œ˜%šœM˜RKšœ7œ˜@Kš
œ1™1—K˜
—Kšœ$˜(KšœCœœ˜OKš
œ7˜7Kš
œI˜IKš
œ'˜'Kšœœœ˜'Kš
œ7˜7Kšœœ˜)Kš
œ3˜3Kš
œ*˜*Kš
œ"˜"Kš
œ"˜"šœœ˜'Kšœœ˜-K˜
K˜Kš
œ˜Kš
œ˜K˜Kš
œ˜Kš
œ/˜/Kš
œ
˜
Kš
œ
˜
K˜K˜!K˜Kš
œ˜—šœ	˜Kšœœ˜/˜
Kš
œJ˜JKš
œL˜LKš
œN˜NKšœ
œ=˜K—˜Kš
œL˜LKš
œP˜PKš
œO˜OKšœ
œ.˜<—Kšœœ
˜—Kš
œ˜Jš
œ˜J˜Kšœœ˜Kšœ˜—K˜šŸœœœ
œœœœ˜CKšœœ
œœ
˜Kšœœœ
œ˜/šœœ
œ˜K˜Kšœ
œœœ˜6K˜—Kšœ˜—K˜š
Ÿœœœœœ˜DKšœœœ*˜SKšœ
œœœI˜zKšœœ)˜;Kšœ
˜—K˜šŸœœœœ˜+Kšœœ
˜"Kšœœœœ˜sšœœ˜FK™!—Kšœœ
œœœ
œ˜bKšœœœ˜+˜K˜——šŸ	œœ˜Kšœœ
˜šœœ˜Kšœœ
˜Kšœ
˜K˜—Kš
œK˜KKšœœ
œ˜%Kšœœ
˜Kšœ
œœΟ
˜δ
Kšœ
œœέ
˜π
Kšœ˜—K˜šŸœœœœ
œ œ˜rIresušœΠae
‘œ‘œ\™‹
Mšœ‘œ™0Kš
˜Kšœœ$˜;Kšœœ$˜AKšœ- !˜NKšœœ
˜Kšœœœ
˜šŸœœœ
œœœœ œ˜bK™0K™sKš
œ$˜$Kš
œ%˜%Kšœ
œ˜-Kšœœ˜&K˜*K˜"K˜Kšœ œ
œœ˜6Kšœœ
˜Kšœ
œœ
œ˜/šœ0œ˜8Kšœ
œ
˜Kšœ	œv˜
Kšœœ˜K˜—K˜Kš
œœœ
œœ˜5Kš
œ#˜#šœœ
œ˜4šœ˜šŸœœœ)œ8˜ˆ
šœœ
œ8œœ
˜\Kš
œ(˜(Kšœ#œ
œ˜<Kšœ
˜—K˜—Kš
œG˜Gšœ$œ˜,Kš	œœ
œœ
œ˜Kšœ"œ˜5Kšœ;œ˜IKšœFœ˜YKšœ.œ˜<K˜Kšœ
œ
˜Kš
œ˜Kšœœ˜Kš
œ˜—Kš
œ
˜
—šœ˜Kšœœœ
˜šŸœœœœœ œ˜uKšœœœi˜wKšœœ
œœ˜<Kšœœ˜—šœ˜Kšœ-˜1—Kš
œ'˜'Kš
œN˜Nšœœ
œ˜Kšœ
œ
˜Kšœ	œb˜mKšœœ˜Kš
œ˜——Kš
œ
˜
—K˜—Kšœ"œ˜5K˜Kš
œ4˜4šœ˜Kšœ)œ
˜.Kšœœœ(˜?Kšœœ˜!—K˜Kšœœ
œœ
œœ˜Qšœ&œ˜.Kšœœ
˜šœœ5˜HKšœ
œœ.˜@——Kšœ
œ
˜Kš
œ$˜$Kš
œ%˜%Kš
œ
œœ
œœ/˜TKš
œ
œœ
œœ&˜LKšœ
˜—K˜šŸ
œœ˜(Kš
œ=™=Kšœs‘
œ‘™Ÿ
K˜K˜Kšœ	œ
˜
K˜2Kšœœ&˜7Kšœ&œ
œ
˜4š
œœ
œœ
œ
˜@Kš
œ™—K˜šœœ˜Kš
œ(˜(šœ
œœ
˜(K˜,—Kšœœ
œœ
˜7K˜—Kšœœ
˜K˜K˜—K˜šŸœœ
œœ$˜PK™>Kšœ
œ˜Kšœœ˜6Kšœœ˜/Kšœ
œ!˜/šŸœœœ#œ˜AKšœœ˜2Kšœ-œœœ˜WKšœœœœ
œœ˜?Kšœ˜K˜—šœœ
œ˜Kš
œ˜šœ
œ˜ Kš
œ˜Kšœ	œ
˜
Kšœœ˜—K˜—šœ˜ šœ˜Kšœœ
˜Kšœ
œ
˜Kšœ'œ
˜,Kšœ ˜6K˜——šœœ˜šœ
œœ˜ Kšœœ
˜K˜K˜—Kšœ ˜6K˜—K˜Kšœœ
˜Kšœœ
˜K˜Kš
œ˜Kšœ˜K˜K˜—š
Ÿœœ)œœœ˜WKš
œœ
œ
œœ˜%Kšœ˜%K˜K˜—šŸ
œœ
œœ,˜WK™LKšœ
œ˜Kšœœ˜6Kšœœ˜/Kšœ
œ!˜/Kšœœ˜!šŸœœ3œœ,˜†
K™Sš
Ÿ	œœœœœ˜.Kšœ
œ
œ˜Kšœ˜
K˜—Kšœœ
˜Kšœ
œ˜#Kšœœ
˜šœ˜šœ˜Kšœœ ˜2Kš
œ"˜"Kšœœ
˜K˜
—šœ˜Kšœ	œ
˜
Kš
œF˜FKšœ9œ˜?šœœ
œœ˜"K™—Kš
œ&˜&Kšœœ7˜MK˜——šœœ
œ8œœ
˜\Kš
œ(˜(šœ˜šœ
œ˜šœ
œœ
˜K™—šœ˜Kšœœ8˜KKšœ	œœ7˜IK˜K˜———Kšœ
˜—Kšœ˜K˜—š
œN˜Nšœ
œ%˜2Kš
œƒ
˜ƒ
Kšœœ+˜=Kšœ˜Kš
œ˜—Kš
œ˜—šŸœœœ*œ˜Hš
œ˜Kšœœ&œœ˜Ošœ	œ>˜JKšœ)œ˜<K˜Kš
œ˜—šœ	œ>˜JKšœ)œ˜<K˜Kš
œ˜—šœ˜Kšœ œ˜3Kšœjœ˜vK˜2Kš
œ˜——Kšœ˜K˜—šœœ
œ˜Kš
œ˜šœ
œ˜ Kš
œ˜Kšœ	œ
˜
Kšœœ˜—K˜—šœ˜ šœ˜Kšœœ
˜Kšœ
œ
˜Kšœ'œ
˜,Kšœ ˜0Kš
œ˜——šœœ˜šœ
œœ˜Kšœœ
˜Kš
œ˜K˜—Kšœ ˜0K˜—K˜Kšœœ
˜Kšœœ
˜Kš
œ˜Kš
œ˜Kšœ ˜0K˜—K˜š
Ÿœœ
œœ œ˜UKšœœ$˜;Kšœ˜—K˜šŸœœœ	œ
œœœœœ˜ƒ
Kš
œT™TKšœœ
˜
Kšœœ
œ
œœœ˜(Kš
œ2˜2šœœ
œ œœ
˜DK˜Kšœœœ
œœœœ
œœ˜š
Kšœ
˜—Kšœœœ
˜K˜K˜—šŸœœœœ˜GKšœD‘œƒ
‘	œ
™Τ
šŸœœœ˜"Kšœ%‘œ‘™MKš
œS™SKšœœ
œœ
˜Kš	œœœœš
œ˜δ
Kšœœ˜Kšœœ˜Kš
œ˜K˜Kšœœ˜'Kšœ
˜Kšœ	œ˜—Kšœœ
˜Kšœœ
˜Kš
œœœœ
œ œ
œ
˜OKšœ<œ
˜AKš
œs˜sKšœœ
œ
œ!œ
œ
˜OK˜šœ˜š
œ
˜
Kšœœœ˜CKšœ
œ"œ
œ
˜3Kšœ*œœ
˜9Kšœ+œœ
˜:KšœGœ
œ˜T—š
œ˜Kšœœœ˜CKšœ
œ"œ
œ
˜3Kšœ;œ˜A—š
œ˜Kšœœœ˜Kšœ,œœ
˜;Kšœ/œœœ
˜DKšœ<œœ
œ
˜Mšœœ˜*Kšœ
œ	œœ
˜:Kš
œ˜Kšœœ
˜Kšœœ
˜—šœ	œ
œ˜Kšœ
œ!œ
œ
˜2Kšœœ˜.—Kš
œ˜—Kšœœ
˜—Kšœœ
˜Kš
œ˜Kš
œ+˜+Kš
œ4˜4šœ˜˜Kš
œF˜FKš
œ˜Kš
œU˜UK˜—š
œ	˜	Kš
œI˜IKš
œ˜Kš
œ˜—š
œ˜Kš
œK˜KKš
œ˜š
œ˜Kš
œ2˜2Kš
œ3˜3Kš
œ˜—Kš
œ˜—šœœœ˜#Kšœ˜Kšœ˜Kš
œ,˜,—K˜Rš
œ˜šœ˜Kš
œ˜Kš
œ%˜%Kš
œ!˜!Kšœœ
˜—Kš
œ˜—Kšœœ˜!—K˜
Kšœ˜—K˜šŸœœœœœ	œ 3œ˜–
Kšœ	œ˜!Kšœ	œ˜ š
Ÿœœœ
œœ˜DKšœ
œ
˜Kšœœ
˜K˜3K˜Kšœœ
œ;œ
œœ˜dšœ4œ˜<Kš
œ,˜,Kšœœ(˜MKšœ˜—Kšœ
˜—Kšœœ
˜šœ&œœ
˜<Kšœœ˜+Kšœœ
œ)˜>Kšœ
˜—Kšœ˜—K˜š
Ÿ	œœœœœ˜/Kšœœ˜Kšœœ:˜U—K˜šŸœœ$œ	œ˜RšŸ	œœœ
œ˜;Kšœœ
˜Kšœœ˜K˜3Kšœ$œ˜<Kš
œu˜uK˜—Kšœœ
˜šœ&œœ
˜<Kšœœ5˜PKšœ
˜—Kšœ˜Kš
œ˜K˜—šŸœœ$œ	œ™Rš
Ÿ
œœœœœ™YKšœœ)™9Kšœœ
™Kšœ
œ™ Kšœ-œ™GKš
œE™EKšœG™MK™—Kšœ™Kšœ™šŸ	œœœ
œ™;Kšœœ
™K™3Kšœœ ™-Kš
œ1™1K™—Kš
œW™WKšœœ
™šœ&œ™<Kš
œ&™&šœ
œ4œ™EKš
œ&™&—Kšœ
™—Kšœ™Kš
œ™K™—šŸœœ$œ	œ™RšŸ	œœœ
œ™;Kšœœ
™Kš
œ™K™3Kšœ$œ™<Kš
œu™uK™—Kšœœ
™šœ&œ™<Kš
œ&™&šœ
œ+œ™<Kš
œ&™&—Kšœ
™—Kšœ™Kš
œ™K™—šŸœœ:œœœœœœœ˜³
Kšœ‘
œ‘œ
‘	œ6‘
œ‘œ™Ά
šŸœœœ˜Kš	œœœœœ˜AKšœœœ$˜;K˜—K˜?Kš
œœ
œ
œœ˜šœ	œ
œ˜KšŸœœœœœœ	˜HKš
œ7˜7Kš
œ(œœ
œœ
˜PKš
œ˜—K˜K˜Kšœœ˜—K˜šŸœœœœ˜(Kšœ
œœ
œ
˜Kš
œ<˜<Kšœ˜—K˜šŸœ$˜3Kšœ9œ˜@Kš
œ*˜*Kšœ˜—K˜K˜%K˜4K˜Kšœ
˜K˜™#K™K™—™"K™ —K™—…—b”Ώ