C / C++ / MFC

Fedrer wrote:

Do I need to register tlb file like a com dll?

typedef union {
	void* void_ptr;
	struct mySmallStruct1_s* SmallStruct1_ptr;
	struct mySmallStruct2_s* SmallStruct2_ptr;
	struct mySmallStruct3_s* SmallStruct3_ptr;
} smallstruct_ptr;

struct mySmallStruct1_s {
	smallstruct_ptr ptrToNextElement;
	int myArray[1];
};

struct mySmallStruct2_s {
	smallstruct_ptr ptrToNextElement;
	int myArray[2];
};

struct mySmallStruct3_s {
	smallstruct_ptr ptrToNextElement;
	int myArray[3];
};

struct myBigStruct_s {
	struct mySmallStruct1_s mySmallStruct1;
	struct mySmallStruct2_s mySmallStruct2;
	struct mySmallStruct3_s mySmallStruct3;
};


struct myBigStruct_s myBigStruct = {
	{ .ptrToNextElement.SmallStruct2_ptr = &myBigStruct.mySmallStruct2, .myArray[0] = 0 },
	{ .ptrToNextElement.SmallStruct3_ptr = &myBigStruct.mySmallStruct3,  .myArray[0] = 0, .myArray[1] = 0 },
	{ .ptrToNextElement.void_ptr = 0,.myArray[0] = 0,.myArray[1] = 0, .myArray[2] = 0 }
};


struct myBigStruct_s myBigStruct1 = {
	{ .ptrToNextElement.SmallStruct2_ptr = &myBigStruct1.mySmallStruct2,.myArray[0] = 1 },
	{ .ptrToNextElement.SmallStruct3_ptr = &myBigStruct1.mySmallStruct3,.myArray[0] = 1,.myArray[1] = 2 },
	{ .ptrToNextElement.void_ptr = 0, .myArray[0] = 1,.myArray[1] = 2,.myArray[2] = 3 }
};

AllocConsole();  //Allocate a console
freopen("CONIN$", "r", stdin); // Redirect standard in
freopen("CONOUT$", "w", stdout);  // Redirect standard out
freopen("CONOUT$", "w", stderr);  // Redirect standard error
setbuf(stdout, NULL);  // Clear the buffer from standard out

#include <stdio.h>
#include <iostream>
#include <windows.h>
#include <tchar.h>
#include <thread>

using namespace std;

FILE* OutStream;
FILE* InStream;
FILE* ErrStream;

/*---------------------------------------------------------------------------
Application handler.
---------------------------------------------------------------------------*/
LRESULT CALLBACK GUIDemoHandler (HWND Wnd, UINT Msg, WPARAM wParam, LPARAM lParam) {
	switch (Msg) {
		case WM_CREATE:
			AllocConsole();  //Allocate a console
			freopen_s(&InStream, "CONIN$", "r", stdin); // Redirect standard in
			freopen_s(&OutStream, "CONOUT$", "w", stdout);  // Redirect standard out
			freopen_s(&ErrStream, "CONOUT$", "w", stderr);  // Redirect standard error
			break;
		case WM_DESTROY:											// WM_DESTROY MESSAGE
			FreeConsole();
			PostQuitMessage(0);										// Post quit message
			break;

		default: return DefWindowProc(Wnd, Msg, wParam, lParam);	// Default handler
	};// end switch case
	return 0;
}




int SystemCapture(
	TCHAR*         CmdLine,    //Command Line
	TCHAR*         CmdRunDir,  //set to '.' for current directory
	uint32_t&      RetCode)    //Return Exit Code
{
	int                  Success;
	SECURITY_ATTRIBUTES  security_attributes;
	HANDLE               stdout_rd = INVALID_HANDLE_VALUE;
	HANDLE               stdout_wr = INVALID_HANDLE_VALUE;
	PROCESS_INFORMATION  process_info = { 0 };
	STARTUPINFO          startup_info = { 0 };
	thread               stdout_thread;

	security_attributes.nLength = sizeof(SECURITY_ATTRIBUTES);
	security_attributes.bInheritHandle = TRUE;
	security_attributes.lpSecurityDescriptor = nullptr;

	if (!CreatePipe(&stdout_rd, &stdout_wr, &security_attributes, 0) ||
		!SetHandleInformation(stdout_rd, HANDLE_FLAG_INHERIT, 0)) {
		return -1;
	}

	startup_info.cb = sizeof(STARTUPINFO);
	startup_info.hStdInput = 0;
	startup_info.hStdOutput = stdout_wr;
	startup_info.hStdError = 0;

	if (stdout_rd)
		startup_info.dwFlags |= STARTF_USESTDHANDLES;

	Success = CreateProcess(
		nullptr,
		CmdLine,
		nullptr,
		nullptr,
		TRUE,
		0,
		nullptr,
		CmdRunDir,
		&startup_info,
		&process_info
	);
	CloseHandle(stdout_wr);

	if (!Success) {
		CloseHandle(process_info.hProcess);
		CloseHandle(process_info.hThread);
		CloseHandle(stdout_rd);
		return -4;
	}
	else {
		CloseHandle(process_info.hThread);
	}

	if (stdout_rd) {

		stdout_thread = thread([&]() {
			DWORD  n;	
			for (;;) {
				const size_t bufsize = 256;
				char buffer[bufsize];
				n = 0;
				int Success = ReadFile(
					stdout_rd,
					buffer,
					(DWORD)bufsize-1,
					&n,
					nullptr
				);
				if (!Success || n == 0)
					break;
				buffer[n] = '\0';
				printf(&buffer[0]);
			}
		});
	}


	WaitForSingleObject(process_info.hProcess, INFINITE);
	if (!GetExitCodeProcess(process_info.hProcess, (DWORD*)&RetCode))
		RetCode = -1;

	CloseHandle(process_info.hProcess);

	if (stdout_thread.joinable())
		stdout_thread.join();

	CloseHandle(stdout_rd);

	return 0;
}



const TCHAR* ClassName = _T("GUI_CONSOLE_APP");

/* ------------------------------------------------------------------------
   The application entry point
   -----------------------------------------------------------------------*/
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow){
	MSG Msg;
	HWND Wnd;

	WNDCLASSEX WndClass = { 0 };
	WndClass.cbSize = sizeof(WNDCLASSEX);							// Size of this record
	WndClass.style = CS_OWNDC;										// Class styles
	WndClass.lpfnWndProc = &GUIDemoHandler;							// Handler for this class
	WndClass.cbClsExtra = 0;										// No extra class data
	WndClass.cbWndExtra = 0;										// No extra window data
	WndClass.hInstance = GetModuleHandle(NULL);						// This instance
	WndClass.hIcon = LoadIcon(0, IDI_APPLICATION);					// Set icon
	WndClass.hCursor = LoadCursor(0, IDC_ARROW);					// Set cursor
	WndClass.hbrBackground = (HBRUSH) GetStockObject(WHITE_BRUSH);	// Set background brush
	WndClass.lpszMenuName = NULL;									// No menu yet
	WndClass.lpszClassName = ClassName;								// Set class name
	RegisterClassEx(&WndClass);										// Register the class				
   	Wnd = CreateWindowEx(0, ClassName, _T("GUI Console Demo Program"), 
		WS_VISIBLE | WS_OVERLAPPEDWINDOW, 
		50, 50, 500, 400,
		0, 0, 0, NULL);												// Create a window

	_tprintf(_T("This will go to the console\r\n"));
	std::cout << "Second line to console\r\n" << std::endl;

	std::cout << "Execute IPConfig and display result:" << std::endl;
	int            rc;
	uint32_t       RetCode;
	TCHAR szCmdLine[256] = _T("C:\\Windows\\System32\\ipconfig.exe");
	TCHAR szCmdDir[256] = _T(".");

	rc = SystemCapture(
		szCmdLine,								 //Command Line
		szCmdDir,                                //CmdRunDir
		RetCode                                  //Return Exit Code
	);



	std::cout << "\r\nExecute dir and display result:" << std::endl;
	TCHAR szCmdLine1[256] = _T("cmd.exe /C dir");
	rc = SystemCapture(
		szCmdLine1,								 //Command Line
		szCmdDir,                                //CmdRunDir
		RetCode                                  //Return Exit Code
	);


 	while (GetMessage(&Msg, 0, 0, 0)){								// Get messages
		TranslateMessage(&Msg);										// Translate each message
		DispatchMessage(&Msg);										// Dispatch each message
	};
	return (0);
}

#include <stdio.h>
#include <iostream>
#include <windows.h>
#include <tchar.h>

FILE* OutStream;
FILE* InStream;
FILE* ErrStream;

struct execData {
	TCHAR* CmdLine;
	TCHAR* CmdRunDir;
	PROCESS_INFORMATION  process_info;
	STARTUPINFO  startup_info;
};

struct execData		 data = { 0 };

/*---------------------------------------------------------------------------
Application handler.
---------------------------------------------------------------------------*/
LRESULT CALLBACK GUIDemoHandler (HWND Wnd, UINT Msg, WPARAM wParam, LPARAM lParam) {
	switch (Msg) {
		case WM_CREATE:
			AllocConsole();  //Allocate a console
			freopen_s(&InStream, "CONIN$", "r", stdin); // Redirect standard in
			freopen_s(&OutStream, "CONOUT$", "w", stdout);  // Redirect standard out
			freopen_s(&ErrStream, "CONOUT$", "w", stderr);  // Redirect standard error
			break;
		case WM_DESTROY:											// WM_DESTROY MESSAGE
			if (data.process_info.hProcess) TerminateProcess(data.process_info.hProcess, 0);
			FreeConsole();
			PostQuitMessage(0);										// Post quit message
			break;

		default: return DefWindowProc(Wnd, Msg, wParam, lParam);	// Default handler
	};// end switch case
	return 0;
}

DWORD WINAPI ExecThreadFunction(LPVOID lpParam)
{
	int  Success;
	struct execData* data = (struct execData*)lpParam;
	Success = CreateProcess(
		nullptr,
		data->CmdLine,
		nullptr,
		nullptr,
		TRUE,
		0,
		nullptr,
		data->CmdRunDir,
		&data->startup_info,
		&data->process_info
	);

	if (!Success) {
		CloseHandle(data->process_info.hProcess);
		CloseHandle(data->process_info.hThread);
		return -4;
	}
	else {
		CloseHandle(data->process_info.hThread);
	}

	WaitForSingleObject(data->process_info.hProcess, INFINITE);

	CloseHandle(data->process_info.hProcess);
	
	data->process_info.hProcess = 0;
	return (0);
}



int SystemCapture(
	TCHAR*         CmdLine,    //Command Line
	TCHAR*         CmdRunDir)  //set to '.' for current directory
{
	SECURITY_ATTRIBUTES  security_attributes;             

	data.CmdLine = CmdLine;
	data.CmdRunDir = CmdRunDir;
	security_attributes.nLength = sizeof(SECURITY_ATTRIBUTES);
	security_attributes.bInheritHandle = TRUE;
	security_attributes.lpSecurityDescriptor = nullptr;
	data.startup_info.cb = sizeof(STARTUPINFO);
	data.startup_info.hStdInput = 0;
	data.startup_info.hStdOutput = GetStdHandle(STD_OUTPUT_HANDLE);
	data.startup_info.hStdError = 0;
	data.startup_info.dwFlags |= STARTF_USESTDHANDLES;

	CreateThread(NULL, 0, ExecThreadFunction, (LPVOID)&data, 0, NULL);
	
	return 0;
}



const TCHAR* ClassName = _T("GUI_CONSOLE_APP");

/* ------------------------------------------------------------------------
   The application entry point
   -----------------------------------------------------------------------*/
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow){
	MSG Msg;
	HWND Wnd;

	WNDCLASSEX WndClass = { 0 };
	WndClass.cbSize = sizeof(WNDCLASSEX);							// Size of this record
	WndClass.style = CS_OWNDC;										// Class styles
	WndClass.lpfnWndProc = &GUIDemoHandler;							// Handler for this class
	WndClass.cbClsExtra = 0;										// No extra class data
	WndClass.cbWndExtra = 0;										// No extra window data
	WndClass.hInstance = GetModuleHandle(NULL);						// This instance
	WndClass.hIcon = LoadIcon(0, IDI_APPLICATION);					// Set icon
	WndClass.hCursor = LoadCursor(0, IDC_ARROW);					// Set cursor
	WndClass.hbrBackground = (HBRUSH) GetStockObject(WHITE_BRUSH);	// Set background brush
	WndClass.lpszMenuName = NULL;									// No menu yet
	WndClass.lpszClassName = ClassName;								// Set class name
	RegisterClassEx(&WndClass);										// Register the class				
   	Wnd = CreateWindowEx(0, ClassName, _T("GUI Console Demo Program"), 
		WS_VISIBLE | WS_OVERLAPPEDWINDOW, 
		50, 50, 500, 400,
		0, 0, 0, NULL);												// Create a window

	_tprintf(_T("This will go to the console\r\n"));
	std::cout << "Second line to console\r\n" << std::endl;

	int            rc;
	TCHAR szCmdDir[256] = _T(".");
	std::cout << "\r\nExecute console app:" << std::endl;
	TCHAR szCmdLine1[256] = _T("ConsoleApp.exe");    // You strange non terminating app
	rc = SystemCapture(
		szCmdLine1,								 //Command Line
		szCmdDir                               //CmdRunDir
	);

 	while (GetMessage(&Msg, 0, 0, 0)){								// Get messages
		TranslateMessage(&Msg);										// Translate each message
		DispatchMessage(&Msg);										// Dispatch each message
	};
	return (0);
}

static const char Spin[4] = { '|', '/', '-', '\\' };



int main()
{

	int i = 0;
	while (1) {
		printf("Deadloop %c\r", Spin[i]);
		for (long j = 0; j < 10000000; j++) {};
		i++;
		i %= 4;
	}

    return 0;
}

static void runCommand() {
    //* Create your Process
    Process process = new Process();
    process.StartInfo.FileName = "cmd.exe";
    process.StartInfo.Arguments = "/c yourfile.exe";
    process.StartInfo.UseShellExecute = false;
    process.StartInfo.RedirectStandardOutput = true;
    process.StartInfo.RedirectStandardError = true;
    //* Set your output and error (asynchronous) handlers
    process.OutputDataReceived += new DataReceivedEventHandler(OutputHandler);
    process.ErrorDataReceived += new DataReceivedEventHandler(OutputHandler);
    //* Start process and handlers
    process.Start();
    process.BeginOutputReadLine();
    process.BeginErrorReadLine();
    process.WaitForExit();
}
static void OutputHandler(object sendingProcess, DataReceivedEventArgs outLine) {
    //* Do your stuff with the output (write to console/log/StringBuilder)
    Console.WriteLine(outLine.Data);
}

public partial class MainWindow : Window
{
    Process process = new Process();

    public MainWindow()
    {
        InitializeComponent();
        runCommand();
    }

    private void button_Click(object sender, RoutedEventArgs e)
    {
        textBox.Text += "test\r\n";
        process.StandardInput.Write('e');
    }

    void runCommand()
    {
        //* Create your Process

        process.StartInfo.FileName = "c:\\ConsoleApp.exe";
        process.StartInfo.Arguments = ".";
        process.StartInfo.UseShellExecute = false;
        process.StartInfo.RedirectStandardOutput = true;
        process.StartInfo.RedirectStandardError = true;
        process.StartInfo.RedirectStandardInput = true;
        //* Set your output and error (asynchronous) handlers
        process.OutputDataReceived += new DataReceivedEventHandler(OutputHandler);
        process.ErrorDataReceived += new DataReceivedEventHandler(OutputHandler);

        //* Start process and handlers
        process.Start();
        process.BeginOutputReadLine();
        process.BeginErrorReadLine();
        //            process.WaitForExit();
    }
    void OutputHandler(object sendingProcess, DataReceivedEventArgs outLine)
    {
        //* Do your stuff with the output (write to console/log/StringBuilder)
        Console.WriteLine(outLine);
    }
}

using System.Threading;
new Thread(() => 
{
    Thread.CurrentThread.IsBackground = true; 
    runCommand();
}).Start();

MyApp.exe -Iinput.txt -Ooutput.txt

setvbuf(stdout, NULL, _IONBF, 0);
setvbuf(stderr, NULL, _IONBF, 0);