I have an imbedded Tcl interpreter and want to redirect its stderr and stdout to a console widget in the application.

Using a chan push command for stderr seems to work (not much testing yet), like explained here:

TCL: Redirect output of proc to a file

I could have a file with the required tcl namespace definition, etc, and do a Tcl_Eval to source that script after creating an interp with Tcl_CreateInterp.

Can I do the same thing using Tcl C library calls instead of running the Tcl commands via a Tcl_Eval?

CodePudding user response：

To implement a channel transformation in C, you first have to define a Tcl_ChannelType structure. Such a structure specifies a name for the transformation and pointers to functions for the different operations that may be done on a channel. Next, you implement the functions that perform those operations. The most important ones are inputProc and outputProc. You also have to implement a watchProc. The pointers for other operations can be set to NULL, if you don't need them.

For your example it may look something like:

static const Tcl_ChannelType colorChannelType = {
    "color",
    TCL_CHANNEL_VERSION_5,
    NULL,
    ColorTransformInput,
    ColorTransformOutput,
    NULL,                       /* seekProc */
    NULL,                       /* setOptionProc */
    NULL,                       /* getOptionProc */
    ColorTransformWatch,
    NULL,                       /* getHandleProc */
    NULL,                       /* close2Proc */
    NULL,                       /* blockModeProc */
    NULL,                       /* flushProc */
    NULL,                       /* handlerProc */
    NULL,                       /* wideSeekProc */
    NULL,
    NULL
};

Then, when you want to push the transformation onto a channel:

chan = Tcl_StackChannel(interp, &colorChannelType, clientData,
        Tcl_GetChannelMode(channel), channel);

For a complete example from the Tcl sources, see tclZlib.c

CodePudding user response：

Not really an answer to my question, but maybe it will help someone to see what works by using a Tcl_Eval to show the tcl code that does the redirection.

proc redir_stdout {whichChan args} {
    switch -- [lindex $args 0] {
        initialize {
            return {initialize write finalize}
        }
        write {
            ::HT_puts $whichChan [lindex $args 2]
        }
        finalize {
        }
    }
}

chan push stderr [list redir_stdout 1]
chan push stdout [list redir_stdout 2]

Both the chan push commands use the same proc, but pass an different identifier (1 or 2) to indicate whether stdout or stderr was the originator of the output.

HT_puts is an extension provided by the C code:

 Tcl_CreateObjCommand(interp,"HT_puts",putsCmd,(ClientData) NULL,NULL);


int TclInterp::putsCmd(ClientData ,Tcl_Interp *,int objcnt,Tcl_Obj * CONST *objv)
{
    if (objcnt != 3)
        return TCL_ERROR;
    int length;
    int whichChan;
    Tcl_GetIntFromObj(interp,objv[1],&whichChan);
    //qDebug() << "Channel is $whichChan";

    QString out =Tcl_GetStringFromObj(objv[2],&length);
    QColor textColor;
    if (whichChan==1)
        textColor = QColor(Qt::red);
    else
        textColor = QColor(Qt::white);

    console->putData(out.toUtf8(),textColor);
    //qDebug() << out;
    return TCL_OK;
}

Text forwarded from stderr gets colored red and text from stdout gets colored white.

And, as I mentioned above, each subsequent command that gets executed via Tcl_Eval needs to have the Tcl_Eval return value processed something like this:

if (rtn != TCL_OK)
    {
        QString output = Tcl_GetVar(interp, "errorInfo", TCL_GLOBAL_ONLY);
        console->putData(output.toUtf8(),QColor(Qt::red));
        //qDebug("Failed Tcl_Eval: %d \n%s\n", rtn,
   }

To get what's normally printed to stderr by tclsh on a TCL_ERROR into the console (instead of the app's stderr).

I was planning to do the equivalent in C to eliminate the need to run Tcl code in the interpreter for the redirect. But, really there's no need for that.

The Tcl_Eval that does the redirection is done right after doing the Tcl_CreateInterp. Any subsequent Tcl_Evals using that interp will have stdout and stderr redirected to my application's console.

Besides, I'm having trouble understanding how to use Tcl_StackChannel and can't find an example I can follow.

Honestly, can't say that I completely understand the Tcl implementation. I made some assumptions on what gets passed to the proc used in the "chan push" command based on the referenced thread.

It looks like the proc is called with the list specified in the chan push command AND an args list. The first element of the args list is a name like "write" or "initialize". The third element looks like the string to be printed.

Still trying to find a definition of what's passed without having to dig into something like namespace ensemble.

So, it's likely that this Tcl code isn't the best implementation but it's working so far (with limited testing).