main() called twice. I have no idea...

[JensMunkHansen]

I am using Node 20.18.0_64 bit and emsdk 3.1.73

My linker arguments are the following

-sASSERTIONS=1;-sERROR_ON_UNDEFINED_SYMBOLS=1;-sDISABLE_EXCEPTION_CATCHING=0;-sALLOW_MEMORY_GROWTH=1;-sNO_EXIT_RUNTIME=1;-sENVIRONMENT=node;-sEXPORTED_RUNTIME_METHODS=['ccall','cwrap','stringToNewUTF8','stringToUTF8','callMain'];-sEXPORTED_FUNCTIONS=['_malloc','_free','_main'];-O0;-g3

I had issues forwarding STDIN from JavaScript to C++, so I am reading STDIN using EM_JS.

Simple program for reading command-line parameters

#include <emscripten.h>
#include <iostream>
#include <string>

// Define a reusable JavaScript function to read input
EM_JS(const char*, getInputFromStdin, (), {
  const readlineSync = require('readline-sync');
  const input = readlineSync.question("Enter input (or type 'exit' to quit): ");
  if (input === null || input === undefined)
  {
    return 0; // Return null pointer for invalid input
  }
  return Module.stringToNewUTF8(input);
});

int main()
{
  std::cout << "Interactive mode. Type something:\n";

  while (true)
  {
    std::cout << "> ";
    const char* jsInput = getInputFromStdin();
    if (jsInput == nullptr)
    {
      std::cout << "No input received. Exiting...\n";
      break;
    }

    std::string input(jsInput);
    bool doExit = false;

    if (input == "exit")
    {
      std::cout << "Exiting...\n";
      doExit = true;
    }

    std::cout << "You entered: " << input << "\n";

    EM_ASM({ Module._free($0); }, jsInput);

    if (doExit)
    {
      return 0;
      break;
    }
  }

  return 0;
}

Super funny. If called from this script

const Module = require('./example.cjs'); // Load the Emscripten module

Module.onRuntimeInitialized = async function () {
    console.log("Module initialized.");
    // Wrap main logic in an async function
    const runMain = async () => {
        console.log("Starting main...");
        try {
            // Call the WebAssembly main function
            await Module.callMain([]);
        } catch (err) {
            console.error("Error in main:", err);
        }
        console.log("Main finished.");
    };

    // Call the async wrapper
    await runMain();

    console.log("Exiting...");
};

I have to enter exit twice for the program to exit. The runMain is called once, but the C++ main is called twice. A static variable in C++ will fix the second call.

If called directly, i.e. node example.cjs, it works as anticipated.

Thanks in advance.

[sbc100]

By default emscripten will run main automatically, so you don't need to export callMain or call it.

If you want to disable this you can use the (seeminly badly names) INVOKE_RUN setting: https://emscripten.org/docs/tools_reference/settings_reference.html#invoke-run

[JensMunkHansen]

It actually complains if I don't export it.

Module initialized.
Starting main...
Aborted('callMain' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the Emscripten FAQ))

[sbc100]

You also need to remove the actual usage of it.. since its automatic by default. You can completely remove your runMain function.

[JensMunkHansen]

I know that I can call it directly. I had issues forwarding stdin for reading it from c++, some I/O error 29, both with fgets and std::cin in C++. My work around was to load it and call it and access stdin using a JavaScript from C++.

[sbc100]

If you want to call main directly then you should build with -sINVOKE_RUN=0 so that its not also called automatically. which is the default.

[JensMunkHansen]

Thanks. This solved it. When I figure out how to perfectly forward stdin for reading in C++, I can get rid of these ugly hacks. It get a litle ugly, since now it is not directly called if just executing node example.cjs. I will look into forwarding, this is more neat

[sbc100]

BTW you can use the short form for EXPORTED_RUNTIME_METHODS and EXPORTED_FUNCTIONS these days. e.g. -sEXPORTED_RUNTIME_METHODS=ccall,cwrap,stringToNewUTF8

[JensMunkHansen]

That is much neater. To make it work, I added an atomic to ensure main was not called twice. Work without this trick if the output is called directly, but from with the module above, the module calls it once, but the underlying c++ main is called twice.