VersionMapFromDFImpl.mesa
Russ Atkinson, December 12, 1983 1:33 pm
DIRECTORY
Basics USING [bytesPerWord],
BasicTime USING [GMT, Now, nullGMT, ToPupTime],
BcdDefs USING [BCD, NullVersion, VersionStamp],
Commander USING [CommandProc, Register],
DFUtilities USING [Date, RemoveVersionNumber],
FS USING
[Error, FileInfo, minimumStreamBufferParms, Open, OpenFile, StreamFromOpenFile, StreamOpen],
FSBackdoor USING [EnumerateCacheForInfo, InfoProc],
GenerateDFClosure USING [ActionProc, ClosureInfo, GenerateClosureToProc],
IFSFile USING
[Close, Completer, Error, FileHandle, Finalize, FSInstance, Initialize, Login, Logout, Open, Problem, StartRead, UnableToLogin],
IO USING
[Close, EndOfStream, GetIndex, GetTokenRope, IDProc, PutChar, PutF, PutFR, PutRope, RIS, SetIndex, SetLength, STREAM, UnsafeGetBlock],
MessagesOut USING [PutRopes],
PriorityQueue USING [Insert, Predict, Ref, Remove, Size, SortPred],
Process USING [Pause, SecondsToTicks],
ProcessExtras USING [CheckForAbort],
Rope USING
[Concat, Equal, Fetch, Find, Flatten, FromProc, Index, Length, Match, ROPE, Run, Size, SkipTo, Substr],
UserCredentials USING [Get],
VersionMap USING
[FillInShortNames, Map, MapEntry, MapList, MapRep, MyStamp, Range, RangeList, RangeToEntry, RestoreMapFromFile, SaveMapToFile, ShortNameToRanges, VersionToName],
ViewerIO USING [CreateViewerStreams];
VersionMapFromDFImpl: CEDAR MONITOR
LOCKS myData USING myData: MyData
IMPORTS
BasicTime, Commander, DFUtilities, FS, FSBackdoor, GenerateDFClosure, IFSFile, IO, MessagesOut, PriorityQueue, Process, ProcessExtras, Rope, UserCredentials, VersionMap, ViewerIO
SHARES IO, VersionMap
= BEGIN
T Y P E S
BCD: TYPE = BcdDefs.BCD;
bytesPerWord: NAT = Basics.bytesPerWord;
Date: TYPE = DFUtilities.Date;
LORA: TYPE = LIST OF REF ANY;
PQ: TYPE = PriorityQueue.Ref;
GMT: TYPE = BasicTime.GMT;
Map: TYPE = VersionMap.Map;
MapList: TYPE = VersionMap.MapList;
MapEntry: TYPE = VersionMap.MapEntry;
MapRep: TYPE = VersionMap.MapRep;
MyStamp: TYPE = VersionMap.MyStamp;
NullStamp: MyStamp = LOOPHOLE[NullVersion];
MyStampAsHex: TYPE = PACKED ARRAY [0..12) OF [0..16);
ROPE: TYPE = Rope.ROPE;
RopeList: TYPE = LIST OF ROPE;
STREAM: TYPE = IO.STREAM;
VersionStamp: TYPE = BcdDefs.VersionStamp;
NullVersion: VersionStamp = BcdDefs.NullVersion;
FileEntry: TYPE = REF FileEntryRep;
FileEntryRep: TYPE = RECORD [
name: ROPE, date: Date, version: VersionStamp, from: ROPE];
NameSeq: TYPE = REF NameSeqRep;
NameSeqRep: TYPE = RECORD [
SEQUENCE len: NAT OF NameEntry];
NameEntry: TYPE = RECORD [hasPrefix: BOOL, name: ROPE];
MyData: TYPE = REF MyDataRep;
MyDataRep: TYPE = MONITORED RECORD [
sourceQueue: PQ ← NIL,
objectQueue: PQ ← NIL,
objectFiles,sourceFiles: INT ← 0,
oldObjectMap: MapList ← NIL,
oldSourceMap: MapList ← NIL,
prefix: ROPE ← NIL,
errs: STREAM ← NIL,
remoteHandle: IFSFile.FSInstance ← NIL,
remoteHandleServer: ROPE ← NIL,
remoteHandleReleased: CONDITION,
which: {source, object, both} ← both,
checkRemote: BOOL ← TRUE,
remoteHandleOwned: NAT ← 0,
abortRequested: BOOL ← FALSE
];
Single file processing
EachFile: GenerateDFClosure.ActionProc = {
[data: REF, kind: {file, notFound, syntaxError}, name: ROPE, date: Date, from: ROPE]
myData: MyData ← NARROW[data];
CheckAbort[myData];
SELECT kind FROM
file => {
needsVersion: BOOL ← FALSE;
isBcd: BOOL ← FALSE;
entry: FileEntry ← NEW[FileEntryRep ← [
name: name, date: date, version: NullVersion, from: from]];
triesLeft: NAT ← 10; -- must be >= 1
IF Rope.Match["*!*", name]
THEN
isBcd ← Rope.Match["*.symbols!*", name, FALSE]
OR Rope.Match["*.bcd!*", name, FALSE]
ELSE
isBcd ← Rope.Match["*.symbols", name, FALSE]
OR Rope.Match["*.bcd", name, FALSE];
IF myData.prefix = NIL AND NOT Rope.Match["[]*", name] THEN {
We need to establish the remote prefix
pos: INT ← Rope.Find[name, ">"];
IF pos > 0 THEN myData.prefix ← Rope.Flatten[name, 0, pos+1];
};
IF myData.prefix # NIL THEN
Check file for prefix occurence, give warning if missing
IF Rope.Run[myData.prefix, 0, name, 0, FALSE] # Rope.Length[myData.prefix]
THEN MessagesOut.PutRopes[
myData.errs, "Prefix warning: ", name, "\n from: ", from];
DO
ENABLE
FS.Error => {
SELECT error.code FROM
$serverInaccessible => {
MessagesOut.PutRopes[myData.errs, "Server glitch: ", name];
IF (triesLeft ← triesLeft - 1) # 0 THEN LOOP;
};
ENDCASE;
MessagesOut.PutRopes[
myData.errs, "File not found: ", name,
IO.PutFR["\n from: %g\n reason: %g\n",
[rope[from]], [rope[error.explanation]]]];
IF error.group # bug THEN EXIT ELSE REJECT;
};
IF isBcd
THEN
SELECT myData.which FROM
object,both => FillInObjectVersion[myData, entry, myData.checkRemote];
ENDCASE
ELSE
SELECT myData.which FROM
source,both => FillInSourceVersion[myData, entry, myData.checkRemote];
ENDCASE;
EXIT;
ENDLOOP;
};
ENDCASE;
};
FillInSourceVersion: PROC
[myData: MyData, entry: FileEntry, checkRemote: BOOL ← TRUE] = {
created: BasicTime.GMT ← entry.date.gmt;
full: ROPE ← entry.name;
attached: ROPE ← NIL;
version: VersionStamp;
useFileSystem: BOOL ← FALSE;
IF entry.date.format = explicit AND created # BasicTime.nullGMT
THEN {
There is an explicit date in the DF file
version ← [0, 0, BasicTime.ToPupTime[created]];
IF checkRemote THEN {
We have been instructed to verify the DF file date, either through the remote server OR through the old source version map.
IF myData.oldSourceMap = NIL
THEN useFileSystem ← TRUE
ELSE {
We have been instructed to TRUST the old map (if the file is present)
full ← VersionMap.VersionToName[myData.oldSourceMap, version].name;
IF full = NIL THEN {useFileSystem ← TRUE; full ← entry.name};
};
};
}
ELSE {
For a non-explicit date, we can't trust anything.
useFileSystem ← TRUE;
created ← BasicTime.nullGMT;
checkRemote ← TRUE;
};
At this point, created = BasicTime.nullGMT if we are supposed to check the rremote file server. If this check fails, it is the caller's responsibility to handle the error.
IF useFileSystem THEN {
IF created = BasicTime.nullGMT THEN full ← DFUtilities.RemoveVersionNumber[full];
[created: created, fullFName: full, attachedTo: attached] ← FS.FileInfo[
name: full, wantedCreatedTime: created, remoteCheck: checkRemote];
version ← [0, 0, BasicTime.ToPupTime[created]];
};
At this point, created # BasicTime.nullGMT, and the full name is presumed correct (although attached may take precedence as the 'real' name). So it is time to insert this file entry into the priority queue.
entry.date ← [format: explicit, gmt: created];
entry.version ← version;
IF attached # NIL THEN entry.name ← attached ELSE entry.name ← full;
PriorityQueue.Insert[myData.sourceQueue, entry];
myData.sourceFiles ← myData.sourceFiles + 1;
};
FillInObjectVersion: PROC
[myData: MyData, entry: FileEntry, checkRemote: BOOL ← TRUE] = {
Read the version number from the BCD. Too bad we have to get the whole file!
outerCreated: BasicTime.GMT ← entry.date.gmt;
full: ROPE ← entry.name;
attached: ROPE ← NIL;
valid: BOOL ← FALSE; -- indicates validity of version stamp
IF entry.date.format # explicit THEN {
outerCreated ← BasicTime.nullGMT;
full ← DFUtilities.RemoveVersionNumber[full];
};
For object files we are not sure whether we can trust the version number, so we MUST ask the file system. We use the resulting full file name as the truth when searching the old object map. As a side effect, the date in the entry is now explicit.
[created: outerCreated, fullFName: full, attachedTo: attached] ← FS.FileInfo[
name: full, wantedCreatedTime: outerCreated, remoteCheck: checkRemote];
entry.date ← [format: explicit, gmt: outerCreated];
IF attached # NIL THEN full ← attached;
entry.name ← full;
[valid, entry.version] ← FindShortObjectName[myData, full];
IF NOT valid THEN {
We have to check the file itself, rather than trust the old symbols map
cacheChecker: FSBackdoor.InfoProc = {
[fullGName: ROPE, created: BasicTime.GMT, bytes: INT, keep: CARDINAL]
RETURNS [continue: BOOLEAN]
IF outerCreated = created AND bytes > 0 THEN {
full ← fullGName;
inCache ← TRUE;
RETURN [FALSE];
};
RETURN [TRUE];
};
inCache: BOOL ← FALSE;
FSBackdoor.EnumerateCacheForInfo[cacheChecker, NIL, full];
IF inCache
THEN {
We can afford to open the file on the local disk, since this is better than trying to open the remote file.
file: FS.OpenFile ← FS.Open[
name: full, lock: read, wantedCreatedTime: outerCreated, remoteCheck: FALSE];
stream: STREAM ← FS.StreamFromOpenFile[
openFile: file, streamBufferParms: FS.minimumStreamBufferParms];
TRUSTED {
ENABLE UNWIND => IO.Close[stream];
versionOffset: NAT = bytesPerWord*SIZE[CARDINAL];
versionBytes: NAT = bytesPerWord*SIZE[VersionStamp];
IO.SetIndex[stream, versionOffset];
[] ← IO.UnsafeGetBlock[
stream, [LOOPHOLE[@entry.version], 0, versionBytes]];
};
IO.Close[stream];
}
ELSE {
We should try to use the remote server for this file.
serverPos: INT = Rope.SkipTo[full, 1, "]"];
server: ROPE = Rope.Flatten[full, 1, serverPos-1];
rest: ROPE = Rope.Flatten[full, serverPos+1];
IF AcquireRemoteHandle[myData, server]
THEN {
{ENABLE UNWIND => ReleaseRemoteHandle[myData];
[valid, entry.version] ← VersionStampFromRemoteHandle[
myData, server, rest, outerCreated];
};
ReleaseRemoteHandle[myData];
IF NOT valid THEN {
We could not find the file, so give a message and return
MessagesOut.PutRopes[myData.errs, "File not found: ", full];
RETURN;
};
}
ELSE {
We could NOT get to the server, a message has been produced by AcquireRemoteHandle, so we can just return?
RETURN;
};
};
};
PriorityQueue.Insert[myData.objectQueue, entry];
myData.objectFiles ← myData.objectFiles + 1;
};
EntrySortPred: PriorityQueue.SortPred = TRUSTED {
[x: Item, y: Item, data: REF ← NIL] RETURNS [BOOL]
xx: MyStamp = LOOPHOLE[LOOPHOLE[x, FileEntry].version];
yy: MyStamp = LOOPHOLE[LOOPHOLE[y, FileEntry].version];
IF xx.num # yy.num THEN RETURN [xx.num < yy.num];
IF xx.hi # yy.hi THEN RETURN [xx.hi < yy.hi];
RETURN [xx.lo < yy.lo];
};
VersionSortPred: PROC [xx,yy: MyStamp] RETURNS [BOOL] = TRUSTED {
IF xx.num # yy.num THEN RETURN [xx.num < yy.num];
IF xx.hi # yy.hi THEN RETURN [xx.hi < yy.hi];
RETURN [xx.lo < yy.lo];
};
VersionMapFromPQ: PROC
[pq: PQ, prefix: ROPE, myData: MyData] RETURNS [map: Map] = {
currentName: ROPE ← prefix ← Rope.Flatten[prefix];
prefixLen: NAT = Rope.Size[prefix];
pos: INT ← prefixLen+1;
entries: NAT = PriorityQueue.Size[pq];
seq: NameSeq ← NEW[NameSeqRep[entries]];
entryIndex: NAT ← 0;
subPos: NAT ← 0;
subLim: NAT ← prefixLen;
lastPos: INT ← 0;
lag: FileEntry ← NIL;
getChar: PROC [] RETURNS [c: CHAR] = {
IF subPos < subLim THEN {
c ← currentName.Fetch[subPos];
subPos ← subPos + 1;
RETURN;
};
c ← '\n;
IF entryIndex < entries THEN {
nameEntry: NameEntry ← seq[entryIndex];
currentName ← nameEntry.name;
subLim ← Rope.Length[currentName];
IF nameEntry.hasPrefix THEN subPos ← prefixLen ELSE subPos ← 0;
entryIndex ← entryIndex + 1;
};
};
ProcessExtras.CheckForAbort[];
map ← NEW[MapRep[entries]];
FOR i: NAT IN [0..entries) DO
entry: FileEntry = NARROW[PriorityQueue.Remove[pq]];
name: ROPE = entry.name;
hasPrefix: BOOL = Rope.Run[name, 0, prefix, 0, FALSE] = prefixLen;
seq[i] ← [hasPrefix, name];
map[i] ← [stamp: LOOPHOLE[entry.version], index: pos];
pos ← pos + Rope.Length[name] + 1;
IF hasPrefix THEN pos ← pos - prefixLen;
IF lag # NIL AND lag.version = entry.version THEN {
Warn the user that there are duplicate versions
MessagesOut.PutRopes[myData.errs,
"Warning, duplicate versions for",
IO.PutFR["\n %g\n from: %g", [rope[lag.name]], [rope[lag.from]]],
IO.PutFR["\n %g\n from: %g", [rope[entry.name]], [rope[entry.from]]]
];
};
lag ← entry;
ENDLOOP;
map.names ← Rope.FromProc[pos, getChar, 4040];
VersionMap.FillInShortNames[map];
};
WriteMapToFile: PROC [map: Map, name: ROPE] = {
prefix: ROPE ← NIL;
st: IO.STREAM ← FS.StreamOpen[name, create];
count: NAT ← map.len;
names: ROPE ← map.names;
firstCR: INT ← names.Index[0, "\n"];
ProcessExtras.CheckForAbort[];
prefix ← names.Flatten[0, firstCR];
IO.PutRope[st, prefix];
IO.PutRope[st, "\n"];
FOR i: NAT IN [0..map.len) DO
Display the entry.
entry: MapEntry ← map[i];
index: INT ← entry.index;
stamp: MyStamp ← entry.stamp;
PutStampAsHex[st, stamp];
IO.PutRope[st, " "];
DO
c: CHAR ← names.Fetch[index];
index ← index + 1;
IO.PutChar[st, c];
IF c = '\n THEN EXIT;
ENDLOOP;
ENDLOOP;
IO.PutRope[st, "\n"];
IO.SetLength[st, IO.GetIndex[st]]; -- force goddamm truncation already!!!
IO.Close[st];
};
IndexToShortName: PROC [map: Map, index: INT] RETURNS [ROPE] = {
Return the name without the prefix or version
names: ROPE ← map.names;
end: INT ← names.SkipTo[index, "!\n"];
pos: INT ← end;
WHILE pos > index DO
SELECT names.Fetch[pos] FROM
'/, '], '> => EXIT;
ENDCASE;
pos ← pos - 1;
ENDLOOP;
RETURN [names.Substr[pos, end-pos]];
};
PutStampAsHex: PROC [st: IO.STREAM, stamp: MyStamp] = {
hex: MyStampAsHex ← LOOPHOLE[stamp];
FOR index: CARDINAL IN [0..12) DO
x: CARDINAL [0..15] ← hex[index];
c: CHAR ← IF x IN [0..9] THEN '0 + x ELSE 'A + (x-10);
st.PutChar[c];
ENDLOOP;
};
ScanName: PROC [name: ROPE] RETURNS [pos,bang,dot: INT] = {
len: INT = Rope.Length[name];
pos ← bang ← dot ← len;
WHILE pos > 0 DO
posM: INT = pos-1;
SELECT Rope.Fetch[name, posM] FROM
'! => bang ← dot ← posM;
'. => dot ← posM;
'>, '/, '] => RETURN;
ENDCASE;
pos ← posM;
ENDLOOP;
};
CheckAbort: ENTRY PROC [myData: MyData] = {
... puts out the given ropes to the MessageWindow. This is an entry procedure to keep the message in the MessageWindow consistent.
ENABLE UNWIND => myData.abortRequested ← TRUE;
IF myData.abortRequested THEN RETURN WITH ERROR ABORTED;
ProcessExtras.CheckForAbort[];
};
CheckAbortInternal: INTERNAL PROC [myData: MyData] = {
... puts out the given ropes to the MessageWindow. This is an entry procedure to keep the message in the MessageWindow consistent.
ENABLE UNWIND => myData.abortRequested ← TRUE;
IF myData.abortRequested THEN RETURN WITH ERROR ABORTED;
ProcessExtras.CheckForAbort[];
};
RemoteHandle stuff (to avoid races in using it)
AcquireRemoteHandle: ENTRY PROC
[myData: MyData, server: ROPE] RETURNS [ok: BOOL ← TRUE] = {
ENABLE UNWIND => myData.abortRequested ← TRUE;
fs: IFSFile.FSInstance ← NIL;
problem: IFSFile.Problem ← ok;
CheckAbortInternal[myData];
IF myData.remoteHandle # NIL THEN
IF NOT Rope.Equal[myData.remoteHandleServer, server, FALSE] THEN TRUSTED {
We have a server open, but it is the wrong one, so close it. Notice that we have limited remote handle ownership to one per process by this approach, since if the current process already owns the wrong server, we will never exit this loop. This is OK, since each process handles only one file at a time when using IFSFile.
WHILE myData.remoteHandleOwned # 0 DO
CheckAbortInternal[myData];
WAIT myData.remoteHandleReleased;
ENDLOOP;
fs ← myData.remoteHandle;
myData.remoteHandle ← NIL;
IF fs # NIL THEN IFSFile.Logout[fs];
};
IF myData.remoteHandle = NIL THEN TRUSTED {
There is no remote handle, so open one
userName,password: ROPE;
[userName,password] ← UserCredentials.Get[];
fs ← IFSFile.Login[server, userName, password
! IFSFile.UnableToLogin => {
why: ROPE ← "Remote access failed for ";
SELECT problem FROM
credentials => why ← "Invalid credentials for ";
io => why ← "Server not found: ";
ENDCASE;
MessagesOut.PutRopes[myData.errs, why, server];
GO TO notGood;
}];
myData.remoteHandle ← fs;
myData.remoteHandleServer ← server;
};
myData.remoteHandleOwned ← myData.remoteHandleOwned + 1;
EXITS notGood => ok ← FALSE;
};
NotOwned: ERROR = CODE;
ReleaseRemoteHandle: ENTRY PROC [myData: MyData] = {
ENABLE UNWIND => myData.abortRequested ← TRUE;
IF myData.remoteHandleOwned = 0 THEN RETURN WITH ERROR NotOwned;
myData.remoteHandleOwned ← myData.remoteHandleOwned - 1;
CheckAbortInternal[myData];
};
FinalizeRemoteHandle: ENTRY PROC [myData: MyData] = TRUSTED {
ENABLE UNWIND => myData.abortRequested ← TRUE;
fs: IFSFile.FSInstance ← NIL;
WHILE myData.remoteHandleOwned # 0 DO
WAIT myData.remoteHandleReleased;
ENDLOOP;
fs ← myData.remoteHandle;
myData.remoteHandle ← NIL;
IF fs # NIL THEN IFSFile.Logout[fs];
IFSFile.Finalize[];
CheckAbortInternal[myData];
};
VersionStampFromRemoteHandle: PROC
[myData: MyData, server,name: ROPE, created: GMT]
RETURNS [valid: BOOL ← FALSE, stamp: VersionStamp] = TRUSTED {
ENABLE UNWIND => myData.abortRequested ← TRUE;
completed: CONDITION;
problem: IFSFile.Problem ← ok;
OnCompletion: IFSFile.Completer = TRUSTED {
problem ← outcome;
NoteCompleted[myData];
};
NoteCompleted: ENTRY PROC [myData: MyData] = TRUSTED {
BROADCAST completed;
};
WaitForCompleted: ENTRY PROC [myData: MyData] = TRUSTED {
WAIT completed;
};
bcd: BCD;
ifsFile: IFSFile.FileHandle ← NIL;
bcd.version ← NullVersion;
ProcessExtras.CheckForAbort[];
FOR pause: NAT IN [2..7] DO
ifsFile ← IFSFile.Open[myData.remoteHandle, name
! IFSFile.Error => {problem ← reason; CONTINUE}];
IF problem = ok THEN EXIT;
MessagesOut.PutRopes[myData.errs, "File open glitch: [", server, "]", name];
Process.Pause[Process.SecondsToTicks[pause/2]];
ENDLOOP;
IF problem = ok THEN {
FOR pause: NAT IN [2..7] DO
IFSFile.StartRead[
ifsFile, 0, SIZE[BCD]*bytesPerWord, LOOPHOLE[LONG[@bcd]], OnCompletion, NIL];
WaitForCompleted[myData];
IF problem = ok THEN EXIT;
MessagesOut.PutRopes[myData.errs, "File access glitch: [", server, "]", name];
Process.Pause[Process.SecondsToTicks[pause/2]];
ENDLOOP;
IFSFile.Close[ifsFile];
valid ← problem = ok;
stamp ← bcd.version;
};
};
Routines to use the old maps for verification of names
ShortName: PROC
[full: ROPE] RETURNS [ROPE] = {
pos: INT ← Rope.Length[full];
lim: INT ← pos;
WHILE pos > 0 DO
c: CHAR = Rope.Fetch[full, pos←pos-1];
SELECT c FROM
'! => lim ← pos;
'>, '] => {pos ← pos + 1; EXIT};
ENDCASE;
ENDLOOP;
RETURN [Rope.Flatten[full, pos, lim-pos]];
};
FindShortObjectName: PROC
[myData: MyData, full: ROPE] RETURNS [valid: BOOL ← FALSE, stamp: VersionStamp] = {
IF myData.oldObjectMap # NIL THEN {
short: ROPE = ShortName[full];
rangeList: VersionMap.RangeList ←
VersionMap.ShortNameToRanges[myData.oldObjectMap, short];
WHILE rangeList # NIL DO
range: VersionMap.Range ← rangeList.first;
rangeList ← rangeList.rest;
WHILE range.len # 0 DO
name: ROPE;
stamp: VersionStamp;
[name, stamp, range] ← VersionMap.RangeToEntry[range];
IF Rope.Equal[full, name, FALSE] THEN RETURN [TRUE, stamp];
ENDLOOP;
ENDLOOP;
At this point we did NOT get a match, so flake out!
valid ← FALSE;
};
};
Main command routine
warningList: RopeList ← LIST["[Indigo]<Cedar>*", "[Ivy]*"];
GenMap: Commander.CommandProc = {
[cmd: Handle] RETURNS [result: REF ← NIL, msg: ROPE ← NIL]
ris: STREAM = IO.RIS[cmd.commandLine];
token: ROPE ← "CurrentCedar";
dump: BOOL ← TRUE;
dumpDebug: BOOL ← TRUE;
namesOnly: BOOL ← FALSE;
remoteOpened: BOOL ← FALSE;
pos,bang,dot: INT ← 0;
inName,sourceName,objectName,outPrefix: ROPE ← NIL;
command: ROPE ← cmd.command;
forkers: NAT ← 0;
results: GenerateDFClosure.ClosureInfo;
myData: MyData;
sourceMap: Map ← NIL;
objectMap: Map ← NIL;
checkRemote: BOOL ← TRUE;
inLog,outLog: STREAM ← NIL;
genMaps: BOOL ← FALSE; -- gen regular version maps if TRUE
trustOld: BOOL ← FALSE; -- trust old version maps if TRUE
token ← IO.GetTokenRope[ris, IO.IDProc ! IO.EndOfStream => CONTINUE].token;
[pos,bang,dot] ← ScanName[inName ← token];
IF bang = Rope.Size[inName] -- no version stuff
AND (bang-dot # 3 OR Rope.Run[inName, dot, ".df", 0, FALSE] # 3) -- no DF extension
THEN inName ← Rope.Concat[token, ".df"];
inName ← FS.FileInfo[inName
! FS.Error =>
IF error.group # bug THEN {
IO.PutF[
cmd.out, "\nCan't open %g\n %g\n",
[rope[inName]], [rope[error.explanation]]];
GO TO quit;
};
].fullFName;
[inLog,outLog] ← ViewerIO.CreateViewerStreams[
"VersionMapBuilder.log", NIL, "VersionMapBuilder.log", FALSE];
[pos,bang,dot] ← ScanName[inName];
outPrefix ← Rope.Flatten[inName, pos, dot-pos];
IO.PutF[outLog, "\nVersion Map Builder started at %g", [time[BasicTime.Now[]]]];
IO.PutF[outLog, "\n\nInput from: %g\n", [rope[inName]]];
sourceName ← Rope.Concat[outPrefix, ".sourceMap"];
objectName ← Rope.Concat[outPrefix, ".objectMap"];
TRUSTED {IFSFile.Initialize[]};
{ENABLE
UNWIND => {
FinalizeRemoteHandle[myData];
};
SELECT TRUE FROM
Rope.Equal[command, "TestMap", FALSE] => {
forkers ← 0;
};
Rope.Equal[command, "TestMap1", FALSE] => {
forkers ← 1;
};
Rope.Equal[command, "TestMap2", FALSE] => {
forkers ← 2;
};
Rope.Equal[command, "TestMap3", FALSE] => {
forkers ← 3;
};
Rope.Equal[command, "TestMap4", FALSE] => {
forkers ← 4;
};
Rope.Equal[command, "TestMap8", FALSE] => {
forkers ← 8;
};
Rope.Equal[command, "GenMap", FALSE] => {
forkers ← 2;
genMaps ← TRUE;
};
Rope.Equal[command, "MergeMap", FALSE] => {
forkers ← 2;
trustOld ← genMaps ← TRUE;
};
Rope.Equal[command, "GenCedarMap", FALSE] => {
forkers ← 2;
genMaps ← TRUE;
outPrefix ← "Cedar";
};
Rope.Equal[command, "MergeCedarMap", FALSE] => {
forkers ← 2;
trustOld ← genMaps ← TRUE;
outPrefix ← "Cedar";
};
ENDCASE;
myData ← NEW[MyDataRep ← [
sourceQueue: PriorityQueue.Predict[2000, EntrySortPred],
objectQueue: PriorityQueue.Predict[1500, EntrySortPred],
errs: outLog,
checkRemote: checkRemote
]];
IF genMaps THEN {
sourceName ← Rope.Concat[outPrefix, "Source.VersionMap"];
objectName ← Rope.Concat[outPrefix, "Symbols.VersionMap"];
};
IF trustOld THEN {
Setup the old maps (if any); also make an index for the object map.
IO.PutRope[outLog, "\nReading old maps."];
myData.oldSourceMap ← LIST[
VersionMap.RestoreMapFromFile[sourceName
! FS.Error => {
IO.PutRope[outLog, "\nWarning, can't read "];
IO.PutRope[outLog, sourceName];
CONTINUE}]
];
myData.oldObjectMap ← LIST[
VersionMap.RestoreMapFromFile[objectName
! FS.Error => {
IO.PutRope[outLog, "\nWarning, can't read "];
IO.PutRope[outLog, objectName];
GO TO exit}]
];
EXITS exit => {};
};
CheckAbort[myData];
myData.which ← both;
IO.PutRope[outLog, "\nGenerating DF closure."];
results ← GenerateDFClosure.GenerateClosureToProc[
inName, outLog, EachFile, myData, [toFork: forkers]];
};
FinalizeRemoteHandle[myData];
IO.PutF[outLog, "\n\n%g DF files, %g source files, %g object files.\n",
[integer[results.dfFiles]], [integer[myData.sourceFiles]], [integer[myData.objectFiles]]];
IO.PutRope[outLog, "\nMaking short name index for source map."];
sourceMap ← VersionMapFromPQ[myData.sourceQueue, myData.prefix, myData];
CheckAbort[myData];
IO.PutRope[outLog, "\n\nWriting "];
IO.PutRope[outLog, sourceName];
IO.PutRope[outLog, "\n"];
IF genMaps
THEN VersionMap.SaveMapToFile[sourceMap, sourceName]
ELSE WriteMapToFile[sourceMap, sourceName];
IO.PutRope[outLog, "\nMaking short name index for object map."];
objectMap ← VersionMapFromPQ[myData.objectQueue, myData.prefix, myData];
CheckAbort[myData];
IO.PutRope[outLog, "\n\nWriting "];
IO.PutRope[outLog, objectName];
IO.PutRope[outLog, "\n"];
IF genMaps
THEN VersionMap.SaveMapToFile[objectMap, objectName]
ELSE WriteMapToFile[objectMap, objectName];
IO.PutF[outLog, "\n\nVersion maps built at %g\n\n", [time[BasicTime.Now[]]]];
IO.Close[inLog];
IO.Close[outLog];
EXITS quit => {};
};
Commander.Register["GenMap", GenMap];
stores to *Source.VersionMap & *Symbols.VersionMap
Commander.Register["MergeMap", GenMap];
stores to *Source.VersionMap & *Symbols.VersionMap
Commander.Register["GenCedarMap", GenMap];
stores to CedarSource.VersionMap & CedarSymbols.VersionMap
Commander.Register["MergeCedarMap", GenMap];
stores to CedarSource.VersionMap & CedarSymbols.VersionMap
END.