src/generic/Dsw/Mod/MakeMain.cp

   1 MODULE DswMakeMain;
   2
   3   IMPORT Kernel, Files, Log, Strings, DswOpts, DswProcs, DswDocuments, DevCPM, DevCPT, DevCPR, DevCPS;
   4
   5   CONST
   6     version = "0.3.0";
   7
   8     maxImps = 127;
   9     maxJobs = maxImps;
  10
  11     (* symbol values *)
  12     null = 0; times = 1; slash = 2; div = 3; mod = 4;
  13     and = 5; plus = 6; minus = 7; or = 8; eql = 9;
  14     neq = 10; lss = 11; leq = 12; gtr = 13; geq = 14;
  15     in = 15; is = 16; arrow = 17; dollar = 18; period = 19;
  16     comma = 20; colon = 21; upto = 22; rparen = 23; rbrak = 24;
  17     rbrace = 25; of = 26; then = 27; do = 28; to = 29;
  18     by = 30; not = 33;
  19     lparen = 40; lbrak = 41; lbrace = 42; becomes = 44;
  20     number = 45; nil = 46; string = 47; ident = 48; semicolon = 49;
  21     bar = 50; end = 51; else = 52; elsif = 53; until = 54;
  22     if = 55; case = 56; while = 57; repeat = 58; for = 59;
  23     loop = 60; with = 61; exit = 62; return = 63; array = 64;
  24     record = 65; pointer = 66; begin = 67; const = 68; type = 69;
  25     var = 70; out = 71; procedure = 72; close = 73; import = 74;
  26     module = 75; eof = 76;
  27
  28     (* module state flags *)
  29     imported = 0; trace = 1; hasObj = 2; hasSym = 3; hasErrors = 4; library = 5;
  30
  31     (* procesor types *)
  32     anymach = 0; cmach = 1; mach386 = 10; mach68k = 20;
  33
  34     (* operation system types *)
  35     anyos = 0; linux = 1; freebsd = 2; openbsd = 3; win32 = 4; cygwin = 5; darwin = 6;
  36
  37     (* compiler types *)
  38     anycp = 0; cpnative = 1; cpfront = 2;
  39
  40     (* internal linker types *)
  41     anyint = 0; dev2 = 1;
  42
  43     debugImport = FALSE;
  44     debugOrder = FALSE;
  45     debugJobs = FALSE;
  46     debugArgs = FALSE;
  47
  48   TYPE
  49     String = POINTER TO ARRAY OF CHAR;
  50     StringList = POINTER TO ARRAY OF String;
  51
  52     Selector = POINTER TO RECORD
  53       name: DevCPT.Name;
  54       value: BOOLEAN;
  55       next: Selector
  56     END;
  57
  58     Module = POINTER TO RECORD
  59       name: DevCPT.Name;
  60       path: Files.Name;
  61       selectors: Selector; (* with head, list of selectors for this module *)
  62       depth: INTEGER; (* 0: leaf, MAX: root *)
  63       mno: INTEGER;
  64       imp: ARRAY maxImps OF Module;
  65       flags: SET;
  66       worker: DswProcs.Process;
  67     END;
  68
  69   VAR
  70     werr, err: INTEGER;
  71     mno, rno: INTEGER; (* num modules *)
  72     modList, lnkList, cmpList: ARRAY maxImps OF Module;
  73     def: Selector; (* with head, global list of selectors *)
  74     processor, compiler, os, linker: INTEGER;
  75     cpcExe, cplExe: String;
  76     cpcArgs, cplArgs: StringList;
  77     auto: BOOLEAN;
  78     jobs: INTEGER;
  79     exe: String;
  80
  81   PROCEDURE Error (e: INTEGER; IN p0, p1: ARRAY OF CHAR; i2: INTEGER);
  82     VAR msg, p2: ARRAY 128 OF CHAR;
  83   BEGIN
  84     CASE e OF
  85     | 0: msg := "option -D expect + or - after identifier"
  86     | 1: msg := "option -D expect identifier"
  87     | 2: msg := "option -U expect identifier"
  88     | 3: msg := "module name must be identifier"
  89     | 4: msg := "expected integer" (* p0 = in str *)
  90     | 5: msg := "unterminated string"
  91     | 6: msg := "unknown processor ^0"
  92     | 7: msg := "unknown os ^0"
  93     | 8: msg := "unknown compiler ^0"
  94     | 9: msg := "unknown linker ^0"
  95     | 10: msg := "missing argument for option ^0"
  96     | 11: msg := "unknown option ^0"
  97     | 12: msg := "compiler not selected"
  98     | 13: msg := "processor not selected"
  99     | 14: msg := "processor not supported by native compiler"
 100     | 15: msg := "internal linker not required for cpfront"
 101     | 16: msg := "cpfront can't out executable file"
 102     | 17: msg := "linker not selected"
 103     | 18: msg := "os not selected"
 104     | 19: msg := "output file name can't be empty"
 105     | 20: msg := "recursive import of ^0 in ^1"
 106     | 21: msg := "unable to open module ^1"
 107     | 22: msg := "linker terminated with code ^2"
 108     | 23: msg := "unable to execute linker"
 109     | 24: msg := "trap occured"
 110     ELSE
 111       Strings.IntToString(err, msg)
 112     END;
 113     Strings.IntToString(i2, p2);
 114     Log.String(Kernel.argv[0]$); Log.String(": ");
 115     Log.ParamMsg(msg, p0, p1, p2); Log.Ln;
 116     INC(err)
 117   END Error;
 118
 119   (* --------- options --------- *)
 120
 121   PROCEDURE IdentLen (IN s: ARRAY OF CHAR): INTEGER;
 122     VAR i: INTEGER;
 123   BEGIN
 124     i := 0;
 125     IF Strings.IsIdentStart(s[0]) THEN
 126       REPEAT INC(i) UNTIL ~Strings.IsIdent(s[i])
 127     END;
 128     RETURN i
 129   END IdentLen;
 130
 131   PROCEDURE Define (n: ARRAY OF CHAR);
 132     VAR i: INTEGER; v: BOOLEAN; s: Selector;
 133   BEGIN
 134     i := IdentLen(n);
 135     IF i # 0 THEN
 136       IF ~((n[i] = 0X) OR (((n[i] = "+") OR (n[i] = "-")) & (n[i + 1] = 0X))) THEN
 137         Error(0, "", "", 0)
 138       END;
 139       v := n[i] # "-"; n[i] := 0X; s := def;
 140       WHILE (s.next # NIL) & (s.next.name$ # n$) DO s := s.next END;
 141       IF s.next = NIL THEN
 142         NEW(s.next);
 143         Strings.StringToUtf8(n, s.next.name, i);
 144         ASSERT(i = 0)
 145       END;
 146       s.next.value := v
 147     ELSE
 148       Error(1, "", "", 0)
 149     END
 150   END Define;
 151
 152   PROCEDURE Undefine (IN n: ARRAY OF CHAR);
 153     VAR i: INTEGER; s: Selector;
 154   BEGIN
 155     i := IdentLen(n);
 156     IF (i # 0) & (n[i] = 0X) THEN
 157       s := def;
 158       WHILE (s.next # NIL) & (s.next.name$ # n$) DO s := s.next END;
 159       IF s.next # NIL THEN s.next := s.next.next END
 160     ELSE
 161       Error(2, "", "", 0)
 162     END
 163   END Undefine;
 164
 165   PROCEDURE CopySelectorList (base: Selector): Selector;
 166     VAR s, t, x: Selector;
 167   BEGIN
 168     ASSERT(base # NIL, 20);
 169     s := base; NEW(t); x := t;
 170     WHILE s # NIL DO
 171       x^ := s^;
 172       IF s.next # NIL THEN NEW(x.next); x := x.next END;
 173       s := s.next
 174     END;
 175     RETURN t
 176   END CopySelectorList;
 177
 178   PROCEDURE AddModule (IN n: ARRAY OF CHAR; selectors: Selector);
 179     VAR i, res: INTEGER; m: Module;
 180   BEGIN
 181     i := IdentLen(n);
 182     IF (i # 0) & (n[i] = 0X) THEN
 183       i := 0;
 184       WHILE (i < mno) & (modList[i].name$ # n$) DO INC(i) END;
 185       IF i >= mno THEN
 186         NEW(m);
 187         Strings.StringToUtf8(n, m.name, res);
 188         ASSERT(res = 0);
 189         m.selectors := CopySelectorList(selectors);
 190         modList[i] := m;
 191         INC(mno)
 192       END
 193     ELSE
 194       Error(3, "", "", 0)
 195     END
 196   END AddModule;
 197
 198   PROCEDURE StrToInt (IN s: ARRAY OF CHAR; def: INTEGER): INTEGER;
 199     VAR x, res: INTEGER;
 200   BEGIN
 201     Strings.StringToInt(s, x, res);
 202     IF res # 0 THEN
 203       Error(4, s, "", 0);
 204       x := def
 205     END;
 206     RETURN x
 207   END StrToInt;
 208
 209   PROCEDURE NewStr (IN s: ARRAY OF CHAR): String;
 210     VAR p: String;
 211   BEGIN
 212     NEW(p, LEN(s$) + 1); p^ := s$;
 213     RETURN p
 214   END NewStr;
 215
 216   PROCEDURE ToStringList (IN s: ARRAY OF CHAR): StringList;
 217     VAR i: INTEGER; ch, term: CHAR; pars: StringList;
 218
 219     PROCEDURE AddChar (c: CHAR);
 220       VAR i, n, len: INTEGER; str: String;
 221     BEGIN
 222       IF pars = NIL THEN
 223         NEW(pars, 1); NEW(pars[0], 2); pars[0, 0] := c
 224       ELSE
 225         n := LEN(pars) - 1;
 226         len := LEN(pars[n]$);
 227         NEW(str, len + 2);
 228         FOR i := 0 TO len - 1 DO
 229           str[i] := pars[n, i]
 230         END;
 231         str[i] := c;
 232         pars[n] := str
 233       END
 234     END AddChar;
 235
 236     PROCEDURE AddLine;
 237       VAR i, len: INTEGER; p: StringList;
 238     BEGIN
 239       IF pars = NIL THEN
 240         NEW(pars, 1); i := 0;
 241       ELSE
 242         len := LEN(pars);
 243         NEW(p, len + 1);
 244         FOR i := 0 TO len - 1 DO
 245           p[i] := pars[i]
 246         END;
 247         pars := p
 248       END;
 249       NEW(pars[i], 1)
 250     END AddLine;
 251
 252   BEGIN
 253     i := 0;
 254     REPEAT ch := s[i]; INC(i) UNTIL ch # " ";
 255     WHILE ch # 0X DO
 256       CASE ch OF
 257       | '"', "'":
 258         term := ch; ch := s[i]; INC(i);
 259         WHILE (ch # term) & (ch # 0X) DO
 260           AddChar(ch); ch := s[i]; INC(i)
 261         END;
 262         IF ch # 0X THEN ch := s[i]; INC(i)
 263         ELSE Error(5, "", "", 0)
 264         END
 265       | " ":
 266         REPEAT ch := s[i]; INC(i) UNTIL ch # " ";
 267         IF ch # 0X THEN AddLine END
 268       ELSE
 269         AddChar(ch); ch := s[i]; INC(i)
 270       END
 271     END;
 272     RETURN pars
 273   END ToStringList;
 274
 275   PROCEDURE Help;
 276   BEGIN
 277     Log.String("Usage: cpmake [options] module..."); Log.Ln;
 278     Log.String("Options:"); Log.Ln;
 279     Log.String("  -Tm cpu      Generate code for specified processor"); Log.Ln;
 280     Log.String("      none     Unknown processor (cpfront only)"); Log.Ln;
 281     Log.String("      486      Intel 486"); Log.Ln;
 282     Log.String("  -Ts os       Generate code for specified operation system"); Log.Ln;
 283     Log.String("      none     Unknown operation system"); Log.Ln;
 284     Log.String("      linux    Linux"); Log.Ln;
 285     Log.String("  -Tg compiler Specify Component Pascal compiler"); Log.Ln;
 286     Log.String("      native   BlackBox based native code compiler"); Log.Ln;
 287     Log.String("      cpfront  BlackBox based C code translator"); Log.Ln;
 288     Log.String("  -Ti linker   Specify internal linker (native only)"); Log.Ln;
 289     Log.String("      dev2     Dev2 based ELF/PE linker"); Log.Ln;
 290 (*
 291     Log.String("  -Fp path     Add path with project"); Log.Ln;
 292     Log.String("  -Fx path     Add postfix for project directories"); Log.Ln;
 293 *)
 294     Log.String("  -Xp path     Use executable file for Component Pascal compiler"); Log.Ln;
 295     Log.String("  -Xi path     Use executable file for internal linker (native only)"); Log.Ln;
 296     Log.String("  -Cg params   Pass parameters to Component Pasacal compiler directly"); Log.Ln;
 297     Log.String("  -Ci params   Pass parameters to internal linker directly"); Log.Ln;
 298     Log.String("  -II          Trap on user interrupt"); Log.Ln;
 299     Log.String("  -a           Enable automatic dependency resolution"); Log.Ln;
 300     Log.String("  -o name      Generate executable file"); Log.Ln;
 301     Log.String("  -j num       Specifies the number of jobs to run simultaneously"); Log.Ln;
 302     Log.String('  -D ident["+"|"-"] Add preprocessor selector'); Log.Ln;
 303     Log.String('  -U ident     Remove preprocessor selector'); Log.Ln;
 304     Log.String("  -h           Print help and quit"); Log.Ln;
 305     Log.String("  -V           Print version and quit"); Log.Ln;
 306     Kernel.Quit(1)
 307   END Help;
 308
 309   PROCEDURE Version;
 310   BEGIN
 311     Log.String(version); Log.Ln;
 312     Kernel.Quit(0)
 313   END Version;
 314
 315   PROCEDURE ParseTargetOpts;
 316     VAR s: DswOpts.String;
 317   BEGIN
 318     CASE DswOpts.GetOpt("m:s:g:i:") OF
 319     | "m":
 320       s := DswOpts.str;
 321       Strings.ToLower(s, s);
 322       IF s$ = "none" THEN processor := anymach
 323       ELSIF s$ = "486" THEN processor := mach386
 324       ELSIF s$ = "68k" THEN processor := mach68k
 325       ELSE Error(6, s, "", 0)
 326       END
 327     | "s":
 328       s := DswOpts.str;
 329       Strings.ToLower(s, s);
 330       IF s$ = "none" THEN os := anyos
 331       ELSIF s$ = "linux" THEN os := linux
 332       ELSIF s$ = "freebsd" THEN os := freebsd
 333       ELSIF s$ = "openbsd" THEN os := openbsd
 334       ELSIF s$ = "win32" THEN os := win32
 335       ELSIF s$ = "cygwin" THEN os := cygwin
 336       ELSIF s$ = "darwin" THEN os := darwin
 337       ELSE Error(7, s, "", 0)
 338       END
 339     | "g":
 340       s := DswOpts.str;
 341       Strings.ToLower(s, s);
 342       IF s$ = "native" THEN compiler := cpnative
 343       ELSIF s$ = "cpfront" THEN compiler := cpfront
 344       ELSE Error(8, s, "", 0)
 345       END
 346     | "i":
 347       s := DswOpts.str;
 348       Strings.ToLower(s, s);
 349       IF s$ = "dev2" THEN linker := dev2
 350       ELSE Error(9, s, "", 0)
 351       END
 352     | ":": Error(10, "-T" + DswOpts.str, "", 0)
 353     | "?": Error(11, "-T" + DswOpts.str, "", 0)
 354     | 0X: Error(11, "-T", "", 0)
 355     END
 356   END ParseTargetOpts;
 357
 358   PROCEDURE ParseCommandOpts;
 359   BEGIN
 360     CASE DswOpts.GetOpt("g:i:") OF
 361     | "g": cpcArgs := ToStringList(DswOpts.str);
 362     | "i": cplArgs := ToStringList(DswOpts.str);
 363     | ":": Error(10, "-C" + DswOpts.str, "", 0)
 364     | "?": Error(11, "-C" + DswOpts.str, "", 0)
 365     | 0X: Error(11, "-C", "", 0)
 366     END
 367   END ParseCommandOpts;
 368
 369   PROCEDURE ParseExternalOpts;
 370   BEGIN
 371     CASE DswOpts.GetOpt("g:i:") OF
 372     | "g": cpcExe := DswOpts.str;
 373     | "i": cplExe := DswOpts.str;
 374     | ":": Error(10, "-X" + DswOpts.str, "", 0)
 375     | "?": Error(11, "-X" + DswOpts.str, "", 0)
 376     | 0X: Error(11, "-X", "", 0)
 377     END
 378   END ParseExternalOpts;
 379
 380   PROCEDURE ParseInfoOpts;
 381   BEGIN
 382     CASE DswOpts.GetOpt("I") OF
 383     | "I": Kernel.intTrap := TRUE
 384     | ":": Error(10, "-I" + DswOpts.str, "", 0)
 385     | "?": Error(11, "-I" + DswOpts.str, "", 0)
 386     | 0X: Error(11, "-I", "", 0)
 387     END
 388   END ParseInfoOpts;
 389
 390   PROCEDURE ParseArgs;
 391   BEGIN
 392     exe := NIL; auto := FALSE; jobs := 1; def.next := NIL; mno := 0; rno := 0;
 393     processor := anymach; os := anyos; compiler := anycp;
 394     LOOP
 395       CASE DswOpts.GetOpt("ao:j:D:U:TCXIhV") OF
 396       | "a": auto := TRUE
 397       | "o": exe := DswOpts.str
 398       | "j": jobs := MIN(MAX(StrToInt(DswOpts.str, 1), 1), maxJobs)
 399       | "h": Help
 400       | "V": Version
 401       | "D": Define(DswOpts.str)
 402       | "U": Undefine(DswOpts.str)
 403       | "T": ParseTargetOpts
 404       | "C": ParseCommandOpts
 405       | "X": ParseExternalOpts
 406       | "I": ParseInfoOpts
 407       | ":": Error(10, "-" + DswOpts.str, "", 0)
 408       | "?": Error(11, "-" + DswOpts.str, "", 0)
 409       | "$": AddModule(DswOpts.str, def)
 410       | 0X: EXIT
 411       END
 412     END;
 413   END ParseArgs;
 414
 415   PROCEDURE CheckParams;
 416   BEGIN
 417     IF compiler = anycp THEN
 418       Error(12, "", "", 0)
 419     ELSIF compiler = cpnative THEN
 420       IF processor = anymach THEN
 421         Error(13, "", "", 0)
 422       ELSIF processor # mach386 THEN
 423         Error(14, "", "", 0)
 424       END
 425     END;
 426     IF (compiler = cpfront) & (linker # anyint) THEN
 427       Error(15, "", "", 0)
 428     END;
 429     IF (compiler = cpfront) & (exe # NIL) THEN
 430       Error(16, "", "", 0)
 431     END;
 432     IF (exe # NIL) & (compiler = cpnative) & (linker = anyint) THEN
 433       Error(17, "", "", 0)
 434     END;
 435     IF (linker = dev2) & (os = anyos) THEN
 436       Error(18, "", "", 0)
 437     END;
 438     IF (exe # NIL) & (exe^ = "") THEN
 439       Error(19, "", "", 0)
 440     END;
 441     IF cpcExe = NIL THEN
 442       IF compiler = cpnative THEN cpcExe := NewStr("cpc486")
 443       ELSIF compiler = cpfront THEN cpcExe := NewStr("cpfront")
 444       END
 445     END;
 446     IF cplExe = NIL THEN
 447       IF linker = dev2 THEN cplExe := NewStr("cpl486") END
 448     END
 449   END CheckParams;
 450
 451   (* --------- loader --------- *)
 452
 453   PROCEDURE Import (m: Module; IN name: DevCPT.Name);
 454     VAR i, j: INTEGER; imp: Module;
 455   BEGIN
 456     ASSERT(m # NIL, 20);
 457     ASSERT(name # "", 21);
 458     IF debugImport THEN Log.String("  import "); Log.String(name$) END;
 459     IF name = "SYSTEM" THEN INCL(DevCPM.options, DevCPM.sysImp)
 460     ELSIF name = "COM" THEN INCL(DevCPM.options, DevCPM.com)
 461     ELSIF name = "JAVA" THEN INCL(DevCPM.options, DevCPM.java)
 462     ELSE
 463       IF debugImport THEN Log.Char(" ") END;
 464       i := 0; (* find module in local list *)
 465       WHILE (i < m.mno) & (m.imp[i].name$ # name$) DO INC(i) END;
 466       IF i >= m.mno THEN
 467         j := 0; (* find module in global list *)
 468         WHILE (j < mno) & (modList[j].name$ # name$) DO INC(j) END;
 469         IF j >= mno THEN
 470           IF ~auto THEN
 471             Log.String("module " + name + " required before " + m.name); Log.Ln; INC(werr)
 472           END;
 473           NEW(imp); imp.name := name$; imp.selectors := CopySelectorList(m.selectors);
 474           modList[mno] := imp; INC(mno)
 475         ELSE
 476           imp := modList[j]
 477         END;
 478         m.imp[m.mno] := imp; INC(m.mno)
 479       ELSE DevCPM.err(1)
 480       END
 481     END;
 482     IF debugImport THEN Log.Ln END;
 483   END Import;
 484
 485   PROCEDURE ParseModule (m: Module);
 486     VAR sym: BYTE; SelfName, impName, aliasName: DevCPT.Name;
 487
 488     PROCEDURE err (n: SHORTINT);
 489     BEGIN DevCPM.err(n)
 490     END err;
 491
 492     PROCEDURE CheckSym(s: SHORTINT);
 493     BEGIN
 494       IF sym = s THEN DevCPS.Get(sym) ELSE DevCPM.err(s) END
 495     END CheckSym;
 496
 497   BEGIN
 498     IF debugImport THEN Log.String("module " + m.name); Log.Ln END;
 499     DevCPS.Init; DevCPS.Get(sym);
 500     IF sym = module THEN DevCPS.Get(sym) ELSE err(16) END;
 501     IF sym = ident THEN
 502       SelfName := DevCPS.name$; DevCPS.Get(sym);
 503       IF sym = lbrak THEN
 504         INCL(DevCPM.options, DevCPM.interface); DevCPS.Get(sym);
 505         IF sym = eql THEN DevCPS.Get(sym)
 506         ELSE INCL(DevCPM.options, DevCPM.noCode)
 507         END;
 508         IF sym = string THEN INCL(m.flags, library); DevCPS.Get(sym)
 509         ELSE err(string)
 510         END;
 511         CheckSym(rbrak)
 512       END;
 513       CheckSym(semicolon);
 514       IF sym = import THEN DevCPS.Get(sym);
 515         LOOP
 516           IF sym = ident THEN
 517             aliasName := DevCPS.name$; impName := aliasName$; DevCPS.Get(sym);
 518             IF sym = becomes THEN DevCPS.Get(sym);
 519               IF sym = ident THEN impName := DevCPS.name$; DevCPS.Get(sym) ELSE err(ident) END
 520             END;
 521             Import(m, impName)
 522           ELSE err(ident)
 523           END;
 524           IF sym = comma THEN DevCPS.Get(sym)
 525           ELSIF sym = ident THEN err(comma)
 526           ELSE EXIT
 527           END
 528         END;
 529         CheckSym(semicolon)
 530       END;
 531       LOOP (* preprocessor must read module fully *)
 532         IF sym = end THEN
 533           DevCPS.Get(sym);
 534           IF sym = ident THEN
 535             DevCPS.Get(sym);
 536             IF sym = period THEN
 537               IF DevCPS.name # SelfName THEN err(4) END;
 538               EXIT
 539             ELSIF sym = eof THEN
 540               err(period);
 541               EXIT
 542             END
 543           ELSIF sym = eof THEN
 544             err(ident);
 545             EXIT
 546           END;
 547         ELSIF sym = eof THEN
 548           err(end);
 549           EXIT
 550         ELSE
 551           DevCPS.Get(sym);
 552         END
 553       END
 554     ELSE err(ident)
 555     END;
 556     DevCPS.str := NIL
 557   END ParseModule;
 558
 559   PROCEDURE CheckModule (m: Module; source: String; OUT ok: BOOLEAN);
 560     VAR s: Selector;
 561   BEGIN
 562     DevCPM.Init(source);
 563 (*
 564     DevCPM.symList := m.insym;
 565     DevCPM.codePath := m.outcode;
 566     DevCPM.symPath := m.outsym;
 567 *)
 568     DevCPM.name := m.name$;
 569 (*
 570     IF m.found THEN INCL(DevCPM.options, DevCPM.comAware) END;
 571     IF errorTrap IN m.opts THEN INCL(DevCPM.options, DevCPM.trap) END;
 572     IF oberon IN m.opts THEN INCL(DevCPM.options, DevCPM.oberon) END;
 573 *)
 574     DevCPR.Init;
 575     s := m.selectors.next;
 576     WHILE s # NIL DO
 577       DevCPR.Set(s.name, s.value);
 578       s := s.next
 579     END;
 580     ParseModule(m);
 581     DevCPR.Check;
 582     ok := DevCPM.noerr;
 583     DevCPR.Close;
 584     DevCPM.InsertMarks;
 585     DevCPM.Close;
 586     Kernel.FastCollect
 587   END CheckModule;
 588
 589   PROCEDURE GetSource (IN modName: ARRAY OF CHAR; OUT path: Files.Name; OUT s: String);
 590     CONST modDir = "Mod"; sysDir = "System";
 591     VAR dir, name: Files.Name; loc: Files.Locator;
 592       text: DswDocuments.Model; r: DswDocuments.Reader; i, res: INTEGER;
 593
 594     PROCEDURE MakePath (dir, name: Files.Name; type: Files.Type; OUT path: Files.Name);
 595     BEGIN
 596       ASSERT(name # "", 21);
 597       IF dir = "" THEN path := modDir + "/" + name
 598       ELSE path := dir + "/" + modDir + "/" + name
 599       END;
 600       Kernel.MakeFileName(path, type)
 601     END MakePath;
 602
 603   BEGIN
 604     s := NIL; path := "";
 605     Kernel.SplitName(modName, dir, name);
 606     loc := Files.dir.This(dir).This(modDir);
 607     (* --> Kernel.MakeFileName(name, Kernel.docType); <-- *)
 608     MakePath(dir, name, "cp", path);
 609     DswDocuments.Open(loc, name + ".cp", text, res);
 610     IF text = NIL THEN
 611       MakePath(dir, name, "odc", path);
 612       DswDocuments.Open(loc, name + ".odc", text, res);
 613       IF (text = NIL) & (dir = "") THEN
 614         MakePath(sysDir, name, "cp", path);
 615         loc := Files.dir.This(sysDir).This(modDir);
 616         DswDocuments.Open(loc, name + ".cp", text, res);
 617         IF text = NIL THEN
 618           MakePath(sysDir, name, "odc", path);
 619           DswDocuments.Open(loc, name + ".odc", text, res);
 620           IF text = NIL THEN
 621             path := ""
 622           END
 623         END
 624       END
 625     END;
 626     IF text # NIL THEN
 627       NEW(s, text.Length() + 1);
 628       IF s # NIL THEN
 629         r := text.NewReader(NIL);
 630         FOR i := 0 TO text.Length() - 1 DO
 631           r.Read; s[i] := r.char
 632         END
 633       END
 634     END
 635   END GetSource;
 636
 637   PROCEDURE Trace (m, parent: Module; VAR lno: INTEGER);
 638     VAR i: INTEGER;
 639   BEGIN
 640     IF ~(trace IN m.flags) THEN
 641       INCL(m.flags, trace);
 642       FOR i := 0 TO m.mno - 1 DO
 643         Trace(m.imp[i], m, lno);
 644         m.depth := MAX(m.depth, m.imp[i].depth + 1)
 645       END;
 646       IF ~(imported IN m.flags) THEN
 647         INCL(m.flags, imported);
 648         lnkList[lno] := m;
 649         INC(lno)
 650       END;
 651       EXCL(m.flags, trace)
 652     ELSE
 653       Error(20, m.name$, parent.name$, 0)
 654     END
 655   END Trace;
 656
 657   PROCEDURE Sort;
 658     VAR i, j: INTEGER; m: Module;
 659   BEGIN
 660     ASSERT((mno = 0) OR (lnkList[0] # NIL), 20);
 661     cmpList := lnkList;
 662     i := 1;
 663     WHILE i < mno DO
 664       m := cmpList[i];
 665       j := i - 1;
 666       WHILE (j >= 0) & (cmpList[j].depth > m.depth) DO
 667         cmpList[j + 1] := cmpList[j];
 668         DEC(j)
 669       END;
 670       cmpList[j + 1] := m;
 671       INC(i)
 672     END
 673   END Sort;
 674
 675   PROCEDURE CheckDeps;
 676     VAR i, j, num: INTEGER; m: Module; s: String; ok: BOOLEAN;
 677   BEGIN
 678     i := 0; rno := mno;
 679     WHILE (err = 0) & (i < mno) DO
 680       m := modList[i];
 681       GetSource(m.name$, m.path, s);
 682       IF s # NIL THEN
 683         CheckModule(m, s, ok);
 684         IF ~ok THEN INC(err) END
 685       ELSE
 686         Error(21, m.name$, "", 0)
 687       END;
 688       INC(i)
 689     END;
 690     INC(err, werr);
 691     num := 0;
 692     FOR i := 0 TO rno - 1 DO
 693       Trace(modList[i], modList[i], num)
 694     END;
 695     ASSERT((err # 0) OR (num = mno), 100);
 696     Sort;
 697     IF debugOrder THEN
 698       Log.String("Parallel depth:"); Log.Ln;
 699       FOR i := 0 TO mno - 1 DO
 700         Log.String("  " + cmpList[i].name); Log.Int(cmpList[i].depth); Log.Ln;
 701       END
 702     END
 703   END CheckDeps;
 704
 705   PROCEDURE IsCompiled (m: Module): BOOLEAN;
 706     CONST target = {hasSym, hasObj};
 707     VAR i: INTEGER; ready: BOOLEAN;
 708   BEGIN
 709     ASSERT(m # NIL, 20);
 710     i := 0;
 711     ready := ~(hasErrors IN m.flags) & (m.flags * target = target);
 712     WHILE ready & (i < m.mno) DO
 713       ready := IsCompiled(m.imp[i]);
 714       INC(i)
 715     END;
 716     RETURN ready
 717   END IsCompiled;
 718
 719   PROCEDURE Ready (m: Module): BOOLEAN;
 720     CONST target = {hasSym, hasObj};
 721     VAR i: INTEGER; ready: BOOLEAN;
 722   BEGIN
 723     i := 0;
 724     ready := ~(hasErrors IN m.flags) & (m.flags * target # target) & (m.worker = NIL);
 725     WHILE ready & (i < m.mno) DO
 726       ready := IsCompiled(m.imp[i]);
 727       INC(i)
 728     END;
 729     RETURN ready
 730   END Ready;
 731
 732   PROCEDURE PutParams (w: DswProcs.Process; p: StringList);
 733     VAR i: INTEGER;
 734   BEGIN
 735     ASSERT(w # NIL, 20);
 736     IF debugArgs THEN Log.String("PutParams") END;
 737     IF p # NIL THEN
 738       IF debugArgs THEN Log.String(":[" + p[0]) END;
 739       w.PutParam(p[0]);
 740       FOR i := 1 TO LEN(p) - 1 DO
 741         IF debugArgs THEN Log.String("|" + p[i]) END;
 742         w.PutParam(p[i])
 743       END;
 744       IF debugArgs THEN Log.Char("]") END
 745     END;
 746     IF debugArgs THEN Log.Ln END
 747   END PutParams;
 748
 749   PROCEDURE ExecuteCompiler (m: Module): DswProcs.Process;
 750     VAR w: DswProcs.Process; ok: BOOLEAN;
 751   BEGIN
 752     ASSERT(m # NIL, 20);
 753     ASSERT(m.path # "", 21);
 754     ASSERT(m.worker = NIL, 22);
 755     w := DswProcs.dir.New();
 756     w.Program(cpcExe);
 757     w.PutParam("-legacy");
 758     PutParams(w, cpcArgs);
 759     CASE compiler OF
 760     | cpfront:
 761       w.PutParam("-define+"); w.PutParam("CPFRONT");
 762       w.PutParam("-define-"); w.PutParam("NATIVE");
 763     | cpnative:
 764       w.PutParam("-define-"); w.PutParam("CPFRONT");
 765       w.PutParam("-define+"); w.PutParam("NATIVE");
 766     END;
 767     CASE processor OF
 768     | mach386:
 769       w.PutParam("-define+"); w.PutParam("I486");
 770       w.PutParam("-define-"); w.PutParam("M68K");
 771     | mach68k:
 772       w.PutParam("-define+"); w.PutParam("I486");
 773       w.PutParam("-define-"); w.PutParam("M68K");
 774     ELSE
 775       w.PutParam("-define-"); w.PutParam("I486");
 776       w.PutParam("-define-"); w.PutParam("M68K");
 777     END;
 778     CASE os OF
 779     | anyos:
 780       w.PutParam("-define-"); w.PutParam("POSIX");
 781       w.PutParam("-define-"); w.PutParam("LINUX");
 782       w.PutParam("-define-"); w.PutParam("FREEBSD");
 783       w.PutParam("-define-"); w.PutParam("OPENBSD");
 784       w.PutParam("-define-"); w.PutParam("WIN32");
 785       w.PutParam("-define-"); w.PutParam("DARWIN");
 786     | linux:
 787       w.PutParam("-define+"); w.PutParam("POSIX");
 788       w.PutParam("-define+"); w.PutParam("LINUX");
 789       w.PutParam("-define-"); w.PutParam("FREEBSD");
 790       w.PutParam("-define-"); w.PutParam("OPENBSD");
 791       w.PutParam("-define-"); w.PutParam("WIN32");
 792       w.PutParam("-define-"); w.PutParam("DARWIN");
 793     | freebsd:
 794       w.PutParam("-define+"); w.PutParam("POSIX");
 795       w.PutParam("-define-"); w.PutParam("LINUX");
 796       w.PutParam("-define+"); w.PutParam("FREEBSD");
 797       w.PutParam("-define-"); w.PutParam("OPENBSD");
 798       w.PutParam("-define-"); w.PutParam("WIN32");
 799       w.PutParam("-define-"); w.PutParam("CYGWIN");
 800       w.PutParam("-define-"); w.PutParam("DARWIN");
 801     | openbsd:
 802       w.PutParam("-define+"); w.PutParam("POSIX");
 803       w.PutParam("-define-"); w.PutParam("LINUX");
 804       w.PutParam("-define-"); w.PutParam("FREEBSD");
 805       w.PutParam("-define+"); w.PutParam("OPENBSD");
 806       w.PutParam("-define-"); w.PutParam("WIN32");
 807       w.PutParam("-define-"); w.PutParam("CYGWIN");
 808       w.PutParam("-define-"); w.PutParam("DARWIN");
 809     | win32:
 810       w.PutParam("-define-"); w.PutParam("POSIX");
 811       w.PutParam("-define-"); w.PutParam("LINUX");
 812       w.PutParam("-define-"); w.PutParam("FREEBSD");
 813       w.PutParam("-define-"); w.PutParam("OPENBSD");
 814       w.PutParam("-define+"); w.PutParam("WIN32");
 815       w.PutParam("-define-"); w.PutParam("CYGWIN");
 816       w.PutParam("-define-"); w.PutParam("DARWIN");
 817     | cygwin:
 818       w.PutParam("-define+"); w.PutParam("POSIX");
 819       w.PutParam("-define-"); w.PutParam("LINUX");
 820       w.PutParam("-define-"); w.PutParam("FREEBSD");
 821       w.PutParam("-define-"); w.PutParam("OPENBSD");
 822       w.PutParam("-define+"); w.PutParam("WIN32");
 823       w.PutParam("-define+"); w.PutParam("CYGWIN");
 824       w.PutParam("-define-"); w.PutParam("DARWIN");
 825     | darwin:
 826       w.PutParam("-define+"); w.PutParam("POSIX");
 827       w.PutParam("-define-"); w.PutParam("LINUX");
 828       w.PutParam("-define-"); w.PutParam("FREEBSD");
 829       w.PutParam("-define-"); w.PutParam("OPENBSD");
 830       w.PutParam("-define-"); w.PutParam("WIN32");
 831       w.PutParam("-define-"); w.PutParam("CYGWIN");
 832       w.PutParam("-define+"); w.PutParam("DARWIN");
 833     END;
 834     CASE linker OF
 835     | dev2:
 836       w.PutParam("-define+"); w.PutParam("DEV2");
 837     ELSE
 838       w.PutParam("-define-"); w.PutParam("DEV2");
 839     END;
 840     w.PutParam(m.path);
 841     w.Execute(ok);
 842     IF ok THEN
 843       Log.String("Compile " + m.name + " (" + m.path + ")"); Log.Ln;
 844     ELSE
 845       w := NIL
 846     END;
 847     RETURN w
 848   END ExecuteCompiler;
 849
 850   PROCEDURE Compile;
 851     VAR i, j, num: INTEGER; ok: BOOLEAN; m: Module; w: DswProcs.Process;
 852   BEGIN
 853     IF mno = 0 THEN RETURN END;
 854     num := 0; j := 0;
 855     WHILE (err = 0) & (num < mno) OR (j > 0) DO
 856       i := 0;
 857       WHILE (err = 0) & (i < mno) & (j < jobs) DO
 858         m := cmpList[i];
 859         IF Ready(m) THEN
 860           w := ExecuteCompiler(m);
 861           IF debugJobs THEN Log.String("Start job " + m.name) END;
 862           IF w # NIL THEN
 863             IF debugJobs THEN Log.String(" ok") END;
 864             m.worker := w;
 865             INC(j)
 866           ELSE
 867             IF debugJobs THEN Log.String(" fail") END;
 868             INCL(m.flags, hasErrors);
 869             INC(err)
 870           END;
 871           IF debugJobs THEN Log.Ln END
 872         END;
 873         INC(i)
 874       END;
 875       WHILE (err = 0) & (j >= jobs) OR (j > 0) DO
 876         i := 0;
 877         WHILE (j > 0) & (i < mno) DO
 878           m := cmpList[i];
 879           w := m.worker;
 880           IF (w # NIL) & w.IsTerminated() THEN
 881             IF debugJobs THEN Log.String("Stop job " + m.name); Log.Int(w.Result()); Log.Ln END;
 882             IF w.Result() = 0 THEN
 883               INCL(m.flags, hasObj);
 884               INCL(m.flags, hasSym);
 885               INC(num)
 886             ELSE
 887               INCL(m.flags, hasErrors);
 888               INC(err)
 889             END;
 890             m.worker := NIL;
 891             DEC(j)
 892           END;
 893           INC(i)
 894         END
 895       END
 896     END
 897   END Compile;
 898
 899   PROCEDURE LinkDev2;
 900     VAR p: DswProcs.Process; i, res: INTEGER; ok: BOOLEAN;
 901   BEGIN
 902     ASSERT((exe # NIL) & (exe^ # ""), 20);
 903     ASSERT(processor = mach386, 21);
 904     ASSERT(compiler = cpnative, 22);
 905     p := DswProcs.dir.New();
 906     p.Program(cplExe);
 907     IF os # anyos THEN
 908       p.PutParam("-os");
 909       CASE os OF
 910       | linux: p.PutParam("linux")
 911       | freebsd: p.PutParam("freebsd")
 912       | openbsd: p.PutParam("openbsd")
 913       | win32, cygwin: p.PutParam("win32")
 914       | darwin: p.PutParam("darwin")
 915       END
 916     END;
 917     p.PutParam("-kernel");
 918     p.PutParam("Kernel");
 919     p.PutParam("-main");
 920     p.PutParam("Kernel");
 921     p.PutParam("-legacycodedir");
 922     p.PutParam(".");
 923     p.PutParam("-o");
 924     p.PutParam(exe);
 925     PutParams(p, cplArgs);
 926     i := 0;
 927     WHILE i < mno DO
 928       IF ~(library IN lnkList[i].flags) THEN
 929         p.PutParam(lnkList[i].name$)
 930       END;
 931       INC(i)
 932     END;
 933     p.Execute(ok);
 934     IF ok THEN
 935       Log.String("Link "); Log.String(exe); Log.Ln;
 936       res := p.Result();
 937       IF res # 0 THEN
 938         Error(22, "", "", res)
 939       END
 940     ELSE
 941       Error(23, "", "", 0)
 942     END
 943   END LinkDev2;
 944
 945   PROCEDURE Link;
 946   BEGIN
 947     IF exe # NIL THEN
 948       CASE linker OF
 949       | anyint: (* do not link *)
 950       | dev2: LinkDev2
 951       END
 952     END
 953   END Link;
 954
 955   PROCEDURE Main;
 956     VAR m: Module; s: Selector; p: DswProcs.Process; ok: BOOLEAN; i, res: INTEGER;
 957   BEGIN
 958     IF Kernel.trapCount = 0 THEN
 959       ParseArgs;
 960       IF err = 0 THEN
 961         CheckParams;
 962         IF err = 0 THEN
 963           CheckDeps;
 964           IF err = 0 THEN
 965             Compile;
 966             IF err = 0 THEN
 967               Link
 968             END
 969           END
 970         END
 971       END
 972     ELSE Error(24, "", "", 0)
 973     END;
 974     IF err = 0 THEN Kernel.Quit(0)
 975     ELSE Kernel.Quit(1)
 976     END;
 977   END Main;
 978
 979 BEGIN
 980   NEW(def);
 981   ASSERT(def # NIL, 100);
 982   Kernel.intTrap := FALSE;
 983   Kernel.Start(Main)
 984 END DswMakeMain.