DIRECTORY
AMBridge USING [TVForGFHReferent, TVForRemoteGFHReferent, GFHFromTV, RemoteGFHFromTV, GetWorld, RemoteGlobalFrameHandle, nilRemoteGlobalFrameHandle],
AMMiniModel USING [AcquireIRType],
AMModel USING [Class, Source, SourceObj, CharIndex],
AMModelPrivate USING [FGIndex, FGNull, EPI, EPIToFirstFGI, GetModuleSTB, EPIToLastFGI, FGIToFirstChar, FGIToLastChar, FGIToEPI, NextFGI, SectionRec, RefTVRec, GetLocalBCD, GetRemoteBCD],
AMTypes USING [TVType, Error, TVToName, TV],
BcdDefs USING [MTIndex, NameRecord, BcdBase, MTHandle, NameString, VersionStamp, ModuleIndex],
BcdOps USING [ProcessModules],
BrandXSymbolDefs USING[BodyIndex, rootBodyIndex, nullBodyIndex, SymbolTableBase, FineGrainTableHeader],
BrandYSymbolDefs USING[BodyIndex, rootBodyIndex, nullBodyIndex, SymbolTableBase, FineGrainTableHeader],
ConvertUnsafe USING [ToRope, SubStringToRope, SubString],
IO USING [PutR, card],
LoadState USING [local, Acquire, Release, Handle, ConfigInfo, ModuleToGlobalFrame, ConfigID, GlobalFrameToModule],
PrincOps USING [wordsPerPage, GlobalFrameHandle],
Rope USING [ROPE, Concat],
RTSymbolDefs USING [SymbolTableBase, SymbolTableHandle],
RTSymbolOps USING [AcquireRope, AcquireType, STBSourceVersion],
RTSymbols USING [AcquireSTB, ReleaseSTB, GetSTHForModule],
RTSymbolsPrivate USING [AcquireBCDFromVersion, ReleaseBCD],
RTTypesRemotePrivate USING [AcquireRemoteBCD, ReleaseRemoteBCD],
SafeStorage USING [Type],
Table USING [Base],
WorldVM USING [World, Lock, Unlock, LocalWorld, Loadstate, CurrentIncarnation, Incarnation];

AMModelSectionImpl: PROGRAM
IMPORTS AMBridge, AMMiniModel, AMModelPrivate, AMTypes, BcdOps, ConvertUnsafe, IO, LoadState, Rope, RTSymbolOps, RTSymbols, RTSymbolsPrivate, RTTypesRemotePrivate, WorldVM
EXPORTS AMModel
= { OPEN AMBridge, AMMiniModel, AMTypes, bx: BrandXSymbolDefs, by: BrandYSymbolDefs, PrincOps, Rope, AMModel, AMModelPrivate, RTSymbolDefs, RTSymbolOps, RTSymbols, RTTypesRemotePrivate, WorldVM;



Section: TYPE = REF SectionObj;
SectionObj: PUBLIC TYPE = SectionRec;


SectionClass: PUBLIC PROC [section: Section] RETURNS [Class] = {
RETURN[section.class];
};

SectionName: PUBLIC PROC [section: Section] RETURNS [ans: ROPE _ NIL] = {
WITH s: section SELECT FROM
model => RETURN[s.configName];
prog => RETURN[s.moduleName];  
interface => RETURN[s.moduleName];  
proc => IF s.procTV # NIL
THEN RETURN[TVToName[s.procTV]]
ELSE {
sth: SymbolTableHandle = GetSTHForModule [
stamp: s.prog.versionStamp,
fileName: Rope.Concat[s.prog.moduleName, ".bcd"],
moduleName: s.prog.moduleName];
stb: SymbolTableBase _ AcquireSTB[sth];
FindProcX: PROC [bti: bx.BodyIndex] RETURNS [stop: BOOLEAN _ FALSE] = {
xstb: bx.SymbolTableBase = NARROW[stb, SymbolTableBase.x].e;
WITH b: xstb.bb[bti] SELECT FROM
Callable => IF ~b.inline AND b.entryIndex = s.entryPointIndex
THEN {ans _ AcquireRope[stb, [x[xstb.seb[b.id].hash]]]; RETURN[TRUE]};
ENDCASE};
FindProcY: PROC [bti: by.BodyIndex] RETURNS [stop: BOOLEAN _ FALSE] = {
ystb: by.SymbolTableBase = NARROW[stb, SymbolTableBase.y].e;
WITH b: ystb.bb[bti] SELECT FROM
Callable => IF ~b.inline AND b.entryIndex = s.entryPointIndex
THEN {ans _ AcquireRope[stb, [y[ystb.seb[b.id].hash]]]; RETURN[TRUE]};
ENDCASE};

WITH stb SELECT FROM
t: SymbolTableBase.x =>
IF t.e.EnumerateBodies[bx.rootBodyIndex, FindProcX
! UNWIND => ReleaseSTB[stb]] = bx.nullBodyIndex
THEN {ReleaseSTB[stb]; ERROR};
t: SymbolTableBase.y =>
IF t.e.EnumerateBodies[by.rootBodyIndex, FindProcY
! UNWIND => ReleaseSTB[stb]] = by.nullBodyIndex
THEN {ReleaseSTB[stb]; ERROR};
ENDCASE => ERROR;
ReleaseSTB[stb];
RETURN[ans]};  -- figure it out from the ep# and the prog section
statement => RETURN[Rope.Concat[Rope.Concat[s.prog.moduleName, "."],
IO.PutR[IO.card[s.fgtIndex.fgCard]]]]
ENDCASE => ERROR
};

SectionSource: PUBLIC PROC [section: Section] RETURNS [ans: Source] = {
WITH s: section SELECT FROM
model => {
name: ROPE _ NIL;
version: BcdDefs.VersionStamp;
IF s.configContext # NIL
THEN {
IF s.configContext.world = LocalWorld[]
THEN {
bcd: BcdDefs.BcdBase;
LoadState.local.Acquire[];
{ ENABLE UNWIND => LoadState.local.Release[];
bcd _ LoadState.local.ConfigInfo[s.configContext.configIndex].bcd;
};  -- end ENABLE UNWIND => LoadState.local.Release[];
LoadState.local.Release[];
name _ BcdNameToRope[bcd, bcd.source];
version _ bcd.sourceVersion;
}
ELSE {
world: World = s.configContext.world;
Lock[world];
{ ENABLE UNWIND => Unlock[world];
h: LoadState.Handle = WorldVM.Loadstate[world];
h.Acquire[];
{ ENABLE UNWIND => h.Release[];
bcd: BcdDefs.BcdBase = AcquireRemoteBCD[
world: world,
incarnation: CurrentIncarnation[world],
bcd: h.ConfigInfo[s.configContext.configIndex].bcd];
IF bcd = NIL THEN ERROR AMTypes.Error[reason: noSymbols];
{ ENABLE UNWIND => ReleaseRemoteBCD[bcd];
name _ BcdNameToRope[bcd, bcd.source];
version _ bcd.sourceVersion;
};  -- end ENABLE UNWIND => ReleaseRemoteBCD[bcd];
ReleaseRemoteBCD[bcd];
};  -- end ENABLE UNWIND => h.Release[];
h.Release[];
};  -- end ENABLE UNWIND => Unlock[world];
Unlock[world];
}
}
ELSE {
bcd: BcdDefs.BcdBase = RTSymbolsPrivate.AcquireBCDFromVersion [
versionStamp: s.versionStamp,
shortFileNameHint: Rope.Concat[s.configName, ".bcd"]];
IF bcd = NIL THEN ERROR AMTypes.Error[reason: noSymbols];
name _ BcdNameToRope[bcd, bcd.source];
version _ bcd.sourceVersion;
RTSymbolsPrivate.ReleaseBCD[bcd];
};
ans _ NEW[SourceObj _ [fileName: name, class: model, versionStamp: version, sourceRange: entire[]]];
};
prog => {
name: ROPE _ NIL;
version: BcdDefs.VersionStamp;
IF s.someGFHTV = NIL
THEN {
bcd: BcdDefs.BcdBase = RTSymbolsPrivate.AcquireBCDFromVersion [
versionStamp: s.versionStamp,
shortFileNameHint: Rope.Concat[s.moduleName, ".bcd"]];
IF bcd = NIL THEN ERROR AMTypes.Error[reason: noSymbols];
name _ BcdNameToRope[bcd, bcd.source];
version _ bcd.sourceVersion;
RTSymbolsPrivate.ReleaseBCD[bcd]}
ELSE {
ptv: TV = s.someGFHTV;
world: World _ GetWorld[ptv];
IF world = LocalWorld[]
THEN {
bcd: BcdDefs.BcdBase = GetLocalBCD[GFHFromTV[ptv]];
stb: SymbolTableBase _ GetModuleSTB[bcd, s.versionStamp];
{ ENABLE UNWIND => ReleaseSTB[stb];
name _ STB2Source[stb];
version _ STBSourceVersion[stb];
};  -- end ENABLE UNWIND => ReleaseSTB[stb]
ReleaseSTB[stb];
}
ELSE {
bcd: BcdDefs.BcdBase _ GetRemoteBCD[RemoteGFHFromTV[ptv]];
{ ENABLE UNWIND => ReleaseRemoteBCD[bcd];
stb: SymbolTableBase _ GetModuleSTB[bcd, s.versionStamp];
{ ENABLE UNWIND => ReleaseSTB[stb];
name _ STB2Source[stb];
version _ STBSourceVersion[stb];
};  -- end ENABLE UNWIND => ReleaseSTB[stb]
ReleaseSTB[stb];
};  -- end ENABLE UNWIND => ... FREE[@bcd];
ReleaseRemoteBCD[bcd];
}
};
ans _ NEW[SourceObj _ [fileName: name, class: prog, versionStamp: version, sourceRange: entire[]]];
}; 
interface => {
bcd: BcdDefs.BcdBase = RTSymbolsPrivate.AcquireBCDFromVersion [
versionStamp: s.versionStamp,
shortFileNameHint: Rope.Concat[s.moduleName, ".bcd"]];
IF bcd = NIL THEN ERROR AMTypes.Error[reason: noSymbols];
ans _ NEW[SourceObj _ [fileName: BcdNameToRope[bcd, bcd.source],
class: interface,
versionStamp: bcd.sourceVersion,
sourceRange: entire[]]];
RTSymbolsPrivate.ReleaseBCD[bcd];
};  
proc => {
nSect: REF proc SectionObj _ NARROW[section];
fci: INT;
lci: INT;
name: ROPE _ NIL;
version: BcdDefs.VersionStamp;
[firstCI: fci, lastCI: lci] _ ProcToInfo[nSect];
IF s.prog.someGFHTV = NIL
THEN {
bcd: BcdDefs.BcdBase = RTSymbolsPrivate.AcquireBCDFromVersion [
versionStamp: s.prog.versionStamp,
shortFileNameHint: Rope.Concat[s.prog.moduleName, ".bcd"]];
IF bcd = NIL THEN ERROR AMTypes.Error[reason: noSymbols];
name _ BcdNameToRope[bcd, bcd.source];
version _ bcd.sourceVersion;
RTSymbolsPrivate.ReleaseBCD[bcd]}
ELSE {
ptv: TV = s.prog.someGFHTV;
world: World _ GetWorld[ptv];
IF world = LocalWorld[]
THEN {
bcd: BcdDefs.BcdBase = GetLocalBCD[GFHFromTV[ptv]];
stb: SymbolTableBase _ GetModuleSTB[bcd, s.prog.versionStamp];
{ ENABLE UNWIND => ReleaseSTB[stb];
name _ STB2Source[stb];
version _ STBSourceVersion[stb];
};  -- end ENABLE UNWIND => ReleaseSTB[stb]
ReleaseSTB[stb];
}
ELSE {
bcd: BcdDefs.BcdBase _ GetRemoteBCD[RemoteGFHFromTV[ptv]];
{ ENABLE UNWIND => ReleaseRemoteBCD[bcd];
stb: SymbolTableBase _ GetModuleSTB[bcd, s.prog.versionStamp];
{ ENABLE UNWIND => ReleaseSTB[stb];
name _ STB2Source[stb];
version _ STBSourceVersion[stb];
};  -- end ENABLE UNWIND => ReleaseSTB[stb]
ReleaseSTB[stb];
};  -- end ENABLE UNWIND => ... FREE[@bcd];
ReleaseRemoteBCD[bcd];
}
};
ans _ NEW[SourceObj _ [fileName: name, class: proc, versionStamp: version, sourceRange: field[firstCharIndex: fci, lastCharIndex: lci]]];
}; 

statement => {
nSect: REF statement SectionObj _ NARROW[section];
fci: INT;
lci: INT;
name: ROPE _ NIL;
version: BcdDefs.VersionStamp;
[firstCI: fci, lastCI: fci] _ StatementToInfo[nSect];
IF s.prog.someGFHTV = NIL
THEN {
bcd: BcdDefs.BcdBase = RTSymbolsPrivate.AcquireBCDFromVersion [
versionStamp: s.prog.versionStamp,
shortFileNameHint: Rope.Concat[s.prog.moduleName, ".bcd"]];
IF bcd = NIL THEN ERROR AMTypes.Error[reason: noSymbols];
name _ BcdNameToRope[bcd, bcd.source];
version _ bcd.sourceVersion;
RTSymbolsPrivate.ReleaseBCD[bcd]}
ELSE {
ptv: TV = s.prog.someGFHTV;
world: World _ GetWorld[ptv];
IF world = LocalWorld[]
THEN {
bcd: BcdDefs.BcdBase = GetLocalBCD[GFHFromTV[ptv]];
stb: SymbolTableBase _ GetModuleSTB[bcd, s.prog.versionStamp];
{ ENABLE UNWIND => ReleaseSTB[stb];
name _ STB2Source[stb];
version _ STBSourceVersion[stb];
};  -- end ENABLE UNWIND => ReleaseSTB[stb]
ReleaseSTB[stb];
}
ELSE {
bcd: BcdDefs.BcdBase _ GetRemoteBCD[RemoteGFHFromTV[ptv]];
{ ENABLE UNWIND => ReleaseRemoteBCD[bcd];
stb: SymbolTableBase _ GetModuleSTB[bcd, s.prog.versionStamp];
{ ENABLE UNWIND => ReleaseSTB[stb];
name _ STB2Source[stb];
version _ STBSourceVersion[stb];
};  -- end ENABLE UNWIND => ReleaseSTB[stb]
ReleaseSTB[stb];
};  -- end ENABLE UNWIND => ... FREE[@bcd];
ReleaseRemoteBCD[bcd];
}
};
ans _ NEW[SourceObj _ [fileName: name, class: statement, versionStamp: version, sourceRange: field[firstCharIndex: fci, lastCharIndex: lci]]];
}; 
ENDCASE => ERROR
};

SectionParams: PUBLIC PROC [section: Section] RETURNS [list: LIST OF SafeStorage.Type _ NIL] = {
WITH s: section SELECT FROM
model => ERROR;  --NOTE enumerate the directory entries;
prog => ERROR;  --NOTE enumerate the directory entries;  
interface => ERROR;  --NOTE enumerate the directory entries;  
proc => ERROR AMTypes.Error[reason: notImplemented];   
statement => ERROR AMTypes.Error[reason: notImplemented];
ENDCASE => ERROR
};

ParentSection: PUBLIC PROC [section: Section] RETURNS [Section] = {
WITH s: section SELECT FROM
proc => RETURN[s.prog];   
statement => RETURN[NEW[SectionObj _ [proc[prog: s.prog,
entryPointIndex: StatementToInfo[NARROW[section]].epi ]]]];
ENDCASE => ERROR AMTypes.Error[reason: notImplemented];
};  -- end ParentSections

SectionChildren: PUBLIC PROC [section: Section, proc: PROC [Section] RETURNS [stop: BOOL]] RETURNS [ans: Section _ NIL--NIL if not stopped--] = {
x: INT _ 0;
NextSection: PROC [parent, child: Section] RETURNS [s: Section _ NIL] = {
[s, x] _ NextSiblingSection[parent: parent, child: child, indexInParent: x]};

FOR s: Section _ FirstChildSection[section], NextSection[section, s]
UNTIL s = NIL DO IF proc[s] THEN RETURN[s]; ENDLOOP;
};

FirstChildSection: PROC [section: Section] RETURNS [ans: Section] = {
WITH s: section SELECT FROM
model =>   IF s.configContext # NIL
THEN {
IF s.configContext.world = LocalWorld[]
THEN {
bcd: BcdDefs.BcdBase; 
ftb: Table.Base;
mth: BcdDefs.MTHandle;
p: PROC [mth: BcdDefs.MTHandle, mti: BcdDefs.MTIndex]
RETURNS [BOOL] = {RETURN[TRUE]};

LoadState.local.Acquire[];
bcd _ LoadState.local.ConfigInfo[s.configContext.configIndex].bcd;
IF bcd = NIL
THEN {LoadState.local.Release[];
ERROR AMTypes.Error[reason: noSymbols]};
ftb _ LOOPHOLE[bcd + bcd.ftOffset];
mth _ BcdOps.ProcessModules[bcd, p].mth;
ans _ NEW
[SectionObj
_ [prog[moduleName: BcdNameToRope[bcd, mth.name],
versionStamp: ftb[mth.file].version,
someGFHTV:
NARROW
[TVForGFHReferent
[LoadState.local.ModuleToGlobalFrame
[s.configContext.configIndex, mth.gfi]
]
]
]
]
];
LoadState.local.Release[];
RETURN;
}
ELSE {
world: World = s.configContext.world;
cx: LoadState.ConfigID = s.configContext.configIndex;
moduleName: ROPE;
v: BcdDefs.VersionStamp;
mx: BcdDefs.ModuleIndex;

Lock[world];
{ ENABLE UNWIND => Unlock[world];
incarnation: Incarnation _ CurrentIncarnation[world];
rgfh: GlobalFrameHandle;
newState: LoadState.Handle = WorldVM.Loadstate[world];
newState.Acquire[];
{ ENABLE UNWIND => newState.Release[];
bcd: BcdDefs.BcdBase
= AcquireRemoteBCD[
world: world,
incarnation: CurrentIncarnation[world],
bcd: newState.ConfigInfo[cx].bcd];
IF bcd = NIL THEN ERROR AMTypes.Error[reason: noSymbols];
{ ENABLE UNWIND => ReleaseRemoteBCD[bcd];
ftb: Table.Base = LOOPHOLE[bcd + bcd.ftOffset];
p: PROC [mth: BcdDefs.MTHandle, mti: BcdDefs.MTIndex]
RETURNS [BOOL] = {RETURN[TRUE]};
mth: BcdDefs.MTHandle = BcdOps.ProcessModules[bcd, p].mth;
v _ ftb[mth.file].version;
moduleName _ BcdNameToRope[bcd, mth.name];
mx _ mth.gfi;
};  -- end ENABLE UNWIND => ReleaseRemoteBCD[bcd]
ReleaseRemoteBCD[bcd];
rgfh _ newState.ModuleToGlobalFrame[cx, mx];
};  -- end ENABLE UNWIND => newState.Release[]
newState.Release[];
ans _ NEW[SectionObj
_ [prog[moduleName: moduleName,
versionStamp: v,
someGFHTV: NARROW[TVForRemoteGFHReferent[[world: world, worldIncarnation: incarnation, gfh: LOOPHOLE[rgfh]]]]
]]];
};  -- end ENABLE UNWIND => Unlock[world];
Unlock[world];
RETURN;
}
}
ELSE {
bcd: BcdDefs.BcdBase = RTSymbolsPrivate.AcquireBCDFromVersion [
versionStamp: s.versionStamp,
shortFileNameHint: Rope.Concat[s.configName, ".bcd"]];
ftb: Table.Base;
mth: BcdDefs.MTHandle;
p: PROC [mth: BcdDefs.MTHandle, mti: BcdDefs.MTIndex] RETURNS [BOOLEAN] = {
RETURN[TRUE]};

IF bcd = NIL THEN ERROR AMTypes.Error[reason: noSymbols];
ftb _ LOOPHOLE[bcd + bcd.ftOffset];

mth _ BcdOps.ProcessModules[bcd, p].mth;
ans _ NEW[SectionObj _ [prog[moduleName: BcdNameToRope
[bcd, mth.name],
versionStamp: ftb[mth.file].version,
someGFHTV: NIL]]];
RTSymbolsPrivate.ReleaseBCD[bcd];
};
prog =>
RETURN[NEW[SectionObj _ [proc[prog: NARROW[section, REF prog SectionObj], entryPointIndex: 0]]]];  --ep# wizardry: StartProc.  
interface => RETURN[NIL];  

proc => RETURN[NEW[SectionObj _ [statement[prog: s.prog, fgtIndex: ProcToInfo [NARROW[section]].fgi]]]];

statement => RETURN[NIL];
ENDCASE => ERROR
};  -- end FirstChildSection

NextSiblingSection: PROC [parent, child: Section, indexInParent: INT _ 0] RETURNS [ans: Section _ NIL, newIndexInParent: INT _ 0] = {
IF parent = NIL THEN RETURN[NIL];
WITH s: child SELECT FROM
model => ERROR AMTypes.Error[reason: notImplemented];
prog => {
lastWasOldChild: BOOL _ FALSE;
ftb: Table.Base _ NIL;

FindNextModule: PROC [mth: BcdDefs.MTHandle, mti: BcdDefs.MTIndex] RETURNS [stop: BOOL _ FALSE] = {
newIndexInParent _ newIndexInParent + 1;
IF lastWasOldChild THEN RETURN[TRUE];
IF (indexInParent = 0 OR newIndexInParent >= indexInParent)
AND s.versionStamp = ftb[mth.file].version
THEN lastWasOldChild _ TRUE;
};

IF s.someGFHTV # NIL
THEN {
world: World = GetWorld[s.someGFHTV];
IF world = LocalWorld[]
THEN {
gfh: GlobalFrameHandle _ NIL;
bcd: BcdDefs.BcdBase;
mth: BcdDefs.MTHandle;
LoadState.local.Acquire[];
{ ENABLE UNWIND => LoadState.local.Release[];
config: LoadState.ConfigID
= LoadState.local.GlobalFrameToModule
[GFHFromTV[s.someGFHTV]].config;
bcd _ LoadState.local.ConfigInfo[config].bcd;
ftb _ LOOPHOLE[bcd + bcd.ftOffset];
mth _ BcdOps.ProcessModules[bcd, FindNextModule].mth;
IF mth # NIL THEN
gfh _ LoadState.local.ModuleToGlobalFrame[config, mth.gfi];
};  --  ENABLE UNWIND => LoadState.local.Release[];
LoadState.local.Release[];
IF gfh # NIL THEN
ans _ NEW [SectionObj
_ [prog[moduleName: BcdNameToRope[bcd, mth.name],
versionStamp: ftb[mth.file].version,
someGFHTV: NARROW[TVForGFHReferent[gfh]] ]]];
}
ELSE {
Lock[world];
{ ENABLE UNWIND => Unlock[world];
v: BcdDefs.VersionStamp;
moduleName: ROPE;
rgfh: RemoteGlobalFrameHandle _ nilRemoteGlobalFrameHandle;
h: LoadState.Handle = WorldVM.Loadstate[world];
h.Acquire[];
{ ENABLE UNWIND => h.Release[];
config: LoadState.ConfigID = h.GlobalFrameToModule
[LOOPHOLE[RemoteGFHFromTV[s.someGFHTV].gfh]].config;
bcd: BcdDefs.BcdBase = GetRemoteBCD[RemoteGFHFromTV[s.someGFHTV]];
IF bcd = NIL THEN ERROR;
ftb _ LOOPHOLE[bcd + bcd.ftOffset];
{ ENABLE UNWIND => ReleaseRemoteBCD[bcd];
mth: BcdDefs.MTHandle
= BcdOps.ProcessModules[bcd, FindNextModule].mth;
IF mth # NIL
THEN {gfh: GlobalFrameHandle
= h.ModuleToGlobalFrame[config, mth.gfi];
v _ ftb[mth.file].version;
moduleName _ BcdNameToRope[bcd, mth.name];
rgfh _ [world, CurrentIncarnation[world], LOOPHOLE[gfh]]};
};  --  ENABLE UNWIND => ReleaseRemoteBCD[bcd];
ReleaseRemoteBCD[bcd];
};  --  ENABLE UNWIND => h.Release[];
h.Release[];
IF rgfh # nilRemoteGlobalFrameHandle THEN
ans _ NEW [SectionObj
_ [prog[moduleName: moduleName,
versionStamp: v,
someGFHTV: NARROW[TVForRemoteGFHReferent[rgfh]] ]]];
};  --  ENABLE UNWIND => Unlock[world];
};  -- end ELSE
}  -- end case where the sections are loaded
ELSE {
p: REF model SectionObj = NARROW[parent];
mth: BcdDefs.MTHandle;
bcd: BcdDefs.BcdBase _ RTSymbolsPrivate.AcquireBCDFromVersion [
versionStamp: p.versionStamp,
shortFileNameHint: Rope.Concat[p.configName, ".bcd"]];
IF bcd = NIL THEN ERROR AMTypes.Error[reason: noSymbols];
{ ENABLE UNWIND => RTSymbolsPrivate.ReleaseBCD[bcd]; 
ftb _ LOOPHOLE[bcd + bcd.ftOffset];
mth _ BcdOps.ProcessModules[bcd, FindNextModule].mth;
IF mth # NIL THEN ans _ NEW[SectionObj
_ [prog[moduleName: BcdNameToRope[bcd, mth.name],
versionStamp: ftb[mth.file].version,
someGFHTV: NIL]]];
};  -- end ENABLE UNWIND => RTSymbolsPrivate.ReleaseBCD[bcd]; 
RTSymbolsPrivate.ReleaseBCD[bcd];
}};  -- end prog child case of NextSiblingSection
interface => ERROR AMTypes.Error[reason: notImplemented];  
proc => {
sth: SymbolTableHandle = GetSTHForModule [
stamp: s.prog.versionStamp,
fileName: Rope.Concat[s.prog.moduleName, ".bcd"],
moduleName: s.prog.moduleName];
stb: SymbolTableBase _ AcquireSTB[sth];
maxEI: EPI _ 0;
GetMaxX: PROC [bti: bx.BodyIndex] RETURNS [stop: BOOL _ FALSE] = {
WITH NARROW[stb, SymbolTableBase.x].e.bb[bti] SELECT FROM
Callable => IF ~inline THEN maxEI _ MAX[maxEI, entryIndex];
ENDCASE};
GetMaxY: PROC [bti: by.BodyIndex] RETURNS [stop: BOOL _ FALSE] = {
WITH NARROW[stb, SymbolTableBase.y].e.bb[bti] SELECT FROM
Callable => IF ~inline THEN maxEI _ MAX[maxEI, entryIndex];
ENDCASE};
WITH stb SELECT FROM
t: SymbolTableBase.x => [] _ t.e.EnumerateBodies[bx.rootBodyIndex, GetMaxX];
t: SymbolTableBase.y => [] _ t.e.EnumerateBodies[by.rootBodyIndex, GetMaxY];
ENDCASE => ERROR;
IF s.entryPointIndex = maxEI
THEN ans _ NIL
ELSE ans _ NEW[SectionObj _
[proc[prog: NARROW[parent, REF prog SectionObj],
entryPointIndex: s.entryPointIndex + 1]]];
ReleaseSTB[stb]};  -- end proc child case of NextSiblingSection
statement => {
nextFGI: FGIndex = StatementToInfo[NARROW[child, REF statement SectionObj]].nextFgi;
IF nextFGI = FGNull
THEN RETURN[NIL]
ELSE RETURN[NEW[SectionObj _
[statement[prog: NARROW[parent, REF proc SectionObj].prog, fgtIndex: nextFGI]]]];
};  -- end statement child case of NextSiblingSection
ENDCASE => ERROR
};  -- end NextSiblingSection


SectionType: PUBLIC PROC [section: Section] RETURNS [type: SafeStorage.Type] = {
WITH s: section SELECT FROM
model => ERROR AMTypes.Error[reason: notImplemented];
prog => ERROR AMTypes.Error[reason: notImplemented];  
interface => RETURN[AcquireIRType[defsName: s.moduleName, version: s.versionStamp]];  
proc => IF s.procTV = NIL
THEN {
sth: SymbolTableHandle
= GetSTHForModule [
stamp: s.prog.versionStamp,
fileName: Rope.Concat[s.prog.moduleName, ".bcd"],
moduleName: s.prog.moduleName];
stb: SymbolTableBase _ AcquireSTB[sth];
FindProcX: PROC [bti: bx.BodyIndex] RETURNS [stop: BOOLEAN _ FALSE] = {
WITH b: NARROW[stb, SymbolTableBase.x].e.bb[bti] SELECT FROM
Callable => IF ~b.inline AND b.entryIndex = s.entryPointIndex
THEN {type _ AcquireType[stb, [x[b.ioType]]];
RETURN[TRUE]};
ENDCASE};
FindProcY: PROC [bti: by.BodyIndex] RETURNS [stop: BOOLEAN _ FALSE] = {
WITH b: NARROW[stb, SymbolTableBase.y].e.bb[bti] SELECT FROM
Callable => IF ~b.inline AND b.entryIndex = s.entryPointIndex
THEN {type _ AcquireType[stb, [y[b.ioType]]];
RETURN[TRUE]};
ENDCASE};

WITH stb SELECT FROM
t: SymbolTableBase.x =>
IF t.e.EnumerateBodies[bx.rootBodyIndex, FindProcX
! UNWIND => ReleaseSTB[stb]] = bx.nullBodyIndex
THEN {ReleaseSTB[stb]; ERROR};
t: SymbolTableBase.y =>
IF t.e.EnumerateBodies[by.rootBodyIndex, FindProcY
! UNWIND => ReleaseSTB[stb]] = by.nullBodyIndex
THEN {ReleaseSTB[stb]; ERROR};
ENDCASE => ERROR;

ReleaseSTB[stb];
RETURN[type]}  -- figure it out from the ep# and the prog section
ELSE RETURN[TVType[s.procTV]];
statement => ERROR AMTypes.Error[reason: notImplemented];
ENDCASE => ERROR
};

SectionVersion: PUBLIC PROC [section: Section] RETURNS [BcdDefs.VersionStamp] = {
WITH s: section SELECT FROM
model => RETURN[s.versionStamp];
prog => RETURN[s.versionStamp];
interface => RETURN[s.versionStamp];
proc => RETURN[s.prog.versionStamp];
statement => RETURN[s.prog.versionStamp];
ENDCASE => ERROR;
};


BcdNameToRope: PROC [bcd: BcdDefs.BcdBase, n: BcdDefs.NameRecord] RETURNS [ROPE] =  {
ssb: BcdDefs.NameString = LOOPHOLE[bcd + bcd.ssOffset];
ssd: ConvertUnsafe.SubString _ [base: @ssb.string, offset: n, length: ssb.size[n]];
RETURN[ConvertUnsafe.SubStringToRope[ssd]]};

ProcToInfo: PROC [proc: REF proc SectionObj] RETURNS [fgi: FGIndex _ FGNull, firstCI, lastCI: INT _ 0] = {
localBCD: BOOL _ FALSE;
remoteBCD: BOOL _ FALSE;
versionBCD: BOOL _ FALSE;
bcd: BcdDefs.BcdBase;
ptv: TV = proc.prog.someGFHTV;
stb: SymbolTableBase;
IF ptv = NIL  -- proc not loaded
THEN {
bcd _ RTSymbolsPrivate.AcquireBCDFromVersion [
versionStamp: proc.prog.versionStamp,
shortFileNameHint: Rope.Concat[proc.prog.moduleName, ".bcd"]];
versionBCD _ TRUE}
ELSE IF GetWorld[ptv] = LocalWorld[]
THEN {bcd _ GetLocalBCD[GFHFromTV[ptv]]; localBCD _ TRUE}
ELSE { bcd _ GetRemoteBCD[RemoteGFHFromTV[ptv]]; remoteBCD _ TRUE};
{ ENABLE UNWIND => IF versionBCD
THEN RTSymbolsPrivate.ReleaseBCD[bcd]
ELSE IF remoteBCD THEN ReleaseRemoteBCD[bcd];
stb _ GetModuleSTB[bcd, proc.prog.versionStamp];
};  -- end ENABLE UNWIND => RTSymbolsPrivate.ReleaseBCD[bcd];
{ ENABLE UNWIND => ReleaseSTB[stb];
IF versionBCD
THEN RTSymbolsPrivate.ReleaseBCD[bcd]
ELSE IF remoteBCD THEN ReleaseRemoteBCD[bcd];
fgi _ EPIToFirstFGI[stb, proc.entryPointIndex, TRUE];
firstCI _ FGIToFirstChar[stb, EPIToFirstFGI[stb, proc.entryPointIndex, TRUE]];
lastCI _ FGIToLastChar[stb, EPIToLastFGI[stb, proc.entryPointIndex]];
IF lastCI = firstCI THEN lastCI _ lastCI - 1;
};  -- end  ENABLE UNWIND => ReleaseSTB[stb];
ReleaseSTB[stb];
};

StatementToInfo: PROC [statement: REF statement SectionObj] RETURNS [epi: EPI _ 0, fgi: FGIndex _ FGNull, nextFgi: FGIndex _ FGNull, firstCI: INT _ 0, lastCI: INT _ 0] = {
localBCD: BOOL _ FALSE;
remoteBCD: BOOL _ FALSE;
versionBCD: BOOL _ FALSE;
bcd: BcdDefs.BcdBase;
ptv: TV = statement.prog.someGFHTV;
stb: SymbolTableBase;
IF ptv = NIL  -- statement not loaded
THEN {
bcd _ RTSymbolsPrivate.AcquireBCDFromVersion [
versionStamp: statement.prog.versionStamp,
shortFileNameHint: Rope.Concat[statement.prog.moduleName, ".bcd"]];
versionBCD _ TRUE}
ELSE IF GetWorld[ptv] = LocalWorld[]
THEN {bcd _ GetLocalBCD[GFHFromTV[ptv]]; localBCD _ TRUE}
ELSE { bcd _ GetRemoteBCD[RemoteGFHFromTV[ptv]]; remoteBCD _ TRUE};
{ ENABLE UNWIND => IF versionBCD
THEN RTSymbolsPrivate.ReleaseBCD[bcd]
ELSE IF remoteBCD THEN ReleaseRemoteBCD[bcd];
stb _ GetModuleSTB[bcd, statement.prog.versionStamp];
};  -- end ENABLE UNWIND => RTSymbolsPrivate.ReleaseBCD[bcd];
{ ENABLE UNWIND => ReleaseSTB[stb];
IF versionBCD
THEN RTSymbolsPrivate.ReleaseBCD[bcd]
ELSE IF remoteBCD THEN ReleaseRemoteBCD[bcd];
fgi _ statement.fgtIndex;
epi _ FGIToEPI[stb, fgi];
nextFgi _ NextFGI[stb, fgi, epi];
firstCI _ FGIToFirstChar[stb, statement.fgtIndex];
lastCI _ FGIToLastChar[stb, statement.fgtIndex];
IF lastCI = firstCI THEN lastCI _ lastCI - 1;
};  -- end  ENABLE UNWIND => ReleaseSTB[stb];
ReleaseSTB[stb];
};

STB2Source: PROC [stb: SymbolTableBase] RETURNS [nr: ROPE] = {
RETURN [ConvertUnsafe.ToRope[
WITH stb SELECT FROM
t: SymbolTableBase.x =>
@LOOPHOLE [
t.e.stHandle + t.e.stHandle.fgRelPgBase*wordsPerPage,
LONG POINTER TO bx.FineGrainTableHeader].sourceFile,
t: SymbolTableBase.y =>
@LOOPHOLE [
t.e.stHandle + t.e.stHandle.fgRelPgBase*wordsPerPage,
LONG POINTER TO by.FineGrainTableHeader].sourceFile,
ENDCASE => ERROR
]];
};

}.



ζAMModelSectionImpl.mesa
Copyright c 1985 by Xerox Corporation.  All rights reserved.
Rovner, August 10, 1983 12:45 pm
Russ Atkinson (RRA) February 12, 1985 1:36:00 am PST
TYPEs
either binder output bundle for a config, or compiler output bundle
for a prog module, DEFs module, proc, or statement
PROCs dealing with Sections
param to creator of section.
loaded model section
model section, not loaded. Get the binder output bcd, given the config name and its version stamp
get the compiler output bcd, given the module name and its version stamp. Could poke around in the loadstate, but painful.
unloaded prog section
loaded prog section; get the bcd from the loadstate
remote world
get the compiler output bcd, given the module name and its version stamp.
unloaded proc section
loaded proc section; get the bcd from the loadstate
remote world
unloaded proc section
loaded proc section; get the bcd from the loadstate
remote world
param to creator of section.
(DIRECTORY entries)
Implemented only for model, prog and interface sections
containers:
prog module for a proc
proc for a statement
parts: modules of a model, procs of a module, statements of a proc
parts: modules of a model, procs of a module, statements of a proc
section has a local configContext
section has a remote configContext
here if model section is not loaded; get the binder output bcd, given the config name and its version stamp
parts: modules of a model, procs of a module, statements of a proc
NextSiblingSection will never get a child that represents a loadstate entry
for children that are progs, indexInParent # 0 means use it to pass over previous modules
returns NIL if nomore
the sections are loaded
NextSiblingSection, prog child, the sections are loaded, remote world
NextSiblingSection, prog child, not loaded
get the binder output bcd, given the config name and version stamp
Implemented only for proc sections
Private utilities
[prog module bcd, entryPointIndex] => FGIndex
[prog module bcd, FGIndex] => entryPointIndex (maybe 0)
Κγ˜
codeš
œ™Kšœ
Οm
œ1™<Kš
œ ™ K™4—K˜š
Οk	˜	Kšœ	žœ‡
˜•
Kšœžœ˜"Kšœžœ'˜4Kšœžœžœ
˜Ί
Kšœžœžœ˜,KšœžœQ˜^Kšœžœ˜KšœžœQ˜gKšœžœQ˜gKšœžœ&˜9Kšžœ
žœ˜Kšœ
žœc˜rKšœ	žœ#˜1Kšœžœžœ
˜Kšœ
žœ&˜8Kšœžœ.˜?Kšœ
žœ+˜:Kšœžœ%˜;Kšœžœ&˜@Kšœžœ˜Kšœžœ˜KšœžœO˜\K˜—šœž˜KšžœGžœZ˜«
Kšžœ˜KšœžœΊ
˜Β
K˜K˜—Kš
œ™˜Kš
œC™CKš
œ2™2Kšœ	žœžœ˜Kšœžœ
žœ˜%K˜—Kš
œ™˜šΟnœžœ
žœžœ˜@Kšžœ˜Kš
œ˜K˜—šŸœžœ
žœžœžœžœ˜Išžœžœ
ž˜Kšœ	žœ˜Kšœžœ˜Kšœ
žœ˜$šœžœž˜Kšžœ
žœ˜šžœ˜š
œ*˜*Kš
œ˜Kš
œ1˜1Kš
œ˜—K˜'š
Ÿ	œžœžœžœžœ˜GKšœžœ˜<šžœžœ
ž˜ šœžœžœ!˜=Kšžœ3žœ
žœ˜F—Kšžœ˜	——š
Ÿ	œžœžœžœžœ˜GKšœžœ˜<šžœžœ
ž˜ šœžœžœ!˜=Kšžœ3žœ
žœ˜F—Kšžœ˜	K˜—šžœžœ
ž˜˜šžœ0˜2Kšœžœ'˜/Kšžœžœ˜——˜šžœ0˜2Kšœžœ'˜/Kšžœžœ˜——Kšžœžœ
˜——K˜Kšžœ	Οc2˜A——šœ
žœ1˜DKšžœžœ˜%—Kšžœž˜—K˜K˜—šŸ
œžœ
žœžœ˜GKš
œ™šžœžœ
ž˜š
œ
˜
Kšœžœžœ
˜K˜šžœž˜šžœ˜Kš
œ™šžœ%˜'šžœ˜K˜K˜šœžœ
žœ˜-K˜BKšœ 2˜6—K˜Kš
œ&˜&K˜K˜
—šžœ˜K˜%K˜šœžœ
žœ˜!K˜/K˜šœžœ
žœ˜˜(K˜
K˜'K˜4—Kšžœžœ
žœ
žœ"˜9šœžœ
žœ˜)Kš
œ&˜&K˜Kšœ .˜2—K˜Kšœ $˜(—K˜Kšœ &˜*—K˜K˜
—K˜
——šžœ˜Kš
œa™a˜?K˜K˜6—Kšžœžœ
žœ
žœ"˜9Kš
œ&˜&K˜K˜!K˜——Kšœžœ[˜dK˜—š
œ	˜	Kš
œz™zKšœžœžœ
˜K˜šžœž˜šžœ˜Kš
œ™˜?K˜K˜6—Kšžœžœ
žœ
žœ"˜9Kš
œ&˜&K˜K˜!—šžœ˜Kš
œ3™3Kšœžœ˜K˜šžœ˜šžœ˜K˜3K˜9šœžœ
žœ˜#Kš
œ˜Kš
œ ˜ Kšœ '˜+—K˜K˜
—šžœ˜Kš
œ™K˜:šœžœ
žœ˜)K˜9šœžœ
žœ˜#Kš
œ˜Kš
œ ˜ Kšœ '˜+—K˜Kšœ '˜+—K˜K˜
——K˜——KšœžœZ˜cK˜—š
œ˜Kš
œI™I˜?K˜K˜6—Kšžœžœ
žœ
žœ"˜9šœžœ7˜@K˜K˜ K˜—K˜!K˜—š
œ	˜	Kšœžœžœ
˜-Kšœžœ
˜	Kšœžœ
˜	Kšœžœžœ
˜K˜Kš
œ0˜0šžœž˜šžœ˜š
œ?˜?Kš
œ"˜"K˜;—Kš
œ™Kšžœžœ
žœ
žœ"˜9Kš
œ&˜&K˜K˜!—šžœ˜Kš
œ3™3Kšœžœ˜K˜šžœ˜šžœ˜Kš
œ3˜3K˜>šœžœ
žœ˜#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š
œ5˜5šžœž˜šžœ˜Kš
œ™˜?K˜"K˜;—Kšžœžœ
žœ
žœ"˜9Kš
œ&˜&K˜K˜!—šžœ˜Kš
œ3™3Kšœžœ˜K˜šžœ˜šžœ˜Kš
œ3˜3K˜>šœžœ
žœ˜#Kš
œ˜Kš
œ ˜ Kšœ '˜+—K˜K˜
—šžœ˜Kš
œ™K˜:šœžœ
žœ˜)K˜>šœžœ
žœ˜#Kš
œ˜Kš
œ ˜ Kšœ '˜+—K˜Kšœ '˜+—K˜K˜
——K˜——Kšœžœ…
˜Ž
K˜—Kšžœž˜—Kš
œ˜K˜—šŸ
œžœ
žœžœžœ
žœžœ˜`Kš
œ™Kš
œ™Kš
œ7™7šžœžœ
ž˜Kšœ	žœ '˜8Kšœžœ )˜9Kšœ
žœ )˜>Kšœžœ*˜7Kšœ
žœ'˜9Kšžœž˜—K˜K˜—šŸ
œžœ
žœžœ˜Cš
œ™Kš
œ™Kš
œ™—šžœžœ
ž˜Kšœžœ˜šœ
žœ
žœ!˜8Kšœ!žœ˜;—Kšžœžœ'˜7—Kšœ ˜˜Kš
œB™B——šŸœžœ
žœžœžœžœžœž œ˜‘
Kšœžœ˜šŸœžœžœžœ˜IKš
œM˜MK˜—šžœA˜DKšžœžœ
žœ
žœ	žœ
žœžœ
˜4—K˜˜Kš
œB™B——šŸœžœžœ˜Ešžœžœ
ž˜šœžœž˜#šžœ˜šžœ%˜'šžœ˜Kš
œ!™!Kš
œ˜K˜K˜šœžœ.˜5Kšžœžœžœ
žœ˜ K˜—K˜K˜Bšžœž˜šžœ˜ Kšžœ#˜(——Kšœžœ˜#K˜(šœž˜	˜˜1K˜$˜
š
ž˜˜˜$K˜&—K˜
—K˜
——K˜
K˜
——K˜—K˜Kšžœ
˜K˜
—šžœ˜Kš
œ"™"Kš
œ%˜%K˜5Kšœžœ
˜K˜K˜K˜K˜šœžœ
žœ˜!K˜5K˜K˜6K˜šœžœ
žœ˜&˜˜K˜
K˜'K˜"——Kšžœžœ
žœ
žœ"˜9šœžœ
žœ˜)Kšœžœ˜/šœžœ.˜5Kšžœžœžœ
žœ˜ —K˜:K˜K˜*K˜
Kšœ -˜1—K˜K˜,Kšœ *˜.—K˜šœžœ˜˜K˜KšœžœKžœ	˜mKš
œ˜——Kšœ &˜*—K˜Kšžœ
˜K˜
——K˜
—šžœ˜Kš
œk™k˜?K˜K˜6—K˜K˜šœžœ.žœžœ˜KKšžœ
žœ˜K˜—Kšžœžœ
žœ
žœ"˜9Kšœžœ˜#K˜K˜(šœžœ-˜6K˜K˜$Kšœžœ˜—K˜!—K˜—š
œ˜Kš	žœ
žœžœ
žœ, ˜—Kšœ
žœ
žœ˜K˜š	œžœ
žœ;ž
œ
žœ˜hK˜—Kšœ
žœ
žœ˜Kšžœž˜—Kšœ ˜K˜—šŸœžœ)žœžœžœžœ	˜…
Kš
œB™BKš
œK™KKš
œY™YKš
œ™Kš
žœ
žœ
žœ
žœ
žœ˜!šžœ
žœ
ž˜Kšœ	žœ'˜5š
œ	˜	Kšœžœžœ
˜Kšœžœ
˜K˜š
Ÿœžœ.žœžœžœ˜cK˜(Kšžœžœ
žœ
žœ˜%šžœžœ#˜;Kšžœ'˜*Kšžœžœ
˜—K˜K˜—šžœž˜šžœ˜Kš
œ™Kš
œ%˜%šžœ˜šžœ˜Kšœžœ
˜K˜K˜K˜šœžœ
žœ˜-˜˜%K˜ ——K˜-Kšœžœ˜#K˜5šžœž˜Kš
œ;˜;—Kšœ /˜3—K˜šžœž˜šœžœ˜˜1K˜$Kšœžœ˜-——K˜
——šžœ˜Kš
œE™EK˜šœžœ
žœ˜!K˜Kšœžœ
˜K˜;K˜/K˜šœžœ
žœ˜˜2Kšœ
žœ+˜4—K˜BKšžœžœ
žœ
žœ
˜Kšœžœ˜#šœžœ
žœ˜)˜K˜1—šžœž˜šžœ˜K˜)K˜K˜*Kšœ*žœ˜:——Kšœ +˜/—K˜Kšœ !˜%—K˜šžœ"ž˜)šœžœ˜˜K˜Kšœ
žœ#˜4———Kšœ #˜'—Kšœ ˜——Kšœ )˜,šžœ˜Kš
 *™*Kš
œB™BKšœžœžœ	˜)K˜˜?K˜K˜6—Kšžœžœ
žœ
žœ"˜9šœžœ
žœ&˜5Kšœžœ˜#K˜5šžœžœžœ˜&˜1K˜$Kšœžœ˜——Kšœ :˜>—K˜!Kšœ ,˜1————Kšœ
žœ)˜;˜	˜*K˜K˜1K˜—K˜'Kšœžœ˜š
Ÿœžœžœžœžœ˜Bšžœ
žœ#žœ
ž˜9Kšœžœ	žœ	žœ˜;Kšžœ˜	——š
Ÿœžœžœžœžœ˜Bšžœ
žœ#žœ
ž˜9Kšœžœ	žœ	žœ˜;Kšžœ˜	——šžœžœ
ž˜K˜LK˜LKšžœžœ
˜—šžœ˜Kšžœž˜šžœžœ
˜šœžœ	žœ˜0K˜*———Kšœ ,˜?—š
œ˜Kšœ#žœžœ ˜Tšžœ˜Kšžœ
žœ
žœ
˜šžœ
žœ
žœ
˜Kšœžœžœ.˜Q——Kšœ 1˜5—Kšžœž˜—Kšœ ˜K˜K˜—šŸœžœ
žœžœ˜PKš
œ"™"šžœžœ
ž˜Kšœ	žœ'˜5Kšœžœ)˜6Kšœ
žœC˜Všœžœž˜šžœ˜š
œ˜˜K˜K˜1K˜——K˜'š
Ÿ	œžœžœžœžœ˜Gšžœžœ#žœ
ž˜<šœžœžœ!˜=šžœ)˜-Kšžœ
žœ˜——Kšžœ˜	——š
Ÿ	œžœžœžœžœ˜Gšžœžœ#žœ
ž˜<šœžœžœ!˜=šžœ)˜-Kšžœ
žœ˜——Kšžœ˜	K˜——šžœžœ
ž˜˜šžœ0˜2Kšœžœ'˜/Kšžœžœ˜——˜šžœ0˜2Kšœžœ'˜/Kšžœžœ˜——Kšžœžœ
˜K˜—K˜Kšžœ	 2˜A—Kšžœ
žœ˜—Kšœ
žœ'˜9Kšžœž˜—K˜K˜—šŸœžœ
žœžœ˜Qšžœžœ
ž˜Kšœ	žœ˜ Kšœžœ˜Kšœ
žœ˜$Kšœžœ˜$Kšœ
žœ˜)Kšžœžœ
˜—K˜K˜——š
œ™K˜šŸ
œžœ/žœžœ˜UKšœžœ˜7K˜SKšžœ&˜,K˜—š
Ÿ
œžœžœžœ*žœ	˜jKš
œ-™-Kšœ
žœžœ
˜Kšœžœžœ
˜Kšœžœžœ
˜K˜Kšœžœ˜K˜šžœžœ ˜ šžœ˜š
œ.˜.Kš
œ%˜%K˜>—Kšœ
žœ
˜—Kšžœ
žœ˜$Kšžœ0žœ
˜9Kšžœ9žœ˜C—šœžœ
žœžœ˜ Kšžœ!˜%Kšžœ
žœžœ˜-K˜0Kšœ 9˜=—šœžœ
žœ˜#šžœ˜
Kšžœ!˜%Kšžœ
žœžœ˜-—Kšœ/žœ˜5KšœGžœ˜NKš
œE˜EKšžœžœ˜-Kšœ )˜-—K˜K˜K˜—šŸœžœ
žœžœžœAžœžœ	˜«
Kš
œ7™7Kšœ
žœžœ
˜Kšœžœžœ
˜Kšœžœžœ
˜K˜Kšœžœ˜#K˜šžœžœ ˜%šžœ˜š
œ.˜.Kš
œ*˜*K˜C—Kšœ
žœ
˜—Kšžœ
žœ˜$Kšžœ0žœ
˜9Kšžœ9žœ˜C—šœžœ
žœžœ˜ Kšžœ!˜%Kšžœ
žœžœ˜-K˜5Kšœ 9˜=—šœžœ
žœ˜#šžœ˜
Kšžœ!˜%Kšžœ
žœžœ˜-—Kš
œ˜Kš
œ˜Kš
œ!˜!Kš
œ2˜2Kš
œ0˜0Kšžœžœ˜-Kšœ )˜-—K˜K˜K˜—šŸ
œžœžœžœ˜>šžœ˜šžœžœ
ž˜˜šœ
žœ˜Kš
œ5˜5Kšžœ
žœ
žœ%˜4——˜šœ
žœ˜Kš
œ5˜5Kšžœ
žœ
žœ%˜4——Kšžœž˜—K˜—K˜K˜——K˜K˜K˜K˜—…—_h1