
    <<CommandToolProceduresImpl.Mesa>>
        <<Spreitzer, December 18, 1985 2:35:11 pm PST>>

    DIRECTORY AMBridge, AMTypes, BBUrpEval, Commander, CommandTool, CommandToolProcedures, EvalQuote, InterpreterOps, 
    InterpreterPrivate, IO, List, PPTreeOps, ProcessProps, Rope, SymTab;

    CommandToolProceduresImpl: CEDAR PROGRAM
        IMPORTS AMBridge, AMTypes, BBUrpEval, CommandTool, EvalQuote, InterpreterOps, InterpreterPrivate, IO, List, PPTreeOps, ProcessProps
        EXPORTS CommandToolProcedures =

    BEGIN

    ROPE: TYPE = Rope.ROPE;
    Type: TYPE = AMTypes.Type;
    TV: TYPE = AMTypes.TV;
    Tree: TYPE = InterpreterOps.Tree;
    EvalHead: TYPE = InterpreterOps.EvalHead;
    nullType: Type = AMTypes.nullType;
    CmdHandle: TYPE = Commander.Handle;

    ROPEType: Type _ CODE[ROPE];
    empty: TV _ AMTypes.GetEmptyTV[];

    EvalCmd: PROC [head: EvalHead, tree: Tree, target: Type _ nullType, data: REF _ NIL] RETURNS [return: TV] -- 
    EvalQuote.EvalQuoteProc -- =
        BEGIN
        args: Tree _ PPTreeOps.NthSon[tree, 2];
        result: REF ANY;
        first: BOOL _ TRUE;
        PerArg: PROC [t: Tree] = {
            IF first THEN {
                val: TV _ InterpreterOps.Eval[tree: t, head: head, target: ROPEType];
                cmdLine: ROPE _ NIL;
                first _ FALSE;
                DO
                    type: Type _ AMTypes.TVType[val];
                    SELECT AMTypes.UnderClass[type] FROM
                        rope => {cmdLine _ AMTypes.TVToName[val]; EXIT};
                        ENDCASE => val _ BBUrpEval.UrpWrongType[head: head, parent: t, value: val, target: ROPEType, msg: "should have been a ROPE"];
                    ENDLOOP;
                result _ CmdWork[cmdLine, head];
                };
            };
        return _ empty;
        PPTreeOps.ScanList[args, PerArg];
        TRUSTED {return _ AMBridge.TVForReferent[NEW [REF ANY _ result], readOnly]};
        END;

    Cmd: PUBLIC PROC [command: ROPE] RETURNS [result: REF ANY] =
        {result _ CmdWork[command]};

    CmdWork: PROC [command: ROPE, head: EvalHead _ NIL] RETURNS [result: REF ANY] = {
        ch: CmdHandle _ GetHandle[];
        oldSymtab: SymTab.Ref _ NARROW[List.Assoc[key: $SymTab, aList: ch.propertyList]];
        RestoreSymTab: PROC =
            {ch.propertyList _ List.PutAssoc[key: $SymTab, val: oldSymtab, aList: ch.propertyList]};
        WithHead: PROC = {
            ch.propertyList _ List.PutAssoc[key: $SymTab, val: head.specials, aList: ch.propertyList];
            {ENABLE UNWIND => RestoreSymTab[];
            result _ CommandTool.DoCommand[command, ch];
            };
            RestoreSymTab[];
            };
        IF head = NIL THEN head _ NARROW[List.Assoc[$EvalHead, ProcessProps.GetPropList[]]];
        ProcessProps.AddPropList[
            propList: List.PutAssoc[key: $EvalHead, val: head, aList: NIL],
            inner: WithHead];
        };

    Stdin: PUBLIC PROC RETURNS [s: IO.STREAM] =
        BEGIN
        ch: CmdHandle _ GetHandle[];
        s _ ch.in;
        END;

    Stdout: PUBLIC PROC RETURNS [s: IO.STREAM] =
        BEGIN
        ch: CmdHandle _ GetHandle[];
        s _ ch.out;
        END;

    Stderr: PUBLIC PROC RETURNS [s: IO.STREAM] =
        BEGIN
        ch: CmdHandle _ GetHandle[];
        s _ ch.err;
        END;

    PrintRope: PROC [rope: ROPE] RETURNS [ROPE] =
        BEGIN
    Stdout[].PutRope[rope];
    RETURN [rope];
        END;

    GetHandle: PUBLIC PROC RETURNS [ch: CmdHandle] = {
        ch _ NARROW[List.Assoc[$CommanderHandle, ProcessProps.GetPropList[]]];
        };

    EvalQuote.Register["&cmd", EvalCmd, NIL];
    TRUSTED {
        InterpreterOps.RegisterTV[
            name: "&stdin",
            tv: AMBridge.TVForReferent[NEW [PROC RETURNS [IO.STREAM] _ Stdin], readOnly],
            symTab: InterpreterPrivate.GetGlobalSymTab[]];
        InterpreterOps.RegisterTV[
            name: "&stdout",
            tv: AMBridge.TVForReferent[NEW [PROC RETURNS [IO.STREAM] _ Stdout], readOnly],
            symTab: InterpreterPrivate.GetGlobalSymTab[]];
        InterpreterOps.RegisterTV[
            name: "&stderr",
            tv: AMBridge.TVForReferent[NEW [PROC RETURNS [IO.STREAM] _ Stderr], readOnly],
            symTab: InterpreterPrivate.GetGlobalSymTab[]];
        InterpreterOps.RegisterTV[
            name: "&printRope",
            tv: AMBridge.TVForReferent[NEW [PROC [ROPE] RETURNS [ROPE] _ PrintRope], readOnly],
            symTab: InterpreterPrivate.GetGlobalSymTab[]];
        InterpreterOps.RegisterTV[
            name: "&cmd",
            tv: AMBridge.TVForReferent[NEW [PROC [command: ROPE] RETURNS [result: REF ANY] _ Cmd], readOnly],
            symTab: InterpreterPrivate.GetGlobalSymTab[]];
        };

    END.