<<>> <> <> <> <> <> <> <> <> <> <> <> <<>> DIRECTORY Args USING [ Arg, ArgRope, Error, GetRope, NArgs ], Ascii, Basics USING [HighByte, LowByte, LowHalf], BasicTime USING [ GMT, Now, Period ], Commander USING [ CommandProc, Handle, Register ], CommanderOps USING [NextArgument], Convert, CStrings USING [CString], <> IO, PFS, PFSNames, PFSPrefixMap, Process USING [ CheckForAbort, EnableAborts, GetCurrent, InitializeCondition, SecondsToTicks ], Rope USING [ Cat, Concat, Equal, Fetch, Find, FindBackward, Flatten, Index, Length, ROPE, Substr], SimpleFeedback USING [PutFL], SymTab, SystemVersion USING [GetMachineType, MachineType, release], ThisMachine USING [ ProcessorID ], UnixErrno, UnixSysCalls USING [ GetPID, SymLink, Unlink ], UnixSysCallExtensions USING [Spawn], UnixTypes USING [CHARPtr, Mode, SysCallResult], UserProfile USING [Boolean, CallWhenProfileChanges, ListOfTokens, ProfileChangedProc, Token], UXStrings; CcCommandsImpl: CEDAR MONITOR IMPORTS Args, Ascii, Basics, BasicTime, Commander, CommanderOps, Convert, --ExtendADotOut,-- IO, PFS, PFSNames, PFSPrefixMap, Process, Rope, SimpleFeedback, SymTab, SystemVersion, ThisMachine, UnixErrno, UnixSysCalls, UnixSysCallExtensions, UserProfile, UXStrings ~ { ROPE: TYPE ~ Rope.ROPE; LOR: TYPE ~ LIST OF ROPE; ShouldNotHappen: ERROR [message: ROPE] ~ CODE; ForkTrouble: ERROR ~ CODE; NYI: ERROR ~ CODE; DeleteFiles: BOOL ~ TRUE; <> <> amd29000: SystemVersion.MachineType ~ LOOPHOLE[20, SystemVersion.MachineType]; rs6000: SystemVersion.MachineType ~ LOOPHOLE[21, SystemVersion.MachineType]; mipsle: SystemVersion.MachineType ~ LOOPHOLE[22, SystemVersion.MachineType]; -- little endian version of mips r3000 mipsbe: SystemVersion.MachineType ~ LOOPHOLE[23, SystemVersion.MachineType]; -- big endian version of mips r3000 <> <> <> <> <> <> <<>> CommandNames: TYPE = REF CommandNamesRep; CommandNamesRep: TYPE = RECORD[target: SystemVersion.MachineType, compiler, loader, move, csh, include, preCName, actualCName, insert: ROPE]; commandNamesList: LIST OF CommandNames; defaultCommandNames: CommandNames; <> uid: CARD32 ¬ 0; processID: INT ~ UnixSysCalls.GetPID[]; processorID: ROPE ~ ThisMachine.ProcessorID[$Octal]; MACHINECLASS: ROPE ~ "ComplexCc.MachineClass"; NewName: ENTRY PROC [suffix: ROPE ¬ ".o", wDir: ROPE--UXIO name--] RETURNS [ fName: ROPE ] ~ { ENABLE { UNWIND => NULL }; fName ¬ IO.PutFLR["cedarCc%gFrom%gp%g%g", LIST[IO.card[uid], IO.int[processID], IO.rope[processorID], IO.rope[suffix]]]; IF NOT Rope.Equal[wDir, NIL] THEN { IF wDir.Fetch[wDir.Length[]-1] # '/ THEN wDir ¬ Rope.Concat[wDir, "/"]; fName ¬ Rope.Concat[wDir, fName]; }; uid ¬ uid.SUCC; }; <> ViewFix: PROC [cedar, insert: ROPE, isDir, simpleExt, create: BOOL, otherUnlink: LOR, log: IO.STREAM] RETURNS [unix: ROPE ¬ NIL, unlink: LOR ¬ NIL] ~ { ENABLE PFS.Error => ERROR ShouldNotHappen[IO.PutFR["Got PFS.Error[%g, %g] while UXifying %g", [atom[error.code]], [rope[error.explanation]], [rope[cedar]] ]]; RETURN RealViewFix[cedar, insert, isDir, simpleExt, create, otherUnlink, log]}; RealViewFix: PROC [cedar, insert: ROPE, isDir, simpleExt, create: BOOL, otherUnlink: LOR, log: IO.STREAM] RETURNS [unix: ROPE ¬ NIL, unlink: LOR ¬ NIL] ~ { given: PFS.PATH ~ PFS.PathFromRope[cedar]; cedarPath: PFS.PATH ¬ PFSPrefixMap.Translate[ PFS.AbsoluteName[given]]; rawRope: ROPE ¬ PFS.RopeFromPath[cedarPath].Flatten[]; --for debugging viewComp: PFSNames.Component ¬ cedarPath.Fetch[0]; view: ROPE ¬ viewComp.ComponentRope[]; IF isDir # given.IsADirectory[] THEN ERROR ShouldNotHappen[IO.PutFR1[IF isDir THEN "%g not a directory" ELSE "%g is a directory", [rope[cedar]] ]]; IF isDir AND (insert#NIL OR create OR simpleExt) THEN ERROR--not implemented because not needed--; IF create THEN { out: IO.STREAM ~ PFS.StreamOpen[fileName: cedarPath, accessOptions: create, createOptions: [keep~1]]; file: PFS.OpenFile ~ PFS.OpenFileFromStream[out]; modeProp: ROPE; dm: UnixTypes.Mode; cedarPath ¬ PFS.GetInfo[file].fullFName; modeProp ¬ PFS.GetClientProperty[file, "UnixMode"]; dm ¬ LOOPHOLE[Convert.CardFromRope[modeProp]]; dm.owner.write ¬ true; PFS.SetClientProperty[file, "UnixMode", Convert.RopeFromCard[LOOPHOLE[dm, CARD16], 8]]; out.Close[] } ELSE cedarPath ¬ PFS.FileInfo[cedarPath].fullFName; SELECT TRUE FROM view.Equal["-ux", FALSE] => { original: ROPE ~ PFS.PFSNameToUnixName[cedarPath]; IF insert#NIL THEN { parent: PFS.PATH ~ cedarPath.Parent[]; parentRope: ROPE ~ PFS.PFSNameToUnixName[parent]; last: PFSNames.Component ~ cedarPath.ShortName[]; lastRope: ROPE ~ last.ComponentRope[--PFS doesn't put in version info--]; new: ROPE ~ parentRope.Cat[insert, lastRope]; GetLink[original, new, log]; RETURN [new, CONS[new, otherUnlink]]}; RETURN [original, otherUnlink]}; view.Equal["-vux", FALSE] => { fullRope: ROPE; unix ¬ PFS.PFSNameToUnixName[cedarPath]; fullRope ¬ unix.Flatten[]; --for debugging IF isDir THEN { RETURN [unix, otherUnlink]}; IF simpleExt OR insert#NIL THEN { fullLast: PFSNames.Component ¬ cedarPath.ShortName[]; verlessLast: ROPE ¬ fullLast.ComponentRope[--PFS doesn't put in version info--]; parent: PFS.PATH ¬ cedarPath.Parent[]; parentRope: ROPE ¬ PFS.PFSNameToUnixName[parent]; uxishRope: ROPE ¬ parentRope.Cat["/", insert, verlessLast]; IF NOT parent.IsADirectory[] THEN ERROR ShouldNotHappen["PFS shouldn't be crocky!"]; IF fullLast.version.versionKind # numeric THEN ERROR ShouldNotHappen[ IO.PutFR1["Didn't expect to find %g in file system (note version!)", [rope[PFS.RopeFromPath[cedarPath]]] ]]; GetLink[unix, uxishRope, log]; RETURN [uxishRope, CONS[uxishRope, otherUnlink]]} ELSE RETURN [unix, otherUnlink]; }; ENDCASE => ERROR ShouldNotHappen[ IO.PutFR1["Can't apply UNIX tools to %g because of its view", IO.rope[PFS.RopeFromPath[cedarPath]] ]]; }; emptyComponent: PFSNames.Component ~ []; Lower: PROC [old: CHAR] RETURNS [CHAR] ~ {RETURN Ascii.Lower[old]}; LinkData: TYPE ~ REF LinkDataRec; LinkDataRec: TYPE ~ RECORD [ from: ROPE, count: NAT, aHolder: PROCESS, toCP: UnixTypes.CHARPtr ¬ NIL, change: CONDITION]; GetLink: ENTRY PROC [from, to: ROPE, log: IO.STREAM] ~ { ENABLE UNWIND => NULL; err: ROPE ~ InnerGetLink[from, to, log]; IF err#NIL THEN RETURN WITH ERROR ShouldNotHappen[err]; RETURN}; InnerGetLink: INTERNAL PROC [from, to: ROPE, log: IO.STREAM] RETURNS [ROPE] ~ { start: BasicTime.GMT ~ BasicTime.Now[]; me: PROCESS ~ Process.GetCurrent[]; DO ld: LinkData ¬ NARROW[linkTab.Fetch[to].val]; IF ld=NIL THEN { ld ¬ NEW [LinkDataRec ¬ [NIL, 0, me]]; TRUSTED { Process.InitializeCondition[@ld.change, Process.SecondsToTicks[10]]; Process.EnableAborts[@ld.change]}; IF NOT linkTab.Insert[to, ld] THEN ERROR}; SELECT TRUE FROM ld.count=0 => { fromCP: UnixTypes.CHARPtr ~ UXStrings.Create[from]; toCP: UnixTypes.CHARPtr ¬ ld.toCP ¬ UXStrings.Create[to]; res: UnixTypes.SysCallResult ¬ UnixSysCalls.SymLink[fromCP, toCP]; IF res=failure THEN RETURN [IO.PutFR["Link from %g to %g failed; errno is %g", IO.rope[from], IO.rope[to], IO.card[LOOPHOLE[UnixErrno.GetErrno[], CARD]]]]; ld.count ¬ ld.count.SUCC; ld.from ¬ from; ld.aHolder ¬ me; IF debugLinks AND log#NIL THEN log.PutF["%g -> %g: %g\n", [rope[from]], [rope[to]], [integer[ld.count]]]; RETURN [NIL]}; ld.from.Equal[from, TRUE--UNIX is case sensitive--] => { ld.count ¬ ld.count.SUCC; IF debugLinks AND log#NIL THEN log.PutF["%g -> %g: %g\n", [rope[from]], [rope[to]], [integer[ld.count]]]; RETURN [NIL]}; ld.aHolder = me => RETURN [IO.PutFR["Trying to link %g to both %g and %g", [rope[to]], [rope[from]], [rope[ld.from]] ]]; ENDCASE => { now: BasicTime.GMT ~ BasicTime.Now[]; waited: INT ~ BasicTime.Period[start, now]; IF waited > linkTimeout THEN RETURN[IO.PutFLR["Unable to link %g -> %g for %gs (timeout is %g) 'cause of conflict with %g", LIST[[rope[to]], [rope[from]], [integer[waited]], [integer[linkTimeout]], [rope[ld.from]]]]]; WAIT ld.change}; ENDLOOP; }; linkTab: SymTab.Ref ~ SymTab.Create[case: TRUE]; debugLinks: BOOL ¬ FALSE; linkTimeout: NAT ¬ 100; DropLink: ENTRY PROC [to: ROPE, log: IO.STREAM] ~ { ENABLE UNWIND => NULL; err: ROPE ~ InnerDropLink[to, log]; IF err#NIL THEN RETURN WITH ERROR ShouldNotHappen[err]; RETURN}; InnerDropLink: INTERNAL PROC [to: ROPE, log: IO.STREAM] RETURNS [ROPE] ~ { ld: LinkData ¬ NARROW[linkTab.Fetch[to].val]; IF ld=NIL OR ld.count=0 THEN RETURN [IO.PutFR1["Excess dropping of link to %g", [rope[to]] ]]; ld.count ¬ ld.count.PRED; IF debugLinks AND log#NIL THEN log.PutF["%g: %g\n", [rope[to]], [integer[ld.count]]]; IF ld.count=0 THEN { res: UnixTypes.SysCallResult ~ UnixSysCalls.Unlink[ld.toCP]; IF NOT linkTab.Delete[to] THEN ERROR; IF res = failure THEN RETURN [IO.PutFR["Unlink failed for %g; errno is %g", IO.rope[to], IO.card[LOOPHOLE[UnixErrno.GetErrno[], CARD]]]]; }; BROADCAST ld.change; RETURN [NIL]}; UnlinkList: PROC [list: LOR, log: IO.STREAM] ~ { FOR list ¬ list, list.rest WHILE list#NIL DO DropLink[list.first, log]; ENDLOOP; RETURN}; ConsComponent: PROC [name: ROPE, version: PFSNames.Version] RETURNS [PFSNames.Component] ~ { RETURN [[name: [base: name, start: 0, len: name.Length[]], version: version]]}; <> MachineTypeFromMachineClass: PROC [ machineClass: ROPE ] RETURNS [ machineType: SystemVersion.MachineType ] ~ { X: INT ¬ 1; -- for breakpoint for debugging SELECT TRUE FROM Rope.Equal[machineClass, "sparc", FALSE] => machineType ¬ sun4; Rope.Equal[machineClass, "mc68020", FALSE] => machineType ¬ sun3; Rope.Equal[machineClass, "sun4", FALSE] => machineType ¬ sun4; Rope.Equal[machineClass, "sun3", FALSE] => machineType ¬ sun3; Rope.Equal[machineClass, "amd29000", FALSE] => machineType ¬ amd29000; Rope.Equal[machineClass, "rs6000", FALSE] => machineType _ rs6000; Rope.Equal[machineClass, "mipsl", FALSE] => machineType _ mipsle; Rope.Equal[machineClass, "mips", FALSE] => machineType _ mipsbe; ENDCASE => { FOR list: LIST OF MachinePair ¬ userList, list.rest UNTIL list = NIL DO IF Rope.Equal[machineClass, list.first.machineClass, FALSE] THEN RETURN[list.first.machineType]; ENDLOOP; ERROR; }; }; MachineClassFromMachineType: PROC [ machineType: SystemVersion.MachineType ] RETURNS [ machineClass: ROPE ] ~ { SELECT machineType FROM sun4 => machineClass ¬ "sun4"; sun3 => machineClass ¬ "sun3"; amd29000 => machineClass ¬ "amd29000"; rs6000 => machineClass _ "rs6000"; mipsle => machineClass _ "mipsl"; mipsbe => machineClass _ "mips"; ENDCASE => { FOR list: LIST OF MachinePair ¬ userList, list.rest UNTIL list = NIL DO IF machineType = list.first.machineType THEN RETURN[list.first.machineClass]; ENDLOOP; machineClass _ "I don't know"; }; }; GetCommandNames: PROC [host, target: SystemVersion.MachineType] RETURNS[CommandNames] ~ { IF host # sun4 THEN ERROR ShouldNotHappen ["host is not a sun4"]; FOR cnL: LIST OF CommandNames ¬ commandNamesList, cnL.rest UNTIL cnL=NIL DO IF target = cnL.first.target THEN RETURN[cnL.first]; ENDLOOP; RETURN[defaultCommandNames]; }; OnProfileChange: UserProfile.ProfileChangedProc ~ { pList: LIST OF ROPE ~ UserProfile.ListOfTokens["MakeDo.UserClasses", NIL]; compiler, loader, move, csh, include, insertRope, preCName, actualCName: ROPE; useLinks: BOOL ¬ TRUE; this: CommandNames; userList ¬ NIL; commandNamesList ¬ NIL; FOR list: LIST OF ROPE _ pList, list.rest UNTIL list = NIL DO userList ¬ CONS[[list.first, nextMachineType], userList]; nextMachineType ¬ nextMachineType.SUCC; ENDLOOP; compiler ¬ UserProfile.Token["ComplexCc.cc", compilerDefault]; include ¬ UserProfile.Token["ComplexCc.include", includeDefault]; loader ¬ UserProfile.Token["ComplexCc.ld", loadDefault]; move ¬ UserProfile.Token["ComplexCc.mv", moveDefault]; csh ¬ UserProfile.Token["ComplexCc.csh", cshDefault]; useLinks ¬ UserProfile.Boolean["ComplexCc.useLinks", useLinks]; [preCName, actualCName] ¬ ExamineCompilerName[compiler]; defaultCommandNames ¬ NEW[CommandNamesRep ¬ [ sun4, compiler, loader, move, csh, include, preCName, actualCName, IF useLinks THEN insertRopeDefault ELSE NIL]]; FOR uL: LIST OF ROPE ¬ pList, uL.rest UNTIL uL=NIL DO class: ROPE ~ uL.first; compiler ¬ UserProfile.Token[Rope.Cat["ComplexCc.", class, ".cc"], defaultCommandNames.compiler]; include ¬ UserProfile.Token[Rope.Cat["ComplexCc.", class, ".include"], defaultCommandNames.include]; loader ¬ UserProfile.Token[Rope.Cat["ComplexCc.", class, ".ld"], defaultCommandNames.loader]; move ¬ UserProfile.Token[Rope.Cat["ComplexCc.", class, ".mv"], defaultCommandNames.move]; csh ¬ UserProfile.Token[Rope.Cat["ComplexCc.", class, ".csh"], defaultCommandNames.csh]; useLinks ¬ UserProfile.Boolean[Rope.Cat["ComplexCc.", class, ".useLinks"], TRUE]; [preCName, actualCName] ¬ ExamineCompilerName[compiler]; this ¬ NEW[CommandNamesRep ¬ [ MachineTypeFromMachineClass[class], compiler, loader, move, csh, include, preCName, actualCName, IF useLinks THEN insertRopeDefault ELSE NIL]]; commandNamesList ¬ CONS[this, commandNamesList]; ENDLOOP; }; ExamineCompilerName: PROC[cName: ROPE] RETURNS[preCName, actualCName: ROPE ¬ NIL] ~ { <> pos: INT; IF NOT Rope.Find[cName, "rsh ", 0] = 0 THEN RETURN[NIL, cName]; pos ¬ Rope.FindBackward[cName, " "]; RETURN[Rope.Substr[cName, 0, pos], Rope.Substr[cName, pos+1]]; }; UnixNil: UnixTypes.CHARPtr ~ LOOPHOLE[NIL]; MsgFromExitError: PROC [status: INT, command: ROPE] RETURNS [msg: ROPE] ~ { lowHalf: CARD16 ~ Basics.LowHalf[LOOPHOLE[status, CARD32]]; lowByte: BYTE ~ Basics.LowByte[lowHalf]; nextLowByte: BYTE ~ Basics.HighByte[lowHalf]; low7: BYTE; IF lowByte = 177B THEN { msg ¬ IO.PutFR["execution of %g stopped by signal %g\n", IO.rope[command], IO.int[nextLowByte]]; RETURN [msg]; }; IF lowByte = 0 THEN { msg ¬ IO.PutFR["execution of %g exited with %g\n", IO.rope[command], IO.int[nextLowByte]]; RETURN [msg]; }; <> < low7 ¬ PBasics.BITAND[lowByte, 077B];>> < low7 ¬ PBasics.BITAND[lowByte, 176B];>> < ERROR;>> low7 ¬ lowByte MOD 2**7; msg ¬ IO.PutFR["execution of %g terminated due to signal %g\n", IO.rope[command], IO.int[low7]]; }; MsgFromFile: PROC [fileName: ROPE, delete: BOOL ¬ TRUE] RETURNS [msg: ROPE] ~ { stream: IO.STREAM; path: PFS.PATH ~ PFS.PathFromRope[fileName]; stream ¬ PFS.StreamOpen[fileName: path ! PFS.Error => { stream ¬ NIL; CONTINUE }]; IF stream # NIL THEN { msg ¬ stream.GetRope[]; stream.Close[]; IF delete THEN PFS.Delete[name: path ! PFS.Error => CONTINUE]; }; }; Execute: PROC [command: ROPE, wDir: ROPE ¬ NIL] RETURNS [status: INT, msg: ROPE ¬ NIL] ~ { newCommand: ROPE ~ IF wDir.Equal[NIL] THEN command ELSE Rope.Cat["cd ", wDir, " ; ", command]; string: CStrings.CString ~ UXStrings.Create[from: newCommand]; ropeStdErr: ROPE ~ NewName[".stderr", wDir]; stringStdErr: CStrings.CString ~ UXStrings.Create[from: ropeStdErr]; ropeStdOut: ROPE ~ NewName[".stdout",wDir]; stringStdOut: CStrings.CString ~ UXStrings.Create[from: ropeStdOut]; status ¬ UnixSysCallExtensions.Spawn[string, UnixNil, stringStdOut, stringStdErr]; IF status # 0 THEN msg ¬ MsgFromExitError[status: status, command: command]; msg ¬ Rope.Concat[msg, MsgFromFile[fileName: ropeStdErr, delete: DeleteFiles]]; msg ¬ Rope.Concat[msg, MsgFromFile[fileName: ropeStdOut, delete: DeleteFiles]]; }; ExecuteCsh: PROC [hostType, targetType: SystemVersion.MachineType, commandLines: ROPE, wDir: ROPE ¬ NIL] RETURNS [status: INT, msg: ROPE ¬ NIL] ~ { cshCommandRope: ROPE ~ GetCommandNames[ host: hostType, target: targetType].csh; cshCommandString: UnixTypes.CHARPtr ~ UXStrings.Create[cshCommandRope].string; IF cshCommandRope = NIL THEN ERROR ShouldNotHappen[IO.PutFR[ "Cshell execution on target of class %g cannot be done from host of class %g", IO.rope[MachineClassFromMachineType[targetType]], IO.rope[MachineClassFromMachineType[hostType]], ]]; { ropeStdIn: ROPE ~ NewName[".stdin", wDir]; stringStdIn: CStrings.CString ~ UXStrings.Create[from: ropeStdIn]; ropeStdErr: ROPE ~ NewName[".stderr", wDir]; stringStdErr: CStrings.CString ~ UXStrings.Create[from: ropeStdErr]; ropeStdOut: ROPE ~ NewName[".stdout", wDir]; stringStdOut: CStrings.CString ~ UXStrings.Create[from: ropeStdOut]; ropeStdInPath: PFS.PATH ~ PFS.PathFromRope[ropeStdIn]; streamIn: IO.STREAM ~ PFS.StreamOpen[fileName: ropeStdInPath, accessOptions: $create]; IF NOT wDir.Equal[NIL] THEN streamIn.PutF1["cd %g\n", IO.rope[wDir]]; streamIn.PutF1["%g\n", IO.rope[commandLines]]; streamIn.Close[]; status ¬ UnixSysCallExtensions.Spawn[cshCommandString, stringStdIn, stringStdOut, stringStdErr]; IF status # 0 THEN msg ¬ MsgFromExitError[status: status, command: cshCommandRope]; msg ¬ Rope.Concat[msg, MsgFromFile[fileName: ropeStdErr, delete: DeleteFiles]]; msg ¬ Rope.Concat[msg, MsgFromFile[fileName: ropeStdOut, delete: DeleteFiles]]; PFS.Delete[name: ropeStdInPath ! PFS.Error => CONTINUE]; } }; OutFilename: PROC [ template: PFS.PATH ] RETURNS [ name: PFS.PATH ] ~ { shortName: ROPE ¬ PFSNames.ComponentRope[PFSNames.ShortName[template]]; name ¬ PFS.PathFromRope[shortName.Concat[".o"]]; RETURN}; FixPath: PROC [ origName: ROPE ] RETURNS [ newName: ROPE ¬ NIL ] ~ { IF Rope.Equal[origName, NIL] THEN RETURN; newName ¬ PFS.RopeFromPath[PFS.PathFromRope[origName], slashes]; RETURN}; BaseFromFileName: PROC [name: PFS.PATH] RETURNS [ROPE] ~ { short: ROPE ~ PFSNames.ShortNameRope[name]; RETURN[Rope.Substr[base: short, len: Rope.Index[s1: short, s2: "."]]]; }; GetDirAndFixPath: PROC [ origDir, origName: PFS.PATH ] RETURNS [ dir, basename: PFS.PATH ¬ NIL ] ~ { <> cc: INT; dir ¬ origDir; IF origName = NIL THEN RETURN; basename ¬ origName; IF (cc ¬ PFSNames.ComponentCount[basename]) > 1 THEN { dir ¬ PFSNames.Cat[dir, PFSNames.SubName[basename, 0, cc-1, FALSE, TRUE]]; basename ¬ PFSNames.SubName[basename, cc-1, 1, FALSE, FALSE]; RETURN} ELSE RETURN}; <> CommandSyntaxError: ERROR ~ CODE; ComplexCCProc: Commander.CommandProc ~ { binDir, srcDir: PFS.PATH ¬ NIL; ccSwitches, ldSwitches, libSwitches: ROPE ¬ NIL; doALoad: BOOL ¬ FALSE; xFlag: BOOL ¬ FALSE; inFilename, outFilename: PFS.PATH ¬ NIL; currentDir: ROPE ¬ NIL; intFileList: LIST OF ROPE; -- list of file names for intermediate files loadFileList: LIST OF ROPE; -- list of file names for loading rloadFileList: LIST OF ROPE; -- list of righteous file names for loading targetClass, hostClass: ROPE ¬ NIL; { ENABLE { Args.Error => { msg ¬ ComplexCCUsage; GOTO Failed }; ShouldNotHappen => { msg ¬ message; GOTO Failed }; CommandSyntaxError => { msg ¬ ComplexCCUsage; GOTO Failed }; PFS.Error => { msg ¬ error.explanation; GOTO Failed }; ABORTED => { msg ¬ "-- Aborted!"; GOTO Failed }; }; ProcessCommandLine: PROC ~ { nArgs: INT32 ~ Args.NArgs[cmd]; i: NAT; FOR i ¬ 0, i.SUCC WHILE ( i < nArgs ) DO NextRope: PROC RETURNS [ r: ROPE ] ~ INLINE { ropeArg: Args.Arg ~ Args.ArgRope[cmd, i.SUCC]; r ¬ ropeArg.rope; i ¬ i.SUCC; }; NextList: PROC RETURNS [ l: LIST OF ROPE ¬ NIL ] ~ INLINE { FOR j: INT32 ¬ i.SUCC, j.SUCC WHILE ( j < nArgs ) DO anArg: ROPE ~ Args.GetRope[cmd, j]; IF ( anArg.Fetch[0] = '- ) THEN { i ¬ j.PRED; EXIT} ; l ¬ CONS[anArg, l]; REPEAT FINISHED => { i ¬ nArgs } ENDLOOP; }; x: INT; -- for breakpoint anArg: ROPE ~ Args.GetRope[cmd, i]; x ¬ 1; -- for breakpoint SELECT TRUE FROM anArg.Equal[s2: "-in", case: FALSE] => { inFilename ¬ PFS.PathFromRope[NextRope[]] }; anArg.Equal[s2: "-out", case: FALSE] => { outFilename ¬ PFS.PathFromRope[NextRope[]] }; anArg.Equal[s2: "-binDir", case: FALSE] => { binDir ¬ PFS.PathFromRope[NextRope[]] }; anArg.Equal[s2: "-srcDir", case: FALSE] => { srcDir ¬ PFS.PathFromRope[NextRope[]] }; anArg.Equal[s2: "-lSwitch", case: FALSE] => { ldSwitches ¬ NextRope[] }; anArg.Equal[s2: "-cSwitch", case: FALSE] => { ccSwitches ¬ NextRope[] }; < { userHost _ NextRope[] };>> anArg.Equal[s2: "-class", case: FALSE] => { targetClass ¬ NextRope[] }; anArg.Equal[s2: "-lib", case: FALSE] => { libSwitches ¬ NextRope[] }; anArg.Equal[s2: "-int", case: FALSE] => { intFileList ¬ NextList[] }; anArg.Equal[s2: "-X", case: FALSE] => { xFlag ¬ TRUE }; anArg.Equal[s2: "-load", case: FALSE] => { doALoad ¬ TRUE; loadFileList ¬ NextList[] }; anArg.Equal[s2: "-rload", case: FALSE] => { doALoad ¬ TRUE; rloadFileList ¬ NextList[] }; ENDCASE => ERROR CommandSyntaxError; ENDLOOP; }; currentDir ¬ ViewFix[PFS.RopeFromPath[PFS.GetWDir[]], NIL, TRUE, FALSE, FALSE, NIL, cmd.err].unix; --a UXIO name targetClass ¬ UserProfile.Token[key: MACHINECLASS, default: "sun4"]; hostClass ¬ MachineClassFromMachineType[ GetMachineType[] ]; ProcessCommandLine[]; IF binDir#NIL THEN binDir ¬ PFSNames.EnsureDirectory[binDir]; IF srcDir#NIL THEN srcDir ¬ PFSNames.EnsureDirectory[srcDir]; IF ( outFilename = NIL ) THEN outFilename ¬ OutFilename[inFilename]; [binDir, outFilename] ¬ GetDirAndFixPath[binDir, outFilename]; <> <<>> cmd.err.PutF1["C compiling %g ", IO.rope[BaseFromFileName[inFilename]]]; cmd.err.Flush[]; [result, msg] ¬ InnerCcc[PFS.RopeFromPath[binDir], PFS.RopeFromPath[srcDir], ccSwitches, ldSwitches, libSwitches, PFS.RopeFromPath[inFilename], PFS.RopeFromPath[outFilename], currentDir, doALoad, xFlag, intFileList, loadFileList, rloadFileList, MachineTypeFromMachineClass[hostClass], MachineTypeFromMachineClass[targetClass], cmd]; RETURN; <> EXITS Failed => { result ¬ $Failure }; }}; InnerCcc: PROC [binDir, srcDir, ccSwitches, ldSwitches, libSwitches, inFilename, outFilename, currentDir: ROPE, doALoad, xFlag: BOOL, intFileList, loadFileList, rloadFileList: LOR, hostType, targetType: SystemVersion.MachineType, cmd: Commander.Handle] RETURNS [result: REF ANY ¬ NIL, msg: ROPE ¬ NIL] ~ { <> links: LOR ¬ NIL; ccSrc, ccOut, intFudge, ldOut, ldOutUX: ROPE; ldCommand, failMsg: ROPE ¬ NIL; cmdNames: CommandNames; cmdNames ¬ GetCommandNames[host: hostType, target: targetType]; IF cmdNames.compiler.Equal[NIL] OR cmdNames.loader.Equal[NIL] THEN { msg ¬ IO.PutFR["Compilation from host type %g to target type %g is not valid", IO.rope[MachineClassFromMachineType[hostType]], IO.rope[MachineClassFromMachineType[targetType]], ]; GOTO Failed; }; <> <<>> {ENABLE UNWIND => UnlinkList[links, cmd.err]; [ccSrc, links] ¬ ViewFix[Rope.Concat[srcDir, inFilename], NIL, FALSE, TRUE, FALSE, links, cmd.err]; [ccOut, links] ¬ ViewFix[Rope.Concat[binDir, outFilename], NIL, FALSE, TRUE, TRUE, links, cmd.err]; IF doALoad THEN { inputDir: ROPE ~ Rope.Concat[currentDir, binDir]; ldOut ¬ binDir.Concat[NewName[".o", NIL]]; [ldOutUX, links] ¬ ViewFix[ldOut, NIL, FALSE, FALSE, TRUE, links, cmd.err]; FOR tail: LIST OF ROPE ¬ loadFileList, tail.rest WHILE ( tail # NIL ) DO renamed: ROPE; [renamed, links] ¬ ViewFix[Rope.Concat[binDir, tail.first], cmdNames.insert, FALSE, FALSE, FALSE, links, cmd.err]; ldCommand ¬ Rope.Cat[ldCommand, " ", renamed]; ENDLOOP; FOR tail: LIST OF ROPE ¬ rloadFileList, tail.rest WHILE ( tail # NIL ) DO renamed: ROPE; [renamed, links] ¬ ViewFix[tail.first, cmdNames.insert, FALSE, FALSE, FALSE, links, cmd.err]; ldCommand ¬ Rope.Cat[ldCommand, " ", renamed]; ENDLOOP; ldCommand ¬ Rope.Cat[ldCommand, " ", libSwitches]; }; <> <<>> { status: INT; localMsg, command: ROPE ¬ NIL; <> includePart: ROPE ~ IF cmdNames.include = NIL THEN NIL ELSE Rope.Concat["-I", cmdNames.include]; <> IF cmdNames.preCName#NIL THEN { command ¬ IO.PutFLR["%g \" cd %g%g; %g", LIST[[rope[cmdNames.preCName]], [rope[currentDir]], [rope[binDir]], [rope[cmdNames.actualCName]]] ]; command ¬ IO.PutFLR["%g %g -o %g %g -I./%g %g\"", LIST[[rope[command]], [rope[ccSwitches]], [rope[ccOut]], [rope[ccSrc]], [rope[srcDir]], [rope[includePart]]] ]; } ELSE { command _ IO.PutFLR["%g %g -o %g %g -I./%g %g", LIST[IO.rope[cmdNames.compiler], IO.rope[ccSwitches], IO.rope[ccOut], IO.rope[ccSrc], IO.rope[srcDir], [rope[includePart]] ] ]; command ¬ Rope.Cat["cd ", currentDir, " ; ", command]; }; IF showCcCommand THEN SimpleFeedback.PutFL[$ComplexCc, $oneLiner, $info, "\nCC Command: %g\n", LIST[[rope[command]]] ]; [status: status, msg: localMsg] ¬ Execute[command: command, wDir: currentDir]; IF ( NOT localMsg.Equal[NIL] ) THEN { IF ( status # 0 ) THEN { msg ¬ IO.PutFR["Compilation failed; error: %g, msg: %g", IO.int[status], IO.rope[localMsg]]; UnlinkList[links, cmd.err]; GOTO Failed; }; msg ¬ IO.PutFR1[".\nCompilation warnings: %g\n", IO.rope[localMsg]]; } ELSE { msg ¬ "."; }; cmd.err.PutRope[msg]; cmd.err.Flush[]; }; Process.CheckForAbort[]; <> IF ( doALoad ) THEN { status: INT; localMsg: ROPE; [intFudge, links] ¬ ViewFix[Rope.Concat[binDir, outFilename], cmdNames.insert, FALSE, TRUE, FALSE, links, cmd.err]; ldCommand ¬ IO.PutFLR["%g %g -o %g %g %g", LIST[IO.rope[cmdNames.loader], IO.rope[ldSwitches], IO.rope[ldOutUX], IO.rope[intFudge], IO.rope[ldCommand]]]; IF showCcCommand THEN SimpleFeedback.PutFL[$ComplexCc, $oneLiner, $info, "\nld Command: %g\n", LIST[[rope[ldCommand]]] ]; [status: status, msg: localMsg] ¬ Execute[command: ldCommand, wDir: currentDir]; IF ( NOT localMsg.Equal[NIL] ) THEN { IF ( status # 0 ) THEN { msg ¬ IO.PutFR["Load failed; error: %g, msg: %g", IO.int[status], IO.rope[localMsg]]; UnlinkList[links, cmd.err]; GOTO Failed; }; msg ¬ IO.PutFR1[".\nLoad warnings: %g\n", IO.rope[localMsg]]; } ELSE { msg ¬ "."; }; cmd.err.PutRope[msg]; cmd.err.Flush[]; Process.CheckForAbort[]; }; }; UnlinkList[links, cmd.err]; IF ( doALoad ) THEN { PFS.Rename[from: PFS.PathFromRope[ldOut], to: PFS.PathFromRope[binDir.Concat[outFilename]] ! PFS.Error => { msg ¬ IO.PutFLR["PFS.Error[%g, %g] while trying to rename %g to %g", LIST[[atom[error.code]], [rope[error.explanation]], [rope[ldOut]], [rope[binDir.Concat[outFilename]]]]]; GOTO Failed}]; }; Process.CheckForAbort[]; <> <<>> <> <> < {>> <> <> < {failMsg _ msg; GOTO EFail};>> <<};>> <> <> <> <> <> <<>> <> <> <> <> <> <> <> <> <> <> <> <> <> <> <> <> <> <<>> <> <> <> <> <> <> <> <<]];>> <<>> <> <> <<>> < {msg _ failMsg; GOTO Failed}>> <<};>> <<>> msg ¬ " no errors."; EXITS Failed => { result ¬ $Failure }; }; GetMachineType: PROC RETURNS [SystemVersion.MachineType] ~ TRUSTED { RETURN [SystemVersion.GetMachineType[]] }; ComplexRshProc: Commander.CommandProc ~ { xFlag: BOOL ¬ FALSE; xClassName: ROPE ¬ NIL; -- The name of the class for this action srcDir, binDir: PFS.PATH ¬ NIL; srcInFileList: LIST OF ROPE; -- Source files that will be transfered FROM Cedar binInFileList: LIST OF ROPE; -- Binary files that will be transfered FROM Cedar srcOutFileList: LIST OF ROPE; -- Source files that will be copied TO Cedar back binOutFileList: LIST OF ROPE; -- Binary files that will be copied TO Cedar back rshCmd, currentDir, targetClass, hostClass: ROPE ¬ NIL; { ENABLE { Args.Error => { msg ¬ ComplexRshUsage; GOTO Failed }; ShouldNotHappen => { msg ¬ message; GOTO Failed }; CommandSyntaxError => { msg ¬ ComplexRshUsage; GOTO Failed }; PFS.Error => { msg ¬ error.explanation; GOTO Failed }; ABORTED => { msg ¬ "-- Aborted!"; GOTO Failed }; }; ProcessCommandLine: PROC ~ { nArgs: INT32 ~ Args.NArgs[cmd]; i: NAT; FOR i ¬ 0, i.SUCC WHILE ( i < nArgs ) DO NextRope: PROC RETURNS [ r: ROPE ] ~ INLINE { ropeArg: Args.Arg ~ Args.ArgRope[cmd, i.SUCC]; r ¬ ropeArg.rope; i ¬ i.SUCC; }; FixNextList: PROC RETURNS [ l: LIST OF ROPE ¬ NIL ] ~ INLINE { <> FOR j: INT32 ¬ i.SUCC, j.SUCC WHILE ( j < nArgs ) DO anArg: ROPE ~ Args.GetRope[cmd, j]; IF ( anArg.Fetch[0] = '- ) THEN { i ¬ j.PRED; EXIT} ; l ¬ CONS[FixPath[anArg], l]; REPEAT FINISHED => { i ¬ nArgs } ENDLOOP; }; anArg: ROPE ~ Args.GetRope[cmd, i]; SELECT TRUE FROM anArg.Equal[s2: "-binIn", case: FALSE] => { binInFileList ¬ FixNextList[] }; anArg.Equal[s2: "-srcIn", case: FALSE] => { srcInFileList ¬ FixNextList[] }; anArg.Equal[s2: "-binOut", case: FALSE] => { binOutFileList ¬ FixNextList[] }; anArg.Equal[s2: "-srcOut", case: FALSE] => { srcOutFileList ¬ FixNextList[] }; anArg.Equal[s2: "-srcDir", case: FALSE] => { srcDir ¬ PFS.PathFromRope[NextRope[]] }; anArg.Equal[s2: "-binDir", case: FALSE] => { binDir ¬ PFS.PathFromRope[NextRope[]] }; < { userHost _ NextRope[] };>> anArg.Equal[s2: "-class", case: FALSE] => { targetClass ¬ NextRope[] }; anArg.Equal[s2: "-cmd", case: FALSE] => { rshCmd ¬ NextRope[] }; anArg.Equal[s2: "-XClass", case: FALSE] => { xFlag ¬ TRUE; xClassName ¬ NextRope[] }; ENDCASE => ERROR CommandSyntaxError; ENDLOOP; IF binDir.Equal[NIL] THEN binDir ¬ srcDir; }; currentDir ¬ ViewFix[PFS.RopeFromPath[PFS.GetWDir[]], NIL, TRUE, FALSE, FALSE, NIL, cmd.err].unix; --a UXIO name targetClass ¬ UserProfile.Token[key: MACHINECLASS, default: "sun4"]; hostClass ¬ MachineClassFromMachineType[ GetMachineType[] ]; ProcessCommandLine[]; IF srcDir#NIL THEN srcDir ¬ PFSNames.EnsureDirectory[srcDir]; IF binDir#NIL THEN binDir ¬ PFSNames.EnsureDirectory[binDir]; cmd.err.PutRope["Starting Rsh"]; cmd.err.Flush[]; [result, msg] ¬ InnerCrsh[xClassName, PFS.RopeFromPath[srcDir], PFS.RopeFromPath[binDir], rshCmd, currentDir, xFlag, srcInFileList, binInFileList, srcOutFileList, binOutFileList, MachineTypeFromMachineClass[hostClass], MachineTypeFromMachineClass[targetClass], cmd]; <> EXITS Failed => { result ¬ $Failure }; }}; InnerCrsh: PROC [xClassName, srcDir, binDir, rshCmd, currentDir: ROPE, xFlag: BOOL, srcInFileList, binInFileList, srcOutFileList, binOutFileList: LOR, hostType, targetType: SystemVersion.MachineType, cmd: Commander.Handle] RETURNS [result: REF ANY ¬ NIL, msg: ROPE ¬ NIL] ~ { unlinkList: LOR ¬ NIL; --files to unlink later failMsg: ROPE ¬ NIL; <> <> <<>> {ENABLE UNWIND => UnlinkList[unlinkList, cmd.err]; FOR list: LIST OF ROPE ¬ srcOutFileList, list.rest WHILE list # NIL DO fileName: ROPE ~ list.first; FOR list2: LIST OF ROPE ¬ srcInFileList, list2.rest WHILE list2 # NIL DO fileName2: ROPE ~ list2.first; IF Rope.Equal[fileName, fileName2] THEN EXIT; -- if command writes a file that it reads we just let the read fix-up occur REPEAT FINISHED => [, unlinkList] ¬ ViewFix[Rope.Concat[srcDir, fileName], NIL, FALSE, TRUE, TRUE, unlinkList, cmd.err]; ENDLOOP; ENDLOOP; FOR list: LIST OF ROPE ¬ binOutFileList, list.rest WHILE list # NIL DO fileName: ROPE ~ list.first; FOR list2: LIST OF ROPE ¬ binInFileList, list2.rest WHILE list2 # NIL DO fileName2: ROPE ~ list2.first; IF Rope.Equal[fileName, fileName2] THEN EXIT; -- if command writes a file that it reads we just let the read fix-up occur REPEAT FINISHED => [, unlinkList] ¬ ViewFix[Rope.Concat[binDir, fileName], NIL, FALSE, TRUE, TRUE, unlinkList, cmd.err]; ENDLOOP; ENDLOOP; FOR list: LIST OF ROPE ¬ srcInFileList, list.rest WHILE list # NIL DO fileName: ROPE ~ list.first; [, unlinkList] ¬ ViewFix[Rope.Concat[srcDir, fileName], NIL, FALSE, TRUE, FALSE, unlinkList, cmd.err]; ENDLOOP; FOR list: LIST OF ROPE ¬ binInFileList, list.rest WHILE list # NIL DO fileName: ROPE ~ list.first; [, unlinkList] ¬ ViewFix[Rope.Concat[binDir, fileName], NIL, FALSE, TRUE, FALSE, unlinkList, cmd.err]; ENDLOOP; <> <<>> { status: INT; localMsg: ROPE ¬ NIL; realDir: ROPE ¬ currentDir; IF NOT srcDir.Equal[NIL] THEN IF srcDir.Fetch[0] = '/ THEN realDir ¬ srcDir ELSE realDir ¬ Rope.Cat[currentDir, "/", srcDir] ELSE realDir ¬ currentDir; [status: status, msg: localMsg] ¬ ExecuteCsh[hostType: hostType, targetType: targetType, commandLines: rshCmd, wDir: realDir]; IF ( NOT localMsg.Equal[NIL] ) THEN { IF ( status # 0 ) THEN { msg ¬ IO.PutFR["Command failed; error: %g, msg: %g", IO.int[status], IO.rope[localMsg]]; UnlinkList[unlinkList, cmd.err]; GOTO Failed; }; msg ¬ IO.PutFR1[".\nCommand warnings: %g", IO.rope[localMsg]]; } ELSE { msg ¬ "."; }; cmd.err.PutRope[msg]; cmd.err.Flush[]; }; Process.CheckForAbort[]; <> }; UnlinkList[unlinkList, cmd.err]; <> <<>> <> <> < {>> <> <> < {failMsg _ msg; GOTO EFail};>> <<};>> <> <> <> <> <> <> <<>> <> <> <> <> <> <> <> <> <> <> <> <> <<>> <> <<>> <> <> <> <> <> <> <> <> <> <<]];>> <<>> <> <> <> <<>> < {msg _ failMsg; GOTO Failed}>> <<};>> <<>> msg ¬ " no errors."; EXITS Failed => { result ¬ $Failure }; }; <> ComplexCC: ROPE ~ "ComplexCC"; ComplexCCDoc: ROPE ~ " - cc with all the frills. Switches are: -in -out -class -host -cSwitch -rload => load compiled file together with (rel to cwd) -X => eXtend the resulting binary file with fast symbol and dependecy info -lSwitch -Lib libstring => string with the libraries to load -int => files to copy to the host before compiling -srcDir => remote source directory -binDir => remote object file directory (overridden by directory part specified in -out) "; ComplexCCUsage: ROPE ~ Rope.Concat["Usage: ComplexCC ", ComplexCCDoc]; ComplexRsh: ROPE ~ "ComplexRsh"; ComplexRshDoc: ROPE ~ " - Rsh with all the frills. Switches are: -class -host -srcIn => source files to copy to the host before doing Rsh -binIn => binary files to copy to the host before doing Rsh -srcOut => source files to copy from the host after doing Rsh -binOut => binary files to copy from the host after doing Rsh -srcDir => remote source directory (command will execute in srcDir) -binDir => remote binary directory (equal to -srcDir by default) -XClass => eXtend the resulting binary files with fast symbol and dependency information; use to identify the action performed. -cmd => command to execute remotely "; ComplexRshUsage: ROPE ~ Rope.Concat["Usage: ComplexRsh ", ComplexRshDoc]; ComplexRshUsageHostMissing: ROPE ~ Rope.Concat["No host has been specified\nUsage: ComplexRsh ", ComplexRshDoc]; ComplexErrorProc: Commander.CommandProc ~ {ERROR}; ComplexDebugLinksProc: Commander.CommandProc ~ {debugLinks ¬ TRUE}; ComplexDontDebugLinksProc: Commander.CommandProc ~ {debugLinks ¬ FALSE}; nextMachineType: SystemVersion.MachineType ¬ LOOPHOLE[40]; AddUserClassCmd: Commander.CommandProc ~ { arg: ROPE; UNTIL ( arg ¬ CommanderOps.NextArgument[cmd] ) = NIL DO userList ¬ CONS[[arg, nextMachineType], userList]; nextMachineType ¬ nextMachineType.SUCC; ENDLOOP; }; ShowCcCommandCmd: Commander.CommandProc ~ { showCcCommand ¬ TRUE; }; DontShowCcCommandCmd: Commander.CommandProc ~ { showCcCommand ¬ FALSE; }; showCcCommand: BOOL ¬ FALSE; userList: LIST OF MachinePair ¬ NIL; MachinePair: TYPE ~ RECORD[machineClass: ROPE, machineType: SystemVersion.MachineType]; compilerDefault, includeDefault, moveDefault, loadDefault, cshDefault: ROPE; insertRopeDefault: ROPE ~ "FILE-"; Init: PROC ~ { projectCedar: ROPE ~ IO.PutFR["/project/cedar%g.%g/", [cardinal[SystemVersion.release.major]], [cardinal[SystemVersion.release.minor]] ]; Commander.Register[ComplexCC, ComplexCCProc, ComplexCCDoc]; Commander.Register[ComplexRsh, ComplexRshProc, ComplexRshDoc]; Commander.Register["ComplexError", ComplexErrorProc, "raises ERROR, for debugging"]; Commander.Register["ComplexDebugLinks", ComplexDebugLinksProc, "turns on debugging printout for links"]; Commander.Register["ComplexDontDebugLinks", ComplexDontDebugLinksProc, "turns off debugging printout for links"]; Commander.Register["ComplexCc.AddUserClasses", AddUserClassCmd, "add user classes to ComplexCc; syntax is: name* "]; Commander.Register["ComplexCc.ShowCcCommand", ShowCcCommandCmd, "turn on printing of cc command to system script"]; Commander.Register["ComplexCc.DontShowCcCommand", DontShowCcCommandCmd, "turn off printing of cc command to system script"]; includeDefault ¬ Rope.Concat[projectCedar, "include/"]; moveDefault ¬ "/bin/mv"; loadDefault ¬ Rope.Concat[projectCedar, "lang/ld/sparc/ld"]; cshDefault ¬ "/bin/csh -s"; compilerDefault ¬ Rope.Concat[projectCedar, "bin/ccc"]; UserProfile.CallWhenProfileChanges[OnProfileChange]; }; Init[]; }. <> <> <> <> <<>> <> <>