index c45005e5b42fc2664bd8b7f383f189795d8a28a7..5c84f5296973d52dd8df3146e4eee924c5bade84 100644 (file)
IMPORT Kernel, Files, Log, Strings, DswOpts, DswProcs, DswDocuments, DevCPM, DevCPT, DevCPR, DevCPS;
CONST
+ version = "0.3";
+
+ modDir = "Mod";
+ sysDir = "System";
+
maxImps = 127;
maxJobs = maxImps;
Module = POINTER TO RECORD
name: DevCPT.Name;
- path: Files.Name;
- selectors: Selector; (* with head, list of selectors for this module *)
+ odc: Files.Name;
depth: INTEGER; (* 0: leaf, MAX: root *)
+ dir: DevCPM.Directory;
mno: INTEGER;
imp: ARRAY maxImps OF Module;
flags: SET;
worker: DswProcs.Process;
END;
+ VAR (* options *)
+ auto, trap, clean: BOOLEAN;
+ exe, target, base: String;
+ jobs: INTEGER;
+
VAR
- err: INTEGER;
+ werr, err: INTEGER;
mno, rno: INTEGER; (* num modules *)
modList, lnkList, cmpList: ARRAY maxImps OF Module;
def: Selector; (* with head, global list of selectors *)
- auto: INTEGER;
- jobs: INTEGER;
- exe: String;
+ dirList: DevCPM.Directory;
+
+ PROCEDURE Error (IN str, p0, p1: ARRAY OF CHAR; i2: INTEGER);
+ VAR p2: ARRAY 32 OF CHAR;
+ BEGIN
+ Strings.IntToString(i2, p2);
+ Log.String("cpmake: "); Log.ParamMsg(str, p0, p1, p2); Log.Ln;
+ INC(err);
+ IF trap THEN
+ HALT(100)
+ END
+ END Error;
(* --------- options --------- *)
RETURN i
END IdentLen;
- PROCEDURE Define (n: ARRAY OF CHAR);
+ PROCEDURE Define (n: ARRAY OF CHAR; overwrite: BOOLEAN);
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)
+ Error("defines: expectd + or - after identifier (^0)", n, "", 0)
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)
+ ASSERT(i = 0);
+ s.next.value := v
+ ELSIF overwrite THEN
+ s.next.value := v
+ END
+ ELSE Error("defines: '^0' not valid identifier", n, "", 0)
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);
+ PROCEDURE AddModule (IN n: ARRAY OF CHAR; selectors: Selector; dir: DevCPM.Directory);
VAR i, res: INTEGER; m: Module;
BEGIN
i := IdentLen(n);
NEW(m);
Strings.StringToUtf8(n, m.name, res);
ASSERT(res = 0);
- m.selectors := CopySelectorList(selectors);
+ m.dir := dir;
modList[i] := m;
INC(mno)
END
ELSE
- Log.String("module name must be identifier"); Log.Ln; INC(err)
+ Error("invalid module name", "", "", 0)
END
END AddModule;
BEGIN
Strings.StringToInt(s, x, res);
IF res # 0 THEN
- Log.String("expected integer"); Log.Ln; INC(err);
+ Error("invalid integer value", s, "", 0);
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 Help;
+ BEGIN
+ Log.String("Usage: cpmake [options] module..."); Log.Ln;
+ Log.String("Options:"); Log.Ln;
+ Log.String(" -a Enable automatic dependency resolution"); Log.Ln;
+ Log.String(" -c Remove all generated files"); Log.Ln;
+ Log.String(" -t target Specify target rules"); Log.Ln;
+ Log.String(" -o file Generate object file"); Log.Ln;
+ Log.String(" -j num Specifies the number of jobs to run simultaneously"); Log.Ln;
+ Log.String(" -f path Specifies path to directory with targets"); Log.Ln;
+ Log.String(" -h Print help"); Log.Ln;
+ Log.String(" -v Print version"); Log.Ln;
+ Kernel.Quit(0)
+ END Help;
+
PROCEDURE ParseArgs;
BEGIN
- jobs := 1;
+ exe := NIL; auto := FALSE; jobs := 1; def.next := NIL; mno := 0; rno := 0;
+ target := NewStr("default"); base := NewStr("cprules");
LOOP
- CASE DswOpts.GetOpt("ao:j:D:U:") OF
- | "a": INC(auto)
+ CASE DswOpts.GetOpt("acdgo:t:j:f:") OF
+ | "a": auto := TRUE
+ | "c": clean := TRUE
+ | "d": trap := TRUE
+ | "f": base := DswOpts.str
+ | "h": Help
+ | "j": jobs := MIN(MAX(StrToInt(DswOpts.str, 1), 1), maxJobs)
| "o": exe := DswOpts.str
- | "j": IF DswOpts.str = NIL THEN jobs := maxJobs ELSE jobs := MIN(MAX(StrToInt(DswOpts.str, 0), 1), maxJobs) END
- | "D": Define(DswOpts.str)
- | "U": Undefine(DswOpts.str)
- | ":": 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
+ | "t": target := DswOpts.str
+ | "v": Log.String(version); Log.Ln; Kernel.Quit(0)
+ | ":": Error("missing argument for option -^0", DswOpts.str, "", 0)
+ | "?": Error("unknown option -^0", DswOpts.str, "", 0)
+ | "$": AddModule(DswOpts.str, def, dirList)
+ | 00X: EXIT
END
END
END ParseArgs;
+ PROCEDURE ReadDefines;
+ VAR loc: Files.Locator; name: Files.Name; m: DswDocuments.Model; r: DswDocuments.Reader; i, res: INTEGER;
+ BEGIN
+ loc := Files.dir.This(base).This(target);
+ DswDocuments.Open(loc, "defines", m, res);
+ IF res = 0 THEN
+ r := m.NewReader(NIL);
+ r.SetPos(0);
+ r.Read;
+ WHILE ~r.eot DO
+ i := 0;
+ WHILE ~r.eot & (r.char <= 20X) DO r.Read END;
+ WHILE ~r.eot & (r.char > 20X) DO name[i] := r.char; r.Read; INC(i) END;
+ IF i # 0 THEN name[i] := 0X; Define(name, FALSE) END
+ END
+ END
+ END ReadDefines;
+
+ PROCEDURE CheckParams;
+ BEGIN
+ IF (exe # NIL) & (exe^ = "") THEN
+ Error("specified empty file name for exe", "", "", 0)
+ END;
+ IF target^ = "" THEN
+ Error("specified empty rule", "", "", 0)
+ END;
+ IF base^ = "" THEN
+ Error("specified empty path to cpmake rules", "", "", 0)
+ END;
+ ReadDefines
+ END CheckParams;
+
(* --------- loader --------- *)
PROCEDURE Import (m: Module; IN name: DevCPT.Name);
j := 0; (* find module in global list *)
WHILE (j < mno) & (modList[j].name$ # name$) DO INC(j) END;
IF j >= mno THEN
- NEW(imp); imp.name := name$; imp.selectors := CopySelectorList(m.selectors);
+ IF ~auto THEN
+ Log.String("module " + name + " required before " + m.name); Log.Ln; INC(werr)
+ END;
+ NEW(imp); imp.name := name$;
modList[mno] := imp; INC(mno)
ELSE
imp := modList[j]
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;
VAR s: Selector;
BEGIN
DevCPM.Init(source);
-(*
- DevCPM.symList := m.insym;
- DevCPM.codePath := m.outcode;
- DevCPM.symPath := m.outsym;
-*)
+ DevCPM.symList := m.dir;
+ (*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;
-*)
+ INCL(DevCPM.options, DevCPM.comAware);
+ IF trap 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;
+ s := def.next;
WHILE s # NIL DO
DevCPR.Set(s.name, s.value);
s := s.next
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;
+ PROCEDURE MakePath (IN dir, name: Files.Name; IN 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;
+ PROCEDURE Open (loc: Files.Locator; IN sub, name: Files.Name; OUT path: Files.Name; OUT text: DswDocuments.Model);
+ VAR res: INTEGER;
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);
+ ASSERT(loc # NIL, 20);
+ ASSERT(name # "", 21);
+ (* !!! use Kernel.MakeFileName instead ".ext" concat !!! *)
+ MakePath(sub, name, "cp", path);
DswDocuments.Open(loc, name + ".cp", text, res);
IF text = NIL THEN
- MakePath(dir, name, "odc", path);
+ MakePath(sub, name, "odc", path);
DswDocuments.Open(loc, name + ".odc", text, res);
- IF (text = NIL) & (dir = "") THEN
+ IF (text = NIL) & (sub = "") THEN
MakePath(sysDir, name, "cp", path);
loc := Files.dir.This(sysDir).This(modDir);
DswDocuments.Open(loc, name + ".cp", text, res);
END
END
END
+ END
+ END Open;
+
+ PROCEDURE GetSource (IN modName: ARRAY OF CHAR; list: DevCPM.Directory; OUT path: Files.Name; OUT s: String);
+ VAR
+ sub, name: Files.Name; loc: Files.Locator; base: DevCPM.Directory;
+ text: DswDocuments.Model; r: DswDocuments.Reader; i, res: INTEGER;
+ BEGIN
+ s := NIL; path := ""; base := list;
+ Kernel.SplitName(modName, sub, name);
+ loc := Files.dir.This(sub).This(modDir);
+ Open(loc, sub, name, path, text);
+ WHILE (text = NIL) & (base # NIL) DO
+ ASSERT(base.legacy, 100);
+ loc := Files.dir.This(base.path).This(sub).This(modDir);
+ Open(loc, sub, name, path, text);
+ base := base.next
END;
IF text # NIL THEN
NEW(s, text.Length() + 1);
END;
EXCL(m.flags, trace)
ELSE
- Log.String("recursive import of " + m.name + " in " + parent.name); Log.Ln; INC(err)
+ Error("recursive import of ^0 in ^1", m.name$, parent.name$, 0)
END
END Trace;
END Sort;
PROCEDURE CheckDeps;
- VAR i, j, num: INTEGER; m: Module; s: String; ok: BOOLEAN;
+ VAR i, j, num: INTEGER; m: Module; src: 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);
+ GetSource(m.name$, m.dir, m.odc, src);
+ IF src # NIL THEN
+ CheckModule(m, src, ok);
IF ~ok THEN INC(err) END
ELSE
- Log.String("unable to open module " + m.name); Log.Ln; INC(err)
+ Error("unable to open module ^1", m.name$, "", 0)
END;
INC(i)
END;
+ INC(err, werr);
num := 0;
FOR i := 0 TO rno - 1 DO
Trace(modList[i], modList[i], num)
RETURN ready
END Ready;
- PROCEDURE ExecuteCompiler (m: Module): DswProcs.Process;
- VAR w: DswProcs.Process; ok: BOOLEAN;
+ PROCEDURE PrepareCompiler (m: Module): DswProcs.Process;
+ VAR p: DswProcs.Process; s: Selector;
BEGIN
ASSERT(m # NIL, 20);
- ASSERT(m.path # "", 21);
+ ASSERT(m.odc # "", 21);
ASSERT(m.worker = NIL, 22);
- w := DswProcs.dir.New();
- w.Program("cpc486");
- w.PutParam("-legacy");
- 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;
+ p := DswProcs.dir.New();
+ p.Program(base + "/" + target + "/" + "build");
+ p.PutParam(m.odc);
+ RETURN p
+ END PrepareCompiler;
PROCEDURE Compile;
- VAR i, j, num: INTEGER; ok: BOOLEAN; m: Module; w: DswProcs.Process;
+ VAR i, j, num, res: INTEGER; ok: BOOLEAN; m: Module; w: DswProcs.Process;
BEGIN
IF mno = 0 THEN RETURN END;
num := 0; j := 0;
WHILE (err = 0) & (i < mno) & (j < jobs) DO
m := cmpList[i];
IF Ready(m) THEN
- w := ExecuteCompiler(m);
+ w := PrepareCompiler(m);
IF debugJobs THEN Log.String("Start job " + m.name) END;
- IF w # NIL THEN
+ w.Execute(ok);
+ IF ok THEN
IF debugJobs THEN Log.String(" ok") END;
m.worker := w;
INC(j)
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
+ res := w.Result();
+ IF debugJobs THEN Log.String("Stop job " + m.name); Log.Int(res); Log.Ln END;
+ IF res = 0 THEN
INCL(m.flags, hasObj);
INCL(m.flags, hasSym);
INC(num)
END Compile;
PROCEDURE Link;
- VAR p: DswProcs.Process; i: INTEGER; ok: BOOLEAN;
+ VAR p: DswProcs.Process; ok: BOOLEAN; i, res: INTEGER;
BEGIN
- ASSERT(exe # NIL, 20);
- ASSERT(exe^ # "", 21);
- p := DswProcs.dir.New();
- p.Program("cpl486");
- p.PutParam("-os");
- p.PutParam("linux");
- p.PutParam("-kernel");
- p.PutParam("Kernel");
- p.PutParam("-main");
- p.PutParam("Kernel");
- p.PutParam("-legacycodedir");
- p.PutParam(".");
- p.PutParam("-o");
- p.PutParam(exe);
- i := 0;
- WHILE i < mno DO
- IF ~(library IN lnkList[i].flags) THEN
- p.PutParam(lnkList[i].name$)
+ IF exe # NIL THEN
+ p := DswProcs.dir.New();
+ p.Program(base + "/" + target + "/" + "link");
+ p.PutParam(exe$);
+ FOR i := 0 TO mno - 1 DO
+ IF ~(library IN lnkList[i].flags) THEN
+ p.PutParam(lnkList[i].name$)
+ END
END;
- INC(i)
- END;
- p.Execute(ok);
- IF ok THEN
- i := p.Result();
- IF i # 0 THEN
- Log.String("linker terminated with error"); Log.Int(i); Log.Ln;
- INC(err)
+ p.Execute(ok);
+ IF ok THEN
+ p.Wait;
+ res := p.Result();
+ IF res # 0 THEN
+ Error("link failed with code ^2", "", "", res)
+ END
+ ELSE Error("link failed: unable to execute script", "", "", 0)
END
- ELSE
- Log.String("unable to execute linker"); Log.Int(i); Log.Ln;
- INC(err)
END
END Link;
+ PROCEDURE Cleanup;
+ VAR p: DswProcs.Process; ok: BOOLEAN; res: INTEGER;
+ BEGIN
+ IF clean THEN
+ p := DswProcs.dir.New();
+ p.Program(base + "/" + target + "/" + "clean");
+ p.Execute(ok);
+ IF ok THEN
+ p.Wait;
+ res := p.Result();
+ IF res # 0 THEN
+ Error("cleanup failed with code ^2", "", "", res)
+ END
+ ELSE Error("cleanup failed: unable to execute script", "", "", 0)
+ END
+ END
+ END Cleanup;
+
PROCEDURE Main;
- VAR m: Module; s: Selector; p: DswProcs.Process; ok: BOOLEAN; i, res: INTEGER;
BEGIN
- IF Kernel.trapCount # 0 THEN Kernel.Quit(1) END;
- ParseArgs;
- IF err = 0 THEN
- CheckDeps;
+ IF Kernel.trapCount = 0 THEN
+ ParseArgs;
IF err = 0 THEN
- Compile;
+ CheckParams;
IF err = 0 THEN
- IF exe # NIL THEN Link END;
+ CheckDeps;
+ IF err = 0 THEN
+ Cleanup;
+ IF err = 0 THEN
+ Compile;
+ IF err = 0 THEN
+ Link
+ END
+ END
+ END
END
END
+ ELSE Error("trap occured", "", "", 0)
END;
IF err = 0 THEN Kernel.Quit(0)
ELSE Kernel.Quit(1)
- END;
+ END
END Main;
BEGIN
NEW(def);
+ ASSERT(def # NIL, 100);
+ Kernel.intTrap := FALSE;
Kernel.Start(Main)
END DswMakeMain.
-
-==============================
-
-SYNTAX
- cpmake {options module}
-
-OPTIONS
- -a Enable automatic dependency resolution
- -o name Generate executable file
- -j num Specifies the number of jobs to run simultaneously
- -D ident["+"|"-"] Add preprocessor selector
- -U ident Remove proprocessor selector