MODULE DswMakeMain; IMPORT Kernel, Files, Log, Strings, DswOpts, DswProcs, DswDocuments, DevCPM, DevCPT, DevCPR, DevCPS; CONST version = "0.3.0"; maxImps = 127; maxJobs = maxImps; (* symbol values *) null = 0; times = 1; slash = 2; div = 3; mod = 4; and = 5; plus = 6; minus = 7; or = 8; eql = 9; neq = 10; lss = 11; leq = 12; gtr = 13; geq = 14; in = 15; is = 16; arrow = 17; dollar = 18; period = 19; comma = 20; colon = 21; upto = 22; rparen = 23; rbrak = 24; rbrace = 25; of = 26; then = 27; do = 28; to = 29; by = 30; not = 33; lparen = 40; lbrak = 41; lbrace = 42; becomes = 44; number = 45; nil = 46; string = 47; ident = 48; semicolon = 49; bar = 50; end = 51; else = 52; elsif = 53; until = 54; if = 55; case = 56; while = 57; repeat = 58; for = 59; loop = 60; with = 61; exit = 62; return = 63; array = 64; record = 65; pointer = 66; begin = 67; const = 68; type = 69; var = 70; out = 71; procedure = 72; close = 73; import = 74; module = 75; eof = 76; (* module state flags *) imported = 0; trace = 1; hasObj = 2; hasSym = 3; hasErrors = 4; library = 5; (* procesor types *) anymach = 0; cmach = 1; mach386 = 10; mach68k = 20; (* operation system types *) anyos = 0; linux = 1; freebsd = 2; openbsd = 3; win32 = 4; cygwin = 5; darwin = 6; (* compiler types *) anycp = 0; cpnative = 1; cpfront = 2; (* internal linker types *) anyint = 0; dev2 = 1; debugImport = FALSE; debugOrder = FALSE; debugJobs = FALSE; debugArgs = FALSE; TYPE String = POINTER TO ARRAY OF CHAR; StringList = POINTER TO ARRAY OF String; Selector = POINTER TO RECORD name: DevCPT.Name; value: BOOLEAN; next: Selector END; Module = POINTER TO RECORD name: DevCPT.Name; path: Files.Name; selectors: Selector; (* with head, list of selectors for this module *) depth: INTEGER; (* 0: leaf, MAX: root *) mno: INTEGER; imp: ARRAY maxImps OF Module; flags: SET; worker: DswProcs.Process; END; VAR werr, err: INTEGER; mno, rno: INTEGER; (* num modules *) modList, lnkList, cmpList: ARRAY maxImps OF Module; def: Selector; (* with head, global list of selectors *) processor, compiler, os, linker: INTEGER; cpcExe, cplExe: String; cpcArgs, cplArgs: StringList; auto: BOOLEAN; jobs: INTEGER; exe: String; (* --------- options --------- *) PROCEDURE IdentLen (IN s: ARRAY OF CHAR): INTEGER; VAR i: INTEGER; BEGIN i := 0; IF Strings.IsIdentStart(s[0]) THEN REPEAT INC(i) UNTIL ~Strings.IsIdent(s[i]) END; RETURN i END IdentLen; PROCEDURE Define (n: ARRAY OF CHAR); VAR i: INTEGER; v: BOOLEAN; s: Selector; BEGIN i := IdentLen(n); IF i # 0 THEN IF ~((n[i] = 0X) OR (((n[i] = "+") OR (n[i] = "-")) & (n[i + 1] = 0X))) THEN Log.String("option -D expect + or - after identifier"); Log.Ln; INC(err) END; v := n[i] # "-"; n[i] := 0X; s := def; WHILE (s.next # NIL) & (s.next.name$ # n$) DO s := s.next END; IF s.next = NIL THEN NEW(s.next); Strings.StringToUtf8(n, s.next.name, i); ASSERT(i = 0) END; s.next.value := v ELSE Log.String("option -D expect identifier"); Log.Ln; INC(err) END END Define; PROCEDURE Undefine (IN n: ARRAY OF CHAR); VAR i: INTEGER; s: Selector; BEGIN i := IdentLen(n); IF (i # 0) & (n[i] = 0X) THEN s := def; WHILE (s.next # NIL) & (s.next.name$ # n$) DO s := s.next END; IF s.next # NIL THEN s.next := s.next.next END ELSE Log.String("option -U expect identifier"); Log.Ln; INC(err) END END Undefine; PROCEDURE CopySelectorList (base: Selector): Selector; VAR s, t, x: Selector; BEGIN ASSERT(base # NIL, 20); s := base; NEW(t); x := t; WHILE s # NIL DO x^ := s^; IF s.next # NIL THEN NEW(x.next); x := x.next END; s := s.next END; RETURN t END CopySelectorList; PROCEDURE AddModule (IN n: ARRAY OF CHAR; selectors: Selector); VAR i, res: INTEGER; m: Module; BEGIN i := IdentLen(n); IF (i # 0) & (n[i] = 0X) THEN i := 0; WHILE (i < mno) & (modList[i].name$ # n$) DO INC(i) END; IF i >= mno THEN NEW(m); Strings.StringToUtf8(n, m.name, res); ASSERT(res = 0); m.selectors := CopySelectorList(selectors); modList[i] := m; INC(mno) END ELSE Log.String("module name must be identifier"); Log.Ln; INC(err) END END AddModule; PROCEDURE StrToInt (IN s: ARRAY OF CHAR; def: INTEGER): INTEGER; VAR x, res: INTEGER; BEGIN Strings.StringToInt(s, x, res); IF res # 0 THEN Log.String("expected integer"); Log.Ln; INC(err); x := def END; RETURN x END StrToInt; PROCEDURE NewStr (IN s: ARRAY OF CHAR): String; VAR p: String; BEGIN NEW(p, LEN(s$) + 1); p^ := s$; RETURN p END NewStr; PROCEDURE ToStringList (IN s: ARRAY OF CHAR): StringList; VAR i: INTEGER; ch, term: CHAR; pars: StringList; PROCEDURE AddChar (c: CHAR); VAR i, n, len: INTEGER; str: String; BEGIN IF pars = NIL THEN NEW(pars, 1); NEW(pars[0], 2); pars[0, 0] := c ELSE n := LEN(pars) - 1; len := LEN(pars[n]$); NEW(str, len + 2); FOR i := 0 TO len - 1 DO str[i] := pars[n, i] END; str[i] := c; pars[n] := str END END AddChar; PROCEDURE AddLine; VAR i, len: INTEGER; p: StringList; BEGIN IF pars = NIL THEN NEW(pars, 1); i := 0; ELSE len := LEN(pars); NEW(p, len + 1); FOR i := 0 TO len - 1 DO p[i] := pars[i] END; pars := p END; NEW(pars[i], 1) END AddLine; BEGIN i := 0; REPEAT ch := s[i]; INC(i) UNTIL ch # " "; WHILE ch # 0X DO CASE ch OF | '"', "'": term := ch; ch := s[i]; INC(i); WHILE (ch # term) & (ch # 0X) DO AddChar(ch); ch := s[i]; INC(i) END; IF ch # 0X THEN ch := s[i]; INC(i) ELSE Log.String("unterminated string"); Log.Ln; INC(err) END | " ": REPEAT ch := s[i]; INC(i) UNTIL ch # " "; IF ch # 0X THEN AddLine END ELSE AddChar(ch); ch := s[i]; INC(i) END END; RETURN pars END ToStringList; PROCEDURE Help; BEGIN Log.String("Usage: cpmake [options] module..."); Log.Ln; Log.String("Options:"); Log.Ln; Log.String(" -Tm cpu Generate code for specified processor"); Log.Ln; Log.String(" none Unknown processor (cpfront only)"); Log.Ln; Log.String(" 486 Intel 486"); Log.Ln; Log.String(" -Ts os Generate code for specified operation system"); Log.Ln; Log.String(" none Unknown operation system"); Log.Ln; Log.String(" linux Linux"); Log.Ln; Log.String(" -Tg compiler Specify Component Pascal compiler"); Log.Ln; Log.String(" native BlackBox based native code compiler"); Log.Ln; Log.String(" cpfront BlackBox based C code translator"); Log.Ln; Log.String(" -Ti linker Specify internal linker (native only)"); Log.Ln; Log.String(" dev2 Dev2 based ELF/PE linker"); Log.Ln; (* Log.String(" -Fp path Add path with project"); Log.Ln; Log.String(" -Fx path Add postfix for project directories"); Log.Ln; *) Log.String(" -Xp path Use executable file for Component Pascal compiler"); Log.Ln; Log.String(" -Xi path Use executable file for internal linker (native only)"); Log.Ln; Log.String(" -Cg params Pass parameters to Component Pasacal compiler directly"); Log.Ln; Log.String(" -Ci params Pass parameters to internal linker directly"); Log.Ln; Log.String(" -a Enable automatic dependency resolution"); Log.Ln; Log.String(" -o name Generate executable file"); Log.Ln; Log.String(" -j num Specifies the number of jobs to run simultaneously"); Log.Ln; Log.String(' -D ident["+"|"-"] Add preprocessor selector'); Log.Ln; Log.String(' -U ident Remove preprocessor selector'); Log.Ln; Log.String(" -h Print help and quit"); Log.Ln; Log.String(" -V Print version and quit"); Log.Ln; Kernel.Quit(1) END Help; PROCEDURE Version; BEGIN Log.String(version); Log.Ln; Kernel.Quit(0) END Version; PROCEDURE ParseTargetOpts; VAR s: DswOpts.String; BEGIN CASE DswOpts.GetOpt("m:s:g:i:") OF | "m": s := DswOpts.str; Strings.ToLower(s, s); IF s$ = "none" THEN processor := anymach ELSIF s$ = "486" THEN processor := mach386 ELSIF s$ = "68k" THEN processor := mach68k ELSE Log.String("unknwon processor "); Log.String(s); Log.Ln; INC(err) END | "s": s := DswOpts.str; Strings.ToLower(s, s); IF s$ = "none" THEN os := anyos ELSIF s$ = "linux" THEN os := linux ELSIF s$ = "freebsd" THEN os := freebsd ELSIF s$ = "openbsd" THEN os := openbsd ELSIF s$ = "win32" THEN os := win32 ELSIF s$ = "cygwin" THEN os := cygwin ELSIF s$ = "darwin" THEN os := darwin ELSE Log.String("unknwon os "); Log.String(s); Log.Ln; INC(err) END | "g": s := DswOpts.str; Strings.ToLower(s, s); IF s$ = "native" THEN compiler := cpnative ELSIF s$ = "cpfront" THEN compiler := cpfront ELSE Log.String("unknwon compiler "); Log.String(s); Log.Ln; INC(err) END | "i": s := DswOpts.str; Strings.ToLower(s, s); IF s$ = "dev2" THEN linker := dev2 ELSE Log.String("unknwon linker "); Log.String(s); Log.Ln; INC(err) END | ":": Log.String("missing argument for option -T"); Log.String(DswOpts.str); Log.Ln; INC(err) | "?": Log.String("unknown option -T"); Log.String(DswOpts.str); Log.Ln; INC(err) | 0X: Log.String("unknown option -T"); Log.Ln; INC(err) END END ParseTargetOpts; PROCEDURE ParseCommandOpts; BEGIN CASE DswOpts.GetOpt("g:i:") OF | "g": cpcArgs := ToStringList(DswOpts.str); | "i": cplArgs := ToStringList(DswOpts.str); | ":": Log.String("missing argument for option -C"); Log.String(DswOpts.str); Log.Ln; INC(err) | "?": Log.String("unknown option -C"); Log.String(DswOpts.str); Log.Ln; INC(err) | 0X: Log.String("unknown option -C"); Log.Ln; INC(err) END END ParseCommandOpts; PROCEDURE ParseExternalOpts; BEGIN CASE DswOpts.GetOpt("g:i:") OF | "g": cpcExe := DswOpts.str; | "i": cplExe := DswOpts.str; | ":": Log.String("missing argument for option -X"); Log.String(DswOpts.str); Log.Ln; INC(err) | "?": Log.String("unknown option -X"); Log.String(DswOpts.str); Log.Ln; INC(err) | 0X: Log.String("unknown option -X"); Log.Ln; INC(err) END END ParseExternalOpts; PROCEDURE ParseArgs; BEGIN exe := NIL; auto := FALSE; jobs := 1; def.next := NIL; mno := 0; rno := 0; processor := anymach; os := anyos; compiler := anycp; LOOP CASE DswOpts.GetOpt("ao:j:D:U:TCXhV") OF | "a": auto := TRUE | "o": exe := DswOpts.str | "j": jobs := MIN(MAX(StrToInt(DswOpts.str, 1), 1), maxJobs) | "h": Help | "V": Version | "D": Define(DswOpts.str) | "U": Undefine(DswOpts.str) | "T": ParseTargetOpts | "C": ParseCommandOpts | "X": ParseExternalOpts | ":": Log.String("missing argument for option -"); Log.String(DswOpts.str); Log.Ln; INC(err) | "?": Log.String("unknown option -"); Log.String(DswOpts.str); Log.Ln; INC(err) | "$": AddModule(DswOpts.str, def) | 0X: EXIT END END; END ParseArgs; PROCEDURE CheckParams; BEGIN IF compiler = anycp THEN Log.String("compiler not selected"); Log.Ln; INC(err) ELSIF compiler = cpnative THEN IF processor = anymach THEN Log.String("processor not selected"); Log.Ln; INC(err) ELSIF processor # mach386 THEN Log.String("processor not supported by native compiler"); Log.Ln; INC(err) END END; IF (compiler = cpfront) & (linker # anyint) THEN Log.String("internal linker not required for cpfront"); Log.Ln; INC(err) END; IF (compiler = cpfront) & (exe # NIL) THEN Log.String("cpfront can't out executable file"); Log.Ln; INC(err) END; IF (exe # NIL) & (compiler = cpnative) & (linker = anyint) THEN Log.String("linker not selected"); Log.Ln; INC(err) END; IF (linker = dev2) & (os = anyos) THEN Log.String("os not selected"); Log.Ln; INC(err) END; IF (exe # NIL) & (exe^ = "") THEN Log.String("output file name can't be empty"); Log.Ln; INC(err) END; IF cpcExe = NIL THEN IF compiler = cpnative THEN cpcExe := NewStr("cpc486") ELSIF compiler = cpfront THEN cpcExe := NewStr("cpfront") END END; IF cplExe = NIL THEN IF linker = dev2 THEN cplExe := NewStr("cpl486") END END END CheckParams; (* --------- loader --------- *) PROCEDURE Import (m: Module; IN name: DevCPT.Name); VAR i, j: INTEGER; imp: Module; BEGIN ASSERT(m # NIL, 20); ASSERT(name # "", 21); IF debugImport THEN Log.String(" import "); Log.String(name$) END; IF name = "SYSTEM" THEN INCL(DevCPM.options, DevCPM.sysImp) ELSIF name = "COM" THEN INCL(DevCPM.options, DevCPM.com) ELSIF name = "JAVA" THEN INCL(DevCPM.options, DevCPM.java) ELSE IF debugImport THEN Log.Char(" ") END; i := 0; (* find module in local list *) WHILE (i < m.mno) & (m.imp[i].name$ # name$) DO INC(i) END; IF i >= m.mno THEN j := 0; (* find module in global list *) WHILE (j < mno) & (modList[j].name$ # name$) DO INC(j) END; IF j >= mno THEN IF ~auto THEN Log.String("module " + name + " required before " + m.name); Log.Ln; INC(werr) END; NEW(imp); imp.name := name$; imp.selectors := CopySelectorList(m.selectors); modList[mno] := imp; INC(mno) ELSE imp := modList[j] END; m.imp[m.mno] := imp; INC(m.mno) ELSE DevCPM.err(1) END END; IF debugImport THEN Log.Ln END; END Import; PROCEDURE ParseModule (m: Module); VAR sym: BYTE; SelfName, impName, aliasName: DevCPT.Name; PROCEDURE err (n: SHORTINT); BEGIN DevCPM.err(n) END err; PROCEDURE CheckSym(s: SHORTINT); BEGIN IF sym = s THEN DevCPS.Get(sym) ELSE DevCPM.err(s) END END CheckSym; BEGIN IF debugImport THEN Log.String("module " + m.name); Log.Ln END; DevCPS.Init; DevCPS.Get(sym); IF sym = module THEN DevCPS.Get(sym) ELSE err(16) END; IF sym = ident THEN SelfName := DevCPS.name$; DevCPS.Get(sym); IF sym = lbrak THEN INCL(DevCPM.options, DevCPM.interface); DevCPS.Get(sym); IF sym = eql THEN DevCPS.Get(sym) ELSE INCL(DevCPM.options, DevCPM.noCode) END; IF sym = string THEN INCL(m.flags, library); DevCPS.Get(sym) ELSE err(string) END; CheckSym(rbrak) END; CheckSym(semicolon); IF sym = import THEN DevCPS.Get(sym); LOOP IF sym = ident THEN aliasName := DevCPS.name$; impName := aliasName$; DevCPS.Get(sym); IF sym = becomes THEN DevCPS.Get(sym); IF sym = ident THEN impName := DevCPS.name$; DevCPS.Get(sym) ELSE err(ident) END END; Import(m, impName) ELSE err(ident) END; IF sym = comma THEN DevCPS.Get(sym) ELSIF sym = ident THEN err(comma) ELSE EXIT END END; CheckSym(semicolon) END; LOOP (* preprocessor must read module fully *) IF sym = end THEN DevCPS.Get(sym); IF sym = ident THEN DevCPS.Get(sym); IF sym = period THEN IF DevCPS.name # SelfName THEN err(4) END; EXIT ELSIF sym = eof THEN err(period); EXIT END ELSIF sym = eof THEN err(ident); EXIT END; ELSIF sym = eof THEN err(end); EXIT ELSE DevCPS.Get(sym); END END ELSE err(ident) END; DevCPS.str := NIL END ParseModule; PROCEDURE CheckModule (m: Module; source: String; OUT ok: BOOLEAN); VAR s: Selector; BEGIN DevCPM.Init(source); (* DevCPM.symList := m.insym; DevCPM.codePath := m.outcode; DevCPM.symPath := m.outsym; *) DevCPM.name := m.name$; (* IF m.found THEN INCL(DevCPM.options, DevCPM.comAware) END; IF errorTrap IN m.opts THEN INCL(DevCPM.options, DevCPM.trap) END; IF oberon IN m.opts THEN INCL(DevCPM.options, DevCPM.oberon) END; *) DevCPR.Init; s := m.selectors.next; WHILE s # NIL DO DevCPR.Set(s.name, s.value); s := s.next END; ParseModule(m); DevCPR.Check; ok := DevCPM.noerr; DevCPR.Close; DevCPM.InsertMarks; DevCPM.Close; Kernel.FastCollect END CheckModule; PROCEDURE GetSource (IN modName: ARRAY OF CHAR; OUT path: Files.Name; OUT s: String); CONST modDir = "Mod"; sysDir = "System"; VAR dir, name: Files.Name; loc: Files.Locator; text: DswDocuments.Model; r: DswDocuments.Reader; i, res: INTEGER; PROCEDURE MakePath (dir, name: Files.Name; type: Files.Type; OUT path: Files.Name); BEGIN ASSERT(name # "", 21); IF dir = "" THEN path := modDir + "/" + name ELSE path := dir + "/" + modDir + "/" + name END; Kernel.MakeFileName(path, type) END MakePath; BEGIN s := NIL; path := ""; Kernel.SplitName(modName, dir, name); loc := Files.dir.This(dir).This(modDir); (* --> Kernel.MakeFileName(name, Kernel.docType); <-- *) MakePath(dir, name, "cp", path); DswDocuments.Open(loc, name + ".cp", text, res); IF text = NIL THEN MakePath(dir, name, "odc", path); DswDocuments.Open(loc, name + ".odc", text, res); IF (text = NIL) & (dir = "") THEN MakePath(sysDir, name, "cp", path); loc := Files.dir.This(sysDir).This(modDir); DswDocuments.Open(loc, name + ".cp", text, res); IF text = NIL THEN MakePath(sysDir, name, "odc", path); DswDocuments.Open(loc, name + ".odc", text, res); IF text = NIL THEN path := "" END END END END; IF text # NIL THEN NEW(s, text.Length() + 1); IF s # NIL THEN r := text.NewReader(NIL); FOR i := 0 TO text.Length() - 1 DO r.Read; s[i] := r.char END END END END GetSource; PROCEDURE Trace (m, parent: Module; VAR lno: INTEGER); VAR i: INTEGER; BEGIN IF ~(trace IN m.flags) THEN INCL(m.flags, trace); FOR i := 0 TO m.mno - 1 DO Trace(m.imp[i], m, lno); m.depth := MAX(m.depth, m.imp[i].depth + 1) END; IF ~(imported IN m.flags) THEN INCL(m.flags, imported); lnkList[lno] := m; INC(lno) END; EXCL(m.flags, trace) ELSE Log.String("recursive import of " + m.name + " in " + parent.name); Log.Ln; INC(err) END END Trace; PROCEDURE Sort; VAR i, j: INTEGER; m: Module; BEGIN ASSERT((mno = 0) OR (lnkList[0] # NIL), 20); cmpList := lnkList; i := 1; WHILE i < mno DO m := cmpList[i]; j := i - 1; WHILE (j >= 0) & (cmpList[j].depth > m.depth) DO cmpList[j + 1] := cmpList[j]; DEC(j) END; cmpList[j + 1] := m; INC(i) END END Sort; PROCEDURE CheckDeps; VAR i, j, num: INTEGER; m: Module; s: String; ok: BOOLEAN; BEGIN i := 0; rno := mno; WHILE (err = 0) & (i < mno) DO m := modList[i]; GetSource(m.name$, m.path, s); IF s # NIL THEN CheckModule(m, s, ok); IF ~ok THEN INC(err) END ELSE Log.String("unable to open module " + m.name); Log.Ln; INC(err) END; INC(i) END; INC(err, werr); num := 0; FOR i := 0 TO rno - 1 DO Trace(modList[i], modList[i], num) END; ASSERT((err # 0) OR (num = mno), 100); Sort; IF debugOrder THEN Log.String("Parallel depth:"); Log.Ln; FOR i := 0 TO mno - 1 DO Log.String(" " + cmpList[i].name); Log.Int(cmpList[i].depth); Log.Ln; END END END CheckDeps; PROCEDURE IsCompiled (m: Module): BOOLEAN; CONST target = {hasSym, hasObj}; VAR i: INTEGER; ready: BOOLEAN; BEGIN ASSERT(m # NIL, 20); i := 0; ready := ~(hasErrors IN m.flags) & (m.flags * target = target); WHILE ready & (i < m.mno) DO ready := IsCompiled(m.imp[i]); INC(i) END; RETURN ready END IsCompiled; PROCEDURE Ready (m: Module): BOOLEAN; CONST target = {hasSym, hasObj}; VAR i: INTEGER; ready: BOOLEAN; BEGIN i := 0; ready := ~(hasErrors IN m.flags) & (m.flags * target # target) & (m.worker = NIL); WHILE ready & (i < m.mno) DO ready := IsCompiled(m.imp[i]); INC(i) END; RETURN ready END Ready; PROCEDURE PutParams (w: DswProcs.Process; p: StringList); VAR i: INTEGER; BEGIN ASSERT(w # NIL, 20); IF debugArgs THEN Log.String("PutParams") END; IF p # NIL THEN IF debugArgs THEN Log.String(":[" + p[0]) END; w.PutParam(p[0]); FOR i := 1 TO LEN(p) - 1 DO IF debugArgs THEN Log.String("|" + p[i]) END; w.PutParam(p[i]) END; IF debugArgs THEN Log.Char("]") END END; IF debugArgs THEN Log.Ln END END PutParams; PROCEDURE ExecuteCompiler (m: Module): DswProcs.Process; VAR w: DswProcs.Process; ok: BOOLEAN; BEGIN ASSERT(m # NIL, 20); ASSERT(m.path # "", 21); ASSERT(m.worker = NIL, 22); w := DswProcs.dir.New(); w.Program(cpcExe); w.PutParam("-legacy"); PutParams(w, cpcArgs); CASE compiler OF | cpfront: w.PutParam("-define+"); w.PutParam("CPFRONT"); w.PutParam("-define-"); w.PutParam("NATIVE"); | cpnative: w.PutParam("-define-"); w.PutParam("CPFRONT"); w.PutParam("-define+"); w.PutParam("NATIVE"); END; CASE processor OF | mach386: w.PutParam("-define+"); w.PutParam("I486"); w.PutParam("-define-"); w.PutParam("M68K"); | mach68k: w.PutParam("-define+"); w.PutParam("I486"); w.PutParam("-define-"); w.PutParam("M68K"); ELSE w.PutParam("-define-"); w.PutParam("I486"); w.PutParam("-define-"); w.PutParam("M68K"); END; CASE os OF | anyos: w.PutParam("-define-"); w.PutParam("POSIX"); w.PutParam("-define-"); w.PutParam("LINUX"); w.PutParam("-define-"); w.PutParam("FREEBSD"); w.PutParam("-define-"); w.PutParam("OPENBSD"); w.PutParam("-define-"); w.PutParam("WIN32"); w.PutParam("-define-"); w.PutParam("DARWIN"); | linux: w.PutParam("-define+"); w.PutParam("POSIX"); w.PutParam("-define+"); w.PutParam("LINUX"); w.PutParam("-define-"); w.PutParam("FREEBSD"); w.PutParam("-define-"); w.PutParam("OPENBSD"); w.PutParam("-define-"); w.PutParam("WIN32"); w.PutParam("-define-"); w.PutParam("DARWIN"); | freebsd: w.PutParam("-define+"); w.PutParam("POSIX"); w.PutParam("-define-"); w.PutParam("LINUX"); w.PutParam("-define+"); w.PutParam("FREEBSD"); w.PutParam("-define-"); w.PutParam("OPENBSD"); w.PutParam("-define-"); w.PutParam("WIN32"); w.PutParam("-define-"); w.PutParam("CYGWIN"); w.PutParam("-define-"); w.PutParam("DARWIN"); | openbsd: w.PutParam("-define+"); w.PutParam("POSIX"); w.PutParam("-define-"); w.PutParam("LINUX"); w.PutParam("-define-"); w.PutParam("FREEBSD"); w.PutParam("-define+"); w.PutParam("OPENBSD"); w.PutParam("-define-"); w.PutParam("WIN32"); w.PutParam("-define-"); w.PutParam("CYGWIN"); w.PutParam("-define-"); w.PutParam("DARWIN"); | win32: w.PutParam("-define-"); w.PutParam("POSIX"); w.PutParam("-define-"); w.PutParam("LINUX"); w.PutParam("-define-"); w.PutParam("FREEBSD"); w.PutParam("-define-"); w.PutParam("OPENBSD"); w.PutParam("-define+"); w.PutParam("WIN32"); w.PutParam("-define-"); w.PutParam("CYGWIN"); w.PutParam("-define-"); w.PutParam("DARWIN"); | cygwin: w.PutParam("-define+"); w.PutParam("POSIX"); w.PutParam("-define-"); w.PutParam("LINUX"); w.PutParam("-define-"); w.PutParam("FREEBSD"); w.PutParam("-define-"); w.PutParam("OPENBSD"); w.PutParam("-define+"); w.PutParam("WIN32"); w.PutParam("-define+"); w.PutParam("CYGWIN"); w.PutParam("-define-"); w.PutParam("DARWIN"); | darwin: w.PutParam("-define+"); w.PutParam("POSIX"); w.PutParam("-define-"); w.PutParam("LINUX"); w.PutParam("-define-"); w.PutParam("FREEBSD"); w.PutParam("-define-"); w.PutParam("OPENBSD"); w.PutParam("-define-"); w.PutParam("WIN32"); w.PutParam("-define-"); w.PutParam("CYGWIN"); w.PutParam("-define+"); w.PutParam("DARWIN"); END; CASE linker OF | dev2: w.PutParam("-define+"); w.PutParam("DEV2"); ELSE w.PutParam("-define-"); w.PutParam("DEV2"); END; w.PutParam(m.path); w.Execute(ok); IF ok THEN Log.String("Compile " + m.name + " (" + m.path + ")"); Log.Ln; ELSE w := NIL END; RETURN w END ExecuteCompiler; PROCEDURE Compile; VAR i, j, num: INTEGER; ok: BOOLEAN; m: Module; w: DswProcs.Process; BEGIN IF mno = 0 THEN RETURN END; num := 0; j := 0; WHILE (err = 0) & (num < mno) OR (j > 0) DO i := 0; WHILE (err = 0) & (i < mno) & (j < jobs) DO m := cmpList[i]; IF Ready(m) THEN w := ExecuteCompiler(m); IF debugJobs THEN Log.String("Start job " + m.name) END; IF w # NIL THEN IF debugJobs THEN Log.String(" ok") END; m.worker := w; INC(j) ELSE IF debugJobs THEN Log.String(" fail") END; INCL(m.flags, hasErrors); INC(err) END; IF debugJobs THEN Log.Ln END END; INC(i) END; WHILE (err = 0) & (j >= jobs) OR (j > 0) DO i := 0; WHILE (j > 0) & (i < mno) DO m := cmpList[i]; w := m.worker; IF (w # NIL) & w.IsTerminated() THEN IF debugJobs THEN Log.String("Stop job " + m.name); Log.Int(w.Result()); Log.Ln END; IF w.Result() = 0 THEN INCL(m.flags, hasObj); INCL(m.flags, hasSym); INC(num) ELSE INCL(m.flags, hasErrors); INC(err) END; m.worker := NIL; DEC(j) END; INC(i) END END END END Compile; PROCEDURE LinkDev2; VAR p: DswProcs.Process; i, res: INTEGER; ok: BOOLEAN; BEGIN ASSERT((exe # NIL) & (exe^ # ""), 20); ASSERT(processor = mach386, 21); ASSERT(compiler = cpnative, 22); p := DswProcs.dir.New(); p.Program(cplExe); IF os # anyos THEN p.PutParam("-os"); CASE os OF | linux: p.PutParam("linux") | freebsd: p.PutParam("freebsd") | openbsd: p.PutParam("openbsd") | win32, cygwin: p.PutParam("win32") | darwin: p.PutParam("darwin") END END; p.PutParam("-kernel"); p.PutParam("Kernel"); p.PutParam("-main"); p.PutParam("Kernel"); p.PutParam("-legacycodedir"); p.PutParam("."); p.PutParam("-o"); p.PutParam(exe); PutParams(p, cplArgs); i := 0; WHILE i < mno DO IF ~(library IN lnkList[i].flags) THEN p.PutParam(lnkList[i].name$) END; INC(i) END; p.Execute(ok); IF ok THEN Log.String("Link "); Log.String(exe); Log.Ln; res := p.Result(); IF res # 0 THEN Log.String("linker terminated with error"); Log.Int(res); Log.Ln; INC(err) END ELSE Log.String("unable to execute linker"); Log.Int(i); Log.Ln; INC(err) END END LinkDev2; PROCEDURE Link; BEGIN IF exe # NIL THEN CASE linker OF | anyint: (* do not link *) | dev2: LinkDev2 END END END Link; PROCEDURE Main; VAR m: Module; s: Selector; p: DswProcs.Process; ok: BOOLEAN; i, res: INTEGER; BEGIN IF Kernel.trapCount = 0 THEN ParseArgs; IF err = 0 THEN CheckParams; IF err = 0 THEN CheckDeps; IF err = 0 THEN Compile; IF err = 0 THEN Link END END END END ELSE INC(err) END; IF err = 0 THEN Kernel.Quit(0) ELSE Kernel.Quit(1) END; END Main; BEGIN NEW(def); Kernel.Start(Main) END DswMakeMain.