<<>>
<<MimosaInterfaceImpl.mesa>>
    <<Copyright Ó 1985, 1986, 1987, 1988, 1989, 1990, 1991, 1992 by Xerox Corporation.  All rights reserved.>>
    <<Satterthwaite, April 21, 1986 5:20:59 pm PST>>
    <<Spreitzer, May 16, 1984 7:45:09 pm PDT>>
    <<Russ Atkinson (RRA) March 8, 1991 11:12 am PST>>
    <<Bob Hagmann May 24, 1985 11:48:36 am PDT>>
    <<JKF March 5, 1990 5:11:51 pm PST>>
    <<Doug Wyatt, March 14, 1992 4:06 pm PST>>

        DIRECTORY
            Ascii USING [Lower],
            BasicTime USING [GMT, Now, nullGMT, Period, ToNSTime],
            Commander USING [CommandObject, Handle, Register],
            CompilerOps USING [AppendHerald, DefaultSwitches, DoTransaction, LetterSwitches, Punt, Start, Stop, StreamId, Transaction],
            FileNames USING [GetShortName],
            FileParms USING [BindingProc, nullActual],
            FileParmOps USING [ClearAList, Finalize, Initialize, SetAList],
            FileViewerOps USING [AttachErrorLog, RemoveErrorLog, ShowLog, WaitUntilSaved],
            IO USING [EndOfStream, Error, GetRope, GetTokenRope, IDProc, Put, PutChar, PutF, PutF1, PutRope, RIS, TIS, STREAM],
            MimCommandUtil USING [Echo, Failed, GetNth, GetRootName, ListLength, PairList, Parse, SetExtension],
            MimosaInterface USING [],
            MimSysOps USING [Cleanup, Close, Delete, Open],
            MobDefs USING [NullVersion],
            Process USING [CheckForAbort, ConditionPointer, GetPriority, MsecToTicks, PauseMsec, Priority, priorityBackground, SetPriority, 
            SetTimeout],
            RefText USING [AppendChar, AppendRope, New],
            Rope USING [Fetch, Length, Match, ROPE],
            UserProfile USING [Boolean, Token];
MimosaInterfaceImpl: MONITOR
    IMPORTS Ascii, BasicTime, Commander, CompilerOps, FileNames, FileParmOps, FileViewerOps, IO, MimCommandUtil, MimSysOps, Process, 
    RefText, Rope, UserProfile
    EXPORTS MimosaInterface
    = {

    ROPE: TYPE = Rope.ROPE;
    STREAM: TYPE = IO.STREAM;

    Outcome: TYPE = {ok, warnings, errors, aborted};

    parms: REF CompilerOps.Transaction = NEW[CompilerOps.Transaction];
    standardSwitchDefaults: CompilerOps.LetterSwitches = CompilerOps.DefaultSwitches[];
    standardChecksDefaults: CompilerOps.LetterSwitches = ALL[FALSE];
    sourceName: ROPE Ź NIL;
    sourceTime: BasicTime.GMT Ź BasicTime.nullGMT;
    objectName: ROPE Ź NIL;
    errorName: ROPE Ź NIL;
    rootName: ROPE Ź NIL;
    sourceStream: STREAM Ź NIL;
    objectStream: STREAM Ź NIL;
    errorStream: STREAM Ź NIL;
    <<>>
    useLog: BOOL;        -- use compiler.log for error reporting
    log: STREAM Ź NIL;
    logName: ROPE Ź "Mimosa.log";

    compilerInUse: BOOL Ź FALSE;
    inUseChanged: CONDITION;
    inUseTimeoutMillis: NAT Ź 1000;

    InterfaceError: ERROR [why: ROPE] = CODE;

    Compile: SAFE PROC [cmd: Commander.Handle]
    RETURNS [result: REF Ź NIL, msg: ROPE Ź NIL] ~ CHECKED {
        in: STREAM Ź IO.RIS[cmd.commandLine];
        out: STREAM Ź cmd.out;
        data: REF Ź cmd.procData.clientData;
        [result, msg] Ź DoCompile[in, out, data];
        IF result#$Failure THEN msg Ź NIL; -- DKW
        };

    DoCompile: PUBLIC SAFE PROC [in: STREAM, out: STREAM, clientData: REF]
    RETURNS [result: REF Ź NIL, msg: ROPE Ź NIL] ~ TRUSTED { 
        userAbort: BOOL Ź FALSE;    -- set by ­DEL, STOP
        errors, warnings: BOOL Ź FALSE;
        priority: Process.Priority = Process.GetPriority[];
        compilerStartTime, moduleStartTime: BasicTime.GMT;
        switchDefaults: CompilerOps.LetterSwitches;
        moduleCount: CARDINAL Ź 0;
        complex: BOOL = (SELECT clientData FROM $Complex => TRUE, ENDCASE => FALSE);
        compilerSwitches: Rope.ROPE Ź UserProfile.Token["Mimosa.Switches"];
        filesInit: BOOL Ź FALSE;
        started: BOOL Ź FALSE;
        errmsg: ROPE Ź NIL;
        destroyLogOnSuccess: BOOL Ź UserProfile.Boolean["Mimosa.DestroyLogOnSuccess", TRUE];
        createIconic: BOOL Ź UserProfile.Boolean["Mimosa.IconicLogs", FALSE];
        blinkIfIconic: BOOL Ź UserProfile.Boolean["Mimosa.BlinkLogs", TRUE];
        viewSeparateLogs: BOOL Ź UserProfile.Boolean["Mimosa.ViewSeparateLogs", FALSE];
        useFileViewerOps: BOOL Ź TRUE;

        WaitForCompilerFree: ENTRY PROC = {
            ENABLE UNWIND => NULL;
            Process.SetPriority[Process.priorityBackground]; 
            WHILE compilerInUse DO
                <<Workaround for Mimosa bug:>>
                Long: PROC [p: LONG POINTER] RETURNS [LONG POINTER] = {RETURN[p]};
                Process.CheckForAbort[];
                Process.SetTimeout[LOOPHOLE[Long[@inUseChanged]], Process.MsecToTicks[inUseTimeoutMillis]];
                WAIT inUseChanged;
                ENDLOOP;
            compilerInUse Ź TRUE;
            };

        SetCompilerFree: ENTRY PROC = {
            ENABLE UNWIND => NULL;
            Process.SetPriority[priority];
            compilerInUse Ź FALSE;
            BROADCAST inUseChanged;
            };

        Cleanup: PROC [oops: BOOL] = {
            started Ź FALSE;
            CompilerOps.Stop[];
            filesInit Ź FALSE;
            FileParmOps.Finalize[];
            MimSysOps.Cleanup[oops];
            log Ź NIL;
            sourceStream Ź NIL;
            objectStream Ź NIL;
            errorStream Ź NIL;
            SetCompilerFree[];
            };

        Finalize: PROC [userAbort: BOOL] = {
            errmsg: ROPE Ź NIL;
            IF objectStream # NIL THEN {
                abortAndDelete: BOOL Ź userAbort OR parms.nErrors # 0;
                errmsg Ź MimSysOps.Close[objectStream, abortAndDelete];
                };
            IF sourceStream # NIL THEN errmsg Ź MimSysOps.Close[sourceStream, userAbort];
            IF errorStream # NIL AND errorStream # log THEN
                errmsg Ź MimSysOps.Close[errorStream, userAbort];
            objectStream Ź sourceStream Ź errorStream Ź NIL;
            IF errorName = NIL AND NOT userAbort THEN {
                <<There were no errors, so delete the error log>>
                errlogFileName: ROPE Ź MimCommandUtil.SetExtension[rootName, "errlog"]; 
                [] Ź MimSysOps.Delete[errlogFileName];
                };
            };

        <<acquire the compiler's resource lock; await success>>
        WaitForCompilerFree[! ABORTED => {msg Ź "A"; GO TO earlyFailure}];

        <<init in and sourceName>>

        MimSysOps.Cleanup[TRUE];
            <<Just in case someone did not cleanup properly last time>>

        --in Ź in;
        sourceName Ź NIL;

        IF compilerSwitches.Length[] # 0 THEN {
            newCommand: REF TEXT Ź RefText.New[compilerSwitches.Length[]+30];
            newCommand Ź RefText.AppendChar[newCommand, IF complex THEN '/ ELSE '-];
            newCommand Ź RefText.AppendRope[newCommand, compilerSwitches];
            newCommand Ź RefText.AppendRope[newCommand, IO.GetRope[in]];
            in Ź IO.TIS[newCommand];
            };

        <<do the compilation>>
        BEGIN
            ENABLE {
                UNWIND => Cleanup[TRUE];
                InterfaceError => {
                    msg Ź why;
                    IF parms.nErrors = 0 THEN parms.nErrors Ź 1;
                    Cleanup[TRUE];
                    GO TO earlyFailure;
                        <<Must use this exit, because "failed" is not in the right scope (sigh)>>
                    }
                };

            StartPass: PROC [pass: CARDINAL] RETURNS [goOn: BOOL] = {
                msg: ROPE Ź " .";
                userAbort Ź FALSE;
                SELECT TRUE FROM
                    parms.nErrors # 0 => msg Ź " !";
                    parms.nWarnings # 0 => msg Ź " ?";
                    ENDCASE;
                IO.PutRope[out, msg ! ABORTED => {userAbort Ź TRUE; CONTINUE}];
                Process.CheckForAbort[ ! ABORTED => {userAbort Ź TRUE; CONTINUE}];
                IF userAbort THEN IO.PutRope[out, " aborted." ! ABORTED => CONTINUE];
                RETURN [~userAbort];
                };

            compilerStartTime Ź BasicTime.Now[];
            switchDefaults Ź CompilerOps.DefaultSwitches[];
            parms.fileParms Ź FileParmOps.Initialize[];
            filesInit Ź TRUE;
            CompilerOps.Start[];
            started Ź TRUE;

            IF log = NIL THEN {
                [stream: log, err: msg] Ź MimSysOps.Open[logName, $writeLog];
                IF log = NIL THEN {Cleanup[TRUE]; GO TO earlyFailure};
                    <<Must use this exit, because "failed" is not in the right scope (sigh)>>
                };
            WriteHerald[log, NIL];
            parms.debugPass Ź CARDINAL.LAST;
            parms.checks Ź standardChecksDefaults;

            DO
                first: BOOL;
                args, results: MimCommandUtil.PairList;
                switches: ROPE Ź NIL;
                localPause: BOOL;
                sense: BOOL;

                SELECT clientData FROM
                    $MimosaServer => useFileViewerOps Ź FALSE;
                    $MimosaDebug => switchDefaults['d] Ź TRUE;
                    $MimosaOnly => switchDefaults['m] Ź TRUE;
                    $MimosaOnlyDebug => switchDefaults['d] Ź switchDefaults['m] Ź TRUE;
                    ENDCASE;
                {
                    <<start scope for EXITS>>
                    parms.switches Ź switchDefaults;
                    parms.getStream Ź GetStream;
                    parms.closeStream Ź CloseStream;
                    parms.startPass Ź StartPass;
                    parms.nErrors Ź parms.nWarnings Ź 0;
                    parms.sourceTokens Ź 0;

                    IF complex
                        THEN
                            [sourceName, args, results, switches] Ź MimCommandUtil.Parse[in
                                ! MimCommandUtil.Failed => GO TO badSyntax]
                        ELSE {
                            <<use a simple syntax for the command line>>
                            sourceName Ź NIL;
                            DO
                                token: ROPE Ź in.GetTokenRope[IO.IDProc
                                    ! IO.EndOfStream => EXIT].token;
                                i: INT Ź 1;
                                len: INT = Rope.Length[token];
                                IF NOT Rope.Match["-*", token] THEN {
                                    sourceName Ź token;
                                    EXIT;
                                    };
                                sense Ź TRUE;
                                switches Ź token;
                                WHILE i < len DO
                                    c: CHAR Ź Rope.Fetch[switches, i];
                                    SELECT c FROM
                                        '~ => {sense Ź NOT sense; i Ź i + 1; LOOP};
                                        '% => {
                                            <<The following letter denotes a checking option>>
                                            i Ź i + 1;
                                            IF i = len THEN EXIT;
                                            c Ź Rope.Fetch[switches, i];
                                            SELECT c FROM
                                                '% => parms.checks Ź ALL[sense];
                                                IN ['a..'z], IN ['A..'Z] => parms.checks[Ascii.Lower[c]] Ź sense;
                                                ENDCASE;
                                            };
                                        IN ['a..'z], IN ['A..'Z] => parms.switches[Ascii.Lower[c]] Ź sense;
                                        IN ['0..'9] => parms.debugPass Ź c-'0;
                                        ENDCASE;
                                    i Ź i + 1;
                                    sense Ź TRUE;
                                    ENDLOOP;
                                ENDLOOP;
                            switchDefaults Ź parms.switches;
                            };
                    IF sourceName = NIL AND switches = NIL THEN EXIT;
                    IO.PutRope[log, "\nCommand: "];
                    MimCommandUtil.Echo[log, sourceName, args, results, switches];
                    IF MimCommandUtil.ListLength[results] > 1 THEN GOTO badSemantics;
                    rootName Ź FileNames.GetShortName[MimCommandUtil.GetRootName[IF MimCommandUtil.ListLength[results] = 1
                        THEN MimCommandUtil.GetNth[results, 0]
                        ELSE sourceName]];
                    sourceName Ź MimCommandUtil.SetExtension[sourceName, "mesa"];
                    IF useFileViewerOps THEN
                        FileViewerOps.WaitUntilSaved[sourceName, out];
                    parms.source.locator Ź FileNames.GetShortName[sourceName];

                    IF MimCommandUtil.ListLength[results] # 0
                        THEN {
                            objectName Ź FileNames.GetShortName[
                            MimCommandUtil.GetNth[list: results, n: 0, delete: TRUE]];
                            results Ź NIL;
                            }
                        ELSE objectName Ź rootName;
                    objectName Ź MimCommandUtil.SetExtension[objectName, "mob"];
                    parms.objectName Ź objectName;

                    moduleCount Ź moduleCount + 1;

                    <<feedback to user>>
                    IO.PutRope[out, "Mimosa"];
                    first Ź TRUE;
                    FOR c: CHAR IN ['a..'z] DO
                        sd: BOOL = standardSwitchDefaults[c];
                        IF parms.switches[c] # sd THEN {
                            IF first THEN {first Ź FALSE; IO.PutRope[out, " -"]};
                            IF sd THEN IO.PutChar[out, '~];
                            out.PutChar[c];
                            };
                        ENDLOOP;
                    IF parms.checks = ALL[TRUE] THEN {
                        IF first THEN {first Ź FALSE; IO.PutRope[out, " -"]};
                        out.PutRope["%%"];
                        }
                    ELSE
                        FOR c: CHAR IN ['a..'z] DO
                            sd: BOOL = standardChecksDefaults[c];
                            IF parms.checks[c] # sd THEN {
                                IF first THEN {first Ź FALSE; IO.PutRope[out, " -"]};
                                IF sd THEN IO.PutChar[out, '~];
                                out.PutChar['%];
                                out.PutChar[c];
                                };
                            ENDLOOP;
                    IO.PutRope[out, " "];
                    IO.PutRope[out, rootName];
                    useLog Ź FALSE;
                    localPause Ź parms.switches['p];

                    <<main line code>>
                    [sourceStream, errmsg, sourceTime] Ź MimSysOps.Open[sourceName, $read];
                    IF sourceStream = NIL THEN GO TO noSource;
                    parms.sourceStream Ź sourceStream;
                    parms.source.version Ź MobDefs.NullVersion;
                    parms.source.version[0] Ź BasicTime.ToNSTime[sourceTime];
                    {
                        ENABLE UNWIND => Finalize[userAbort];
                        FileParmOps.SetAList[args];
                        {
                            ENABLE UNWIND => FileParmOps.ClearAList[];
                            BindPattern: FileParms.BindingProc = {
                                parms.pattern Ź actual;
                                parms.op Ź IF actual = FileParms.nullActual THEN $compile ELSE $replace;
                                };
                            parms.fileParms.Binding[
                            formalId: "$", formalType: NIL, defaultLocator: NIL, binder: BindPattern];
                            IO.PutChar[log, '\n];  
                            moduleStartTime Ź BasicTime.Now[];
                            CompilerOps.DoTransaction[parms
                                ! 
                                    CompilerOps.Punt => {
                                        FileParmOps.ClearAList[];
                                        Finalize[userAbort];
                                        GO TO punt;
                                        };
                                    ABORTED => {
                                        userAbort Ź TRUE;
                                        FileParmOps.ClearAList[];
                                        Finalize[userAbort];
                                        GO TO punt;
                                        }
                                    ];
                            };
                        FileParmOps.ClearAList[];
                        };
                    Finalize[userAbort];

                    SELECT WriteResults[out, moduleStartTime ! IO.Error => CONTINUE] FROM
                        errors => errors Ź TRUE;
                        warnings => warnings Ź TRUE;
                        ENDCASE;
                    IF useFileViewerOps THEN {
                        IF (errors OR warnings OR parms.debugPass # CARDINAL.LAST)
                        AND errorName # NIL
                            THEN {
                                SELECT TRUE FROM
                                    viewSeparateLogs =>
                                        FileViewerOps.ShowLog[
                                        fileName: errorName,
                                        createIconic: createIconic,
                                        blinkIfIconic: blinkIfIconic];
                                    sourceName # NIL =>
                                        FileViewerOps.AttachErrorLog[sourceName];
                                    ENDCASE;
                                }
                            ELSE {
                                IF destroyLogOnSuccess AND errorName # NIL THEN
                                    FileViewerOps.ShowLog[fileName: errorName, destroyIt: TRUE];
                                IF sourceName # NIL THEN
                                    FileViewerOps.RemoveErrorLog[sourceName];
                                }
                        };
                    EXITS
                        noSource => {
                            log.Put[[rope[" -- source not found\n"]], [time[BasicTime.Now[]]]];
                            IO.PutRope[out, " -- source not found\n"];
                            errors Ź TRUE;
                            parms.nErrors Ź 1;
                            args Ź NIL;
                            };
                        badSemantics => {
                            objectName Ź NIL;
                            errors Ź TRUE;
                            IO.PutRope[log, " -- Illegal command"];
                            args Ź NIL;
                            };
                    };

                <<Here after completion of subcommand>>
                sourceName Ź rootName Ź objectName Ź errorName Ź NIL;
                parms.objectName Ź NIL;
                results Ź NIL;
                IO.PutChar[log, '\n];
                IF userAbort THEN {IO.PutRope[log, "\n... command aborted\n"]; GO TO punt};
                IF (errors OR warnings) AND localPause THEN GO TO punt;

                IF NOT errors THEN
                    SELECT result FROM
                        NIL => IF parms.interface THEN result Ź $Definition ELSE result Ź $Implementation;
                        $Definition => IF NOT parms.interface THEN result Ź $Mixed;
                        $Implementation => IF parms.interface THEN result Ź $Mixed;
                        ENDCASE;

                REPEAT
                    badSyntax => {IO.PutRope[log, "\n-- Illegal syntax"]; errors Ź TRUE};
                    punt => {
                        <<was Finalize[]; , but this is done by new UNWIND catch phrase>>
                        errors Ź TRUE;
                        [] Ź WriteResults[out, moduleStartTime ! IO.Error => CONTINUE];
                        IO.PutChar[log, '\n];
                        };
                ENDLOOP;
            <<Here after completion of all subcommands>>
            WriteClosing[out, compilerStartTime, moduleCount];

            SELECT TRUE FROM 
                userAbort => {result Ź $Failure; msg Ź "A"};
                errors => {result Ź $Failure; msg Ź "F"};
                warnings => {
                    SELECT result FROM
                        $Definition => msg Ź "W (Interface)";
                        $Implementation => msg Ź "W (Implementation)";
                        ENDCASE => msg Ź "W";
                    result Ź $Failure};
                ENDCASE =>  {msg Ź "S"};
            END;  -- end catch phrase to release the resource and reset the process priority
        Cleanup[FALSE];
        EXITS
            earlyFailure => result Ź $Failure;
                <<Only use this exit before compiler lock has been acquired,
                or after doing a Cleanup to release the compiler.>>
        };

    <<compiler sequencing>>

        WriteResults: PROC [out: STREAM, startTime: BasicTime.GMT] RETURNS [outcome: Outcome] = {
            elapsed: INT;
            IO.Put[log, [rope[sourceName]], [rope[" -- "]]];
            elapsed Ź BasicTime.Period[from: startTime, to: BasicTime.Now[]];
            IF parms.nErrors # 0
                THEN {
                    IO.PutF1[log, "aborted, %g errors", [integer[parms.nErrors]]];
                    IF parms.nWarnings # 0 THEN
                        IO.PutF1[log, " and %g warnings", [integer[parms.nWarnings]]];
                    IF ~useLog THEN IO.PutF1[log, " on %g", [rope[errorName]]];
                    IO.PutF1[log, ", seconds: %g", [integer[elapsed]]];
                    }
                ELSE {
                    log.PutF["source tokens: %g, seconds: %g",
                    [integer[parms.sourceTokens]], [integer[elapsed]] ];
                    IF parms.nWarnings # 0 THEN {
                        IO.PutF1[log, "\n warnings", [integer[parms.nWarnings]] ];
                        IF log # NIL AND ~useLog THEN IO.PutF1[log, " on %g", [rope[errorName]] ];
                        };
                    };
            <<write to the Commander output file>>
            IO.PutRope[out, " "];
            SELECT parms.nErrors FROM
                0 => IO.PutRope[out, "no errors"];
                1 => IO.PutRope[out, "1 error"];
                ENDCASE => IO.PutF1[out, "%g errors", [integer[parms.nErrors]]];
            SELECT parms.nWarnings FROM
                0 => NULL;
                1 => IO.PutRope[out, ", 1 warning"];
                ENDCASE => IO.PutF1[out, ", %g warnings", [integer[parms.nWarnings]]];
            IO.PutRope[out, ".\n"];
            RETURN [SELECT TRUE FROM
                parms.nErrors # 0 => $errors,
                parms.nWarnings # 0 => $warnings,
                ENDCASE => $ok]
            };

        WriteHerald: PROC [s: STREAM, id: ROPE] = {
            CompilerOps.AppendHerald[s];
            IO.PutRope[s, " (PortaCedar Version)\n"];
            IF id # NIL THEN IO.PutF1[s, "%g --", [rope[id]] ];
            IO.PutF1[s, "%g\n", [time[BasicTime.Now[]]] ];
            };

        WriteClosing: PROC [out: STREAM, startTime: BasicTime.GMT, moduleCount: CARDINAL] = {
            elapsed: INT;
            <<IO.PutRope[out, "End of compilation\n"]; -- DKW>>
            elapsed Ź BasicTime.Period[from: startTime, to: BasicTime.Now[]];
            IF moduleCount > 1 THEN 
                IO.Put[log, [rope["\nTotal elapsed seconds: "]], [integer[elapsed]]];
            IO.PutChar[log, '\n];
            };

        <<special output stream control>>

        outputDate: BasicTime.GMT Ź BasicTime.Now[];
        GetStream: PROC [id: CompilerOps.StreamId] RETURNS [s: STREAM] = {
            error: ROPE Ź NIL;
            SELECT id FROM
                source => RETURN [sourceStream];
                object => {
                    IF objectStream = NIL THEN {
                        WHILE BasicTime.Period[from: outputDate, to: BasicTime.Now[]] = 0 DO
                            <<Wait for the time to change enough to have different output dates>>
                            Process.PauseMsec[100];
                            ENDLOOP;
                        [stream: objectStream, err: error, time: outputDate]
                        Ź MimSysOps.Open[objectName, $write];
                        IF error # NIL THEN ERROR InterfaceError[error];
                        };
                    RETURN [objectStream];
                    };
                log => {
                    IF errorStream = NIL THEN {
                        IF useLog
                            THEN errorStream Ź log
                            ELSE {
                                errorName Ź MimCommandUtil.SetExtension[rootName, "errlog"];
                                [stream: errorStream, err: error] Ź MimSysOps.Open[errorName, $writeLog];
                                IF error # NIL THEN ERROR InterfaceError[error];
                                WriteHerald[errorStream, errorName];
                                IO.PutChar[errorStream, '\n];
                                };
                        };
                    RETURN [errorStream];
                    };
                ENDCASE => ERROR;
            };

        CloseStream: PROC [id: CompilerOps.StreamId] = {
            SELECT id FROM
                source =>
                    IF sourceStream # NIL THEN {
                        [] Ź MimSysOps.Close[sourceStream];
                        sourceStream Ź NIL;
                        };
                object =>
                    IF objectStream # NIL THEN {
                        [] Ź MimSysOps.Close[objectStream, parms.nErrors # 0];
                        objectStream Ź NIL;
                        };
                log =>
                    IF errorStream # NIL THEN {
                        [] Ź MimSysOps.Close[errorStream];
                        errorStream Ź NIL;
                        };
                ENDCASE => ERROR;
            };

    <<START HERE>>
        mimDoc: ROPE = "Mimosa compiler (Cedar to C)";
        Commander.Register["Mimosa", Compile, mimDoc, $Mimosa];
        Commander.Register["MimosaServer", Compile, mimDoc, $MimosaServer];
        Commander.Register["MimosaDebug", Compile, mimDoc, $MimosaDebug];
        Commander.Register["MimosaOnly", Compile, mimDoc, $MimosaOnly];
        Commander.Register["MimosaOnlyDebug", Compile, mimDoc, $MimosaOnlyDebug];

    }.