/*
 * PCRCmdGlueImpl.c
 *
 * Exports to PCRCmdGlue.mesa
 *
 * Demers, July 26, 1990 9:05:26 am PDT
 * Willie Sue Orr, September 3, 1993 2:55:22 pm PDT
 */

#include <xr/BasicTypes.h>
#include <xr/ThreadsMsg.h>
#include <xr/Threads.h>
#include <xr/CommandLine.h>
#include <xr/CommandLoop.h>


/*
 * Stuff for executing PCR commands from PCedar commander
 */

/* the following is the same type as clce_msgSink */

typedef XR_MesaProc PCRCmdGlue_PutProc
        /* (char *msg, int nBytes, XR_MesaProc self) */;

char *
PCRCmdGlue_Execute(cmd, putProc)
    char *cmd;
    PCRCmdGlue_PutProc putProc;
{
    char *cmdCopy;
    XR_CLHandle clh;
    struct XR_CLCallEnvRep clce;
    int verbosity = XR_VERBOSITY_NORMAL;
    int ans;

    if( putProc == NIL ) putProc = XR_stdOutCLMsgSink;
    cmdCopy = (char *) XR_malloc(1+strlen(cmd));
    (void) strcpy(cmdCopy, cmd);
    clh = XR_CLCreateHandleFromString(cmdCopy);
    (void) memset( &clce, 0, (sizeof clce) );
    clce.clce_h = clh;
    clce.clce_pH = XR_globalCLProcsHandle;
    clce.clce_msgSink = putProc;
    clce.clce_msgVerbosityP = &verbosity;
    if( ans = XR_setjmp(&clce.clce_jmpBuf) != 0 ) {
        char *errMsg = (char *) XR_malloc(64);
        XR_SPrintF(errMsg, "Command failed (unwound %d)\n", ans);
        return errMsg;
    }
    ans = XR_CLApply( &clce, NIL, NIL );
    if( ans < 0 ) {
        char *errMsg = (char *) XR_malloc(64);
        XR_SPrintF(errMsg, "Command failed (%d)\n", ans);
        return errMsg;
    }
    return NIL;  
}

/*
 * Stuff for registering PCedar Commander commands with PCR
 */
 
typedef XR_MesaProc
PCRCmdGlue_CommandLineProc /* (
    char * cmdline,
    PCRCmdGlue_PutProc putProc, 
    XR_Pointer data,
    XR_MesaProc self)
    RETURNS XR_Pointer result
*/;

typedef struct DataForProcRegisteredWithPCRRep {
    XR_MesaProc dfp_proc;
    XR_Pointer dfp_data;
    char *dfp_replacementName;
} *DataForProcRegisteredWithPCR;

/* FOLLOWING SHOULD BE EXPORTED IN COMMANDLINE.H */

static char *
ReconstructCmdLine(head, argc, argv)
    char *head;
    int argc;
    char **argv;
{
    int i, len, totalLen;
    char *result;

    if( head == NIL ) head = "";

    totalLen = 1+strlen(head);
    for( i = 0; i < argc; i++ ) totalLen += (1+strlen(argv[i]));
    if( totalLen == 0 ) return ("");
    result = (char *)XR_malloc(totalLen);

    totalLen = 0;
    i = 0;
    for(;;) {
        len = strlen(argv[i]);
        (void)bcopy(argv[i], &(result[totalLen]), len);
        totalLen += len;
        if( (++i) >= argc ) break;
        result[totalLen] = ' ';
        totalLen += 1;
    }
    result[totalLen] = 0;
    return result;
}


static
XR_CLPROC(PCedarCmdCLProc)
{
    XR_MesaProc innerProc, msgSink;
    DataForProcRegisteredWithPCR dfp;
    char *cmdLine;
    XR_Pointer result;

    if( argc <= 0 ) return (-1);
    dfp = (DataForProcRegisteredWithPCR)(self->mp_x);
    cmdLine = ReconstructCmdLine(dfp->dfp_replacementName, argc-1, argv+1);
    innerProc = dfp->dfp_proc;
    result = (*(innerProc->mp_proc))(
            cmdLine,
            clce->clce_msgSink,
            dfp->dfp_data,
            innerProc
    );
    return 1; /* success */
}


int
PCRCmdGlue_RegisterWithPCRCommandLoop(proc, data,
        pcrName, replacementName, helpMsg)
    XR_MesaProc proc; /* (cmdline, data, self) -> out */
    XR_Pointer data;
    char *pcrName;
    char *replacementName;
    char *helpMsg;
{
    DataForProcRegisteredWithPCR dfp;
    XR_MesaProc realRegisteredProc;

    dfp = (DataForProcRegisteredWithPCR) XR_malloc(sizeof *dfp);
    dfp->dfp_proc = proc;
    dfp->dfp_data = data;
    dfp->dfp_replacementName = (char *) XR_malloc(1+strlen(replacementName));
    strcpy(dfp->dfp_replacementName, replacementName);
    realRegisteredProc = XR_MakeMesaProc(PCedarCmdCLProc, dfp);
    (void) XR_CLRegisterProc(
        XR_globalCLProcsHandle,
        pcrName, FALSE,
        helpMsg,
        realRegisteredProc,
        TRUE
    );
    return 0;
}