gdb2\Makefile

svn path=/trunk/; revision=1792

rosapps/devutils/gdb2/Makefile

@@ -0,0 +1,13 @@
+# $Id: Makefile,v 1.1 2001/04/15 23:43:12 narnaoud Exp $
+#
+#  ReactOS makefile for gdb2
+#
+
+include ../../rules.mak
+
+TARGET_NAME=gdb2
+
+all: $(TARGET_NAME)$(EXE_POSTFIX)
+
+gdb2.exe : gdb2.cpp ph.h
+	gcc gdb2.cpp -o gdb2.exe

rosapps/devutils/gdb2/README

@@ -0,0 +1 @@
+dbg2 is a tool that splits the console output of gdb and the debugged program. it runs gdb into new console and redirects its output to the original, so the debugged program outputs to the second console.

rosapps/devutils/gdb2/gdb2.cpp

@@ -0,0 +1,298 @@
+/* $Id: gdb2.cpp,v 1.1 2001/04/15 23:42:07 narnaoud Exp $
+ *
+ * gdb2 - gdb output splitter
+ *
+ * Copyright (C) 2000,2001 Nedko Arnaoudov <nedkohome@atia.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#include "ph.h"
+
+#define GDB_INITIAL_COMMAND "gdb.exe"
+#define PARAMS_SEPARATOR " "
+#define PARAMS_SEPARATOR_LEN strlen(PARAMS_SEPARATOR);
+
+void DisplayError(char *pszAPI);
+void ReadAndHandleOutput(HANDLE hPipeRead);
+void PrepAndLaunchRedirectedChild(HANDLE hChildStdOut,
+								  HANDLE hChildStdIn,
+								  HANDLE hChildStdErr,
+								  char *pchCommandLine);
+
+DWORD WINAPI GetAndSendInputThread(LPVOID lpvThreadParam);
+HANDLE hChildProcess = NULL;
+HANDLE hStdIn = NULL; // Handle to parents std input.
+BOOL bRunThread = TRUE;
+
+int main(int argc, char* argv[])
+{
+	HANDLE hOutputReadTmp,hOutputRead,hOutputWrite;
+	HANDLE hInputWriteTmp,hInputRead,hInputWrite;
+	HANDLE hErrorWrite;
+	HANDLE hThread;
+	DWORD ThreadId;
+	SECURITY_ATTRIBUTES sa;
+	
+	// Set up the security attributes struct.
+	sa.nLength= sizeof(SECURITY_ATTRIBUTES);
+	sa.lpSecurityDescriptor = NULL;
+	sa.bInheritHandle = TRUE;
+	
+	
+	// Create the child output pipe.
+	if (!CreatePipe(&hOutputReadTmp,&hOutputWrite,&sa,0))
+		DisplayError("CreatePipe");
+	
+	
+	// Create a duplicate of the output write handle for the std error
+	// write handle. This is necessary in case the child application
+	// closes one of its std output handles.
+	if (!DuplicateHandle(GetCurrentProcess(),hOutputWrite,
+		GetCurrentProcess(),&hErrorWrite,0,
+		TRUE,DUPLICATE_SAME_ACCESS))
+		DisplayError("DuplicateHandle");
+	
+	
+	// Create the child input pipe.
+	if (!CreatePipe(&hInputRead,&hInputWriteTmp,&sa,0))
+		DisplayError("CreatePipe");
+	
+	
+	// Create new output read handle and the input write handles. Set
+	// the Properties to FALSE. Otherwise, the child inherits the
+	// properties and, as a result, non-closeable handles to the pipes
+	// are created.
+	if (!DuplicateHandle(GetCurrentProcess(),hOutputReadTmp,
+		GetCurrentProcess(),
+		&hOutputRead, // Address of new handle.
+		0,FALSE, // Make it uninheritable.
+		DUPLICATE_SAME_ACCESS))
+		DisplayError("DupliateHandle");
+	
+	if (!DuplicateHandle(GetCurrentProcess(),hInputWriteTmp,
+		GetCurrentProcess(),
+		&hInputWrite, // Address of new handle.
+		0,FALSE, // Make it uninheritable.
+		DUPLICATE_SAME_ACCESS))
+		DisplayError("DupliateHandle");
+	
+	
+	// Close inheritable copies of the handles you do not want to be
+	// inherited.
+	if (!CloseHandle(hOutputReadTmp)) DisplayError("CloseHandle");
+	if (!CloseHandle(hInputWriteTmp)) DisplayError("CloseHandle");
+	
+	
+	// Get std input handle so you can close it and force the ReadFile to
+	// fail when you want the input thread to exit.
+	if ( (hStdIn = GetStdHandle(STD_INPUT_HANDLE)) ==
+		INVALID_HANDLE_VALUE )
+		DisplayError("GetStdHandle");
+	
+	SetConsoleTitle("gdb control console");
+
+	size_t size = strlen(GDB_INITIAL_COMMAND)+PARAMS_SEPARATOR_LEN;
+
+	// get parameters length
+	for (int i = 1 ; i < argc ; i++)
+		size += strlen(argv[i])+PARAMS_SEPARATOR_LEN;
+
+	size++; // terminating null
+
+	char *pszCommandLine = new char [size];
+	if (!pszCommandLine)
+	{
+		printf("out of memory.\n");
+		return -1;
+	}
+
+	strcpy(pszCommandLine,GDB_INITIAL_COMMAND);
+	for (int i = 1 ; i < argc ; i++)
+	{
+		strcat(pszCommandLine,PARAMS_SEPARATOR);
+		strcat(pszCommandLine,argv[i]);
+	}
+
+	PrepAndLaunchRedirectedChild(hOutputWrite,hInputRead,hErrorWrite,pszCommandLine);
+	
+	
+	// Close pipe handles (do not continue to modify the parent).
+	// You need to make sure that no handles to the write end of the
+	// output pipe are maintained in this process or else the pipe will
+	// not close when the child process exits and the ReadFile will hang.
+	if (!CloseHandle(hOutputWrite)) DisplayError("CloseHandle");
+	if (!CloseHandle(hInputRead )) DisplayError("CloseHandle");
+	if (!CloseHandle(hErrorWrite)) DisplayError("CloseHandle");
+	
+	
+	// Launch the thread that gets the input and sends it to the child.
+	hThread = CreateThread(NULL,0,GetAndSendInputThread,
+		(LPVOID)hInputWrite,0,&ThreadId);
+	if (hThread == NULL) DisplayError("CreateThread");
+	
+	
+	// Read the child's output.
+	ReadAndHandleOutput(hOutputRead);
+	// Redirection is complete
+	
+	
+	// Force the read on the input to return by closing the stdin handle.
+	if (!CloseHandle(hStdIn)) DisplayError("CloseHandle");
+	
+	
+	// Tell the thread to exit and wait for thread to die.
+	bRunThread = FALSE;
+	
+	if (WaitForSingleObject(hThread,INFINITE) == WAIT_FAILED)
+		DisplayError("WaitForSingleObject");
+	
+	if (!CloseHandle(hOutputRead)) DisplayError("CloseHandle");
+	if (!CloseHandle(hInputWrite)) DisplayError("CloseHandle");
+
+	return 0;
+}
+
+/////////////////////////////////////////////////////////////////////// 
+// PrepAndLaunchRedirectedChild
+// Sets up STARTUPINFO structure, and launches redirected child.
+/////////////////////////////////////////////////////////////////////// 
+void PrepAndLaunchRedirectedChild(HANDLE hChildStdOut,
+								  HANDLE hChildStdIn,
+								  HANDLE hChildStdErr,
+								  char *pchCommandLine)
+{
+	PROCESS_INFORMATION pi;
+	STARTUPINFO si;
+	
+	// Set up the start up info struct.
+	ZeroMemory(&si,sizeof(STARTUPINFO));
+	si.cb = sizeof(STARTUPINFO);
+	si.dwFlags = STARTF_USESTDHANDLES;
+	si.hStdOutput = hChildStdOut;
+	si.hStdInput  = hChildStdIn;
+	si.hStdError  = hChildStdErr;
+	si.lpTitle = "debugged program console";
+	// Use this if you want to hide the child:
+	//     si.wShowWindow = SW_HIDE;
+	// Note that dwFlags must include STARTF_USESHOWWINDOW if you want to
+	// use the wShowWindow flags.
+	
+	
+	// Launch the process that you want to redirect (in this case,
+	// Child.exe). Make sure Child.exe is in the same directory as
+	// redirect.c launch redirect from a command line to prevent location
+	// confusion.
+	if (!CreateProcess(NULL,pchCommandLine,NULL,NULL,TRUE,
+		CREATE_NEW_CONSOLE,NULL,NULL,&si,&pi))
+		DisplayError("CreateProcess");
+	
+	
+	// Set global child process handle to cause threads to exit.
+	hChildProcess = pi.hProcess;
+	
+	
+	// Close any unnecessary handles.
+	if (!CloseHandle(pi.hThread)) DisplayError("CloseHandle");
+}
+
+/////////////////////////////////////////////////////////////////////// 
+// ReadAndHandleOutput
+// Monitors handle for input. Exits when child exits or pipe breaks.
+/////////////////////////////////////////////////////////////////////// 
+void ReadAndHandleOutput(HANDLE hPipeRead)
+{
+	CHAR lpBuffer[256];
+	DWORD nBytesRead;
+	DWORD nCharsWritten;
+	
+	while(TRUE)
+	{
+		if (!ReadFile(hPipeRead,lpBuffer,sizeof(lpBuffer),
+			&nBytesRead,NULL) || !nBytesRead)
+		{
+            if (GetLastError() == ERROR_BROKEN_PIPE)
+				break; // pipe done - normal exit path.
+            else
+				DisplayError("ReadFile"); // Something bad happened.
+		}
+		
+		// Display the character read on the screen.
+		if (!WriteConsole(GetStdHandle(STD_OUTPUT_HANDLE),lpBuffer,
+			nBytesRead,&nCharsWritten,NULL))
+            DisplayError("WriteConsole");
+	}
+}
+
+
+/////////////////////////////////////////////////////////////////////// 
+// GetAndSendInputThread
+// Thread procedure that monitors the console for input and sends input
+// to the child process through the input pipe.
+// This thread ends when the child application exits.
+/////////////////////////////////////////////////////////////////////// 
+DWORD WINAPI GetAndSendInputThread(LPVOID lpvThreadParam)
+{
+	CHAR read_buff[256];
+	DWORD nBytesRead,nBytesWrote;
+	HANDLE hPipeWrite = (HANDLE)lpvThreadParam;
+	
+	// Get input from our console and send it to child through the pipe.
+	while (bRunThread)
+	{
+		if(!ReadConsole(hStdIn,read_buff,1,&nBytesRead,NULL))
+            DisplayError("ReadConsole");
+		
+		read_buff[nBytesRead] = '\0'; // Follow input with a NULL.
+		
+		if (!WriteFile(hPipeWrite,read_buff,nBytesRead,&nBytesWrote,NULL))
+		{
+            if (GetLastError() == ERROR_NO_DATA)
+				break; // Pipe was closed (normal exit path).
+            else
+				DisplayError("WriteFile");
+		}
+	}
+	
+	return 1;
+}
+
+/////////////////////////////////////////////////////////////////////// 
+// DisplayError
+// Displays the error number and corresponding message.
+/////////////////////////////////////////////////////////////////////// 
+void DisplayError(char *pszAPI)
+{
+	LPVOID lpvMessageBuffer;
+	CHAR szPrintBuffer[512];
+	DWORD nCharsWritten;
+	
+	FormatMessage(
+		FORMAT_MESSAGE_ALLOCATE_BUFFER|FORMAT_MESSAGE_FROM_SYSTEM,
+		NULL, GetLastError(),
+		MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+		(LPTSTR)&lpvMessageBuffer, 0, NULL);
+	
+	wsprintf(szPrintBuffer,
+		"ERROR: API    = %s.\n   error code = %d.\n   message    = %s.\n",
+		pszAPI, GetLastError(), (char *)lpvMessageBuffer);
+	
+	WriteConsole(GetStdHandle(STD_OUTPUT_HANDLE),szPrintBuffer,
+		lstrlen(szPrintBuffer),&nCharsWritten,NULL);
+	
+	LocalFree(lpvMessageBuffer);
+	ExitProcess(GetLastError());
+}

rosapps/devutils/gdb2/ph.h

@@ -0,0 +1,10 @@
+#ifndef PH_H___b210ed20_5d0f_4038_abd3_d42ff283c9d0__INCLUDED
+#define PH_H___b210ed20_5d0f_4038_abd3_d42ff283c9d0__INCLUDED
+
+#define WIN32_LEAN_AND_MEAN		// Exclude rarely-used stuff from Windows headers
+
+#include <stdio.h>
+
+#include <windows.h>
+
+#endif // #ifndef PH_H___b210ed20_5d0f_4038_abd3_d42ff283c9d0__INCLUDED