-- VersionPack.Mesa  Edited by Sandman on July 8, 1980  9:02 AM  
-- Copyright  Xerox Corporation 1979, 1980

DIRECTORY
  AltoDefs USING [BytesPerWord, PageSize],
  BcdDefs USING [BCD, FTIndex, FTRecord, VersionID, VersionStamp, Base],
  BcdOps USING [NameString],
  FastDirDefs USING [
    LookupItem, ScanDir, AllFileSwitches, Cap, StripExtension, FileType,
    GetExtension, ItemHandle],
  ImageDefs USING [StopMesa],
  ImageFormat USING [VersionID],
  IODefs USING [
    CR, ReadChar, ReadID, SP, WriteChar, WriteDecimal, WriteLine, WriteOctal,
    WriteString],
  SegmentDefs USING [
    DeleteFileSegment, FileSegmentAddress, FileSegmentHandle, InsertFile,
    MoveFileSegment, NewFileSegment, Read, SwapIn, Unlock],
  StreamDefs USING [
    CreateByteStream, NewByteStream, Read, ReadBlock, StreamHandle],
  StringDefs USING [
    AppendChar, AppendSubString, EquivalentString, StringToDecimal,
    SubStringDescriptor],
  Storage USING [Pages, FreePages],
  TimeDefs USING [
    AppendDayTime, DefaultTime, InvalidTime, PackDT, PackedTime, UnpackDT,
    UnpackedTime];

VersionPack: PROGRAM
  IMPORTS
    FastDirDefs, ImageDefs, IODefs, SegmentDefs, StreamDefs, StringDefs, Storage,
    TimeDefs =
  BEGIN OPEN IODefs, StreamDefs, StringDefs;
  
  BcdBase: TYPE = POINTER TO BcdDefs.BCD;
  UnpackedTime: TYPE = TimeDefs.UnpackedTime;
  
  BinaryVersion: VersionProc =
    BEGIN OPEN SegmentDefs;
    bcd: BcdBase;
    seg: FileSegmentHandle _ NewFileSegment[
      InsertFile[@info.fp, Read], 1, 1, Read];
    SwapIn[seg];
    bcd _ FileSegmentAddress[seg];
    SELECT bcd.versionIdent FROM
      BcdDefs.VersionID =>
	BEGIN
	PrintVersion[bcd.version];
	WriteChar[CR];
	IF type = bcd AND verbose THEN
	  BEGIN
	  IF bcd.nPages > 1 THEN
	    BEGIN
	    Unlock[seg];
	    MoveFileSegment[seg, 1, bcd.nPages];
	    SwapIn[seg];
	    bcd _ FileSegmentAddress[seg];
	    END;
	  PrintFileVersions[bcd];
	  END;
	END;
      ImageFormat.VersionID =>
	BEGIN PrintVersion[bcd.version]; WriteChar[CR]; END;
      ENDCASE =>
	BEGIN
	WriteString[" unknown version ID "L];
	WriteDecimal[bcd.versionIdent];
	WriteChar[CR];
	END;
    Unlock[seg];
    DeleteFileSegment[seg];
    RETURN
    END;
    
  BufferObject: TYPE = RECORD [p: CARDINAL, s: STRING];
  Buffer: TYPE = POINTER TO BufferObject;
  
  SourceDate: VersionProc =
    BEGIN OPEN AltoDefs;
    LI: TYPE = LONG INTEGER;
    date, tdate: TimeDefs.PackedTime;
    b: BufferObject;
    stream: StreamHandle;
    found: BOOLEAN _ FALSE;
    stream _ CreateByteStream[SegmentDefs.InsertFile[@info.fp, Read], Read];
    b.s _ Storage.Pages[1];
    b.s^ _
      [length: 0, maxlength: (PageSize - SIZE[StringBody])*BytesPerWord, text:];
    b.s.length _
      ReadBlock[stream, @b.s.text, b.s.maxlength/BytesPerWord]*BytesPerWord;
    b.p _ 0;
    [found, date] _ GetDate[@b ! TimeDefs.InvalidTime => CONTINUE];
    IF found THEN
      BEGIN
      DO
	[found, tdate] _ GetDate[@b ! TimeDefs.InvalidTime => EXIT];
	IF ~found THEN EXIT;
	IF LOOPHOLE[tdate, LI] > LOOPHOLE[date, LI] THEN date _ tdate;
	ENDLOOP;
      WriteChar[' ];
      PrintDate[TimeDefs.UnpackDT[date]];
      END
    ELSE WriteString[" ?"L];
    WriteChar[CR];
    Storage.FreePages[b.s];
    stream.destroy[stream];
    RETURN
    END;
    
  GetDate: PROCEDURE [b: Buffer] RETURNS [BOOLEAN, TimeDefs.PackedTime] =
    BEGIN
    token: STRING _ [20];
    found: BOOLEAN _ FALSE;
    index: CARDINAL [0..12);
    u: UnpackedTime _ [0, 0, 0, 0, 0, 0, 0, 0, FALSE];
    NextItem[b, token];
    WHILE token.length # 0 DO
      [found, index] _ IsMonth[token];
      IF found THEN
	BEGIN
	NextItem[b, token];
	IF IsNumber[token] THEN
	  BEGIN u.month _ index; u.day _ StringToDecimal[token]; END
	ELSE LOOP;
	END
      ELSE
	IF IsNumber[token] THEN -- possible Day-Mo-Yr form
	  BEGIN
	  u.day _ StringToDecimal[token];
	  NextItem[b, token];
	  [found, index] _ IsMonth[token];
	  IF found THEN u.month _ index ELSE LOOP;
	  END;
      IF found THEN
	BEGIN
	NextItem[b, token];
	IF IsNumber[token] THEN
	  BEGIN
	  u.year _ StringToDecimal[token];
	  IF u.year < 100 THEN u.year _ u.year + 1900;
	  END
	ELSE LOOP;
	NextItem[b, token];
	IF IsNumber[token] THEN
	  BEGIN
	  u.hour _ StringToDecimal[token];
	  NextItem[b, token];
	  IF IsNumber[token] THEN u.minute _ StringToDecimal[token];
	  NextItem[b, token];
	  IF EquivalentString[token, "PM"L] AND u.hour < 12 THEN
	    u.hour _ u.hour + 12;
	  END;
	RETURN[TRUE, TimeDefs.PackDT[u, TRUE]]
	END;
      NextItem[b, token];
      ENDLOOP;
    RETURN[FALSE, TimeDefs.DefaultTime]
    END;
    
  IsMonth: PROCEDURE [candidate: STRING] RETURNS [BOOLEAN, CARDINAL] =
    BEGIN
    Months: ARRAY [0..12) OF STRING =
      ["JANUARY"L, "FEBRUARY"L, "MARCH"L, "APRIL"L, "MAY"L, "JUNE"L, "JULY"L,
	"AUGUST"L, "SEPTEMBER"L, "OCTOBER"L, "NOVEMBER"L, "DECEMBER"L];
    i, j: CARDINAL;
    test: STRING;
    IF candidate.length >= 3 THEN
      FOR i IN [0..12) DO
	test _ Months[i];
	IF candidate.length <= test.length THEN
	  FOR j IN [0..candidate.length) DO
	    IF FastDirDefs.Cap[candidate[j]] # test[j] THEN EXIT;
	    REPEAT FINISHED => RETURN[TRUE, i];
	    ENDLOOP;
	ENDLOOP;
    RETURN[FALSE, 0]
    END;
    
  IsNumber: PROCEDURE [s: STRING] RETURNS [BOOLEAN] =
    BEGIN
    i: CARDINAL;
    FOR i IN [0..s.length) DO IF s[i] ~ IN ['0..'9] THEN RETURN[FALSE]; ENDLOOP;
    RETURN[TRUE]
    END;
    
  NextItem: PROCEDURE [b: Buffer, token: STRING] =
    BEGIN
    c: CHARACTER;
    token.length _ 0;
    WHILE b.p < b.s.length DO
      c _ b.s[b.p];
      b.p _ b.p + 1;
      SELECT c FROM
	IN ['a..'z], IN ['A..'Z], IN ['0..'9] =>
	  IF token.length < token.maxlength THEN AppendChar[token, c];
	ENDCASE => IF token.length # 0 THEN EXIT;
      ENDLOOP;
    RETURN
    END;
    
  PrintFileVersions: PROCEDURE [bcd: BcdBase] =
    BEGIN OPEN BcdDefs;
    line: STRING _ [40];
    filename: SubStringDescriptor;
    fti: FTIndex;
    ftb: Base = LOOPHOLE[bcd + bcd.ftOffset];
    stb: BcdOps.NameString = LOOPHOLE[bcd + bcd.ssOffset];
    FOR fti _ FIRST[FTIndex], fti + SIZE[FTRecord] UNTIL fti = bcd.ftLimit DO 
      OPEN f: @ftb[fti];
      filename _ SubStringDescriptor[@stb.string, f.name, stb.size[f.name]];
      line.length _ 0;
      WriteChar[' ];
      PrintVersion[f.version];
      WriteChar[' ];
      AppendSubString[line, @filename];
      WriteLine[line];
      ENDLOOP;
    RETURN
    END;
    
  PrintVersion: PROCEDURE [stamp: BcdDefs.VersionStamp] =
    BEGIN
    WriteChar[' ];
    PrintDate[TimeDefs.UnpackDT[stamp.time]];
    WriteChar[' ];
    WriteOctal[stamp.net];
    WriteChar['#];
    WriteOctal[stamp.host];
    WriteChar['#];
    END;
    
  PrintDate: PROCEDURE [dt: UnpackedTime] =
    BEGIN
    tmp: STRING _ [40];
    TimeDefs.AppendDayTime[tmp, dt];
    WriteString[tmp];
    END;
    
  -- command line stuff
  
  
  NextFile: PROCEDURE [token: STRING] RETURNS [BOOLEAN];
  
  ReadFromCmdFile: PROCEDURE [token: STRING] RETURNS [BOOLEAN] =
    BEGIN RETURN[ReadCmdStream[cmdstream, token]] END;
    
  ReadFromKeyboard: PROCEDURE [token: STRING] RETURNS [BOOLEAN] =
    BEGIN
    WriteString["File: "L];
    ReadID[token];
    WriteChar[CR];
    RETURN[token.length # 0];
    END;
    
  ReadCmdStream: PROCEDURE [stream: StreamHandle, token: STRING]
    RETURNS [BOOLEAN] =
    BEGIN
    c: CHARACTER;
    token.length _ 0;
    WHILE ~stream.endof[stream] DO
      c _ stream.get[stream];
      SELECT c FROM
	SP => IF token.length # 0 THEN EXIT;
	CR => EXIT;
	ENDCASE => AppendChar[token, c];
      ENDLOOP;
    RETURN[token.length # 0];
    END;
    
  cmdstream: StreamHandle;
  
  SetCommandInput: PROCEDURE =
    BEGIN
    cmdstream _ NewByteStream["Com.Cm"L, Read];
    [] _ ReadCmdStream[cmdstream, name];
    StripSwitches[name]; -- mesa.image
    [] _ ReadCmdStream[cmdstream, name];
    IF interactive _ cmdstream.endof[cmdstream] THEN
      BEGIN cmdstream.destroy[cmdstream]; NextFile _ ReadFromKeyboard; END
    ELSE NextFile _ ReadFromCmdFile;
    RETURN
    END;
    
  StripSwitches: PROCEDURE [token: STRING] =
    BEGIN
    i, j: CARDINAL;
    option: BOOLEAN _ TRUE;
    FOR i IN [0..token.length) DO
      IF token[i] = '/ THEN
	BEGIN
	FOR j IN (i..token.length) DO
	  SELECT token[
	    j] FROM
	    '~, '- => option _ ~option;
	    'p, 'P => BEGIN pause _ option; option _ TRUE END;
	    'v, 'V => BEGIN verbose _ option; option _ TRUE END;
	    ENDCASE;
	  ENDLOOP;
	token.length _ i;
	END;
      ENDLOOP;
    RETURN
    END;
    
  -- main program
  
  VersionProc: TYPE = PROCEDURE [
    info: FastDirDefs.ItemHandle, type: FastDirDefs.FileType];
  
  dateproc: ARRAY FastDirDefs.FileType OF VersionProc =
    [SourceDate, BinaryVersion, SourceDate, BinaryVersion, BinaryVersion,
      BinaryVersion];
  
  i: FastDirDefs.FileType;
  name: STRING _ [100];
  
  interactive: BOOLEAN;
  pause, pauseDflt: BOOLEAN _ FALSE;
  verbose, verboseDflt: BOOLEAN _ FALSE;
  item: FastDirDefs.ItemHandle;
  
  SetCommandInput[];
  FastDirDefs.ScanDir[FastDirDefs.AllFileSwitches, ];
  pauseDflt _ pause;
  verboseDflt _ verbose;
  WriteChar[CR];
  WHILE NextFile[name] DO
    pause _ pauseDflt;
    verbose _ verboseDflt;
    StripSwitches[name];
    IF name.length = 0 THEN
      BEGIN
      pauseDflt _ pause;
      verboseDflt _ verbose;
      IF interactive THEN WriteChar[CR];
      END
    ELSE
      BEGIN
      FastDirDefs.StripExtension[name, NIL];
      IF ~interactive THEN WriteLine[name];
      FOR i IN FastDirDefs.FileType DO
	IF (item _ FastDirDefs.LookupItem[name, i]) # NIL THEN
	  BEGIN
	  WriteChar[' ];
	  WriteString[FastDirDefs.GetExtension[i]];
	  WriteChar[':];
	  dateproc[i][item, i];
	  END;
	ENDLOOP;
      WriteChar[CR];
      IF pause THEN [] _ ReadChar[];
      END;
    ENDLOOP;
  ImageDefs.StopMesa[];
  
  END.