3 IMPORT Kernel, Files, Log, Strings, DswOpts, DswProcs, DswDocuments, DevCPM, DevCPT, DevCPR, DevCPS;
5 CONST
14 (* symbol values *)
31 (* module state flags *)
34 (* procesor types *)
37 (* operation system types *)
40 (* compiler types *)
43 (* internal linker types *)
51 TYPE
58 next: Selector
72 VAR
90 BEGIN
119 ELSE
128 (* --------- options --------- *)
132 BEGIN
137 RETURN i
142 BEGIN
157 END
158 ELSE
160 END
165 BEGIN
177 END
178 ELSE
180 END
185 BEGIN
189 x := def
191 RETURN x
196 BEGIN
198 RETURN p
206 BEGIN
209 ELSE
218 END
223 BEGIN
226 ELSE
232 pars := p
237 BEGIN
243 term := ch; ch := s[i]; INC(i);
244 WHILE (ch # term) & (ch # 0X) DO
245 AddChar(ch); ch := s[i]; INC(i)
246 END;
247 IF ch # 0X THEN ch := s[i]; INC(i)
249 END
252 IF ch # 0X THEN AddLine END
253 ELSE
254 AddChar(ch); ch := s[i]; INC(i)
255 END
256 END;
257 RETURN pars
258 END ToStringList;
260 PROCEDURE Help;
261 BEGIN
275 (*
277 *)
286 (*
288 *)
295 Kernel.Quit(1)
296 END Help;
298 PROCEDURE Version;
299 BEGIN
300 Log.String(version); Log.Ln;
301 Kernel.Quit(0)
302 END Version;
304 PROCEDURE ParseTargetOpts;
305 VAR s: DswOpts.String;
306 BEGIN
309 s := DswOpts.str;
310 Strings.ToLower(s, s);
315 END
317 s := DswOpts.str;
318 Strings.ToLower(s, s);
327 END
329 s := DswOpts.str;
330 Strings.ToLower(s, s);
334 END
336 s := DswOpts.str;
337 Strings.ToLower(s, s);
340 END
344 END
345 END ParseTargetOpts;
347 PROCEDURE ParseCommandOpts;
348 BEGIN
355 END
356 END ParseCommandOpts;
358 PROCEDURE ParseExternalOpts;
359 BEGIN
366 END
367 END ParseExternalOpts;
369 PROCEDURE ParseInfoOpts;
370 BEGIN
379 END
380 END ParseInfoOpts;
382 PROCEDURE ParseFileOpts;
383 VAR d: DevCPM.Directory;
384 BEGIN
390 END
391 END ParseFileOpts;
393 PROCEDURE ParseArgs;
394 BEGIN
395 exe := NIL; auto := FALSE; jobs := 1; def.next := NIL; mno := 0; rno := 0;
396 processor := anymach; os := anyos; compiler := anycp;
397 LOOP
413 | 0X: EXIT
414 END
415 END;
416 END ParseArgs;
418 PROCEDURE CheckParams;
420 PROCEDURE Default (IN name: ARRAY OF CHAR; value: BOOLEAN);
421 BEGIN
422 IF value = TRUE THEN
424 ELSE
426 END
427 END Default;
429 BEGIN
430 IF compiler = anycp THEN
432 ELSIF compiler = cpnative THEN
433 IF processor = anymach THEN
435 ELSIF processor # mach386 THEN
437 END
438 END;
439 IF (compiler = cpfront) & (linker # anyint) THEN
441 END;
442 IF (compiler = cpfront) & (exe # NIL) THEN
444 END;
445 IF (exe # NIL) & (compiler = cpnative) & (linker = anyint) THEN
447 END;
448 IF (linker = dev2) & (os = anyos) THEN
450 END;
453 END;
454 IF (cpcExe = NIL) & (compiler # anycp) THEN
457 END;
458 IF cpcExe = NIL THEN
460 END
461 END;
462 IF (cplExe = NIL) & (linker # anyint) THEN
464 IF cplExe = NIL THEN
466 END
467 END;
468 (* cpompiler *)
471 (* processor *)
475 (* operating system *)
483 (* linker *)
485 END CheckParams;
487 (* --------- loader --------- *)
489 PROCEDURE Import (m: Module; IN name: DevCPT.Name);
490 VAR i, j: INTEGER; imp: Module;
491 BEGIN
492 ASSERT(m # NIL, 20);
498 ELSE
500 i := 0; (* find module in local list *)
501 WHILE (i < m.mno) & (m.imp[i].name$ # name$) DO INC(i) END;
502 IF i >= m.mno THEN
503 j := 0; (* find module in global list *)
504 WHILE (j < mno) & (modList[j].name$ # name$) DO INC(j) END;
505 IF j >= mno THEN
506 IF ~auto THEN
508 END;
509 NEW(imp); imp.name := name$;
510 modList[mno] := imp; INC(mno)
511 ELSE
512 imp := modList[j]
513 END;
514 m.imp[m.mno] := imp; INC(m.mno)
515 ELSE DevCPM.err(1)
516 END
517 END;
518 IF debugImport THEN Log.Ln END;
519 END Import;
521 PROCEDURE ParseModule (m: Module);
522 VAR sym: BYTE; SelfName, impName, aliasName: DevCPT.Name;
524 PROCEDURE err (n: SHORTINT);
525 BEGIN DevCPM.err(n)
526 END err;
528 PROCEDURE CheckSym(s: SHORTINT);
529 BEGIN
530 IF sym = s THEN DevCPS.Get(sym) ELSE DevCPM.err(s) END
531 END CheckSym;
533 BEGIN
535 DevCPS.Init; DevCPS.Get(sym);
536 IF sym = module THEN DevCPS.Get(sym) ELSE err(16) END;
537 IF sym = ident THEN
538 SelfName := DevCPS.name$; DevCPS.Get(sym);
539 IF sym = lbrak THEN
540 INCL(DevCPM.options, DevCPM.interface); DevCPS.Get(sym);
541 IF sym = eql THEN DevCPS.Get(sym)
542 ELSE INCL(DevCPM.options, DevCPM.noCode)
543 END;
544 IF sym = string THEN INCL(m.flags, library); DevCPS.Get(sym)
545 ELSE err(string)
546 END;
547 CheckSym(rbrak)
548 END;
549 CheckSym(semicolon);
550 IF sym = import THEN DevCPS.Get(sym);
551 LOOP
552 IF sym = ident THEN
553 aliasName := DevCPS.name$; impName := aliasName$; DevCPS.Get(sym);
554 IF sym = becomes THEN DevCPS.Get(sym);
555 IF sym = ident THEN impName := DevCPS.name$; DevCPS.Get(sym) ELSE err(ident) END
556 END;
557 Import(m, impName)
558 ELSE err(ident)
559 END;
560 IF sym = comma THEN DevCPS.Get(sym)
561 ELSIF sym = ident THEN err(comma)
562 ELSE EXIT
563 END
564 END;
565 CheckSym(semicolon)
566 END;
567 LOOP (* preprocessor must read module fully *)
568 IF sym = end THEN
569 DevCPS.Get(sym);
570 IF sym = ident THEN
571 DevCPS.Get(sym);
572 IF sym = period THEN
573 IF DevCPS.name # SelfName THEN err(4) END;
574 EXIT
575 ELSIF sym = eof THEN
576 err(period);
577 EXIT
578 END
579 ELSIF sym = eof THEN
580 err(ident);
581 EXIT
582 END;
583 ELSIF sym = eof THEN
584 err(end);
585 EXIT
586 ELSE
587 DevCPS.Get(sym);
588 END
589 END
590 ELSE err(ident)
591 END;
592 DevCPS.str := NIL
593 END ParseModule;
595 PROCEDURE CheckModule (m: Module; source: String; OUT ok: BOOLEAN);
596 VAR s: Selector;
597 BEGIN
598 DevCPM.Init(source);
599 DevCPM.symList := m.dir;
600 (*
601 DevCPM.codePath := m.outcode;
602 DevCPM.symPath := m.outsym;
603 *)
604 DevCPM.name := m.name$;
605 (*
606 IF m.found THEN INCL(DevCPM.options, DevCPM.comAware) END;
607 IF errorTrap IN m.opts THEN INCL(DevCPM.options, DevCPM.trap) END;
608 IF oberon IN m.opts THEN INCL(DevCPM.options, DevCPM.oberon) END;
609 *)
610 DevCPR.Init;
611 s := def.next;
612 WHILE s # NIL DO
613 DevCPR.Set(s.name, s.value);
614 s := s.next
615 END;
616 ParseModule(m);
617 DevCPR.Check;
618 ok := DevCPM.noerr;
619 DevCPR.Close;
620 DevCPM.InsertMarks;
621 DevCPM.Close;
622 Kernel.FastCollect
623 END CheckModule;
625 PROCEDURE MakePath (IN dir, name: Files.Name; IN type: Files.Type; OUT path: Files.Name);
626 BEGIN
630 END;
631 Kernel.MakeFileName(path, type)
632 END MakePath;
634 PROCEDURE Open (loc: Files.Locator; IN sub, name: Files.Name; OUT path: Files.Name; OUT text: DswDocuments.Model);
635 VAR res: INTEGER;
636 BEGIN
637 ASSERT(loc # NIL, 20);
642 IF text = NIL THEN
647 loc := Files.dir.This(sysDir).This(modDir);
649 IF text = NIL THEN
652 IF text = NIL THEN
654 END
655 END
656 END
657 END
658 END Open;
660 PROCEDURE GetSource (IN modName: ARRAY OF CHAR; list: DevCPM.Directory; OUT path: Files.Name; OUT s: String);
661 VAR
662 sub, name: Files.Name; loc: Files.Locator; base: DevCPM.Directory;
663 text: DswDocuments.Model; r: DswDocuments.Reader; i, res: INTEGER;
664 BEGIN
666 Kernel.SplitName(modName, sub, name);
667 loc := Files.dir.This(sub).This(modDir);
668 Open(loc, sub, name, path, text);
669 WHILE (text = NIL) & (base # NIL) DO
670 ASSERT(base.legacy, 100);
671 loc := Files.dir.This(base.path).This(sub).This(modDir);
672 Open(loc, sub, name, path, text);
673 base := base.next
674 END;
675 IF text # NIL THEN
676 NEW(s, text.Length() + 1);
677 IF s # NIL THEN
678 r := text.NewReader(NIL);
679 FOR i := 0 TO text.Length() - 1 DO
680 r.Read; s[i] := r.char
681 END
682 END
683 END
684 END GetSource;
686 PROCEDURE Trace (m, parent: Module; VAR lno: INTEGER);
687 VAR i: INTEGER;
688 BEGIN
689 IF ~(trace IN m.flags) THEN
690 INCL(m.flags, trace);
691 FOR i := 0 TO m.mno - 1 DO
692 Trace(m.imp[i], m, lno);
693 m.depth := MAX(m.depth, m.imp[i].depth + 1)
694 END;
695 IF ~(imported IN m.flags) THEN
696 INCL(m.flags, imported);
697 lnkList[lno] := m;
698 INC(lno)
699 END;
700 EXCL(m.flags, trace)
701 ELSE
702 Error(20, m.name$, parent.name$, 0)
703 END
704 END Trace;
706 PROCEDURE Sort;
707 VAR i, j: INTEGER; m: Module;
708 BEGIN
709 ASSERT((mno = 0) OR (lnkList[0] # NIL), 20);
710 cmpList := lnkList;
711 i := 1;
712 WHILE i < mno DO
713 m := cmpList[i];
714 j := i - 1;
715 WHILE (j >= 0) & (cmpList[j].depth > m.depth) DO
716 cmpList[j + 1] := cmpList[j];
717 DEC(j)
718 END;
719 cmpList[j + 1] := m;
720 INC(i)
721 END
722 END Sort;
724 PROCEDURE CheckDeps;
725 VAR i, j, num: INTEGER; m: Module; src: String; ok: BOOLEAN;
726 BEGIN
727 i := 0; rno := mno;
728 WHILE (err = 0) & (i < mno) DO
729 m := modList[i];
730 GetSource(m.name$, m.dir, m.odc, src);
731 IF src # NIL THEN
732 CheckModule(m, src, ok);
733 IF ~ok THEN INC(err) END
734 ELSE
736 END;
737 INC(i)
738 END;
739 INC(err, werr);
740 num := 0;
741 FOR i := 0 TO rno - 1 DO
742 Trace(modList[i], modList[i], num)
743 END;
744 ASSERT((err # 0) OR (num = mno), 100);
745 Sort;
746 IF debugOrder THEN
748 FOR i := 0 TO mno - 1 DO
750 END
751 END
752 END CheckDeps;
754 PROCEDURE IsCompiled (m: Module): BOOLEAN;
755 CONST target = {hasSym, hasObj};
756 VAR i: INTEGER; ready: BOOLEAN;
757 BEGIN
758 ASSERT(m # NIL, 20);
759 i := 0;
760 ready := ~(hasErrors IN m.flags) & (m.flags * target = target);
761 WHILE ready & (i < m.mno) DO
762 ready := IsCompiled(m.imp[i]);
763 INC(i)
764 END;
765 RETURN ready
766 END IsCompiled;
768 PROCEDURE Ready (m: Module): BOOLEAN;
769 CONST target = {hasSym, hasObj};
770 VAR i: INTEGER; ready: BOOLEAN;
771 BEGIN
772 i := 0;
773 ready := ~(hasErrors IN m.flags) & (m.flags * target # target) & (m.worker = NIL);
774 WHILE ready & (i < m.mno) DO
775 ready := IsCompiled(m.imp[i]);
776 INC(i)
777 END;
778 RETURN ready
779 END Ready;
781 PROCEDURE PutParams (w: DswProcs.Process; p: StringList);
782 VAR i: INTEGER;
783 BEGIN
784 ASSERT(w # NIL, 20);
786 IF p # NIL THEN
788 w.PutParam(p[0]);
789 FOR i := 1 TO LEN(p) - 1 DO
791 w.PutParam(p[i])
792 END;
794 END;
795 IF debugArgs THEN Log.Ln END
796 END PutParams;
798 PROCEDURE PutPathList (w: DswProcs.Process; IN par: ARRAY OF CHAR; base: DevCPM.Directory);
799 BEGIN
800 IF base # NIL THEN
801 PutPathList(w, par, base.next); (* in revese order *)
802 w.PutParam(par);
803 w.PutParam(base.path);
804 END
805 END PutPathList;
807 PROCEDURE ExecuteCompiler (m: Module): DswProcs.Process;
808 VAR w: DswProcs.Process; ok: BOOLEAN; s: Selector;
809 BEGIN
810 ASSERT(m # NIL, 20);
812 ASSERT(m.worker = NIL, 22);
813 w := DswProcs.dir.New();
814 w.Program(cpcExe);
817 s := def.next;
818 WHILE s # NIL DO
821 END;
822 w.PutParam(s.name$);
823 s := s.next
824 END;
825 PutParams(w, cpcArgs);
826 w.PutParam(m.odc);
827 w.Execute(ok);
828 IF ok THEN
830 ELSE
831 w := NIL
832 END;
833 RETURN w
834 END ExecuteCompiler;
836 PROCEDURE Compile;
837 VAR i, j, num: INTEGER; ok: BOOLEAN; m: Module; w: DswProcs.Process;
838 BEGIN
839 IF mno = 0 THEN RETURN END;
840 num := 0; j := 0;
841 WHILE (err = 0) & (num < mno) OR (j > 0) DO
842 i := 0;
843 WHILE (err = 0) & (i < mno) & (j < jobs) DO
844 m := cmpList[i];
845 IF Ready(m) THEN
846 w := ExecuteCompiler(m);
848 IF w # NIL THEN
850 m.worker := w;
851 INC(j)
852 ELSE
854 INCL(m.flags, hasErrors);
855 INC(err)
856 END;
857 IF debugJobs THEN Log.Ln END
858 END;
859 INC(i)
860 END;
861 WHILE (err = 0) & (j >= jobs) OR (j > 0) DO
862 i := 0;
863 WHILE (j > 0) & (i < mno) DO
864 m := cmpList[i];
865 w := m.worker;
866 IF (w # NIL) & w.IsTerminated() THEN
868 IF w.Result() = 0 THEN
869 INCL(m.flags, hasObj);
870 INCL(m.flags, hasSym);
871 INC(num)
872 ELSE
873 INCL(m.flags, hasErrors);
874 INC(err)
875 END;
876 m.worker := NIL;
877 DEC(j)
878 END;
879 INC(i)
880 END
881 END
882 END
883 END Compile;
885 PROCEDURE LinkDev2;
886 VAR p: DswProcs.Process; i, res: INTEGER; ok: BOOLEAN;
887 BEGIN
889 ASSERT(processor = mach386, 21);
890 ASSERT(compiler = cpnative, 22);
891 p := DswProcs.dir.New();
892 p.Program(cplExe);
894 IF os # anyos THEN
896 CASE os OF
902 END
903 END;
911 p.PutParam(exe);
912 PutParams(p, cplArgs);
913 i := 0;
914 WHILE i < mno DO
915 IF ~(library IN lnkList[i].flags) THEN
916 p.PutParam(lnkList[i].name$)
917 END;
918 INC(i)
919 END;
920 p.Execute(ok);
921 IF ok THEN
923 res := p.Result();
924 IF res # 0 THEN
926 END
927 ELSE
929 END
930 END LinkDev2;
932 PROCEDURE Link;
933 BEGIN
934 IF exe # NIL THEN
935 CASE linker OF
936 | anyint: (* do not link *)
937 | dev2: LinkDev2
938 END
939 END
940 END Link;
942 PROCEDURE PrintInfo;
943 VAR i: INTEGER;
944 BEGIN
945 IF printCompileModList THEN
946 FOR i := 0 TO mno - 1 DO
948 END;
949 Log.Ln
950 ELSIF printLinkModList THEN
951 FOR i := 0 TO mno - 1 DO
952 IF ~(library IN lnkList[i].flags) THEN
954 END
955 END;
956 Log.Ln
957 ELSIF printCompileFileList THEN
958 FOR i := 0 TO mno - 1 DO
960 END;
961 Log.Ln
962 (* ELSIF printLinkFileList THEN
963 FOR i := 0 TO mno - 1 DO
964 IF ~(library IN lnkList[i].flags) THEN
966 END
967 END;
968 Log.Ln*)
969 END
970 END PrintInfo;
972 PROCEDURE Main;
973 BEGIN
974 IF Kernel.trapCount = 0 THEN
975 ParseArgs;
976 IF err = 0 THEN
977 IF printCompileModList OR printLinkModList OR printCompileFileList THEN
978 auto := TRUE
979 END;
980 CheckParams;
981 IF err = 0 THEN
982 CheckDeps;
983 IF err = 0 THEN
984 IF printCompileModList OR printLinkModList OR printCompileFileList THEN
985 PrintInfo
986 ELSE
987 Compile;
988 IF err = 0 THEN
989 Link
990 END
991 END
992 END
993 END
994 END
996 END;
997 IF err = 0 THEN Kernel.Quit(0)
998 ELSE Kernel.Quit(1)
999 END;
1000 END Main;
1002 BEGIN
1003 NEW(def);
1004 ASSERT(def # NIL, 100);
1005 Kernel.intTrap := FALSE;
1006 Kernel.Start(Main)
1007 END DswMakeMain.