}
//---------------------------------------------------------------------------------------
- bool ConfigParser::parseFile(TCHAR * FileName)
+ bool ConfigParser::parseFile(char * FileName)
{
- FILE * file;
-#ifdef UNICODE
- file = _tfopen(FileName, _T("rt,ccs=UNICODE"));
-#else
- file = fopen(FileName, "rt");
-#endif
+ FILE * file = fopen(FileName, "rt");
if (!file)
{
cerr << "Error: ConfigParser::parseFile failed to open configuration file " << FileName << endl;
bool ret = false;
while (!feof(file))
{
- TCHAR buffer[500];
- TCHAR * buf;
+ char buffer[500];
+ char * buf;
- buf = _fgetts(buffer, sizeof(buffer) / sizeof(TCHAR), file);
+ buf = fgets(buffer, sizeof(buffer) / sizeof(char), file);
if (buf)
{
- if (buffer[0] != _T(';'))
+ if (buffer[0] != ';')
{
string s_buffer = string(buffer);
- string::size_type ws_pos = s_buffer.find_first_of (_T("="));
+ string::size_type ws_pos = s_buffer.find_first_of ("=");
if (ws_pos != string::npos && ws_pos > 0 && ws_pos < s_buffer.size())
{
return false;
}
- ConfValue = _tcstod(it->second.c_str(), NULL);
+ ConfValue = strtod(it->second.c_str(), NULL);
return true;
}
//-----------------------------------------------------------------------------------------
return false;
}
- ConfValue = _tcstol(it->second.c_str(), NULL, 10);
+ ConfValue = strtol(it->second.c_str(), NULL, 10);
return true;
}
/// @param FileName path to configuration file
/// @return bool
- bool parseFile(TCHAR * FileName);
+ bool parseFile(char * FileName);
//--------------------------------------------------------------------------------------
///
return true;
}
- TCHAR * value = _tgetenv(EnvName.c_str ());
+ char * value = getenv(EnvName.c_str ());
if (!value)
{
return false;
}
- if (!_tcslen(value))
+ if (!strlen(value))
{
cerr << "EnvironmentVariable::getValue found no value for " << EnvName << endl;
return false;
//---------------------------------------------------------------------------------------
bool FileReader::openSource(const string & filename)
{
-#ifdef UNICODE
- m_File = (FILE*)_tfopen(filename.c_str(), _T("rb,ccs=UNICODE"));
-#else
m_File = fopen((char*)filename.c_str(), (char*)"rb");
-#endif
if (m_File)
{
char szBuffer[256];
int readoffset = 0;
-#ifdef UNICODE
- wchar_t wbuf[512];
- int wbuf_offset = 0;
-
- if (m_BufferedLines.length ())
- {
- wcscpy(wbuf, m_BufferedLines.c_str ());
- wbuf_offset = m_BufferedLines.length ();
- }
-#else
if (m_BufferedLines.length())
{
strcpy(szBuffer, m_BufferedLines.c_str());
readoffset = m_BufferedLines.length();
}
-#endif
do
{
if (total_length < num)
{
-#ifdef UNICODE
- memmove(wbuf, &wbuf[total_length], (num - total_length) * sizeof(wchar_t));
- wbuf_offset = num - total_length;
-#else
memmove(szBuffer, &szBuffer[total_length], num - total_length);
readoffset = num - total_length;
-#endif
}
num = fread(&szBuffer[readoffset],
}
break;
}
- TCHAR * ptr;
-#ifdef UNICODE
- int i = 0;
- int conv;
- while((conv = mbtowc(&wbuf[wbuf_offset+i], &szBuffer[i], num)))
- {
- i += conv;
- if (i == num)
- break;
-
- assert(wbuf_offset + i < 512);
- }
- wbuf[wbuf_offset + num] = L'\0';
-
- TCHAR * offset = wbuf;
-#else
+ char * ptr;
+ char * offset = szBuffer;
- TCHAR * offset = szBuffer;
-#endif
total_length = 0;
- while((ptr = _tcsstr(offset, _T("\x0D\x0A"))) != NULL)
+ while((ptr = strstr(offset, "\x0D\x0A")) != NULL)
{
long length = ((long )ptr - (long)offset);
- length /= sizeof(TCHAR);
+ length /= sizeof(char);
- offset[length] = _T('\0');
+ offset[length] = '\0';
string line = offset;
lines.push_back (line);
if (total_length < num)
{
-#ifdef UNICODE
- m_BufferedLines = &wbuf[total_length];
-#else
- m_BufferedLines = &szBuffer[total_length];
-#endif
+ m_BufferedLines = &szBuffer[total_length];
}
return ret;
*/
#include "namedpipe_reader.h"
-#include "unicode.h"
#include <iostream>
#include <assert.h>
{
#define MIN(a, b) (((a) < (b)) ? (a) : (b))
+#ifdef __LINUX__
+ const char * NamedPipeReader::s_LineBreak = "\x0A\0";
+#else
+ const char * NamedPipeReader::s_LineBreak = "\x0D\x0A\0";
+#endif
using std::vector;
//---------------------------------------------------------------------------------------
NamedPipeReader::NamedPipeReader() : DataSource(), h_Pipe(NULLVAL), m_Buffer(0)
{
-#ifdef UNICODE
- m_WBuffer = 0;
-#endif
}
//---------------------------------------------------------------------------------------
{
if (m_Buffer)
free(m_Buffer);
-#ifdef UNICODE
- if (m_WBuffer)
- free(m_WBuffer);
-#endif
}
bool NamedPipeReader::isSourceOpen()
m_BufferLength = 100;
m_Buffer = (char*)malloc(sizeof(char) * m_BufferLength);
}
-
-#ifdef UNICODE
- if (!m_WBuffer)
- {
- m_WBuffer = (WCHAR*)malloc(sizeof(WCHAR) * m_BufferLength);
- }
-#endif
- ConnectNamedPipe(h_Pipe,
+ ConnectNamedPipe(h_Pipe,
0);
return true;
}
bool NamedPipeReader::closeSource()
{
+ cerr << "NamedPipeReader::closePipe> entered" << endl;
if (h_Pipe == NULLVAL)
{
cerr << "NamedPipeReader::closePipe> pipe is not open" << endl;
return true;
}
//---------------------------------------------------------------------------------------
- void NamedPipeReader::extractLines(TCHAR * buffer, std::vector<string> & vect, bool & append_line, unsigned long cbRead)
+ void NamedPipeReader::insertLine(std::vector<string> & vect, string line, bool append_line)
+ {
+ if (append_line && vect.size ())
+ {
+ string prev = vect[vect.size () - 1];
+ prev += line;
+ vect[vect.size () - 1] = prev;
+ }
+ else
+ {
+ vect.push_back (line);
+ }
+
+ }
+//---------------------------------------------------------------------------------------
+ void NamedPipeReader::extractLines(char * buffer, std::vector<string> & vect, bool & append_line, unsigned long cbRead)
{
- TCHAR * offset = _tcschr(buffer, _T('\x0D'));
- DWORD buf_offset = 0;
+#if 0
+ long offset = 0;
+ size_t start_size = vect.size ();
+ char * start = buffer;
+ buffer[cbRead] = _T('\0');
+ char * end = strstr(buffer, s_LineBreak);
+
+ //cout << "extractLines entered with append_line: " << append_line << " cbRead: " << cbRead << "buffer: " << buffer << endl;
+
+ do
+ {
+ if (end)
+ {
+ end[0] = _T('\0');
+ string line = start;
+ end += (sizeof(s_LineBreak) / sizeof(char));
+ start = end;
+ offset += line.length() + (sizeof(s_LineBreak) / sizeof(char));
+
+ // cout << "Offset: "<< offset << "cbRead: " << cbRead << "line: " << line << endl;
+ insertLine(vect, line, append_line);
+ if (append_line)
+ {
+ append_line = false;
+ }
+ }
+ else
+ {
+ string line = start;
+// cout << "inserting line start_size: " << start_size << "current: " << vect.size () << "line length: "<< line.length () << endl;
+ if (!line.length ())
+ {
+ if (start_size == vect.size ())
+ append_line = true;
+ break;
+ }
+ if (start_size == vect.size ())
+ {
+ insertLine(vect, line, true);
+ }
+ else
+ {
+ insertLine(vect, line, false);
+ }
+ append_line = true;
+ break;
+ }
+
+ end = strstr(end, s_LineBreak);
+
+ }while(append_line);
+
+#else
+ DWORD buf_offset = 0;
+ char * offset = strchr(buffer, '\x0D');
while(offset)
{
///
/// HACKHACK
- /// due to some mysterious reason, _tcschr / _tcsstr sometimes returns
+ /// due to some mysterious reason, strchr / strstr sometimes returns
/// not always the offset to the CR character but to the next LF
/// in MSVC 2005 (Debug Modus)
- if (offset[0] == _T('\x0A'))
+ if (offset[0] == '\x0A')
{
if (buf_offset)
{
}
}
- if (offset[0] == _T('\x0D'))
+ if (offset[0] == '\x0D')
{
buf_offset += 2;
- offset[0] = _T('\0');
+ offset[0] = '\0';
offset +=2;
}
else
}
buffer = offset;
- offset = _tcsstr(buffer, _T("\n"));
+ offset = strstr(buffer, "\n");
}
if (buf_offset < cbRead)
{
- buffer[cbRead - buf_offset] = _T('\0');
+ buffer[cbRead - buf_offset] = '\0';
string line = buffer;
if (append_line)
{
{
append_line = false;
}
+#endif
}
//---------------------------------------------------------------------------------------
bool NamedPipeReader::readPipe(char * buffer, int bufferlength, long & bytesread)
return false;
}
-#ifdef UNICODE
- if (!m_WBuffer)
- {
- cerr << "Error: no memory" << endl;
- return false;
- }
-#endif
-
bool append_line = false;
do
{
memset(m_Buffer, 0x0, m_BufferLength * sizeof(char));
long cbRead = 0;
-
+
if (!readPipe(m_Buffer, m_BufferLength-1, cbRead))
break;
-#ifdef UNICODE
- memset(m_WBuffer, 0x0, m_BufferLength * sizeof(WCHAR));
- if (!UnicodeConverter::ansi2Unicode(m_Buffer, m_WBuffer, cbRead))
- break;
- extractLines(m_WBuffer, vect, append_line, cbRead);
-#else
extractLines(m_Buffer, vect, append_line, cbRead);
-#endif
-
}while (append_line);
return (vect.size () - lines);
/// @param vect vector storing the extracted lines
/// @param append_line if the line isnt fully read, the line is appended
- void extractLines(TCHAR * buffer, std::vector<string> & vect, bool & append_line, unsigned long cbRead);
+ void extractLines(char * buffer, std::vector<string> & vect, bool & append_line, unsigned long cbRead);
+ void insertLine(std::vector<string> & vect, string line, bool append_line);
bool readPipe(char * buffer, int bufferlength, long & read);
WCHAR * m_WBuffer;
#endif
+ static const char * s_LineBreak;
}; // end of class NamedPipeReader
} // end of namespace System_
OsSupport::TimeEntryVector OsSupport::s_Entries;
+ //int gettimeofday(struct timeval *tv, void * tz);
+
void OsSupport::checkAlarms()
{
struct timeval tm;
size_t i;
- gettimeofday(&tm, 0);
+#if 0
+// gettimeofday(&tm, 0);
+#endif
for (i = 0; i < s_Entries.size(); i++)
{
long diffsec = s_Entries[i]->tm.tv_sec - tm.tv_sec;
HANDLE OsSupport::s_hThread = 0;
static HANDLE hTimer;
+#if 0
+__inline int gettimeofday(struct timeval *tv, struct timezone *tz)
+{
+ FILETIME ft;
+ LARGE_INTEGER li;
+ __int64 t;
+ static int tzflag;
+
+ if (tv)
+ {
+ GetSystemTimeAsFileTime(&ft);
+ li.LowPart = ft.dwLowDateTime;
+ li.HighPart = ft.dwHighDateTime;
+ t = li.QuadPart; /* In 100-nanosecond intervals */
+ t -= EPOCHFILETIME; /* Offset to the Epoch time */
+ t /= 10; /* In microseconds */
+ tv->tv_sec = (long)(t / 1000000);
+ tv->tv_usec = (long)(t % 1000000);
+ }
+
+ if (tz)
+ {
+ if (!tzflag)
+ {
+ _tzset();
+ tzflag++;
+ }
+ tz->tz_minuteswest = _timezone / 60;
+ tz->tz_dsttime = _daylight;
+ }
+
+ return 0;
+}
+#endif
bool OsSupport::terminateProcess(OsSupport::ProcessID pid, int exitcode)
{
HANDLE hProcess = OpenProcess(PROCESS_TERMINATE, FALSE, pid);
return ret;
}
- OsSupport::ProcessID OsSupport::createProcess(TCHAR *procname, int procargsnum, TCHAR **procargs, bool wait)
+ OsSupport::ProcessID OsSupport::createProcess(char *procname, int procargsnum, char **procargs, bool wait)
{
STARTUPINFO siStartInfo;
PROCESS_INFORMATION piProcInfo;
OsSupport::ProcessID pid;
DWORD length = 0;
- TCHAR * szBuffer;
- TCHAR * cmd;
+ char * szBuffer;
+ char * cmd;
ZeroMemory(&siStartInfo, sizeof(STARTUPINFO));
ZeroMemory(&piProcInfo, sizeof(PROCESS_INFORMATION));
{
for (int i = 1; i < procargsnum; i++)
{
- length += _tcslen(procargs[i]);
+ length += strlen(procargs[i]);
}
length += procargsnum;
- szBuffer = (TCHAR*)malloc(length * sizeof(TCHAR));
+ szBuffer = (char*)malloc(length * sizeof(char));
length = 0;
for (int i = 1; i < procargsnum; i++)
{
- _tcscpy(&szBuffer[length], procargs[i]);
- length += _tcslen(procargs[i]);
- szBuffer[length] = _T(' ');
+ strcpy(&szBuffer[length], procargs[i]);
+ length += strlen(procargs[i]);
+ if (i + 1 < procargsnum)
+ {
+ szBuffer[length] = ' ';
+ }
+ else
+ {
+ szBuffer[length] = '\0';
+ }
length++;
}
- length = _tcslen(procname) + _tcslen(szBuffer) + 2;
- cmd = (TCHAR*)malloc(length * sizeof(TCHAR));
- _tcscpy(cmd, procname);
- _tcscat(cmd, _T(" "));
- _tcscat(cmd, szBuffer);
+ length = strlen(procname) + strlen(szBuffer) + 2;
+ cmd = (char*)malloc(length * sizeof(char));
+ strcpy(cmd, procname);
+ strcat(cmd, " ");
+ strcat(cmd, szBuffer);
free(szBuffer);
}
else
{
- cmd = _tcsdup(procname);
+ cmd = _strdup(procname);
}
if (!CreateProcess(NULL, cmd, NULL, NULL, FALSE, NORMAL_PRIORITY_CLASS, NULL, NULL, &siStartInfo, &piProcInfo))
{
LARGE_INTEGER liDueTime;
- hTimer = CreateWaitableTimer(NULL, TRUE, _T("SysRegTimer"));
+ hTimer = CreateWaitableTimer(NULL, TRUE, "SysRegTimer");
if (!hTimer)
{
return 0;
void OsSupport::setAlarm(long secs, OsSupport::ProcessID pid)
{
-
+ return;
PTIME_ENTRY entry = (PTIME_ENTRY) malloc(sizeof(TIME_ENTRY));
if (entry)
{
cout << "secs: " << secs << endl;
struct timeval tm;
+#if 0
gettimeofday(&tm, 0);
+#else
+#endif
tm.tv_sec += secs;
entry->tm = tm;
struct sigaction OsSupport::s_sact;
- OsSupport::ProcessID OsSupport::createProcess(TCHAR *procname, int procargsnum, TCHAR **procargs, bool bWait)
+ OsSupport::ProcessID OsSupport::createProcess(char *procname, int procargsnum, char **procargs, bool bWait)
{
ProcessID pid;
#include "user_types.h"
#include <ctime>
#include <vector>
+
+#ifndef _MSC_VER
#include <sys/time.h>
+#endif
#define MAX(a, b) (((a) > (b)) ? (a) : (b))
///
///
- static ProcessID createProcess(TCHAR * procname, int procargsnum, TCHAR ** procargs, bool wait);
+ static ProcessID createProcess(char * procname, int procargsnum, char ** procargs, bool wait);
//---------------------------------------------------------------------------------------
///
bool PipeReader::readSource(vector<string> & lines)
{
- TCHAR * buf = (TCHAR*)malloc(100 * sizeof(TCHAR));
+ char * buf = (char*)malloc(100 * sizeof(char));
//#ifdef NDEBUG
- memset(buf, 0x0, sizeof(TCHAR) * 100);
+ memset(buf, 0x0, sizeof(char) * 100);
//#endif
- TCHAR * res = _fgetts(buf, 100, m_File);
+ char * res = fgets(buf, 100, m_File);
if (!res)
{
//cerr << "Error: PipeReader::readPipe failed" << endl;
using std::ofstream;
#endif
- string RosBootTest::ROS_EMU_TYPE= _T("ROS_EMU_TYPE");
- string RosBootTest::EMU_TYPE_QEMU = _T("qemu");
- string RosBootTest::EMU_TYPE_VMWARE = _T("vmware");
- string RosBootTest::ROS_HDD_IMAGE= _T("ROS_HDD_IMAGE");
- string RosBootTest::ROS_CD_IMAGE = _T("ROS_CD_IMAGE");
- string RosBootTest::ROS_MAX_TIME = _T("ROS_MAX_TIME");
- string RosBootTest::ROS_LOG_FILE = _T("ROS_LOG_FILE");
- string RosBootTest::ROS_SYM_DIR = _T("ROS_SYM_DIR");
- string RosBootTest::ROS_DELAY_READ = _T("ROS_DELAY_READ");
- string RosBootTest::ROS_SYSREG_CHECKPOINT = _T("SYSREG_CHECKPOINT:");
- string RosBootTest::ROS_CRITICAL_IMAGE = _T("ROS_CRITICAL_IMAGE");
- string RosBootTest::ROS_EMU_KILL = _T("ROS_EMU_KILL");
- string RosBootTest::ROS_EMU_MEM = _T("ROS_EMU_MEM");
- string RosBootTest::ROS_BOOT_CMD = _T("ROS_BOOT_CMD");
+ string RosBootTest::ROS_EMU_TYPE= "ROS_EMU_TYPE";
+ string RosBootTest::EMU_TYPE_QEMU = "qemu";
+ string RosBootTest::EMU_TYPE_VMWARE = "vmware";
+ string RosBootTest::ROS_HDD_IMAGE= "ROS_HDD_IMAGE";
+ string RosBootTest::ROS_CD_IMAGE = "ROS_CD_IMAGE";
+ string RosBootTest::ROS_MAX_TIME = "ROS_MAX_TIME";
+ string RosBootTest::ROS_LOG_FILE = "ROS_LOG_FILE";
+ string RosBootTest::ROS_SYM_DIR = "ROS_SYM_DIR";
+ string RosBootTest::ROS_DELAY_READ = "ROS_DELAY_READ";
+ string RosBootTest::ROS_SYSREG_CHECKPOINT = "SYSREG_CHECKPOINT:";
+ string RosBootTest::ROS_CRITICAL_IMAGE = "ROS_CRITICAL_IMAGE";
+ string RosBootTest::ROS_EMU_KILL = "ROS_EMU_KILL";
+ string RosBootTest::ROS_EMU_MEM = "ROS_EMU_MEM";
+ string RosBootTest::ROS_BOOT_CMD = "ROS_BOOT_CMD";
#ifdef __LINUX__
- string RosBootTest::ROS_EMU_PATH = _T("ROS_EMU_PATH_LIN");
+ string RosBootTest::ROS_EMU_PATH = "ROS_EMU_PATH_LIN";
#else
- string RosBootTest::ROS_EMU_PATH = _T("ROS_EMU_PATH_WIN");
+ string RosBootTest::ROS_EMU_PATH = "ROS_EMU_PATH_WIN";
#endif
//---------------------------------------------------------------------------------------
pBuf = (char*)m_BootCmd.c_str ();
if (pBuf)
{
- pBuf = strtok(pBuf, _T(" "));
+ pBuf = strtok(pBuf, " ");
while(pBuf != NULL)
{
if (!numargs)
args[numargs] = pBuf;
numargs++;
- pBuf = _tcstok(NULL, _T(" "));
+ pBuf = strtok(NULL, " ");
}
args[numargs++] = 0;
}
//---------------------------------------------------------------------------------------
void RosBootTest::getDefaultHDDImage(string & img)
{
+#ifndef __LINUX__
+ char buffer[MAX_PATH];
+ if (GetCurrentDirectory(MAX_PATH, buffer))
+ {
+ img = buffer;
+ img += "\\output-i386";
+
+ }
+ else
+#endif
img = "output-i386";
- EnvironmentVariable::getValue(_T("ROS_OUTPUT"), img);
+ EnvironmentVariable::getValue("ROS_OUTPUT", img);
#ifdef __LINUX__
- img += _T("/ros.hd");
+ img += "/ros.hd";
#else
- img += _T("\\ros.hd");
+ img += "\\ros.hd";
#endif
}
//---------------------------------------------------------------------------------------
bool RosBootTest::isFileExisting(string output)
{
FILE * file;
- file = _tfopen(output.c_str(), _T("r"));
+ file = fopen(output.c_str(), "r");
if (file)
{
#ifdef __LINUX__
- qemuimgdir += _T("/qemu-img");
+ qemuimgdir += "/qemu-img";
#else
- qemuimgdir += _T("\\qemu-img.exe");
+ qemuimgdir += "\\qemu-img.exe";
#endif
if (!isFileExisting(qemuimgdir))
{
- cerr << "Error: ROS_EMU_PATH must contain the path to qemu and qemu-img " << qemuimgdir << endl;
+ cerr << "Error: ROS_EMU_PATH must contain the path to qemu and qemu-img " << qemuimgdir << endl;
return false;
}
- _tremove(image.c_str ());
+ remove(image.c_str ());
- TCHAR * options[] = {NULL,
- _T("create"),
- _T("-f"),
+ char * options[] = {NULL,
+ "create",
+ "-f",
#ifdef __LINUX__
_T("raw"),
#else
- _T("vmdk"),
+ "vmdk",
#endif
NULL,
- _T("100M"),
+ "100M",
NULL
};
- options[0] = (TCHAR*)qemuimgdir.c_str();
- options[4] = (TCHAR*)image.c_str();
+ options[0] = (char*)qemuimgdir.c_str();
+ options[4] = (char*)image.c_str();
cerr << "Creating HDD Image ..." << image << endl;
- OsSupport::createProcess ((TCHAR*)qemuimgdir.c_str(), 6, options, true);
+ OsSupport::createProcess ((char*)qemuimgdir.c_str(), 6, options, true);
if (isFileExisting(image))
{
m_HDDImage = image;
/* the boot cmd is already provided
* check if path to qemu is valid
*/
- string::size_type pos = m_BootCmd.find_first_of(_T(" "));
+ string::size_type pos = m_BootCmd.find_first_of(" ");
if (pos == string::npos)
{
/* the bootcmd is certainly not valid */
string::size_type pos;
#ifdef __LINUX__
- pos = m_EmuPath.find_last_of(_T("/"));
+ pos = m_EmuPath.find_last_of("/");
#else
- pos = m_EmuPath.find_last_of(_T("\\"));
+ pos = m_EmuPath.find_last_of("\\");
#endif
if (pos == string::npos)
{
}
#ifdef __LINUX__
- pipe = _T("pipe:/tmp/qemu");
- m_Src = _T("/tmp/qemu");
- qemudir = _T("/usr/share/qemu");
- m_DebugPort = _T("pipe");
+ pipe = "pipe:/tmp/qemu";
+ m_Src = "/tmp/qemu";
+ qemudir = "/usr/share/qemu";
+ m_DebugPort = "pipe";
#else
- pipe = _T("pipe:qemu");
- m_Src = _T("\\\\.\\pipe\\qemu");
- m_DebugPort = _T("pipe");
+ pipe = "pipe:qemu";
+ m_Src = "\\\\.\\pipe\\qemu";
+ m_DebugPort = "pipe";
if (!getQemuDir(qemudir))
{
return false;
#endif
- m_BootCmd = m_EmuPath + _T(" -L ") + qemudir + _T(" -m ") + m_MaxMem + _T(" -serial ") + pipe;
+ m_BootCmd = m_EmuPath + " -L " + qemudir + " -m " + m_MaxMem + " -serial " + pipe;
if (m_CDImage.length())
{
/* boot from cdrom */
- m_BootCmd += _T(" -boot d -cdrom ") + m_CDImage;
+ m_BootCmd += " -boot d -cdrom " + m_CDImage;
if (m_HDDImage.length ())
{
/* add disk when specified */
- m_BootCmd += _T(" -hda ") + m_HDDImage;
+ m_BootCmd += " -hda " + m_HDDImage;
}
}
else if (m_HDDImage.length ())
{
/* boot from hdd */
- m_BootCmd += _T(" -boot c -hda ") + m_HDDImage;
+ m_BootCmd += " -boot c -hda " + m_HDDImage;
}
else
{
* to terminate the emulator in case of errors
* on windows we can get pid as return of CreateProcess
*/
- m_PidFile = _T("output-i386");
- EnvironmentVariable::getValue(_T("ROS_OUTPUT"), m_PidFile);
- m_PidFile += _T("/pid.txt");
- m_BootCmd += _T(" -pidfile ");
+ m_PidFile = "output-i386";
+ EnvironmentVariable::getValue("ROS_OUTPUT", m_PidFile);
+ m_PidFile += "/pid.txt";
+ m_BootCmd += " -pidfile ";
m_BootCmd += m_PidFile;
- m_BootCmd += _T(" -vnc :0");
+ m_BootCmd += " -vnc :0";
#else
if (hasQemuNoRebootOption())
{
- m_BootCmd += _T(" -no-reboot ");
+ m_BootCmd += " -no-reboot ";
}
#endif
return true;
//----------------------------------------------------------------------------------------
bool RosBootTest::extractPipeFromBootCmd()
{
- string::size_type pos = m_BootCmd.find(_T("-serial"));
+ string::size_type pos = m_BootCmd.find("-serial");
if (pos == string::npos)
{
/* no debug options provided */
}
string pipe = m_BootCmd.substr(pos + 7, m_BootCmd.size() - pos -7);
- pos = pipe.find(_T("pipe:"));
+ pos = pipe.find("pipe:");
if (pos == 0)
{
pipe = pipe.substr(pos + 5, pipe.size() - pos - 5);
- pos = pipe.find(_T(" "));
+ pos = pipe.find(" ");
if (pos != string::npos)
{
pipe = pipe.substr(0, pos);
#ifdef __LINUX__
m_Src = pipe;
#else
- m_Src = _T("\\\\.\\pipe\\") + pipe.substr(0, pos);
+ m_Src = "\\\\.\\pipe\\" + pipe.substr(0, pos);
#endif
- m_DebugPort = _T("pipe");
+ m_DebugPort = "pipe";
return true;
}
- pos = pipe.find(_T("stdio"));
+ pos = pipe.find("stdio");
if (pos == 0)
{
#ifdef __LINUX__
m_Src = m_BootCmd;
- m_DebugPort = _T("stdio");
+ m_DebugPort = "stdio";
return true;
#else
cerr << "Error: reading from stdio is not supported for windows hosts - use pipes" << endl;
*/
bool hdaboot = false;
- string::size_type pos = m_BootCmd.find (_T("-boot c"));
+ string::size_type pos = m_BootCmd.find ("-boot c");
if (pos != string::npos)
{
hdaboot = true;
}
- pos = m_BootCmd.find(_T("-hda "));
+ pos = m_BootCmd.find("-hda ");
if (pos != string::npos)
{
string hdd = m_BootCmd.substr(pos + 5, m_BootCmd.length() - pos - 5);
return true;
}
}
- if (isFileExisting(_T("ReactOS-RegTest.iso")))
+ if (isFileExisting("ReactOS-RegTest.iso"))
{
- m_CDImage = _T("ReactOS-RegTest.iso");
+ m_CDImage = "ReactOS-RegTest.iso";
cerr << "Falling back to default CDROM image " << m_CDImage << endl;
return true;
}
cerr << "No CDROM image found, boot device is HDD" << endl;
- m_CDImage = _T("");
+ m_CDImage = "";
return true;
}
- string::size_type pos = m_BootCmd.find(_T("-boot "));
+ string::size_type pos = m_BootCmd.find("-boot ");
if (pos == string::npos)
{
/* ROS_BOOT_CMD must provide a boot parameter*/
cerr << "Error: ROS_BOOT_CMD misses boot parameter" << endl;
return false;
}
- if (rest[0] != _T('c') && rest[0] != _T('d'))
+ if (rest[0] != 'c' && rest[0] != 'd')
{
cerr << "Error: ROS_BOOT_CMD has invalid boot parameter" << endl;
return false;
}
- if (rest[0] == _T('c'))
+ if (rest[0] == 'c')
{
/* ROS_BOOT_CMD boots from hdd */
return true;
}
- pos = m_BootCmd.find(_T("-cdrom "));
+ pos = m_BootCmd.find("-cdrom ");
if (pos == string::npos)
{
cerr << "Error: ROS_BOOT_CMD misses cdrom parameter" << endl;
cerr << "Error: ROS_BOOT_CMD misses cdrom parameter" << endl;
return false;
}
- pos = rest.find(_T(" "));
+ pos = rest.find(" ");
if (pos != string::npos)
{
rest = rest.substr(0, pos);
if (m_PidFile.length () && isFileExisting(m_PidFile))
{
cerr << "Deleting pid file " << m_PidFile << endl;
- _tremove(m_PidFile.c_str ());
+ remove(m_PidFile.c_str ());
}
cerr << "Opening Data Source:" << m_BootCmd << endl;
conf_parser.getStringValue (RosBootTest::ROS_CD_IMAGE, m_CDImage);
}
/* reset boot cmd */
- m_BootCmd = _T("");
+ m_BootCmd = "";
conf_parser.getIntValue (RosBootTest::ROS_MAX_TIME, m_MaxTime);
if (m_PidFile.length ())
{
- _tremove(m_PidFile.c_str ());
+ remove(m_PidFile.c_str ());
}
}
{
line.erase (0, line.find (RosBootTest::ROS_SYSREG_CHECKPOINT) +
RosBootTest::ROS_SYSREG_CHECKPOINT.length ());
- if (!_tcsncmp(line.c_str (), m_Checkpoint.c_str (), m_Checkpoint.length ()))
+ if (!strncmp(line.c_str (), m_Checkpoint.c_str (), m_Checkpoint.length ()))
{
state = DebugStateCPReached;
break;
}
- if (line.find (_T("*** Fatal System Error")) != string::npos)
+ if (line.find ("*** Fatal System Error") != string::npos)
{
cerr << "Blue Screen of Death detected" <<endl;
if (m_Checkpoints.size ())
m_Checkpoints.erase (m_Checkpoints.begin ());
cerr << cp << endl;
}while(m_Checkpoints.size ());
- cerr << _T("----------------------------------") << endl;
+ cerr << "----------------------------------" << endl;
}
if (i + 1 < debug_data.size () )
{
cerr << data << endl;
i++;
}
- cerr << _T("----------------------------------") << endl;
+ cerr << "----------------------------------" << endl;
}
state = DebugStateBSODDetected;
break;
}
- else if (line.find (_T("Unhandled exception")) != string::npos)
+ else if (line.find ("Unhandled exception") != string::npos)
{
- if (m_CriticalImage == _T("IGNORE"))
+ if (m_CriticalImage == "IGNORE")
{
///
/// ignoring all user-mode exceptions
///
string address = debug_data[i+2];
- string::size_type pos = address.find_last_of (_T(" "));
+ string::size_type pos = address.find_last_of (" ");
if (pos == string::npos)
{
cerr << "Error: trace is not available (corrupted debug info" << endl;
///
string modulename = debug_data[i+3];
- pos = modulename.find_last_of (_T("\\"));
+ pos = modulename.find_last_of ("\\");
if (pos == string::npos)
{
cerr << "Error: trace is not available (corrupted debug info" << endl;
continue;
}
- pos = appname.find_last_of (_T("."));
+ pos = appname.find_last_of (".");
if (pos == string::npos)
{
cerr << "Error: trace is not available (corrupted debug info" << endl;
if (m_DebugFile.length ())
{
- _tremove(m_DebugFile.c_str ());
+ remove(m_DebugFile.c_str ());
file.open (m_DebugFile.c_str ());
}
}
lines += (vect.size() -prev_count); //WTF?
}
- m_DataSource->closeSource();
if (write_log)
{
file.close();
{
using std::vector;
- string SymbolFile::VAR_ROS_OUTPUT = _T("ROS_OUTPUT");
- string SymbolFile::ROS_ADDR2LINE = _T("ROS_ADDR2LINE");
- string SymbolFile::m_SymbolPath= _T("");
- string SymbolFile::m_SymResolver= _T("");
+ string SymbolFile::VAR_ROS_OUTPUT = "ROS_OUTPUT";
+ string SymbolFile::ROS_ADDR2LINE = "ROS_ADDR2LINE";
+ string SymbolFile::m_SymbolPath= "";
+ string SymbolFile::m_SymResolver= "";
SymbolFile::SymbolMap SymbolFile::m_Map;
//---------------------------------------------------------------------------------------
vector<string> vect;
string current_dir;
- if (Path == _T(""))
+ if (Path == "")
{
- current_dir = _T("output-i386");
+ current_dir = "output-i386";
EnvironmentVariable::getValue(SymbolFile::VAR_ROS_OUTPUT, current_dir);
}
else
}
string val = current_dir;
- val.insert (val.length()-1, _T("\\*"));
+ val.insert (val.length()-1, "\\*");
- struct _tfinddatai64_t c_file;
- intptr_t hFile = _tfindfirsti64(val.c_str(), &c_file);
+ struct _finddatai64_t c_file;
+ intptr_t hFile = _findfirsti64(val.c_str(), &c_file);
if (hFile == -1L)
{
do
{
- TCHAR * pos;
- if ((pos = _tcsstr(c_file.name, _T(".nostrip."))))
+ char * pos;
+ if ((pos = strstr(c_file.name, ".nostrip.")))
{
- size_t len = _tcslen(pos);
+ size_t len = strlen(pos);
string modulename = c_file.name;
string filename = modulename;
modulename.erase(modulename.length() - len, len);
string path = current_dir;
- path.insert (path.length () -1, _T("\\"));
+ path.insert (path.length () -1, "\\");
path.insert (path.length () -1, filename);
#ifdef NDEBUG
cerr << "Module Name " << modulename << endl << "File Name " << path << endl;
if (c_file.name[0] != _T('.'))
{
string path = current_dir;
- path.insert (path.length ()-1, _T("\\"));
+ path.insert (path.length ()-1, "\\");
path.insert (path.length ()-1, c_file.name);
vect.push_back (path);
}
current_dir = vect.front ();
vect.erase (vect.begin());
val = current_dir;
- val.insert (val.length() -1, _T("\\*"));
+ val.insert (val.length() -1, "\\*");
hFile = _tfindfirsti64(val.c_str(), &c_file);
if (hFile != -1L)
{
{
SymbolMap::const_iterator it = m_Map.find (module_name);
- if (it == m_Map.end () || m_SymResolver == _T(""))
+ if (it == m_Map.end () || m_SymResolver == "")
{
cerr << "SymbolFile::resolveAddress> no symbol file or ROS_ADDR2LINE not set" << endl;
return false;
}
- TCHAR szCmd[300];
+ char szCmd[300];
- _stprintf(szCmd, _T("%s %s %s"), m_SymResolver.c_str (), it->second.c_str (), module_address.c_str());
+ sprintf(szCmd, "%s %s %s", m_SymResolver.c_str (), it->second.c_str (), module_address.c_str());
string pipe_cmd(szCmd);
-
+ vector<string> vect;
PipeReader pipe_reader;
- if (!pipe_reader.openPipe (pipe_cmd))
+ if (!pipe_reader.openSource(pipe_cmd))
{
cerr << "SymbolFile::resolveAddress> failed to open pipe" <<pipe_cmd <<endl;
return false;
}
- if (Buffer.capacity () < 100)
- {
- Buffer.reserve (500);
- }
-
- bool ret = pipe_reader.readPipe (Buffer);
- pipe_reader.closePipe ();
+ bool ret = pipe_reader.readSource (vect);
+ pipe_reader.closeSource ();
return ret;
}
using System_::SymbolFile;
#endif
-static const TCHAR USAGE[] =
-_T("sysreg.exe [conf_file]\nconfiguration file (default: sysreg.cfg)");
+static const char USAGE[] =
+"sysreg.exe [conf_file]\nconfiguration file (default: sysreg.cfg)";
-int _tmain(int argc, TCHAR * argv[])
+int main(int argc, char * argv[])
{
ConfigParser config;
- TCHAR DefaultConfig[] = _T("sysreg.cfg");
- TCHAR *ConfigFile;
+ char DefaultConfig[] = "sysreg.cfg";
+ char *ConfigFile;
if ((argc > 2))
{
}
string envvar;
- string ros = _T("ROS_OUTPUT");
+ string ros = "ROS_OUTPUT";
config.getStringValue (ros, envvar);
#if 0
SymbolFile::initialize (config, envvar);
sysreg.cpp \
file_reader.cpp \
os_support.cpp \
- unicode.cpp \
)
SYSREGBUILD_OBJECTS = \
$(ECHO_CC)
${host_gpp} $(SYSREGBUILD_HOST_CFLAGS) -c $< -o $@
-$(SYSREGBUILD_INT_)unicode.o: $(SYSREGBUILD_BASE_)unicode.cpp | $(SYSREGBUILD_INT)
- $(ECHO_CC)
- ${host_gpp} $(SYSREGBUILD_HOST_CFLAGS) -c $< -o $@
-
.PHONY: sysregbuild_clean
sysreg_clean:
-@$(rm) $(SYSREGBUILD_TARGET) $(SYSREGBUILD_OBJECTS) 2>$(NUL)
+++ /dev/null
-#include "unicode.h"
-
-#include <stdlib.h>
-#include <stdio.h>
-
-namespace System_
-{
-//---------------------------------------------------------------------------------------
- bool UnicodeConverter::ansi2Unicode(char * abuf, wchar_t *outbuf, size_t length)
- {
- size_t i = 0;
- int conv;
-
- while((conv = mbtowc(&outbuf[i], &abuf[i], length - i)))
- {
- i += conv;
- if (i == length)
- break;
- }
- outbuf[i] = L'\0';
-
- if (i)
- {
- return true;
- }
- else
- {
- return false;
- }
- }
-} // end of namespace System_
+++ /dev/null
-#ifndef UNICODE_H__
-#define UNICODE_H__ // unicode.h
-
-#include "user_types.h"
-
-namespace System_
-{
-
- class UnicodeConverter
- {
- public:
-//---------------------------------------------------------------------------------------
-///
-/// UnicodeConverter
-///
-/// Description: destructor of class UnicodeConverter
-
- virtual ~UnicodeConverter()
- {}
-
-//---------------------------------------------------------------------------------------
-///
-/// UnicodeConverter
-///
-/// Description: converts an ANSI buffer to wide character buffer
-/// using standard c routines
-///
-/// Note: make sure before calling that outbuf is big enough to receive the result
-///
-/// @param abuf ansi buffer used a source
-/// @param outbuf wide character buffer receives result
-/// @param length length of abuf
-///
-/// @return bool
-
- static bool ansi2Unicode(char * abuf, wchar_t * outbuf, size_t length);
-
-
- protected:
-//---------------------------------------------------------------------------------------
-///
-/// UnicodeConverter
-///
-/// Description: constructor of class UnicodeConverter
-
- UnicodeConverter()
- {}
-
- }; // end of class UnicodeConverter
-
-
-
-} // end of namespace System_
-
-#endif /* end of UNICODE_H__ */
#include <iostream>
#ifndef __LINUX__
- #include <tchar.h>
-#else
- #define TCHAR char
- #define tstrcpy strcpy
- #define _tcstok strtok
- #define _tcschr strchr
- #define _tcscat strcat
- #define _tcscpy(str1, str2) strcpy(str1, str2)
- #define _tcslen(str1) strlen(str1)
- #define _tcstod strtod
- #define _tcscmp strcmp
- #define _tcstoul strtoul
- #define _tcsncmp strncmp
- #define _tremove remove
- #define _ttoi atoi
- #define _T(x) x
- #define _tfopen fopen
- #define _tcsstr strstr
- #define _fgetts fgets
- #define _tgetenv getenv
- #define _tmain main
- #define _tcstol strtol
+#define popen _popen
+#define pclose _pclose
#endif
- typedef std::basic_string<TCHAR> string;
- typedef std::basic_istringstream<TCHAR> istringstream;
+ typedef std::basic_string<char> string;
+ typedef std::basic_istringstream<char> istringstream;
#ifdef UNICODE
projects / reactos.git / commitdiff