-- CedarMapsBuilderImpl.mesa
-- Russ Atkinson, November 10, 1982 2:51 pm

DIRECTORY
  Rope USING [Concat, Fetch, ROPE, Size, Substr],
  SymTab,
  VersionMap,
  VersionMapBuilder;

CedarMapsBuilderImpl: CEDAR PROGRAM
  IMPORTS Rope, SymTab, VersionMap, VersionMapBuilder
  -- EXPORTS CedarMapsBuilder
  = BEGIN OPEN Rope;

  Map: TYPE = VersionMap.Map;

  sourceName: ROPE _ "CedarSource.VersionMap";
  symbolsName: ROPE _ "CedarSymbols.VersionMap";
  defaultUpdateName: ROPE _ "Release.VersionMapFile";

  MakeCedarMaps: PROC
      [mergeMap,oldSourceMap,oldSymbolsMap: Map _ NIL, overwrite: BOOL _ FALSE] = {
    -- step 1: read old maps & the update map
    mergeLen: INT _ mergeMap.Length[];
    mapIndex: INT _ 0;
    newSourceMap: Map _ NIL;
    newSymbolsMap: Map _ NIL;
    
    -- step 2: invert the update map
    invertTab: SymTab.Ref _ InvertMap[mergeMap];
    oldFilter: VersionMapBuilder.FilterProc = {
      -- [name: ROPE] RETURNS [ok: BOOL]
      RETURN [NOT invertTab.Fetch[StripOffVersion[name]].found]
      };

    -- step 3: make new maps 
    newSourceMap _ MakeMergedMap
      [oldSourceMap, mergeMap, oldFilter, VersionMapBuilder.NonBCDFilter];
    newSymbolsMap _ MakeMergedMap
      [oldSymbolsMap, mergeMap, oldFilter, VersionMapBuilder.OnlyBCDFilter];

    -- step 4: save the maps 
    newSourceMap.SaveMapToFile
      [sourceName.Concat[IF overwrite THEN "" ELSE "$"]];
    newSymbolsMap.SaveMapToFile
      [symbolsName.Concat[IF overwrite THEN "" ELSE "$"]];

    };

  MakeMergedMap: PROC
    [oldMap, mergeMap: Map _ NIL, oldfilter, mergeFilter: VersionMapBuilder.FilterProc _ NIL]
    RETURNS [newMap: Map _ NIL] = {
    getNext: VersionMapBuilder.EachProc = {
      -- [data: REF] RETURNS [stamp: TimeStamp.Stamp, name: ROPE]
      IF oldMap # NIL THEN
        {WHILE index < oldMap.Length[] DO
            [stamp, name] _ oldMap.Fetch[index];
            index _ index + 1;
            IF oldfilter = NIL OR oldfilter[name] THEN RETURN;
            ENDLOOP;
          oldMap _ NIL;
          index _ 0;
          };
      WHILE index <= mergeMap.Length[] DO
        [stamp, name] _ mergeMap.Fetch[index];
        index _ index + 1;
        IF mergeFilter = NIL OR mergeFilter[name] THEN RETURN; 
        ENDLOOP;
      name _ NIL; -- this stops the enumeration
      };
    index: INT _ 0;
    prefix: ROPE _ IF oldMap = NIL THEN NIL ELSE oldMap.GetPrefix[];
    IF prefix.Size[] = 0 AND mergeMap # NIL THEN prefix _ mergeMap.GetPrefix[];
    RETURN [VersionMapBuilder.GenerateMapFromProc[getNext, NIL, prefix]];
    }; 

  InvertMap: PROC [map: Map] RETURNS [tab: SymTab.Ref] = {
    mapLen: INT _ map.Length[];
    tab _ SymTab.Create[mapLen, FALSE];
    FOR index: INT IN [0..mapLen) DO
      name: ROPE _ map.FetchName[index];
      [] _ tab.Store[StripOffVersion[name], name];
      ENDLOOP;
    };

  StripOffVersion: PROC [name: ROPE] RETURNS [ROPE] = {
    FOR i: INT DECREASING IN [0..name.Size[]) DO
       IF name.Fetch[i] = '! THEN
          RETURN [name.Substr[0, i]];
       ENDLOOP;
    RETURN [name];
    };

  END.