用输出参数包装一个 C++ 函数，以便在 javascript/node 中使用

Question

Given a function with the definition int test(char* input, char** output);. How do I configure SWIG interface so that I can get the output value?

This is how I've called it from js:

var input = 'input1';
var output = '';
var result = mylib.test(input, output);
console.log(output);

I understand this does not work because string is immutable in javascript, plus the interface created in SWIG does not write back to the output parameter.

Here is the C++ code:

int test(char* input, char** output) {
  *output = input;
  return 0;
}

Answer 1

The easiest way to map the C++ semantics you've shown onto JavaScript is to make SWIG make the function behave as you would if you'd written it in real JavaScript instead of C++. That is to say we're going to make your function behave like the following JavaScript pseudo code:

function test(input) {
    if (error) {
        throw ....
    }
    return input;
}

To do that with SWIG we need to write a few typemaps. (In some cases those typemaps already exist for us as part of the standard SWIG library, but for char ** there's no such typemap because the semantics are a little less obvious).

I made your code work with the following SWIG interface, annotated below:

%module test

// #1
%typemap(in,numinputs=0) char **output (char *tmp) {
    $1 = &tmp; // #2
}

// #3
%typemap(argout,fragment="SWIG_FromCharPtr") char **output {
    $result = SWIG_FromCharPtr(tmp$argnum);
    // Without more effort the following would be an illegal cast I think:
    //SWIG_AppendOutput($result, tmp$argnum);
}

// #4
%typemap(out) int test %{
    if ($1) {
        SWIG_exception_fail(SWIG_ERROR, "Well, that was unexpected");
    }
%}

%inline %{
int test(char *input, char **output) {
    *output = input;
    return 0;
}
%}

Essentially we've done 4 things here:

1. A typemap that sets up the **output argument, without taking an input from JavaScript at all.numinputs=0 is what suppresses the need to receive an argument from JavaScript callees.
2. Instead we're using a local variable to be the output purely inside the wrapper
3. After the function has been called use the value in our local variable as the function return to JavaScript. We need to refer to it as tmp$argnum because SWIG has internally numbered the local variable to avoid clashes if a typemap gets matched multiple times on the in typemap, but it doesn't do that automatically on argout. There are some standard macros that SWIG supplies for appending things to return multiple items, but they don't work out the box here because it ends up doing an illegal cast and I don't much like using those semantics anyway. The fragment here makes sure we've got some pre-written support for string outputs available in our generated code.
4. Do something with the original return value, in this instance throw an exception if we get non-zero (ie error) from the C++. There are other ways of handling this, but this one is the simplest way to no just silently ignore errors.

I'd almost never used SWIG's JavaScript support before, so once I'd worked my way through the basic documentation for building a module this was sufficient for me to run the following test:

var test = require("./build/Release/test");

console.log(test.test("blah blah"));

Which worked as expected. I also did a quick test changing the return value to force an exception and that behaved as intended also.

Disclaimer: Doing this has pretty much doubled my exposure to node/V8, so check my workings carefully.