gpcp/ModuleHandler.cp

   1 (***********************************************************************)
   2 (*                     Component Pascal Make Tool                      *)
   3 (*                                                                     *)
   4 (*           Diane Corney, 20th July 1999                              *)
   5 (*           Modifications:                                            *)
   6 (*                                                                     *)
   7 (*                                                                     *)
   8 (***********************************************************************)
   9 MODULE ModuleHandler;
  10
  11 IMPORT  GPCPcopyright,
  12         LitValue,
  13         FileNames;
  14
  15 CONST
  16   listIncrement = 10;
  17
  18 TYPE
  19
  20   ModName* = LitValue.CharOpen;
  21
  22   ModInfo* = POINTER TO ModInfoRec;
  23
  24   ModList*  = RECORD
  25                 tide* : INTEGER;
  26                 list* : POINTER TO ARRAY OF ModInfo;
  27               END;
  28
  29   KeyList* = POINTER TO ARRAY OF INTEGER;
  30
  31   ModInfoRec* = RECORD
  32                   name*       : ModName;
  33                   imports*    : ModList;
  34                   importedBy* : ModList;
  35                   importKeys* : KeyList;
  36                   key*        : INTEGER;
  37                   compile*    : BOOLEAN;
  38                   done*       : BOOLEAN;
  39                   isForeign*  : BOOLEAN;
  40                   importsLinked* : BOOLEAN;
  41                 END;
  42
  43   ModTree* = POINTER TO RECORD
  44                module : ModInfo;
  45                left,right : ModTree;
  46              END;
  47
  48
  49 VAR
  50   modules : ModTree;
  51
  52 PROCEDURE Add* (VAR modList : ModList; mod : ModInfo);
  53 VAR
  54   tmp : POINTER TO ARRAY OF ModInfo;
  55   i : INTEGER;
  56 BEGIN
  57   IF modList.list = NIL THEN
  58     NEW(modList.list,listIncrement);
  59     modList.tide := 0;
  60   ELSE
  61     FOR i := 0 TO modList.tide - 1 DO
  62       IF mod = modList.list[i] THEN RETURN; END;
  63     END;
  64     IF modList.tide >= LEN(modList.list) THEN
  65       tmp := modList.list;
  66       NEW(modList.list,(LEN(modList.list) + listIncrement));
  67       FOR i := 0 TO modList.tide - 1 DO
  68         modList.list[i] := tmp[i];
  69       END;
  70     END;
  71   END;
  72   modList.list[modList.tide] := mod;
  73   INC(modList.tide);
  74 END Add;
  75
  76 PROCEDURE AddKey*(thisMod, impMod : ModInfo; impKey : INTEGER);
  77 VAR
  78   i : INTEGER;
  79   mods : ModList;
  80   tmp : POINTER TO ARRAY OF INTEGER;
  81 BEGIN
  82   mods := thisMod.imports;
  83   IF (thisMod.importKeys = NIL) OR
  84      (LEN(thisMod.importKeys) < LEN(mods.list)) THEN
  85     tmp := thisMod.importKeys;
  86     NEW(thisMod.importKeys,LEN(mods.list));
  87     IF (tmp # NIL) THEN
  88       FOR i := 0 TO LEN(tmp)-1 DO
  89         thisMod.importKeys[i] := tmp[i];
  90       END;
  91     END;
  92   END;
  93   i := 0;
  94   WHILE (i < LEN (mods.list)) & (mods.list[i] # impMod) DO INC(i); END;
  95   IF (i < LEN (mods.list)) THEN thisMod.importKeys[i] := impKey; END;
  96 END AddKey;
  97
  98 PROCEDURE GetKey*(thisMod : ModInfo; impMod : ModInfo) : INTEGER;
  99 VAR
 100   ix : INTEGER;
 101 BEGIN
 102   (* Assert:  impMod is in imports list of thisMod *)
 103   ix := 0;
 104   WHILE (thisMod.imports.list[ix] # impMod) DO INC(ix); END;
 105   RETURN thisMod.importKeys[ix];
 106 END GetKey;
 107
 108 PROCEDURE NewModInfo(modName : ModName) : ModInfo;
 109 VAR
 110   mod : ModInfo;
 111 BEGIN
 112   NEW(mod);
 113   mod.name := modName;
 114   mod.key := 0;
 115   mod.compile := FALSE;
 116   mod.done := FALSE;
 117   mod.isForeign := FALSE;
 118   mod.importsLinked := FALSE;
 119   mod.imports.tide := 0;
 120   NEW(mod.imports.list, listIncrement);
 121   mod.importedBy.tide := 0;
 122   RETURN mod;
 123 END NewModInfo;
 124
 125 PROCEDURE GetModule*(modName : ModName) : ModInfo;
 126 VAR
 127   mod : ModInfo;
 128   node, parent : ModTree;
 129   found : BOOLEAN;
 130 BEGIN
 131   IF (modules = NIL) THEN
 132     NEW (modules);
 133     modules.module := NewModInfo(modName);
 134     RETURN modules.module;
 135   END;
 136   mod := NIL;
 137   node := modules;
 138   parent := NIL;
 139   found := FALSE;
 140   WHILE (node # NIL) & (~found) DO
 141     parent := node;
 142     IF node.module.name^ = modName^ THEN
 143       found := TRUE;
 144       mod := node.module;
 145     ELSIF modName^ < node.module.name^ THEN
 146       node := node.left;
 147     ELSE
 148       node := node.right;
 149     END;
 150   END;
 151   IF ~found THEN
 152     ASSERT(parent # NIL);
 153     NEW(node);
 154     mod := NewModInfo(modName);
 155     node.module := mod;
 156     IF modName^ < parent.module.name^ THEN
 157       parent.left := node;
 158     ELSE
 159       parent.right := node;
 160     END;
 161   END;
 162   RETURN mod;
 163 END GetModule;
 164
 165
 166 END ModuleHandler.