DIRECTORY
AMBridge USING [TVForGFHReferent, GFHFromTV, TVToProc, FHFromTV, ContextPC, GetWorld, RemoteGlobalFrameHandle, IsRemote, RemoteGFHFromTV, RemoteFHFromTV, TVToRemoteProc, GetWorldIncarnation, nilRemoteGlobalFrameHandle, TVForRemoteGFHReferent, RemotePD],
AMMiniModel USING [GetInterfaceRecordFromType, GetInterfaceRecordNames, GetInterfaceRecord],
AMModel USING [Class, Context, PartialInterfaceInstance],
AMModelPrivate USING [FGIndex, FGNull, EPI, PCToFGI, SectionRec, RefTVRec, ConfigContext, ConfigContextObj, StatementContext, StatementContextObj, GetLocalBCD, GetRemoteBCD],
AMTypes USING [GlobalParent, Procedure, TVType, Error, TVToName, TypeToName, TV],
BcdDefs USING [NullVersion, VersionStamp, MTIndex, FTSelf, NameRecord, IMPIndex, EXPIndex, CTIndex, CTNull, BcdBase, MTHandle, NameString, IMPHandle, EXPHandle, CTHandle],
BcdOps USING [ProcessModules, ProcessImports, ProcessExports, ProcessConfigs],
ConvertUnsafe USING [SubString, SubStringToRope],
IO USING [PutFR],
LoadState USING [Acquire, local, ConfigInfo, Release, Handle, nullConfig, GetChangeCount, GlobalFrameToModule, ConfigID, ModuleIndex, EnumerateAllModules, ModuleToGlobalFrame, EnumerateModulesInConfig, EnumerateConfigs, nullModule, CopiesList, ModuleInfo],
PrincOps USING [GlobalFrameHandle, BytePC],
PrincOpsUtils USING [GlobalFrameAndEntryPoint],
RemotePrincOpsUtils USING [RemoteGlobalFrameAndEntryPoint],
Rope USING [ROPE, Concat, Substr, SkipTo, Index, Length, Match, Cat],
RTSymbolDefs USING [SymbolTableBase, SymbolTableHandle, SymbolIndex, SymbolIdIndex, SymbolConstructorIndex],
RTSymbolOps USING [EnumerateCtxIseis, STBToModuleName, AcquireType, SEUnderType, STBDirectoryCtx, ISEPublic, ISEType],
RTSymbols USING [GetTypeSymbols, AcquireSTB, ReleaseSTB, AcquireSTBFromSGI, AcquireSTBFromGFH, GetSTHForModule],
RTSymbolsPrivate USING [AcquireBCDFromVersion, ReleaseBCD],
RTTypesPrivate USING [GetEp],
RTTypesRemotePrivate USING [AcquireRemoteBCD, GetRemoteEp, AcquireSTBFromRemoteGFH, ReleaseRemoteBCD],
SafeStorage USING [Type, fhType, gfhType],
Table USING [Base],
WorldVM USING [LocalWorld, World, WorldName, CurrentIncarnation, Lock, Unlock, Loadstate, Incarnation, Read, Address];

AMModelContextImpl: MONITOR  -- protects WorldGFNameLists
IMPORTS AMBridge, AMModelPrivate, AMTypes, BcdOps, IO, ConvertUnsafe, LoadState, PrincOpsUtils, RemotePrincOpsUtils, Rope, AMMiniModel, RTSymbolOps, RTSymbols, RTSymbolsPrivate, RTTypesPrivate, RTTypesRemotePrivate, WorldVM
EXPORTS AMModel, AMModelPrivate
= { OPEN AMBridge, AMMiniModel, AMModel, AMModelPrivate, AMTypes, PrincOps, RemotePrincOpsUtils, Rope, RTSymbolDefs, RTSymbolOps, RTSymbols, RTTypesPrivate, RTTypesRemotePrivate, SafeStorage, WorldVM;
Section: TYPE = REF SectionObj;
SectionObj: PUBLIC TYPE = SectionRec;
WorldGFNameList: TYPE = LIST OF WorldGFNames;
WorldGFNames: TYPE = REF WorldGFNameListRec;
WorldGFNameListRec: TYPE = RECORD[
world: World,
incarnation: Incarnation,
loadStateChangeCount: INT,
gfList: LIST OF GFContextRec];
GFContextRec: TYPE = RECORD[name: ROPE, context: Context];
worldGFNameList: WorldGFNameList _ NIL;

RootContext: PUBLIC PROC [world: World] RETURNS [Context] = {
IF world = NIL THEN world _ WorldVM.LocalWorld[];
RETURN[NEW[ConfigContextObj
_ [world: world,
 worldIncarnation: CurrentIncarnation[world],
 configIndex: LoadState.nullConfig]]];
};

ContextClass: PUBLIC PROC [context: Context] RETURNS [Class] = {
WITH context SELECT FROM
sc: StatementContext => RETURN[statement];
mc: ConfigContext =>
IF mc.configIndex = LoadState.nullConfig
THEN RETURN[world]
ELSE RETURN[model];
tv: RefTVRec => {
SELECT TVType[tv] FROM
gfhType => RETURN[prog];
fhType => RETURN[proc];
ENDCASE => RETURN[interface];
};
ENDCASE => ERROR AMTypes.Error[reason: notImplemented];
};

ContextWorld: PUBLIC PROC [context: Context] RETURNS [World] = {
WITH context SELECT FROM
sc: StatementContext => RETURN[GetWorld[sc.localFrameTV]];
cc: ConfigContext => RETURN[cc.world];
ENDCASE => RETURN[GetWorld[context]];
};
ContextName: PUBLIC PROC [context: Context] RETURNS [ans: ROPE _ NIL] = {
IF context = NIL THEN RETURN[NIL];
WITH context SELECT FROM
sc: StatementContext => {
ans _ IO.PutFR["%g:FGT#%g",
[rope[ContextName[sc.localFrameTV]]],
[cardinal[NARROW[ContextSection[context], REF statement SectionObj].fgtIndex.fgCard]]];
};
tv: RefTVRec => {
SELECT TVType[tv] FROM
gfhType => {
gfhBits: CARDINAL =
IF GetWorld[tv] # LocalWorld[]
THEN LOOPHOLE[RemoteGFHFromTV[tv].gfh, CARDINAL]
ELSE LOOPHOLE[GFHFromTV[tv], CARDINAL];
ans _ TVToName[tv ! AMTypes.Error => CONTINUE];
ans _ IO.PutFR["%g:gfh#%b", [rope[ans]], [cardinal[gfhBits]]];
};
fhType => {
fhBits: CARDINAL =
IF GetWorld[tv] # LocalWorld[]
THEN LOOPHOLE[RemoteFHFromTV[tv].fh, CARDINAL]
ELSE LOOPHOLE[FHFromTV[tv], CARDINAL];
ans _ TVToName[Procedure[tv ! AMTypes.Error => CONTINUE]
! AMTypes.Error => CONTINUE]; 
ans _ IO.PutFR["%g:fh#%b", [rope[ans]], [cardinal[fhBits]]];
};
ENDCASE => {
ans _ Cat["Interface:", TypeToName[TVType[tv]]];
};  -- assume an IR
IF GetWorld[tv] # LocalWorld[] THEN
ans _ Cat[ans, ",world:", WorldName[GetWorld[tv]]];
};
mc: ConfigContext =>
IF mc.configIndex = LoadState.nullConfig
THEN ans _ Rope.Cat["World:", WorldName[mc.world]]
ELSE {
FindRootConfig: PROC [cth: BcdDefs.CTHandle, cti: BcdDefs.CTIndex] RETURNS [stop: BOOL _ FALSE] = {
IF cth.config = BcdDefs.CTNull THEN RETURN[TRUE];
};
IF mc.world = LocalWorld[]
THEN {
bcd: BcdDefs.BcdBase;
ctHandle: BcdDefs.CTHandle;
LoadState.local.Acquire[];
bcd _ LoadState.local.ConfigInfo[mc.configIndex
! UNWIND => LoadState.local.Release[]].bcd;
LoadState.local.Release[];
IF bcd = NIL THEN ERROR;
[ctHandle,] _ BcdOps.ProcessConfigs[bcd, FindRootConfig];
ans _ IO.PutFR[
"%g:ConfigIndex#%g",
[rope[BcdNameToRope[bcd, ctHandle.name]]],
[cardinal[LOOPHOLE[mc.configIndex, CARDINAL]]]
];
}
ELSE {
bcd: BcdDefs.BcdBase;
ctHandle: BcdDefs.CTHandle;
Lock[mc.world];
{ ENABLE UNWIND => Unlock[mc.world];
h: LoadState.Handle = WorldVM.Loadstate[mc.world];
h.Acquire[];
{ ENABLE UNWIND => h.Release[];
bcd _ AcquireRemoteBCD
[mc.world, mc.worldIncarnation, h.ConfigInfo[mc.configIndex].bcd];
};
h.Release[];
};
Unlock[mc.world];
IF bcd = NIL THEN ERROR;
{ ENABLE UNWIND => ReleaseRemoteBCD[bcd];
[ctHandle,] _ BcdOps.ProcessConfigs[bcd, FindRootConfig];
ans _ IO.PutFR["%g:ConfigIndex#%g,world:%g",
[rope[BcdNameToRope[bcd, ctHandle.name]]],
[cardinal[LOOPHOLE[mc.configIndex, CARDINAL]]],
[rope[WorldName[mc.world]]] ];
};
ReleaseRemoteBCD[bcd];
};
};  -- end ELSE arm (mc.configIndex # LoadState.nullConfig)
ENDCASE => ERROR AMTypes.Error[reason: notImplemented];
};
MostRecentNamedContext: PUBLIC PROC [name: ROPE, context: --world or model-- Context] RETURNS [ans: Context _ NIL] = {
WITH context SELECT FROM
mc: ConfigContext => {
IF mc.configIndex = LoadState.nullConfig  -- the model of a world
THEN {
p: PROC [name: ROPE, gf: TV] RETURNS [stop: BOOL _ TRUE] = {NULL};
ans _ FindMatchingGlobalFrames[ContextWorld[context], name, p];
IF ans # NIL THEN RETURN;
};
{
p: PROC [c: Context] RETURNS [stop: BOOL _ FALSE] = {
n: ROPE = ContextName[c];
len: INT _ Rope.Index[s1: n, s2: ":"];
nPart: ROPE _ IF len = Rope.Length[n] THEN n ELSE Rope.Substr[base: n, len: len];
IF name.Match[nPart, FALSE] THEN {ans _ c; stop _ TRUE};
};
[] _ ContextChildren[context, p];
};
};
ENDCASE =>
ERROR AMTypes.Error
[reason: notImplemented,
 msg: "MostRecentNamedContext for other than a world or model Context"];
};
LoadStateChangeCount: INTERNAL PROC [world: World] RETURNS [ans: INT] = {
h: LoadState.Handle = WorldVM.Loadstate[world];
h.Acquire[];
ans _ LoadState.GetChangeCount[h];
h.Release[];
};

FindWorldGFNames: INTERNAL PROC [world: World] RETURNS [WorldGFNames] = {
FOR wgfnl: WorldGFNameList _ worldGFNameList, wgfnl.rest UNTIL wgfnl = NIL
DO
IF world = wgfnl.first.world
THEN {
IF (CurrentIncarnation[world] # wgfnl.first.incarnation)
OR (LoadStateChangeCount[world] # wgfnl.first.loadStateChangeCount)
THEN {
wgfnl.first.gfList _ NIL;
wgfnl.first.incarnation _ CurrentIncarnation[world];
wgfnl.first.loadStateChangeCount _ LoadStateChangeCount[world];
};
RETURN[wgfnl.first];
};
ENDLOOP;
worldGFNameList _ CONS[NEW[WorldGFNameListRec
_ [world: world,
 incarnation: CurrentIncarnation[world],
 loadStateChangeCount: LoadStateChangeCount[world],
 gfList: NIL]],
worldGFNameList];
RETURN[worldGFNameList.first];
};

FindMatchingGlobalFrames: PUBLIC ENTRY PROC [ world: World, name: ROPE, proc: PROC [ROPE, Context] RETURNS [--stop:-- BOOL] ] RETURNS [ans: Context _ NIL] = {
ENABLE UNWIND => NULL;
gfNames: WorldGFNames;
WorldVM.Lock[world];
{ ENABLE UNWIND => WorldVM.Unlock[world];
gfNames _ FindWorldGFNames[world];
IF gfNames.gfList = NIL THEN {
h: LoadState.Handle = WorldVM.Loadstate[world];
p: PROC [ci: LoadState.ConfigID, mx: LoadState.ModuleIndex]
RETURNS [stop: BOOL _ FALSE] = {
rgfh: RemoteGlobalFrameHandle
= [world: world,
worldIncarnation: CurrentIncarnation[world],
gfh: LOOPHOLE[h.ModuleToGlobalFrame[ci, mx]]];
gfNames.gfList
_ CONS[[name: NIL, context: TVForRemoteGFHReferent[rgfh]], gfNames.gfList];
};
h.Acquire[];
[] _ h.EnumerateAllModules[oldestFirst, p ! UNWIND => h.Release[]];
h.Release[];
};
};  -- ENABLE UNWIND => WorldVM.Unlock[world];
WorldVM.Unlock[world];
FOR gfList: LIST OF GFContextRec _ gfNames.gfList, gfList.rest UNTIL gfList = NIL DO
IF gfList.first.name = NIL THEN
gfList.first.name _ AMTypes.TVToName[gfList.first.context];
IF name.Match[gfList.first.name, FALSE]
AND proc[gfList.first.name, gfList.first.context
! AMTypes.Error => LOOP]
THEN RETURN[gfList.first.context];
ENDLOOP;
};

NamedContexts: PUBLIC PROC [name: ROPE, context: Context, proc: PROC [Context] RETURNS [stop: BOOL]] RETURNS [ans: Context _ NIL] = {
lookForNamedContext: PROC [c: Context] RETURNS [stop: BOOL _ FALSE] = {
n: ROPE = ContextName[c];
len: INT _ Rope.Index[s1: n, s2: ":"];
nPart: ROPE _ IF len = Rope.Length[n] THEN n ELSE Rope.Substr[base: n, len: len];
IF name.Match[nPart, FALSE]  --Rope.Equal[name, nPart]
THEN {stop _ proc[c]; IF stop THEN ans _ c}
ELSE
SELECT ContextClass[c] FROM
model => {ans _ NamedContexts[name, c, proc]; IF ans # NIL THEN stop _ TRUE};
ENDCASE;
};
[] _ ContextChildren[context, lookForNamedContext];
};
ContextSection: PUBLIC PROC [context: Context] RETURNS [ans: Section _ NIL] = {
WITH context SELECT FROM
sc: StatementContext => {
parentContext: Context _ ParentContext[context];
UNTIL ContextClass[parentContext] = prog
DO parentContext _ ParentContext[parentContext]; ENDLOOP;
RETURN[NEW[SectionObj
_ [statement[prog: NARROW[ContextSection[parentContext], REF prog SectionObj],
			fgtIndex: StatementContextToFGI[sc]]]]];
};
tv: RefTVRec => {
SELECT TVType[tv] FROM
gfhType =>  -- program module
RETURN[NEW[SectionObj
_ [prog
[moduleName: TVToName[tv],
 versionStamp: IF IsRemote[tv]
THEN RemoteGFHToVersionStamp[RemoteGFHFromTV[tv]]
ELSE GFHToVersionStamp[GFHFromTV[tv]],
 someGFHTV: tv]]]];
fhType => {
procTV: RefTVRec = NARROW[Procedure[tv]];  -- procedure
ep: CARDINAL;
IF IsRemote[procTV] THEN {
rpd: AMBridge.RemotePD = AMBridge.TVToRemoteProc[procTV];
ep _ RemoteGlobalFrameAndEntryPoint[rpd.world, rpd.pd].ep;
}
ELSE ep _ PrincOpsUtils.GlobalFrameAndEntryPoint[ LOOPHOLE[TVToProc[procTV]]].ep;
RETURN[NEW[SectionObj
_ [proc[prog: NARROW[ContextSection[GlobalParent[tv]]],
	   entryPointIndex: ep,
	   procTV: procTV]]]];
};
ENDCASE => { -- better be a TV for an interface record
type: Type = TVType[tv];
stb: SymbolTableBase;
sei: SymbolIndex;
mn: ROPE;
vs: BcdDefs.VersionStamp;
[stb, sei] _ GetTypeSymbols[type];
{ ENABLE UNWIND => ReleaseSTB[stb];
csei: SymbolConstructorIndex = SEUnderType[stb, sei];
WITH stb SELECT FROM
t: SymbolTableBase.x =>
WITH ser: t.e.seb[NARROW[csei, SymbolConstructorIndex.x].e] SELECT FROM
definition => vs _ t.e.stHandle.version;
ENDCASE => ERROR;
t: SymbolTableBase.y =>
WITH ser: t.e.seb[NARROW[csei, SymbolConstructorIndex.y].e] SELECT FROM
definition => vs _ t.e.stHandle.version;
ENDCASE => ERROR;
ENDCASE => ERROR;
mn _ STBToModuleName[stb];
};
ReleaseSTB[stb];
RETURN[NEW[SectionObj _ [interface[moduleName: mn, versionStamp: vs]]]];
};
};
mc: ConfigContext =>
IF mc.world = LocalWorld[]
THEN {
bcd: BcdDefs.BcdBase;
IF mc.configIndex = LoadState.nullConfig THEN RETURN[NIL];
LoadState.local.Acquire[];
bcd _ LoadState.local.ConfigInfo[mc.configIndex
! UNWIND => LoadState.local.Release[]].bcd;
LoadState.local.Release[];
IF bcd = NIL THEN ERROR;
ans _ NEW[SectionObj _
[model[configName: StripExtension[BcdNameToRope[bcd, bcd.source]],
	  versionStamp: bcd.version,
	  configContext: mc]]];
}
ELSE {
bcd: BcdDefs.BcdBase;
IF mc.configIndex = LoadState.nullConfig THEN RETURN[NIL];
Lock[mc.world];
{ ENABLE UNWIND => Unlock[mc.world];
h: LoadState.Handle = WorldVM.Loadstate[mc.world];
h.Acquire[];
{ ENABLE UNWIND => h.Release[];
bcd _ AcquireRemoteBCD
[mc.world, mc.worldIncarnation, h.ConfigInfo[mc.configIndex].bcd];
};
h.Release[];
};
Unlock[mc.world];
IF bcd = NIL THEN ERROR;
{ ENABLE UNWIND => ReleaseRemoteBCD[bcd];
ans _ NEW[SectionObj _ [model[configName: StripExtension[BcdNameToRope[bcd, bcd.source]], versionStamp: bcd.version, configContext: mc]]];
};
ReleaseRemoteBCD[bcd];
};
ENDCASE => ERROR AMTypes.Error[reason: notImplemented];
};
ParentContext: PUBLIC PROC [context: Context] RETURNS [Context] = {
WITH context SELECT FROM
sc: StatementContext => RETURN[sc.localFrameTV];
mc: ConfigContext =>
IF mc.configIndex = LoadState.nullConfig
THEN RETURN[NIL]
ELSE  -- the loadstate has only one level of structure
RETURN[NEW[ConfigContextObj _
[world: mc.world, worldIncarnation: mc.worldIncarnation, configIndex: LoadState.nullConfig]]];
tv: RefTVRec => {
SELECT TVType[tv] FROM
gfhType => {
world: World _ GetWorld[tv];
ci: LoadState.ConfigID;
IF NOT IsRemote[tv]
THEN {
gfh: PrincOps.GlobalFrameHandle = GFHFromTV[tv];
LoadState.local.Acquire[];
ci _ LoadState.local.GlobalFrameToModule[gfh].config;
LoadState.local.Release[];
}
ELSE { -- remote case
rgfh: RemoteGlobalFrameHandle = RemoteGFHFromTV[tv];
Lock[world];
{ ENABLE UNWIND => Unlock[world];
h: LoadState.Handle _ WorldVM.Loadstate[world];
h.Acquire[];
ci _ h.GlobalFrameToModule[LOOPHOLE[rgfh.gfh]
! UNWIND => h.Release[]].config;
h.Release[];
};  -- end ENABLE UNWIND => Unlock[world];
Unlock[world];
};
RETURN[NEW[ConfigContextObj _ [
world: world,
worldIncarnation: GetWorldIncarnation[tv],
configIndex: ci]]];
};
fhType => RETURN[GlobalParent[tv]];
ENDCASE => ERROR AMTypes.Error[reason: typeFault, type: TVType[tv]];
};
ENDCASE => ERROR AMTypes.Error[reason: notImplemented];
};
ContextChildren: PUBLIC PROC [context: Context, proc: PROC [Context] RETURNS [stop: BOOL]] RETURNS [ans: Context _ NIL--NIL if not stopped--] = {
FOR c: Context _ FirstChildContext[context], NextSiblingContext[c]
UNTIL c = NIL DO IF proc[c] THEN RETURN[c]; ENDLOOP;
};

FirstChildContext: PROC [context: Context] RETURNS [ans: Context] = {
WITH context SELECT FROM
sc: StatementContext => RETURN[NIL];  -- do statements have substructure?
tv: RefTVRec =>
SELECT TVType[tv] FROM
fhType => RETURN[NEW[StatementContextObj _ [localFrameTV: tv]]];
gfhType => RETURN[NIL];
ENDCASE => ERROR AMTypes.Error[reason: typeFault, type: TVType[tv]];
mc: ConfigContext =>
IF mc.configIndex = LoadState.nullConfig
THEN {
IF mc.world = LocalWorld[]
THEN {
config: LoadState.ConfigID;
gfh: GlobalFrameHandle;
composite: BOOL;
LoadState.local.Acquire[];
{ ENABLE UNWIND => LoadState.local.Release[];
mx: LoadState.ModuleIndex;
p: PROC [LoadState.ConfigID, LoadState.ModuleIndex] RETURNS [BOOL] = {RETURN[TRUE]};
[config, mx] _ LoadState.local.EnumerateAllModules[newestFirst, p];
composite _ IsComposite[LoadState.local.ConfigInfo[config].bcd];
gfh _ LoadState.local.ModuleToGlobalFrame[config, mx];
IF gfh = NIL THEN ERROR;
};  -- ENABLE UNWIND => LoadState.local.Release[];
LoadState.local.Release[];
IF composite
THEN
RETURN[NEW[ConfigContextObj _
[world: mc.world,
worldIncarnation: mc.worldIncarnation,
configIndex: config]]]
ELSE RETURN[TVForGFHReferent[gfh]];
}
ELSE { -- remote world
config: LoadState.ConfigID;
gfh: GlobalFrameHandle;
rgfh: RemoteGlobalFrameHandle _ nilRemoteGlobalFrameHandle;
composite: BOOL;
Lock[mc.world];
{ ENABLE UNWIND => Unlock[mc.world];
h: LoadState.Handle = WorldVM.Loadstate[mc.world];
h.Acquire[];
{ ENABLE UNWIND => h.Release[];
mx: LoadState.ModuleIndex;
p: PROC [LoadState.ConfigID, LoadState.ModuleIndex] RETURNS [BOOL] = {RETURN[TRUE]};
[config, mx] _ h.EnumerateAllModules[newestFirst, p];
composite _ IsRemoteBCDComposite[mc.world, h.ConfigInfo[config].bcd];
gfh _ h.ModuleToGlobalFrame[config, mx];
IF gfh = NIL THEN ERROR;
rgfh _ [mc.world, mc.worldIncarnation, LOOPHOLE[gfh]];
};  -- ENABLE UNWIND => h.Release[];
h.Release[];
};  -- end ENABLE UNWIND => Unlock[mc.world];
Unlock[mc.world];
IF composite
THEN RETURN[NEW[ConfigContextObj _ [
world: mc.world,
worldIncarnation: mc.worldIncarnation,
configIndex: config]]]
ELSE RETURN[TVForRemoteGFHReferent[rgfh]];
};
}  -- end world config case
ELSE {
IF mc.world = LocalWorld[]
THEN {
gfh: GlobalFrameHandle;
p: PROC [LoadState.ModuleIndex] RETURNS [BOOL] = {RETURN[TRUE]};
LoadState.local.Acquire[];
[gfh: gfh] _ LoadState.local.EnumerateModulesInConfig[mc.configIndex, p
! UNWIND => LoadState.local.Release[]];
LoadState.local.Release[];
RETURN[TVForGFHReferent[gfh]];
}
ELSE {
gfh: GlobalFrameHandle;
rgfh: RemoteGlobalFrameHandle _ nilRemoteGlobalFrameHandle;
Lock[mc.world];
{ ENABLE UNWIND => Unlock[mc.world];
h: LoadState.Handle = WorldVM.Loadstate[mc.world];
p: PROC [LoadState.ModuleIndex] RETURNS [BOOL] = {RETURN[TRUE]};
h.Acquire[];
[gfh: gfh] _ h.EnumerateModulesInConfig[mc.configIndex, p
! UNWIND => h.Release[]];
h.Release[];
};  -- end ENABLE UNWIND => Unlock[mc.world];
Unlock[mc.world];
rgfh _ [mc.world, mc.worldIncarnation, LOOPHOLE[gfh]];
RETURN[TVForRemoteGFHReferent[rgfh]];
};
};
ENDCASE => ERROR AMTypes.Error[reason: notImplemented];
};
NextSiblingContext: PROC [context: Context] RETURNS [ans: Context _ NIL] = { 
IF context = NIL THEN RETURN[NIL];
WITH context SELECT FROM
sc: StatementContext => RETURN[NIL];  -- substructure?
mc: ConfigContext => {
IF mc.configIndex = LoadState.nullConfig THEN RETURN[NIL];
IF mc.world = LocalWorld[]
THEN {
nextIsIt: BOOL _ FALSE;
composite: BOOL;
config: LoadState.ConfigID;
gfh: GlobalFrameHandle;
LoadState.local.Acquire[];
{ ENABLE UNWIND => LoadState.local.Release[];
p: PROC [config: LoadState.ConfigID] RETURNS [BOOL] = {
IF nextIsIt THEN RETURN[TRUE];
IF config = mc.configIndex THEN nextIsIt _ TRUE;
RETURN[FALSE];
};
q: PROC [LoadState.ModuleIndex] RETURNS [BOOL] = {RETURN[TRUE]};
config _ LoadState.local.EnumerateConfigs[newestFirst, p];
IF config = LoadState.nullConfig
THEN {LoadState.local.Release[]; RETURN[NIL]};
composite _ IsComposite[LoadState.local.ConfigInfo[config].bcd];
[gfh: gfh] _ LoadState.local.EnumerateModulesInConfig[config, q];
};
LoadState.local.Release[];
IF composite
THEN RETURN[NEW[ConfigContextObj _ [
world: mc.world,
worldIncarnation: mc.worldIncarnation,
configIndex: config]]]
ELSE RETURN[TVForGFHReferent[gfh]];
}
ELSE {
nextIsIt: BOOL _ FALSE;
composite: BOOL;
config: LoadState.ConfigID;
gfh: GlobalFrameHandle;
Lock[mc.world];
{ ENABLE UNWIND => Unlock[mc.world];
h: LoadState.Handle = WorldVM.Loadstate[mc.world];
h.Acquire[];
{ ENABLE UNWIND => h.Release[];
p: PROC [config: LoadState.ConfigID] RETURNS [BOOL] = {
IF nextIsIt THEN RETURN[TRUE];
IF config = mc.configIndex THEN nextIsIt _ TRUE;
RETURN[FALSE];
};
q: PROC [LoadState.ModuleIndex] RETURNS [BOOL] = {RETURN[TRUE]};
config _ h.EnumerateConfigs[newestFirst, p];
IF config = LoadState.nullConfig
THEN {h.Release[]; WorldVM.Unlock[mc.world]; RETURN[NIL]};
composite _ IsRemoteBCDComposite[mc.world, h.ConfigInfo[config].bcd];
IF NOT composite THEN [gfh: gfh] _ h.EnumerateModulesInConfig[config, q];
};
h.Release[];
};  -- end ENABLE UNWIND => Unlock[mc.world];
Unlock[mc.world];
IF composite
THEN RETURN[NEW[ConfigContextObj _ [
world: mc.world,
worldIncarnation: mc.worldIncarnation,
configIndex: config]]]
ELSE {
rgfh: RemoteGlobalFrameHandle
_ [mc.world, mc.worldIncarnation, LOOPHOLE[gfh]];
RETURN[TVForRemoteGFHReferent[rgfh]];
};
};
};
tv: RefTVRec => {
SELECT TVType[tv] FROM
gfhType =>
IF IsRemote[tv]
THEN { -- remote case
world: World = GetWorld[tv];
WorldVM.Lock[world];
{ ENABLE UNWIND => WorldVM.Unlock[world];
h: LoadState.Handle = WorldVM.Loadstate[world];
h.Acquire[];
{ ENABLE UNWIND => h.Release[];
gfh: GlobalFrameHandle = LOOPHOLE[RemoteGFHFromTV[tv].gfh];
config: LoadState.ConfigID _ h.GlobalFrameToModule[gfh].config;
IF IsRemoteBCDComposite[world, h.ConfigInfo[config].bcd] THEN {
nextGFH: GlobalFrameHandle;
rgfh: RemoteGlobalFrameHandle _ nilRemoteGlobalFrameHandle;
lastWasIt: BOOL _ FALSE;
q: PROC [mx: LoadState.ModuleIndex] RETURNS [stop: BOOL _ FALSE] = {
mgfh: GlobalFrameHandle;
copies: LoadState.CopiesList;
[gfh: mgfh, copies: copies] _ h.ModuleInfo[config, mx];
IF lastWasIt THEN {nextGFH _ mgfh; RETURN[TRUE]};
IF gfh = mgfh THEN
{IF copies = NIL
THEN {lastWasIt _ TRUE; RETURN[FALSE]}
ELSE {nextGFH _ copies.first; RETURN[TRUE]}}
ELSE IF copies # NIL THEN {
FOR x: LoadState.CopiesList _ copies, x.rest UNTIL x = NIL
DO
IF lastWasIt THEN {nextGFH _ x.first; RETURN[TRUE]};
IF x.first = gfh THEN lastWasIt _ TRUE;
ENDLOOP;
};
};
nextModule: LoadState.ModuleIndex _
h.EnumerateModulesInConfig[config, q].module;
rgfh _ [world, CurrentIncarnation[world], LOOPHOLE[nextGFH]];
ans _ IF nextModule = LoadState.nullModule THEN NIL
	ELSE TVForRemoteGFHReferent[rgfh];
}
ELSE {  -- not a composite config
lastWasIt: BOOL _ FALSE;
p: PROC [ci: LoadState.ConfigID] RETURNS [BOOL] = {
IF lastWasIt THEN RETURN[TRUE];
IF ci = config THEN lastWasIt _ TRUE;
RETURN[FALSE];
};
nextConfig: LoadState.ConfigID _
h.EnumerateConfigs[newestFirst, p];
IF nextConfig = LoadState.nullConfig THEN ans _ NIL
ELSE {
r: PROC [LoadState.ModuleIndex] RETURNS [BOOL] =
{RETURN[TRUE]};
IF IsRemoteBCDComposite[world, h.ConfigInfo[nextConfig].bcd] THEN {
ans _ NEW[ConfigContextObj _
[world: world,
 worldIncarnation: CurrentIncarnation[world],
 configIndex: nextConfig]];
}
ELSE ans _ TVForRemoteGFHReferent
[[ world,
CurrentIncarnation[world],
LOOPHOLE[h.EnumerateModulesInConfig[nextConfig, r].gfh]]];
};
};
};  -- end ENABLE UNWIND => h.Release[]
h.Release[];
};  -- end ENABLE UNWIND => WorldVM.Unlock[world];
WorldVM.Unlock[world];
}
ELSE { -- local case
LoadState.local.Acquire[];
{ ENABLE UNWIND => LoadState.local.Release[];
gfh: GlobalFrameHandle = GFHFromTV[tv];
config: LoadState.ConfigID _ LoadState.local.GlobalFrameToModule[gfh].config;
IF IsComposite[LoadState.local.ConfigInfo[config].bcd] THEN {
nextGFH: GlobalFrameHandle;
lastWasIt: BOOL _ FALSE;
q: PROC [mx: LoadState.ModuleIndex] RETURNS [stop: BOOL _ FALSE] = {
mgfh: GlobalFrameHandle;
copies: LoadState.CopiesList;
[gfh: mgfh, copies: copies] _ LoadState.local.ModuleInfo[config, mx];
IF lastWasIt THEN {nextGFH _ mgfh; RETURN[TRUE]};
IF gfh = mgfh
THEN {
IF copies = NIL
THEN {lastWasIt _ TRUE; RETURN[FALSE]}
ELSE {nextGFH _ copies.first; RETURN[TRUE]}}
ELSE IF copies # NIL THEN {
FOR x: LoadState.CopiesList _ copies, x.rest UNTIL x = NIL DO
IF lastWasIt THEN {nextGFH _ x.first; RETURN[TRUE]};
IF x.first = gfh THEN lastWasIt _ TRUE;
ENDLOOP;
};
};
nextModule: LoadState.ModuleIndex _
LoadState.local.EnumerateModulesInConfig[config, q].module;
ans _ IF nextModule = LoadState.nullModule THEN NIL
	ELSE TVForGFHReferent[nextGFH];
}
ELSE {  -- not a composite config
lastWasIt: BOOL _ FALSE;
p: PROC [ci: LoadState.ConfigID] RETURNS [BOOL] = {
IF lastWasIt THEN RETURN[TRUE];
IF ci = config THEN lastWasIt _ TRUE;
RETURN[FALSE];
};
nextConfig: LoadState.ConfigID _
LoadState.local.EnumerateConfigs[newestFirst, p];
IF nextConfig = LoadState.nullConfig THEN ans _ NIL
ELSE {
r: PROC [LoadState.ModuleIndex] RETURNS [BOOL] = {RETURN[TRUE]};
IF IsComposite[LoadState.local.ConfigInfo[nextConfig].bcd] THEN {
ans _ NEW[ConfigContextObj _ [
world: LocalWorld[],
worldIncarnation: CurrentIncarnation[LocalWorld[]],
configIndex: nextConfig]];
}
ELSE ans _ TVForGFHReferent [
LoadState.local.EnumerateModulesInConfig[nextConfig, r].gfh];
};
};
};  -- end ENABLE UNWIND => LoadState.local.Release[]
LoadState.local.Release[];
};
ENDCASE => ERROR AMTypes.Error[reason: typeFault, type: TVType[tv]];
};
ENDCASE => ERROR;
};  -- end NextSiblingContext
Imports: PUBLIC PROC [context: Context] RETURNS [ans: LIST OF PartialInterfaceInstance _ NIL] = {
WITH context SELECT FROM
mc: ConfigContext => {
bcd: BcdDefs.BcdBase; 
ftb: Table.Base; 
AcquireIR: PROC [imph: BcdDefs.IMPHandle, impi: BcdDefs.IMPIndex]
RETURNS [stop: BOOL _ FALSE] = {
type: Type;
seIndex: SymbolIndex;
stb: SymbolTableBase
_ AcquireSTB[
GetSTHForModule
[stamp: ftb[imph.file].version,
 fileName: BcdNameToRope[bcd, ftb[imph.file].name],
 moduleName: BcdNameToRope[bcd, imph.name]]];
p: PROC [stb: SymbolTableBase, isei: SymbolIdIndex] RETURNS [stop: BOOL] = {
IF ISEPublic[stb, isei]
THEN {seIndex _ ISEType[stb, isei]; RETURN[TRUE]} ELSE RETURN[FALSE];
};
IF NOT EnumerateCtxIseis[stb: stb, ctx: STBDirectoryCtx[stb], proc: p
! UNWIND => ReleaseSTB[stb]]
THEN {ReleaseSTB[stb]; ERROR};
type _ AcquireType[stb: stb, seIndex: seIndex ! UNWIND => ReleaseSTB[stb]];
ReleaseSTB[stb];
ans _ CONS[[ir: GetInterfaceRecordFromType[type, mc.world], usingList: NIL], ans];  -- NOTE
};
IF mc.configIndex = LoadState.nullConfig THEN RETURN[NIL];
IF mc.world # LocalWorld[] THEN {
Lock[mc.world];
{ ENABLE UNWIND => Unlock[mc.world];
h: LoadState.Handle = WorldVM.Loadstate[mc.world];
h.Acquire[];
{ ENABLE UNWIND => h.Release[]; 
bcd _ h.ConfigInfo[mc.configIndex].bcd;
IF bcd = NIL THEN ERROR;
bcd _ AcquireRemoteBCD[mc.world, mc.worldIncarnation, bcd];
IF bcd = NIL THEN ERROR;
};  -- end ENABLE UNWIND => h.Release[];
h.Release[];
{ ENABLE UNWIND => ReleaseRemoteBCD[bcd]; 
ftb _ LOOPHOLE[bcd + bcd.ftOffset];
IF NOT IsComposite[bcd] THEN ERROR; -- single module loadstate entry
[] _ BcdOps.ProcessImports[bcd, AcquireIR];
};  -- end ENABLE UNWIND => ... ReleaseRemoteBCD ...
ReleaseRemoteBCD[bcd];
};  -- end ENABLE UNWIND => Unlock[mc.world];
Unlock[mc.world];
}
ELSE { -- local case
LoadState.local.Acquire[];
bcd _ LoadState.local.ConfigInfo[mc.configIndex].bcd;
LoadState.local.Release[];
ftb _ LOOPHOLE[bcd + bcd.ftOffset];
IF NOT IsComposite[bcd] THEN ERROR; -- single module loadstate entry
[] _ BcdOps.ProcessImports[bcd, AcquireIR];
};
};
tv: RefTVRec => {
SELECT TVType[tv] FROM
gfhType => {
bcd: BcdDefs.BcdBase = RTSymbolsPrivate.AcquireBCDFromVersion
[versionStamp:
IF IsRemote[tv] THEN RemoteGFHToVersionStamp[RemoteGFHFromTV[tv]]
ELSE GFHToVersionStamp[GFHFromTV[tv]],
 shortFileNameHint: Rope.Concat[TVToName[tv], ".bcd"]
];
ftb: Table.Base = LOOPHOLE[bcd + bcd.ftOffset];
AcquireIR: PROC [imph: BcdDefs.IMPHandle, impi: BcdDefs.IMPIndex]
RETURNS [stop: BOOL _ FALSE] = {
type: Type;
seIndex: SymbolIndex;
stb: SymbolTableBase _ AcquireSTB
[GetSTHForModule
[stamp: ftb[imph.file].version,
 fileName: BcdNameToRope[bcd, ftb[imph.file].name],
 moduleName: BcdNameToRope[bcd, imph.name]
]
];
p: PROC [stb: SymbolTableBase, isei: SymbolIdIndex] RETURNS [stop: BOOL] = {
IF ISEPublic[stb, isei]
THEN {seIndex _ ISEType[stb, isei]; RETURN[TRUE]}
ELSE RETURN[FALSE];
};
IF NOT EnumerateCtxIseis[stb: stb, ctx: STBDirectoryCtx[stb], proc: p
! UNWIND => ReleaseSTB[stb]]
THEN {ReleaseSTB[stb]; ERROR};
type _ AcquireType[stb: stb, seIndex: seIndex ! UNWIND => ReleaseSTB[stb]];
ReleaseSTB[stb];
ans _ CONS[[ir: GetInterfaceRecordFromType[type, GetWorld[tv]], usingList: NIL], ans];
};
IF IsComposite[bcd] THEN {RTSymbolsPrivate.ReleaseBCD[bcd]; ERROR};--disaster
[] _ BcdOps.ProcessImports[bcd, AcquireIR
! UNWIND => RTSymbolsPrivate.ReleaseBCD[bcd]];
RTSymbolsPrivate.ReleaseBCD[bcd];
};
ENDCASE => ERROR AMTypes.Error[reason: typeFault, type: TVType[tv]];
};
ENDCASE => ERROR;
};
Exports: PUBLIC PROC [context: Context] RETURNS [ans: LIST OF PartialInterfaceInstance _ NIL] = {
WITH context SELECT FROM
mc: ConfigContext => {
bcd: BcdDefs.BcdBase;
ftb: Table.Base;
AcquireIR: PROC [exph: BcdDefs.EXPHandle, expi: BcdDefs.EXPIndex] RETURNS [stop: BOOL _ FALSE] = {
type: Type;
seIndex: SymbolIndex;
stb: SymbolTableBase _ AcquireSTB [
GetSTHForModule [
stamp: ftb[exph.file].version,
fileName: BcdNameToRope[bcd, ftb[exph.file].name],
moduleName: BcdNameToRope[bcd, exph.name]]];
p: PROC [stb: SymbolTableBase, isei: SymbolIdIndex] RETURNS [stop: BOOL] = {
IF ISEPublic[stb, isei]
THEN {seIndex _ ISEType[stb, isei]; RETURN[TRUE]}
ELSE RETURN[FALSE];
};
IF NOT EnumerateCtxIseis[stb: stb, ctx: STBDirectoryCtx[stb], proc: p
! UNWIND => ReleaseSTB[stb]]
THEN {ReleaseSTB[stb]; ERROR};
type _ AcquireType[stb: stb, seIndex: seIndex ! UNWIND => ReleaseSTB[stb]];
ReleaseSTB[stb];
ans _ CONS[[ir: GetInterfaceRecordFromType[type, mc.world], usingList: NIL], ans];
};
IF mc.configIndex = LoadState.nullConfig THEN {
FOR irNames: LIST OF ROPE _ GetInterfaceRecordNames[mc.world], irNames.rest
UNTIL irNames = NIL DO
ans _ CONS[[ir: GetInterfaceRecord[irNames.first, mc.world], usingList: NIL], ans];
ENDLOOP;
RETURN;
};
IF mc.world # LocalWorld[] THEN {
Lock[mc.world];
{ ENABLE UNWIND => Unlock[mc.world];
h: LoadState.Handle = WorldVM.Loadstate[mc.world];
h.Acquire[];
{ ENABLE UNWIND => h.Release[]; 
bcd _ h.ConfigInfo[mc.configIndex].bcd;
IF bcd = NIL THEN ERROR;
bcd _ AcquireRemoteBCD[mc.world, mc.worldIncarnation, bcd];
IF bcd = NIL THEN ERROR;
};  -- end ENABLE UNWIND => h.Release[];
h.Release[];
{ ENABLE UNWIND => ReleaseRemoteBCD[bcd]; 
ftb _ LOOPHOLE[bcd + bcd.ftOffset];
IF NOT IsComposite[bcd] THEN ERROR; -- single module loadstate entry
[] _ BcdOps.ProcessExports[bcd, AcquireIR];
};  -- end ENABLE UNWIND => ... ReleaseRemoteBCD ...
ReleaseRemoteBCD[bcd];
};  -- end ENABLE UNWIND => Unlock[mc.world];
Unlock[mc.world];
}
ELSE { -- local case
LoadState.local.Acquire[];
bcd _ LoadState.local.ConfigInfo[mc.configIndex].bcd;
LoadState.local.Release[];
ftb _ LOOPHOLE[bcd + bcd.ftOffset];
IF NOT IsComposite[bcd] THEN ERROR; -- single module loadstate entry
[] _ BcdOps.ProcessExports[bcd, AcquireIR];
};
};
tv: RefTVRec => {
SELECT TVType[tv] FROM
gfhType => {
bcd: BcdDefs.BcdBase = RTSymbolsPrivate.AcquireBCDFromVersion [
versionStamp:
IF IsRemote[tv]
THEN RemoteGFHToVersionStamp[RemoteGFHFromTV[tv]]
ELSE GFHToVersionStamp[GFHFromTV[tv]],
 shortFileNameHint: Rope.Concat[TVToName[tv], ".bcd"]];
ftb: Table.Base = LOOPHOLE[bcd + bcd.ftOffset];
AcquireIR: PROC [exph: BcdDefs.EXPHandle, expi: BcdDefs.EXPIndex]
RETURNS [stop: BOOL _ FALSE] = {
type: Type;
seIndex: SymbolIndex;
stb: SymbolTableBase _ AcquireSTB [
GetSTHForModule [
stamp: ftb[exph.file].version,
fileName: BcdNameToRope[bcd, ftb[exph.file].name],
moduleName: BcdNameToRope[bcd, exph.name]]];
p: PROC [stb: SymbolTableBase, isei: SymbolIdIndex] RETURNS [stop: BOOL] = {
IF ISEPublic[stb, isei]
THEN {seIndex _ ISEType[stb, isei]; RETURN[TRUE]}
ELSE RETURN[FALSE];
};
IF NOT EnumerateCtxIseis[stb: stb, ctx: STBDirectoryCtx[stb], proc: p
! UNWIND => ReleaseSTB[stb]]
THEN {ReleaseSTB[stb]; ERROR};
type _ AcquireType[stb: stb, seIndex: seIndex ! UNWIND => ReleaseSTB[stb]];
ReleaseSTB[stb];
ans _ CONS[[ir: GetInterfaceRecordFromType[type, GetWorld[tv]], usingList: NIL], ans];
};
IF IsComposite[bcd] THEN {RTSymbolsPrivate.ReleaseBCD[bcd]; ERROR};--disaster
[] _ BcdOps.ProcessExports[bcd, AcquireIR
! UNWIND => RTSymbolsPrivate.ReleaseBCD[bcd]];
RTSymbolsPrivate.ReleaseBCD[bcd];
};
ENDCASE => ERROR AMTypes.Error[reason: typeFault, type: TVType[tv]];
};
ENDCASE => ERROR;
};
StripExtension: PROC [name: ROPE] RETURNS [ROPE] = {
RETURN[Rope.Substr[base: name, start: 0, len: Rope.SkipTo[s: name, pos: 0, skip: "."]]];
};

IsComposite: PROC [bcd: BcdDefs.BcdBase] RETURNS [BOOL] = {RETURN[bcd.nConfigs # 0]};

IsRemoteBCDComposite: PROC [world: World, bcd: BcdDefs.BcdBase] RETURNS [BOOL] = {
RETURN[WorldVM.Read[world, LOOPHOLE[@bcd.nConfigs, WorldVM.Address]] # 0];
};

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]];
};

RemoteGFHToVersionStamp: PROC [gfh: RemoteGlobalFrameHandle] RETURNS [version: BcdDefs.VersionStamp _ BcdDefs.NullVersion] = {
mx: LoadState.ModuleIndex; 
config: LoadState.ConfigID; 
bcd: BcdDefs.BcdBase; 
ftb: Table.Base;
h: LoadState.Handle;
FindModuleVersion: PROC [mth: BcdDefs.MTHandle, mti: BcdDefs.MTIndex] RETURNS [stop: BOOL _ FALSE] = {
IF mx IN [mth.gfi .. mth.gfi + mth.ngfi) THEN {
version _ IF mth.file = BcdDefs.FTSelf THEN bcd.version ELSE ftb[mth.file].version;
RETURN[TRUE];
};
};
IF gfh = nilRemoteGlobalFrameHandle THEN RETURN;
h _ WorldVM.Loadstate[gfh.world];
h.Acquire[]; 
{ ENABLE UNWIND => h.Release[]; 
[config, mx] _ h.GlobalFrameToModule[LOOPHOLE[gfh.gfh]];
IF config = LoadState.nullConfig THEN {h.Release[]; RETURN}; 
bcd _ AcquireRemoteBCD[gfh.world, gfh.worldIncarnation, h.ConfigInfo[config].bcd]; 
{ ENABLE UNWIND => ReleaseRemoteBCD[bcd]; 
ftb _ LOOPHOLE[bcd + bcd.ftOffset];
[] _ BcdOps.ProcessModules[bcd, FindModuleVersion]; 
};  -- end ENABLE UNWIND => ReleaseRemoteBCD[bcd]; 
ReleaseRemoteBCD[bcd]; 
};  -- end ENABLE UNWIND => h.Release[]; 
h.Release[]; 
}; 

GFHToVersionStamp: PROC [gfh: PrincOps.GlobalFrameHandle] RETURNS [version: BcdDefs.VersionStamp _ BcdDefs.NullVersion] = {
mx: LoadState.ModuleIndex; 
config: LoadState.ConfigID; 
bcd: BcdDefs.BcdBase; 
ftb: Table.Base;
FindModuleVersion: PROC [mth: BcdDefs.MTHandle, mti: BcdDefs.MTIndex] RETURNS [stop: BOOL _ FALSE] = {
IF mx IN [mth.gfi .. mth.gfi + mth.ngfi) THEN {
version _ IF mth.file = BcdDefs.FTSelf THEN bcd.version ELSE ftb[mth.file].version;
RETURN[TRUE];
};
};
IF gfh = NIL THEN RETURN;
LoadState.local.Acquire[]; 
{ ENABLE UNWIND => LoadState.local.Release[]; 
[config, mx] _ LoadState.local.GlobalFrameToModule[gfh];
IF config = LoadState.nullConfig THEN {LoadState.local.Release[]; RETURN}; 
bcd _ LoadState.local.ConfigInfo[config].bcd; 
ftb _ LOOPHOLE[bcd + bcd.ftOffset];
[] _ BcdOps.ProcessModules[bcd, FindModuleVersion]; 
};  -- end ENABLE UNWIND => LoadState.local.Release[]; 
LoadState.local.Release[]; 
}; 

ProgPCToFGI: PUBLIC PROC [prog: AMTypes.TV--globalFrame--, pc: PrincOps.BytePC] RETURNS [ans: FGIndex _ FGNull] = {
stb: SymbolTableBase;
IF IsRemote[prog]
THEN stb _ AcquireSTBFromRemoteGFH[RemoteGFHFromTV[prog]]
ELSE stb _ AcquireSTBFromGFH[GFHFromTV[prog]];
{ ENABLE UNWIND => ReleaseSTB[stb];
epi: EPI;
startPC: PrincOps.BytePC;
IF IsRemote[prog]
THEN [epi, startPC] _ RTTypesRemotePrivate.GetRemoteEp [pc: pc, gf: RemoteGFHFromTV[prog], stb: stb]
ELSE [epi, startPC] _ RTTypesPrivate.GetEp [pc: pc, gf: GFHFromTV[prog], stb: stb];
ans _ PCToFGI[stb, epi, pc - startPC];
};  -- end ENABLE UNWIND => ReleaseSTB[stb];
ReleaseSTB[stb];
};
StatementContextToFGI: PROC [sc: StatementContext] RETURNS [ans: FGIndex _ FGNull] = {
prog: REF prog SectionObj _ NIL;
bcd: BcdDefs.BcdBase;
c: Context _ sc;
world: World;
local: BOOL _ FALSE;
UNTIL ContextClass[c] = prog DO c _ ParentContext[c]; ENDLOOP;
world _ GetWorld[c];
prog _ NARROW[ContextSection[c]];
local _ (world = LocalWorld[]);
IF local
THEN bcd _ GetLocalBCD[GFHFromTV[c]]
ELSE bcd _ GetRemoteBCD[RemoteGFHFromTV[c]];
{ ENABLE UNWIND => IF NOT local THEN ReleaseRemoteBCD[bcd];
mth: BcdDefs.MTHandle;
stb: SymbolTableBase;
GetModule: PROC [mth: BcdDefs.MTHandle, mti: BcdDefs.MTIndex] RETURNS [BOOL] =  {RETURN[TRUE]};
[mth,] _ BcdOps.ProcessModules[bcd, GetModule];
IF mth = NIL THEN ERROR;
stb _ AcquireSTBFromSGI[bcd: bcd, sgi: mth.sseg];
{ ENABLE UNWIND => ReleaseSTB[stb];
pc: PrincOps.BytePC = AMBridge.ContextPC[sc.localFrameTV];
epi: EPI;
startPC: PrincOps.BytePC;
IF IsRemote[sc.localFrameTV]
THEN [epi, startPC] _ RTTypesRemotePrivate.GetRemoteEp
[pc: pc, gf: RemoteGFHFromTV[GlobalParent[sc.localFrameTV]], stb: stb]
ELSE [epi, startPC] _ RTTypesPrivate.GetEp
[pc: pc, gf: FHFromTV[sc.localFrameTV].accesslink, stb: stb];
ans _ PCToFGI[stb, epi, pc - startPC];
};  -- end ENABLE UNWIND => ReleaseSTB[stb];
ReleaseSTB[stb];
};  -- end ENABLE UNWIND => ... ReleaseRemoteBCD;
IF NOT local THEN ReleaseRemoteBCD[bcd];
};  -- end StatementContextToFGI

}.




AMModelContextImpl.mesa
Copyright c 1985 by Xerox Corporation.  All rights reserved.
Russ Atkinson, April 18, 1985 12:24:38 pm PST
"h.EnumerateAllModules[oldestFirst," _ "h.EnumerateAllModules[newestFirst,"
Last Modified On October 18, 1983 2:12 pm By Paul Rovner
"h.EnumerateAllModules[newestFirst," _ "h.EnumerateAllModules[oldestFirst,"
Last Modified On December 8, 1983 8:38 am By Paul Rovner

TYPEs
either binder output bundle for a config, or compiler output bundle for a prog module, DEFs module, proc, or statement


PROCs dealing with Contexts (loadstate entries, global or local frames, statements, IR instances)
a "rootContext" represents a Loadstate. Immediate children are the Contexts of loadstate configs for individually loaded program modules and bound configs.

SectionName with instance info

EXAMPLE USAGE: given a module name and a world context, this returns  a Context for the most recently loaded global frame for a program with that name. name must identify a model or prog (someday interface) if context identifies a world, or a prog (someday interface) if context identifies a model. The format of the name should be the same as that produced by ContextName, with elided fields meaning "don't care". The result will be either a model or prog (someday interface) context.
here to look for a named config or a module of a config

RRA: In all cases where we do not already have the name we should fill in the name.  If we get an AMTypes.Error when trying to execute the caller's proc we just go on to the next frame.
an enumerator. Like MostRecentNamedContext, but gets 'em all.
start HERE

param to creator of context

world => NIL
model => world
prog => model
proc => prog
statement => proc

world -> model or prog (TV for a global frame)
model -> prog
proc -> statement

model -> model or prog (TV for a global frame)
prog -> model or prog
returns NIL if nomore

... dealing with PartialInterfaceInstances
Implemented only for loadstate entries and global frames sharing
gets top level imports from the loadstate, via the minimodel. Encapsulation awaits the modeller. 
single module bcd
NOTE interface modules import stuff.

Implemented only for loadstate entries and global frames;  sharing!
gets top level imports from the loadstate, via the minimodel;  Encapsulation awaits the modeller.
single module bcd

Private Procedures

start RemoteGFHToVersionStamp here
start GFHToVersionStamp here
now compute the epi and the relative pc

[local frame, PC] => FGIndex (wrt prog module bcd)
now compute the epi and the relative pc
�Ê-K–

"cedar" style˜
codeš
œ™Kšœ
Ïm
œ1™<™-Kš
œK™K—š
œ8™8Kš
œK™K—Kš
œ8™8—K˜š
Ïk	˜	Kšœ	žœï
˜ý
KšœžœK˜\Kšœžœ,˜9Kšœžœžœ„
˜®
Kšœžœ@žœ˜QKšœžœž
˜«
KšœžœB˜NKšœžœ˜1Kšžœ
žœ	˜Kšœ
žœñ
˜€Kšœ	žœ˜+Kšœžœ˜/Kšœžœ"˜;Kšœžœžœ5˜EKšœ
žœZ˜lKšœžœe˜vKšœ
žœa˜pKšœžœ%˜;Kšœžœ	˜KšœžœL˜fKšœžœ˜*Kšœžœ˜Kšœžœi˜v—K˜šœžœÏc˜9Kšžœ,žœª
˜ß
Kšžœ˜KšœžœÀ
˜È
—™š
œ™Kš
œv™vKšœ	žœžœ˜Kšœžœ
žœ˜%—™Kšœžœžœ
žœ˜-Kšœžœžœ˜,šœžœžœ
˜"Kš
œ
˜
Kš
œ˜Kšœžœ
˜Kšœžœ
žœ˜—Kšœžœžœžœ˜:Kšœ#žœ
˜'K™—Kš
œa™aK˜šÏnœžœ
žœžœ˜=Kš
œ›
™›
Kšžœ	žœ
žœ˜1šžœ
žœ˜š
œ˜Kš
œ-˜-Kš
œ&˜&——Kš
œ˜—K˜š œžœ
žœžœ˜@šžœ	žœ
ž˜Kšœžœ˜*š
œ˜šžœ&˜(Kšžœ
žœ˜Kšžœ
žœ˜——š
œ˜šžœž˜Kšœžœ˜Kšœ
žœ˜Kšžœžœ˜—Kš
œ˜—Kšžœžœ'˜7—Kš
œ˜—K˜š œžœ
žœžœ˜@šžœ	žœ
ž˜Kšœžœ˜:Kšœžœ˜&Kšžœžœ˜%—Kš
œ˜—K™š œžœ
žœžœžœžœ˜IKš
œ™Kš
žœžœ
žœ
žœ
žœ˜"šžœ	žœ
ž˜š
œ˜šœžœ˜Kš
œ%˜%Kšœ
žœžœ*˜W—Kš
œ˜—š
œ˜šžœž˜š
œ˜šœ	žœ˜šžœ˜Kšžœ
žœžœ
˜0Kšžœ
žœžœ˜'——Kšœ%žœ˜/Kšœžœ6˜>Kš
œ˜—š
œ˜šœžœ˜šžœ˜Kšžœ
žœžœ
˜.Kšžœ
žœžœ˜&——šœ/žœ
˜8Kšœžœ˜—Kšœžœ4˜<Kš
œ˜—šžœ˜Kš
œ0˜0KšœŸ˜——šžœž˜#Kš
œ3˜3—Kš
œ˜—š
œ˜šžœ&˜(Kšžœ.˜2šžœ˜š
 œžœ.žœžœžœ˜cKšžœžœ
žœ
žœ˜1Kš
œ˜—šžœ˜šžœ
˜Kš
œ˜Kš
œ˜Kš
œ˜š
œ/˜/Kšœžœ#˜+—Kš
œ˜Kšžœžœ
žœ
žœ
˜Kš
œ9˜9šœžœ˜Kš
œ˜Kš
œ*˜*Kšœ
žœžœ˜.Kš
œ˜—Kš
œ
˜
—šžœ
˜Kš
œ˜Kš
œ˜Kš
œ˜šœžœ
žœ˜$Kš
œ2˜2Kš
œ˜šœžœ
žœ˜š
œ˜Kš
œB˜B——Kš
œ˜Kš
œ˜—Kš
œ˜Kš
œ˜Kšžœžœ
žœ
žœ
˜šœžœ
žœ˜)Kš
œ9˜9šœžœ$˜,Kš
œ*˜*Kšœ
žœžœ˜/Kš
œ˜—Kš
œ˜—Kš
œ˜Kš
œ˜——KšœŸ7˜;———Kšžœžœ'˜7—Kš
œ˜—K™š œžœ
žœžœŸœ	žœžœ˜vKšžœ
žœØ™åšžœ	žœ
ž˜š
œ˜Kšžœ(Ÿ˜Ašžœ
˜Kšœžœžœžœžœžœžœžœ˜BKš
œ?˜?Kšžœžœ
žœ
ž˜Kš
œ˜—Kš
œ7™7š
œ
˜
š	œžœžœžœžœ˜5Kšœžœ˜Kšœžœ˜&Kš	œžœžœžœžœ ˜QKšžœžœžœžœ˜8Kš
œ˜—Kš
œ!˜!—Kš
œ˜Kš
œ˜—šžœ˜
šžœ˜Kš
œ˜Kš
œH˜H———Kš
œ˜—K™š
Ïbœ
ž	œ
žœžœžœ˜IKš
œ/˜/Kš
œ˜Kš
œ"˜"Kš
œ˜K˜K˜—š¡œ
ž	œ
žœžœ˜Išžœ*ž
œžœ	ž˜Jš
ž˜šžœ˜šžœ
˜šžœ6˜8KšžœA˜Cšžœ˜Kšœžœ
˜Kš
œ4˜4Kš
œ?˜?Kš
œ˜——Kšžœ˜Kš
œ˜———Kšžœ
˜—šœžœ
žœ˜-š
œ˜Kš
œ(˜(Kš
œ3˜3Kšœ	žœ˜Kš
œ˜——Kšžœ˜Kš
œ˜K˜—š¡œ
ž
œ
žœžœžœžœžœŸ	œ
žœžœžœ˜ž
Kšžœ
žœžœ
˜Kš
œ˜Kš
œ˜šœžœ
žœ˜)Kš
œ"˜"šžœžœ
žœ˜Kš
œ/˜/šœžœ4˜;Kšžœžœžœ˜ š
œ˜š
œ˜Kš
œ,˜,Kšœžœ!˜.——š
œ˜Kšœžœžœ:˜K—Kš
œ˜—K˜Kšœ,žœ˜CK˜K˜—KšœŸ*˜.—Kš
œ˜š	žœ	žœ
žœ,žœ
ž˜TKšžœ¶
™¹
šžœž˜Kš
œ;˜;—šžœžœ
˜'šžœ-˜0Kšœžœ
˜—Kšžœ
žœ˜"—Kšžœ
˜—Kš
œ˜K˜—š 
œžœ
žœžœžœžœžœžœžœ˜…
Kš
œ=™=š	œžœžœžœžœ˜GKšœžœ˜Kšœžœ˜&Kš	œžœžœžœžœ ˜QšžœžœŸ˜6Kšžœžœžœ	˜+š
ž˜šžœž˜Kš	œ.žœžœ
žœžœ˜MKšžœ
˜———Kš
œ˜—Kš
œ
™
Kš
œ3˜3Kš
œ˜—K™š
 œžœ
žœžœžœ˜OKš
œ™šžœ	žœ
ž˜š
œ˜Kš
œ0˜0šžœ#˜(Kšžœ/žœ
˜9—šžœ
žœ˜šœžœ žœ˜NKš
œ+˜+——Kš
œ˜—š
œ˜šžœž˜šœŸ˜šžœ
žœ˜š
œ˜Kš
œ˜šœžœ
˜Kšžœ-˜1Kšžœ"˜&—Kš
œ˜———š
œ˜KšœžœŸ˜7Kšœžœ
˜
šžœžœ˜Kš
œ9˜9Kš
œ:˜:Kš
œ
˜
—Kšžœ-ž	œ˜Qšžœ
žœ˜šœžœ#˜7Kš
œ˜Kš
œ˜——Kš
œ˜—šžœŸ)˜6Kš
œ˜Kš
œ˜Kš
œ˜Kšœžœ
˜	Kš
œ˜Kš
œ"˜"šœ
žœ
žœ˜#Kš
œ5˜5šžœžœ
ž˜š
œ˜šžœžœ#žœ
ž˜GKš
œ(˜(Kšžœžœ
˜——š
œ˜šžœžœ#žœ
ž˜GKš
œ(˜(Kšžœžœ
˜——Kšžœžœ
˜—Kš
œ˜—Kš
œ˜Kš
œ˜Kšžœ
žœ>˜HKš
œ˜——Kš
œ˜—š
œ˜šžœ˜šžœ
˜Kš
œ˜Kšžœ'žœ
žœ
žœ˜:Kš
œ˜š
œ/˜/Kšœžœ#˜+—Kš
œ˜Kšžœžœ
žœ
žœ
˜šœžœ
˜š
œB˜BKš
œ˜Kš
œ˜——Kš
œ
˜
—šžœ
˜Kš
œ˜Kšžœ'žœ
žœ
žœ˜:Kš
œ˜šœžœ
žœ˜$Kš
œ2˜2Kš
œ˜šœžœ
žœ˜š
œ˜Kš
œB˜B——Kš
œ˜Kš
œ˜Kš
œ˜—Kš
œ˜Kšžœžœ
žœ
žœ
˜šœžœ
žœ˜)Kšœžœ�
˜Š
Kš
œ˜—Kš
œ˜Kš
œ˜———Kšžœžœ'˜7—Kš
œ˜—K™š 
œžœ
žœžœ˜CKš
œ™Kš
œ™Kš
œ
™
Kš
œ™Kš
œ™šžœ	žœ
ž˜Kšœžœ˜0š
œ˜šžœ&˜(Kšžœ
žœ
žœ
˜šžœŸ0˜6šžœ
žœ˜Kš
œ^˜^————š
œ˜šžœž˜š
œ˜K˜Kš
œ˜šžœ
žœ
˜šžœ
˜Kš
œ0˜0Kš
œ˜Kš
œ5˜5Kš
œ˜Kš
œ
˜
—šžœŸ˜Kš
œ4˜4Kš
œ˜šœžœ
žœ˜!Kš
œ/˜/Kš
œ˜šœžœ
˜-Kšœžœ˜ —Kš
œ˜KšœŸ&˜*—Kš
œ˜Kš
œ˜——šžœ
žœ˜Kš
œ
˜
Kš
œ*˜*Kš
œ˜—K˜—Kšœ
žœ˜#Kšžœžœ4˜D—Kš
œ˜—Kšžœžœ'˜7—Kš
œ˜—K™š œžœ
žœžœžœžœžœžŸœ˜‘
Kš
œ.™.Kš
œ
™
Kš
œ™šžœ?˜BKšžœžœ
žœ
žœ	žœ
žœžœ
˜4—Kš
œ˜—K˜š œžœžœ˜Ešžœ	žœ
ž˜KšœŸ
žœ
žœŸ#˜Iš
œ˜šžœž˜Kšœ
žœ
žœ,˜@Kšœžœ
žœ˜Kšžœžœ4˜D——š
œ˜šžœ&˜(šžœ˜šžœ˜šžœ˜Kš
œ˜Kš
œ˜Kšœžœ
˜Kš
œ˜šœžœ
žœ˜-Kš
œ˜Kšœžœ-žœžœžœ
žœ˜TKš
œC˜CKš
œ@˜@Kš
œ6˜6Kšžœžœ
žœ
žœ
˜KšœŸ.˜2—Kš
œ˜šžœ
˜š
ž˜šžœ
žœ˜Kš
œ˜Kš
œ&˜&Kš
œ˜——Kšžœ
žœ˜#—Kš
œ
˜
—šžœŸ˜Kš
œ˜Kš
œ˜Kš
œ;˜;Kšœžœ
˜Kš
œ˜šœžœ
žœ˜$Kš
œ2˜2Kš
œ˜šœžœ
žœ˜Kš
œ˜Kšœžœ-žœžœžœ
žœ˜TKš
œ5˜5Kš
œE˜EKš
œ(˜(Kšžœžœ
žœ
žœ
˜Kšœ'žœ˜6KšœŸ ˜$—Kš
œ˜KšœŸ)˜-—Kš
œ˜šžœ
˜šžœ
žœ
žœ˜$Kš
œ˜Kš
œ&˜&Kš
œ˜—Kšžœ
žœ˜*—Kš
œ˜——Kšœ
Ÿ˜—šžœ˜Kšžœ˜šžœ˜Kš
œ˜Kšœžœžœžœžœ
žœ˜@Kš
œ˜š
œG˜GKšœžœ˜'—Kš
œ˜Kšžœ˜Kš
œ
˜
—šžœ
˜Kš
œ˜Kš
œ;˜;Kš
œ˜šœžœ
žœ˜$Kš
œ2˜2Kšœžœžœžœžœ
žœ˜@Kš
œ˜š
œ9˜9Kšœžœ˜—Kš
œ˜KšœŸ)˜-—Kš
œ˜Kšœ'žœ˜6Kšžœ˜%Kš
œ˜—Kš
œ˜———Kšžœžœ'˜7—Kš
œ˜—K™š œžœžœžœ˜MKš
œ.™.Kš
œ™Kš
œ™Kš
žœžœ
žœ
žœ
žœ˜"šžœ	žœ
ž˜Kšœžœ
žœŸ˜6š
œ˜Kšžœ'žœ
žœ
žœ˜:Kšžœ˜šžœ˜Kšœ
žœžœ
˜Kšœžœ
˜Kš
œ˜Kš
œ˜Kš
œ˜šœžœ
žœ˜-šœžœžœžœ˜7Kšžœ
žœ
žœ
žœ˜Kšžœžœžœ
˜0Kšžœ
žœ˜Kš
œ˜—Kšœžœžœžœžœ
žœ˜@Kš
œ:˜:šžœ˜ Kšžœžœ
žœ˜.—Kš
œ@˜@Kš
œA˜AKš
œ˜—Kš
œ˜šžœ
˜šžœ
žœ
žœ˜$Kš
œ˜Kš
œ&˜&Kš
œ˜—Kšžœ
žœ˜#—Kš
œ
˜
—šžœ˜Kšœ
žœžœ
˜Kšœžœ
˜Kš
œ˜Kš
œ˜Kš
œ˜šœžœ
žœ˜$Kš
œ2˜2Kš
œ˜šœžœ
žœ˜šœžœžœžœ˜7Kšžœ
žœ
žœ
žœ˜Kšžœžœžœ
˜0Kšžœ
žœ˜Kš
œ˜—Kšœžœžœžœžœ
žœ˜@Kš
œ,˜,šžœ˜ Kšžœ)žœ
žœ˜:—Kš
œE˜EKšžœ
žœžœ4˜IKš
œ˜—Kš
œ˜KšœŸ)˜-—Kš
œ˜šžœ
˜šžœ
žœ
žœ˜$Kš
œ˜Kš
œ&˜&Kš
œ˜—šžœ˜š
œ˜Kšœ"žœ˜1—Kšžœ˜%K˜——Kš
œ˜—Kš
œ˜—š
œ˜šžœž˜š
œ
˜
Kšžœ
˜šžœŸ˜K˜K˜šœžœ
žœ˜)Kš
œ/˜/K˜šœžœ
žœ˜Kšœžœ˜;Kš
œ?˜?šžœ7žœ˜?Kš
œ˜Kš
œ;˜;Kšœžœžœ
˜š	œžœžœžœžœ˜DKšœž
˜Kš
œ˜Kšœžœ˜7Kš
žœžœ	žœžœ
žœ˜1šžœž˜šœ
žœ
ž˜Kšžœžœžœ
žœ˜&Kšžœžœ
žœ˜,——šžœ
žœ
žœ
žœ˜šžœ*žœž˜:š
ž˜Kš
žœžœ	žœ	žœ
žœ˜4Kšžœžœ
žœ
˜'—Kšžœ
˜—K˜—Kš
œ˜—š
œ#˜#Kš
œ-˜-—Kšœ*žœ˜=šœžœ#žœ
ž˜3Kšœ
žœ˜#—Kš
œ
˜
—šžœŸ˜!Kšœžœžœ
˜šœžœžœžœ˜3Kšžœžœ
žœ
žœ˜Kšžœ
žœ
žœ
˜%Kšžœ
žœ˜K˜—š
œ ˜ Kš
œ#˜#—šžœ#žœž˜3šžœ˜šœžœžœžœ˜0Kšœ
žœ
žœ˜—šžœ;žœ˜Cšœžœ˜Kš
œ˜Kš
œ-˜-Kš
œ˜—K˜
—šžœ˜!š
œ	˜	Kš
œ˜Kšžœ2˜:——Kš
œ˜——Kš
œ˜——KšœŸ#˜'K˜—KšœŸ.˜2Kš
œ˜Kš
œ
˜
—šžœŸ
˜K˜šœžœ
žœ˜-Kš
œ'˜'Kš
œM˜Mšžœ5žœ˜=Kš
œ˜Kšœžœžœ
˜š	œžœžœžœžœ˜DKšœž
˜Kš
œ˜Kšœžœ'˜EKš
žœžœ	žœžœ
žœ˜1šžœ˜
šžœ˜šžœ
ž˜Kšžœžœžœ
žœ˜&Kšžœžœ
žœ˜,——šžœ
žœ
žœ
žœ˜šžœ*žœž˜=Kš
žœžœ	žœ	žœ
žœ˜4Kšžœžœ
žœ
˜'Kšžœ
˜—K˜——Kš
œ˜—š
œ#˜#Kš
œ;˜;—šœžœ#žœ
ž˜3Kšœ
žœ˜ —Kš
œ
˜
—šžœŸ˜!Kšœžœžœ
˜šœžœžœžœ˜3Kšžœžœ
žœ
žœ˜Kšžœ
žœ
žœ
˜%Kšžœ
žœ˜K˜—š
œ ˜ Kš
œ1˜1—šžœ#žœž˜3šžœ˜Kš
œžœžœžœž
œ
žœ
žœ˜@šžœ9žœ˜Ašœžœ˜Kš
œ˜Kš
œ3˜3Kš
œ˜—K˜
—šžœ˜Kš
œ=˜=—Kš
œ˜——Kš
œ˜—KšœŸ1˜5—K˜Kš
œ˜——Kšžœžœ4˜D—Kš
œ˜—Kšžœžœ
˜—KšœŸ˜—K™š œžœ
žœžœžœ
žœžœ˜aKš
œ*™*Kš
œ@™@šžœ	žœ
ž˜š
œ˜Kš
œ˜Kš
œ˜š 	œžœ2˜AKšžœžœžœ˜ Kš
œ˜Kš
œ˜š
œ˜š
œ
˜
š
œ˜Kš
œ˜Kš
œ3˜3Kš
œ-˜-———šœžœ-žœžœ˜Lšžœ˜Kšžœ žœ
žœžœ
žœ
žœ˜E—Kš
œ˜—šžœ
žœ?˜EKšœžœ˜Kšžœžœ˜—Kšœ0žœ˜KKš
œ˜Kšœžœ1Ÿ
œžœ
Ÿ˜[Kš
œ˜—Kšžœ'žœ
žœ
žœ˜:šžœžœ
˜!Kš
œ˜šœžœ
žœ˜$Kš
œ2˜2Kš
œ˜šœžœ
žœ˜ Kš
œ'˜'Kšžœžœ
žœ
žœ
˜Kš
œ;˜;Kšžœžœ
žœ
žœ
˜—KšœŸ$˜(Kš
œ˜šœžœ
žœ˜*Kšœžœ˜#Kš	žœ
žœžœ
žœŸ ˜DKš
œ+˜+—KšœŸ0˜4Kš
œ˜—KšœŸ)˜-Kš
œ˜Kš
œ
˜
—šžœŸ
˜Kš
œ˜Kš
œ5˜5Kš
œ˜Kšœžœ˜#Kš	žœ
žœžœ
žœŸ ˜DKš
œ+˜+Kš
œ˜—Kš
œ˜—š
œ˜šžœž˜š
œ˜Kš
œa™aš
œ=˜=š
œ˜šžœžœ-˜AKšžœ"˜&——Kš
œ5˜5Kš
œ˜—Kšœžœ˜/Kš 	œžœ2˜Ašžœžœžœ˜ Kš
œ˜Kš
œ˜š
œ!˜!š
œ˜Kš
œ˜Kš
œ3˜3Kš
œ*˜*Kš
œ
˜
—Kš
œ˜—šœžœ-žœžœ˜Lšžœ˜Kšžœ žœ
žœ˜1Kšžœ
žœ
žœ˜—Kš
œ˜—šžœ
žœ?˜EKšœžœ˜Kšžœžœ˜—Kšœ0žœ˜KKš
œ˜Kšœžœ5Ÿ
œžœ˜VKš
œ˜—Kšžœžœ$žœŸ
˜MKš
œ™š
œ)˜)Kšœžœ&˜.—Kš
œ!˜!Kš
œ˜—Kšžœžœ4˜D—Kš
œ$™$Kš
œ˜—Kšžœžœ
˜—Kš
œ˜—K™š œžœ
žœžœžœ
žœžœ˜aKš
œC™Cšžœ	žœ
ž˜š
œ˜Kš
œ˜Kš
œ˜š
 	œžœ2žœžœžœ˜bKš
œ˜Kš
œ˜š
œ#˜#š
œ˜Kš
œ˜Kš
œ2˜2Kš
œ,˜,——šœžœ-žœžœ˜Lšžœ˜Kšžœ žœ
žœ˜1Kšžœ
žœ
žœ˜—Kš
œ˜—šžœ
žœ?˜EKšœžœ˜Kšžœžœ˜—Kšœ0žœ˜KKš
œ˜Kšœžœ1Ÿ
œžœ˜RKš
œ˜—šžœ&žœ˜/šžœ
žœ
žœ
žœ2˜KKšžœžœ
ž˜Kšœžœ>žœ˜SKšžœ
˜—Kšžœ
˜K˜—šžœžœ
˜!Kš
œ˜šœžœ
žœ˜$Kš
œ2˜2Kš
œ˜šœžœ
žœ˜ Kš
œ'˜'Kšžœžœ
žœ
žœ
˜Kš
œ;˜;Kšžœžœ
žœ
žœ
˜—KšœŸ$˜(Kš
œ˜šœžœ
žœ˜*Kšœžœ˜#Kš	žœ
žœžœ
žœŸ ˜DKš
œ+˜+—KšœŸ0˜4Kš
œ˜—KšœŸ)˜-Kš
œ˜Kš
œ
˜
šžœŸ
˜Kš
œ˜Kš
œ5˜5Kš
œ˜Kšœžœ˜#Kš	žœ
žœžœ
žœŸ ˜DKš
œ+˜+Kš
œ˜——Kš
œ˜—š
œ˜šžœž˜š
œ˜Kš
œa™aš
œ?˜?š
œ
˜
šžœ
˜Kšžœ-˜1Kšžœ"˜&——Kš
œ7˜7—Kšœžœ˜/š 	œžœ2˜AKšžœžœžœ˜ Kš
œ˜Kš
œ˜š
œ#˜#š
œ˜Kš
œ˜Kš
œ2˜2Kš
œ,˜,——šœžœ,žœžœ˜Lšžœ˜Kšžœ žœ
žœ˜1Kšžœ
žœ
žœ˜—Kš
œ˜—šžœ
žœ?˜EKšœžœ˜Kšžœžœ˜—Kšœ0žœ˜KKš
œ˜KšœžœAžœ˜VKš
œ˜—Kšžœžœ$žœŸ
˜MKš
œ™š
œ)˜)Kšœžœ&˜.—Kš
œ!˜!Kš
œ˜—Kšžœžœ4˜D—Kš
œ˜—Kšžœžœ
˜—Kš
œ˜—K™—š
œ™K™š
 œžœžœžœžœ˜4KšžœR˜XKš
œ˜—K˜Kš
 œžœžœžœžœ˜UK˜š œžœ&žœžœ˜RKšžœžœ'˜JKš
œ˜—K˜š 
œžœ/žœžœ˜UKšœžœ˜7Kš
œS˜SKšžœ%˜+Kš
œ˜—K˜š œžœžœ:˜~Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜š
 œžœ.žœžœžœ˜fšžœžœ žœ˜/Kšœ
žœžœ
žœ˜SKšžœ
žœ˜
Kš
œ˜—Kš
œ˜—Kš
œ"™"Kšžœ"žœ
žœ
˜0Kš
œ!˜!Kš
œ
˜
šœžœ
žœ˜ Kšœ%žœ˜8Kšžœžœžœ˜=Kš
œS˜Sšœžœ
žœ˜*Kšœžœ˜#Kš
œ4˜4KšœŸœŸ˜3—Kš
œ˜KšœŸ%˜)—Kš
œ
˜
Kš
œ˜—K˜š œžœ"žœ:˜{Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜š
 œžœ.žœžœžœ˜fšžœžœ!žœ˜/Kšœ
žœžœ
žœ˜SKšžœ
žœ˜
Kš
œ˜—Kš
œ˜—Kš
œ™Kšžœžœ
žœ
žœ
˜Kš
œ˜šœžœ
žœ˜.Kš
œ8˜8Kšžœžœžœ˜KKš
œ.˜.Kšœžœ˜#Kš
œ4˜4KšœŸ3˜7—Kš
œ˜Kš
œ˜—K˜š œžœ
žœžŸœžœ˜sKš
œ˜šžœ˜Kšžœ5˜9Kšžœ*˜.—šœ
žœ
žœ˜#Kš
œ'™'Kšœžœ
˜	Kš
œ˜šžœ˜Kšžœ`˜dKšžœO˜S—Kš
œ&˜&KšœŸ(˜,—Kš
œ˜Kš
œ˜—K™š œžœžœ˜VKš
œ2™2Kšœžœžœ
˜ Kš
œ˜Kš
œ˜Kš
œ
˜
Kšœžœžœ
˜Kšžœžœžœ
˜>Kš
œ˜Kšœžœ˜!Kš
œ˜šžœ˜Kšžœ ˜$Kšžœ(˜,—šœ
žœ
žœžœ
žœžœ˜;Kš
œ˜Kš
œ˜Kš 	œžœ/žœžœž
œ
žœ
žœ˜_Kš
œ/˜/Kšžœžœ
žœ
žœ
˜Kš
œ1˜1šœ
žœ
žœ˜#Kš
œ'™'Kš
œ:˜:Kšœžœ
˜	Kš
œ˜šžœ˜šžœ2˜6Kš
œF˜F—šžœ&˜*Kš
œ=˜=——Kš
œ&˜&KšœŸ(˜,—Kš
œ˜KšœŸ-˜1—Kšžœ
žœžœ˜(KšœŸ˜ ——K˜Kš
œ˜K˜K˜K˜—…—�HÄ“