> sourceName _ FileNames.GetShortName[sourceName]; IF complex THEN { first: BOOL _ TRUE; cmdLine _ cmdLine.Cat[rootName, " _ ", originalSourceName, "["]; FOR p: CommandUtil.PairList _ args, p.rest UNTIL p=NIL DO IF ~first THEN cmdLine _ cmdLine.Concat[", "]; cmdLine _ cmdLine.Cat[p.first.key, ": ", p.first.val]; first _ FALSE; ENDLOOP; cmdLine _ cmdLine.Concat["]"]; } ELSE cmdLine _ cmdLine.Concat[sourceName]; { ENABLE UNWIND => Finalize[userAbort]; found: BOOL _ FALSE; success: ComputeServerClient.RemoteSuccess _ false; serverInstance: Rope.ROPE _ NIL; result _ $Blocked; remoteMsg _ NIL; WHILE result = $Blocked DO IF SystemVersion.machineType # dorado THEN { remSuccess: ComputeServerClient.RemoteSuccess; selfBest: BOOL; FigOfMerit: REAL; [success: remSuccess, selfIsBest: selfBest, FOM: FigOfMerit] _ ComputeServerClient.BestServerStats[]; IF remSuccess # true OR selfBest OR FigOfMerit > 0.5 THEN { result _ $TryLocal; EXIT; }; }; IF ~preferRemote THEN result _ $TryLocal; IF result # $TryLocal THEN { IF verboseComputeServer THEN cmd.out.PutRope[" -- Trying remote compile\n"]; IF complex THEN { [found: found, success: success, remoteMsg: remoteMsg, serverInstance: serverInstance] _ ComputeServerClient.StartService[service: "RemoteComplexCompiler", cmdLine: cmdLine, in: NIL, out: cmd.out, queueService: TRUE, timeToWait: 600]; } ELSE { [found: found, success: success, remoteMsg: remoteMsg, serverInstance: serverInstance] _ ComputeServerClient.StartService[service: "RemoteCompiler", cmdLine: cmdLine, in: NIL, out: cmd.out, queueService: TRUE, timeToWait: 600]; }; SELECT TRUE FROM ~found OR success = false OR success = cantImportController OR success = cantImportServer OR success = communicationFailure OR success = commandNotFound OR success = clientNotRunning => { IF verboseComputeServer THEN cmd.out.PutRope[" -- Remote compile did not work; do it locally\n"]; result _ $TryLocal; }; success = aborted => { userAbort _ TRUE; }; success = timeOut OR success = serverTooBusy => { IF verboseComputeServer THEN cmd.out.PutRope[Rope.Cat[" -- Remote compile ", (IF success = timeOut THEN "timed out queuing" ELSE "found a server that was too busy"), "; try again\n"]]; LOOP; }; found AND success = true => { printServerName: PROC = { badName: BOOL _ FALSE; serverName: ROPE _ serverInstance; address: PupDefs.PupAddress; address _ PupDefs.GetPupAddress[PupTypes.fillInSocketID, serverInstance ! PupDefs.PupNameTrouble => { badName _ TRUE; CONTINUE; }; ]; IF ~badName THEN serverName _ PupDefs.GetHostName[address]; IF ~serverName.IsEmpty[] THEN cmd.out.PutRope[Rope.Cat[" -- Compute Server used was ", serverName, "\n"]]; }; IF ~remoteMsg.IsEmpty[] THEN SELECT remoteMsg.Fetch[0] FROM 'F => { -- failure result _ $Failure; errors _ TRUE; warnings _ FALSE; IF verboseComputeServer THEN { printServerName[]; } ELSE { IF ~serverInstance.IsEmpty[] THEN cmd.out.PutRope[Rope.Cat[" Compute Server used was ", serverInstance, "\n"]]; }; }; 'W => { -- warnings result _ $Warning; errors _ FALSE; warnings _ TRUE; IF verboseComputeServer THEN printServerName[]; }; 'S => { -- success result _ $Success; errorName _ NIL; errors _ FALSE; warnings _ FALSE; IF verboseComputeServer THEN printServerName[]; }; 'A => { -- aborted result _ $Aborted; errors _ TRUE; warnings _ FALSE; userAbort _ TRUE; IF verboseComputeServer THEN printServerName[]; }; 'B => { -- blocked bestSuccess: ComputeServerClient.RemoteSuccess; selfIsBest: BOOL; bestFOM: REAL; result _ $Blocked; [success: bestSuccess, selfIsBest: selfIsBest, FOM: bestFOM] _ ComputeServerClient.BestServerStats[]; IF verboseComputeServer THEN { cmd.out.PutRope[" -- Server tried was already busy.\n"]; printServerName[]; }; }; ENDCASE; }; ENDCASE; }; ENDLOOP; IF result = $TryLocal THEN { commandName: ROPE = IF complex THEN "RemoteComplexCompiler" ELSE "RemoteCompiler"; lookupProcData: ComputeServerServer.RegisteredProcHandle; errMsg: ROPE _ NIL; runError: BOOL _ FALSE; lookupProcData _ ComputeServerServer.Lookup["RemoteCompiler", NIL]; IF verboseComputeServer THEN cmd.out.PutRope[" -- Trying to do the compile locally.\n"]; IF lookupProcData = NIL THEN { dir: ROPE; dir _ CommandTool.RegistrationDirectory[cmd]; IF verboseComputeServer THEN cmd.out.PutRope[Rope.Cat[" -- Trying to run CompilerServer.bcd from directory", dir, ".\n"]]; [errMsg: errMsg, error: runError] _ CommandTool.Run[bcdName: dir.Concat["CompilerServer.bcd"], runEvenIfAlreadyRun: FALSE, runEvenIfUnbound: FALSE]; lookupProcData _ ComputeServerServer.Lookup["RemoteCompiler", NIL]; }; IF lookupProcData = NIL THEN { -- try the standard place IF verboseComputeServer THEN cmd.out.PutRope[Rope.Cat[" -- Trying to run CompilerServer.bcd from directory ///Commands/\n"]]; [] _ CommandTool.Run[bcdName: "///Commands/CompilerServer.bcd", runEvenIfAlreadyRun: FALSE, runEvenIfUnbound: FALSE]; lookupProcData _ ComputeServerServer.Lookup["RemoteCompiler", NIL]; }; IF lookupProcData = NIL THEN { msg _ "Failed to start up compiler (CompilerServer.bcd) on the workstation.\n"; IF runError AND ~errMsg.IsEmpty[] THEN msg _ msg.Cat[" Error from Run is ", errMsg]; appendRopeToLog[Rope.Concat[" -- ", msg]]; result _ $Failure; } ELSE { myCmd: Commander.Handle; myCmd _ NEW[Commander.CommandObject _ [ in: cmd.in, out: cmd.out, err: cmd.err, commandLine: cmdLine, command: commandName, propertyList: cmd.propertyList, procData: cmd.procData ]]; result _ $Blocked; WHILE result = $Blocked DO [result: result, msg: remoteMsg] _ lookupProcData.commanderProcHandle.proc[myCmd]; IF ~remoteMsg.IsEmpty[] THEN SELECT remoteMsg.Fetch[0] FROM 'F => { -- failure result _ $Failure; errors _ TRUE; warnings _ FALSE; }; 'W => { -- warnings result _ $Warning; errors _ FALSE; warnings _ TRUE; }; 'S => { -- success result _ $Success; errorName _ NIL; errors _ FALSE; warnings _ FALSE; }; 'A => { -- aborted result _ $Aborted; errors _ TRUE; userAbort _ TRUE; warnings _ FALSE; }; 'B => { -- blocked result _ $Blocked; }; ENDCASE; ENDLOOP; }; }; }; -- end ENABLE UNWIND => Finalize[]; IF result # $Success THEN someNonSuccess _ TRUE; Finalize[userAbort]; EXITS globalSwitches => { objectName _ NIL; sense _ TRUE; FOR i: INT IN [0..switches.Length[]) DO c: CHAR = switches.Fetch[i]; SELECT c FROM '-, '~ => sense _ ~sense; IN ['a..'z] => {switchDefaults[c] _ sense; sense _ TRUE}; IN ['A..'Z] => { switchDefaults[VAL['a.ORD+(c.ORD-'A.ORD)]] _ sense; sense _ TRUE}; ENDCASE => EXIT; ENDLOOP; switches _ NIL; args _ NIL; }; badSemantics => { objectName _ NIL; errors _ TRUE; appendRopeToLog[" -- Illegal command"]; args _ NIL; }; }; <> sourceName _ rootName _ objectName _ errorName _ NIL; parms.objectName _ NIL; results _ NIL; IF userAbort THEN {appendRopeToLog["\n... command aborted\n"]; GOTO truncateList}; IF (errors OR warnings) AND localPause THEN GOTO truncateList; REPEAT badSyntax => {appendRopeToLog["\n-- Illegal syntax"]; errors _ TRUE}; truncateList => switchDefaults['p] _ TRUE; ENDLOOP; <> END; -- end catch phrase to release the resource and reset the process priority Cleanup[]; }; <<>> <> RollbackRecovery: Booting.RollbackProc = CHECKED { directoriesToUseExistingLog _ NIL; }; <<>> <<>> <> NewCompilerLog: ENTRY SAFE PROC [cmd: Commander.Handle] RETURNS [result: REF _ NIL, msg: Rope.ROPE _ NIL] = CHECKED { ENABLE UNWIND => NULL; argv: CommandTool.ArgumentVector; dir: ROPE; prev: LIST OF ROPE; argv _ CommandTool.Parse[cmd ! CommandTool.Failed => { msg _ errorMsg; CONTINUE; }]; dir _ FileNames.ConvertToSlashFormat[IF argv.argc < 2 THEN FileNames.CurrentWorkingDirectory[] ELSE FileNames.ResolveRelativePath[argv[1]]]; FOR l: LIST OF ROPE _ directoriesToUseExistingLog, l.rest UNTIL l = NIL DO IF Rope.Equal[l.first, dir] THEN { IF l = directoriesToUseExistingLog THEN directoriesToUseExistingLog _ l.rest ELSE prev.rest _ l.rest; EXIT; }; prev _ l; ENDLOOP; }; <> DefaultSwitches: PROC RETURNS [CompilerOps.LetterSwitches] = { RETURN [[ TRUE , -- A Address fault for NIL checks TRUE , -- B Bounds checking TRUE , -- C compile for Cedar (special FORK) FALSE, -- D call Debugger on compiler error (FALSE => just log error) TRUE , -- E fixed (big Eval stack) TRUE , -- F Floating point microcode TRUE , -- G TRUE => log goes to compiler.log, FALSE => use foo.errlog FALSE, -- H TRUE => append to compiler.log, FALSE => write new compiler.log FALSE, -- I unused FALSE, -- J cross-Jumping optimization FALSE, -- K unused TRUE , -- L allocate space for code Links TRUE , -- M reference counting Microcode TRUE , -- N Nil pointer checking FALSE, -- O unused FALSE, -- P Pause after compilation with errors FALSE, -- Q unused FALSE, -- R unused TRUE , -- S Sort (by static frequency) global vars & entry indexes FALSE, -- T unused FALSE, -- U uninitialized variable checking FALSE, -- V unused TRUE , -- W log Warning messages FALSE, -- X unused FALSE, -- Y complain about KFCB TRUE -- Z FALSE => use old-style method to access ROPE & ATOM literals ]]}; <> Booting.RegisterProcs[r: RollbackRecovery]; Process.InitializeCondition[@CompilerCondition, Process.MsecToTicks[250]]; Commander.Register["Compile", Compile, "Compile {-switches} xxx* - A simple syntax for compiling a list of cedar modules. (See 'ComplexCompile' for another syntax). Some useful switches are: -b => bounds checking (default: TRUE -- don't turn this off unless you know what you are doing), -d => call debugger on compiler error (else just log error), -g => log goes to compiler.log (-~g => log goes to foo.errlog), -j => cross-jump (default: FALSE -- don't turn this on unless you know what you are doing), -n => nil checking (default: TRUE -- don't turn this off unless you know what you are doing), -u => check for uninitialized variables, -w => log warning messages (default: TRUE) Switches can be negated with '~' (i.e. '-~bj~n'). The complete list of switches is in CompilerSequencer.DefaultSwitches. The defaults can be set in your user profile with Compiler.Switches.", $Vanilla]; Commander.Register["RCompile", Compile, "RCompile {-switches} xxx* - Same switches as Compile, but this prefers remote compilation", $RemoteVanilla]; Commander.Register["ComplexCompile", Compile, "ComplexCompile /j-b-n BcdTreeOps _ ProtoTreeOps[Literals: BcdSymbols, Symbols: BcdSymbols, Tree: BcdTree] . . . - Allows a parameterized compilation. Switches are marked with '/ and negated with '-. (See 'Compile' for more on switches.)", $Complex]; Commander.Register["NewCompilerLog", NewCompilerLog, "NewCompilerLog [directory] - Start a new Compiler.log for compiles done in the current directory or the specified directory. Useful only when the compiles are done with the g switch on "]; }. <> <> <> <> <> <> <> <<>>