<<>> <> <> <> DIRECTORY Atom, Basics, BasicTime, PFS, PFSNames, RefTab, Rope; VersionMap2: CEDAR DEFINITIONS IMPORTS PFSNames = { <> <> ROPE: TYPE ~ Rope.ROPE; LOR: TYPE ~ LIST OF ROPE; Error: READONLY ERROR [error: PFS.ErrorDesc]; <> <> <> Name: TYPE ~ PFS.PATH--that is absolute--; NameList: TYPE ~ LIST OF Name; nullName: Name ~ NIL; NameMatch: PROC [x, p: Name] RETURNS [BOOL]; < result is TRUE; otherwise, the standard PFS rules apply.>> NameEqual: PROC [n1, n2: Name] RETURNS [BOOL] ~ INLINE {RETURN PFSNames.Equal[n1, n2]}; RtNameEqual: RefTab.EqualProc; RtNameHash: RefTab.HashProc; NameCompare: PROC [n1, n2: Name] RETURNS [Basics.Comparison]; <> NamePatternIsConstant: PROC [Name] RETURNS [BOOL]; <> < NameEqual[x1, x2]>> Created: TYPE ~ PFS.UniqueID; nullCreated: Created ~ PFS.nullUniqueID; CreatedFromGMT: PROC [gmt: BasicTime.GMT] RETURNS [Created] ~ INLINE {RETURN [[egmt: [gmt, 0] ]]}; GMTFromCreated: PROC [c: Created] RETURNS [GMTPlus] <> ~ INLINE {RETURN [[c.egmt.gmt, c.egmt.usecs#0 OR c.host#[0, 0] ]]}; GMTPlus: TYPE ~ RECORD [gmt: BasicTime.GMT, other: BOOL]; CreatedMatch: PROC [x, p: Created] RETURNS [BOOL] ~ INLINE {RETURN [p=nullCreated OR x=p]}; CreatedCompare: PROC [c1, c2: Created] RETURNS [Basics.Comparison]; VersionStamp: TYPE ~ ARRAY [0 .. 1] OF CARD --= MobDefs.VersionStamp--; nullStamp: VersionStamp ~ [0, 0]; StampMatch: PROC [x, p: VersionStamp] RETURNS [BOOL] ~ INLINE {RETURN [p=nullStamp OR x=p]}; StampCompare: PROC [s1, s2: VersionStamp] RETURNS [Basics.Comparison]; nullTuple: VersionTuple ~ []; VersionTuple: TYPE ~ RECORD [ name: Name _ nullName, created: Created _ nullCreated, stamp: VersionStamp _ nullStamp]; TMatches: PROC [t, pattern: VersionTuple] RETURNS [BOOL]; <> TEqual: PROC [t1, t2: VersionTuple] RETURNS [BOOL]; <> TupleCompare: PROC [t1, t2: VersionTuple] RETURNS [Basics.Comparison]; <> ShortNameToPattern: PROC [ROPE] RETURNS [VersionTuple]; <> LastComponentToPattern: PROC [PFSNames.Component] RETURNS [VersionTuple]; <> PatternIsConstant: PROC [VersionTuple] RETURNS [BOOL]; <> < TEqual[x1, x2]>> <> <> Map: TYPE ~ RECORD [class: MapClass, data: REF ANY _ NIL]; nullMap: Map ~ [NIL]; MapList: TYPE ~ LIST OF Map; RefMap: TYPE ~ REF Map; Refify: PROC [map: Map] RETURNS [RefMap] ~ INLINE {RETURN [NEW[Map _ map]]}; DeRefify: PROC [arg: REF ANY] RETURNS [RefMap]; cantCode: READONLY ATOM; Functional: PROC [map: Map] RETURNS [BOOL] ~ INLINE {RETURN map.class.Functional[map]}; MMutability: PROC [map: Map] RETURNS [Mutability] ~ INLINE {RETURN map.class.MMutability[map]}; Mutability: TYPE ~ {constant, readonly, writable}; <> <> Has: PROC [map: Map, elt: VersionTuple] RETURNS [BOOL] <> ~ INLINE {RETURN map.class.Has[map, elt]}; Scan: PROC [map: Map, Consume: TupleConsumer, inOrder: BOOL, filters: MapList _ NIL] RETURNS [MaybeTuple] <> ~ INLINE {RETURN map.class.Scan[map, Consume, inOrder, PatternFactorMapList[filters]]}; TupleConsumer: TYPE ~ PROC [VersionTuple] RETURNS [BOOL]; MaybeTuple: TYPE ~ RECORD [found: BOOL, it: VersionTuple]; <<(NOT found) => (it = nullTuple).>> noMaybe: MaybeTuple ~ [FALSE, nullTuple]; AlwaysAccept: TupleConsumer; <> FactoredScan: PROC [map: Map, Consume: TupleConsumer, inOrder: BOOL, pfml: PatternFactoredMapList] RETURNS [MaybeTuple] <> ~ INLINE {RETURN map.class.Scan[map, Consume, inOrder, pfml]}; AllHave: PROC [maplist: MapList, t: VersionTuple] RETURNS [BOOL]; <> OneHas: PROC [maplist: MapList, t: VersionTuple] RETURNS [BOOL]; <> PfmlHas: PROC [pfml: PatternFactoredMapList, t: VersionTuple] RETURNS [BOOL]; <> CreateGenerator: PROC [map: Map, inOrder: BOOL, filters: MapList _ NIL] RETURNS [Generator] <> ~ INLINE {RETURN map.class.CreateGenerator[map, inOrder, PatternFactorMapList[filters]]}; FactoredCreateGenerator: PROC [map: Map, inOrder: BOOL, pfml: PatternFactoredMapList] RETURNS [Generator] ~ INLINE {RETURN map.class.CreateGenerator[map, inOrder, pfml]}; ScanMatches: PROC [map: Map, Consume: TupleConsumer, inOrder: BOOL, pattern: VersionTuple] RETURNS [MaybeTuple] <> ~ INLINE {RETURN map.class.Scan[map, Consume, inOrder, [pattern]]}; GenerateMatches: PROC [map: Map, inOrder: BOOL, pattern: VersionTuple] RETURNS [Generator] ~ INLINE {RETURN map.class.CreateGenerator[map, inOrder, [pattern]]}; TheElt: PROC [map: Map] RETURNS [VersionTuple]; <> AnElt: PROC [map: Map] RETURNS [MaybeTuple]; <> <> <> LookupStamp: PROC [map: Map, stamp: VersionStamp] RETURNS [MaybeTuple]; <> LookupCreated: PROC [map: Map, created: Created] RETURNS [MaybeTuple]; <> LookupShortName: PROC [map: Map, shortName: ROPE] RETURNS [MaybeTuple]; <> Size: PROC [map: Map, limit: INT _ INT.LAST] RETURNS [INT] <> ~ INLINE {RETURN map.class.Size[map, limit]}; Empty: PROC [map: Map] RETURNS [BOOL] ~ INLINE {RETURN [Size[map, 1]=0]}; <> AddTuple: PROC [map: Map, t: VersionTuple, if: IfHads _ always] RETURNS [had: Hads] <> ~ INLINE {RETURN map.class.AddTuple[map, t, if]}; OldCase: TYPE ~ {same, createdDifferent, stampDifferent, bothDifferent, new}; <> <> <> <> <> <> InterestingOldCase: TYPE ~ OldCase[createdDifferent .. new]; <> IfHads: TYPE ~ PACKED ARRAY InterestingOldCase OF --add:--BOOL; <> always: IfHads ~ ALL[TRUE]; ifDifferent: IfHads ~ [TRUE, TRUE, TRUE, FALSE]; ifNew: IfHads ~ [FALSE, FALSE, FALSE, TRUE]; <> Hads: TYPE ~ PACKED ARRAY DependentField OF Had; DependentField: TYPE ~ {created, stamp}; Had: TYPE ~ {same, different, none}; <> <> <> <> AddMap: PROC [map, other: Map, if: IfHads _ always] RETURNS [some: HadSets] <> ~ INLINE {RETURN map.class.AddMap[map, other, if]}; HadSet: TYPE ~ PACKED ARRAY Had OF BOOL; HadSets: TYPE ~ ARRAY DependentField OF HadSet _ ALL[ALL[FALSE]]; <> RemTuple: PROC [map: Map, t: VersionTuple] RETURNS [had: Hads] <> ~ INLINE {RETURN map.class.RemTuple[map, t]}; RemMap: PROC [map, other: Map] RETURNS [some: HadSets] <> ~ INLINE {RETURN map.class.RemMap[map, other]}; RemFilters: PROC [map: Map, filters: MapList]; <> <> Negate: PROC [map: Map] RETURNS [Map] <> ~ INLINE {RETURN map.class.Negate[map]}; IsNegation: PROC [map: Map] RETURNS [MaybeMap] <> ~ INLINE {RETURN map.class.IsNegation[map]}; MaybeMap: TYPE ~ RECORD [found: BOOL, it: Map]; <<(NOT found) => (it = nullMap).>> Intersect: PROC [map, other: Map] RETURNS [Map] <> ~ INLINE {RETURN map.class.Intersect[map, other]}; IsIntersection: PROC [map: Map] RETURNS [Maybe2Maps] <> ~ INLINE {RETURN map.class.IsIntersection[map]}; Maybe2Maps: TYPE ~ RECORD [found: BOOL, map, other: Map]; <<(NOT found) => (map = other = nullMap).>> Union: PROC [map, other: Map, test: UnionTest _ other, ordered: BOOL _ FALSE] RETURNS [Map] < map.Intersect[other].Emtpy>> < TBCompare[t, u] <= equal for all t in map, u in other.>> < enumeration implemented by enumerating map, enumerating other and testing membership in map.>> < enumeration implemented by enumerating other, enumerating map and testing membership in other.>> ~ INLINE {RETURN map.class.Union[map, other, test, ordered]}; UnionTest: TYPE ~ {disjoint, map, other}; IsUnion: PROC [map: Map] RETURNS [Maybe2Maps] ~ INLINE {RETURN map.class.IsUnion[map]}; Difference: PROC [map, other: Map] RETURNS [Map] <> ~ INLINE {RETURN map.class.Difference[map, other]}; IsDifference: PROC [map: Map] RETURNS [Maybe2Maps] ~ INLINE {RETURN map.class.IsDifference[map]}; SymmetricDifference: PROC [map, other: Map] RETURNS [Map] <> ~ INLINE {RETURN map.class.SymmetricDifference[map, other]}; IsSymmetricDifference: PROC [map: Map] RETURNS [Maybe2Maps] ~ INLINE {RETURN map.class.IsSymmetricDifference[map]}; <> anEmpty: READONLY Map; <> aFull: READONLY Map; <> CreateSingleton: PROC [VersionTuple] RETURNS [Map]; MapIsSingleton: PROC [Map] RETURNS [MaybeTuple]; <> CreateVariableMap: PROC RETURNS [Map]; <> MapFromFile: PROC [fileName: Name, created: Created, assumeImmutable: BOOL] RETURNS [Map]; <> MapIsFromFile: PROC [Map] RETURNS [MaybeFromFile]; MaybeFromFile: TYPE ~ RECORD [found: BOOL, fileName: Name, created: Created, assumeImmutable: BOOL]; <<(NOT found) => (it = nullName).>> StoreToFile: PROC [map: Map, fileName: Name]; CreateDirectoriesMap: PROC [dirs: Map, cache, hints: Map _ nullMap] RETURNS [Map]; <> <> CreateMatcher: PROC [pattern: VersionTuple] RETURNS [Map]; <> PatternFactoredMap: TYPE ~ RECORD [ pattern: VersionTuple, stampInd, general: Map ]; < is in stampInd if and only if is in stampInd.>> PatternFactorMap: PROC [map: Map] RETURNS [PatternFactoredMap] <> ~ INLINE {RETURN map.class.PatternFactorMap[map]}; PatternFactoredMapList: TYPE ~ RECORD [ pattern: VersionTuple _ nullTuple, stampInd, general: MapList _ NIL ]; <> listOfEmpty: READONLY MapList; --LIST[anEmpty] PatternFactorMapList: PROC [MapList] RETURNS [PatternFactoredMapList]; <> PatternUnfactorMapList: PROC [PatternFactoredMapList] RETURNS [MapList]; <> PfmlAddMap: PROC [PatternFactoredMapList, Map] RETURNS [PatternFactoredMapList]; <> CreateSetMatcher: PROC [prefix: VersionTuple, suffixes: LOR] RETURNS [Map]; <> <> <> Generator: TYPE ~ REF GeneratorRep; GeneratorRep: TYPE ~ RECORD [ Next: PROC [Generator] RETURNS [VersionTuple], <> Close: PROC [Generator], <> data: REF ANY _ NIL]; GeneratorUnion: PROC [g1, g2: Generator, sort: BOOL] RETURNS [Generator]; <> GeneratorSort: PROC [Generator] RETURNS [Generator]; <> FilterGenerator: PROC [Generator, MapList] RETURNS [Generator]; <> TheGeneratee: PROC [gen: Generator] RETURNS [VersionTuple]; <> GeneratorQuaTuple: PROC [gen: Generator] RETURNS [MaybeTuple]; <> <> <> MapClass: TYPE ~ REF MapClassRep; MapClassRep: TYPE ~ RECORD [ Functional: PROC [map: Map] RETURNS [BOOL], MMutability: PROC [map: Map] RETURNS [Mutability], Has: PROC [map: Map, elt: VersionTuple] RETURNS [BOOL] _ NIL, Scan: PROC [map: Map, Consume: TupleConsumer, inOrder: BOOL, pfml: PatternFactoredMapList] RETURNS [MaybeTuple] _ NIL, CreateGenerator: PROC [map: Map, inOrder: BOOL, pfml: PatternFactoredMapList] RETURNS [Generator] _ NIL, Size: PROC [map: Map, limit: INT] RETURNS [INT] _ NIL, PatternFactorMap: PROC [map: Map] RETURNS [PatternFactoredMap] _ NIL, AddTuple: PROC [map: Map, t: VersionTuple, if: IfHads] RETURNS [had: Hads] _ NIL, AddMap: PROC [map, other: Map, if: IfHads] RETURNS [some: HadSets] _ NIL, RemTuple: PROC [map: Map, t: VersionTuple] RETURNS [had: Hads] _ NIL, RemMap: PROC [map, other: Map] RETURNS [some: HadSets] _ NIL, Negate: PROC [map: Map] RETURNS [Map] _ NIL, IsNegation: PROC [map: Map] RETURNS [MaybeMap] _ NIL, Intersect: PROC [map, other: Map] RETURNS [Map] _ NIL, IsIntersection: PROC [map: Map] RETURNS [Maybe2Maps] _ NIL, Union: PROC [map, other: Map, test: UnionTest, ordered: BOOL] RETURNS [Map] _ NIL, IsUnion: PROC [map: Map] RETURNS [Maybe2Maps] _ NIL, Difference: PROC [map, other: Map] RETURNS [Map] _ NIL, IsDifference: PROC [map: Map] RETURNS [Maybe2Maps] _ NIL, SymmetricDifference: PROC [map, other: Map] RETURNS [Map] _ NIL, IsSymmetricDifference: PROC [map: Map] RETURNS [Maybe2Maps] _ NIL, other: Atom.PropList _ NIL, data: REF ANY]; }.