// Ugh, this is ugly.
static bool ParseLine(const std::string& line, std::string* keyOut, std::string* valueOut, std::string* commentOut)
{
int FirstEquals = (int)line.find("=", 0);
int FirstCommentChar = -1;
// Comments
if (FirstCommentChar < 0)
FirstCommentChar =
(int)line.find("#", FirstEquals > 0 ? FirstEquals : 0);
if (FirstCommentChar < 0 && line[0] == ';')
FirstCommentChar = 0;
// Allow preservation of spacing before comment
while (FirstCommentChar > 0 && line[FirstCommentChar - 1] <= ' ')
{
FirstCommentChar--;
}
if ((FirstEquals >= 0) && ((FirstCommentChar < 0) || (FirstEquals < FirstCommentChar)))
{
// Yes, a valid key/value line!
*keyOut = StripSpaces(line.substr(0, FirstEquals));
if (commentOut) *commentOut = FirstCommentChar > 0 ? line.substr(FirstCommentChar) : std::string("");
if (valueOut) *valueOut = StripQuotes(StripSpaces(line.substr(FirstEquals + 1, FirstCommentChar - FirstEquals - 1)));
return true;
}
return false;
}
// Return a list of all lines in a section
bool IniFile::GetLines(const char* sectionName, std::vector<std::string>& lines, const bool remove_comments) const
{
const Section* section = GetSection(sectionName);
if (!section)
return false;
lines.clear();
for (std::vector<std::string>::const_iterator iter = section->lines.begin(); iter != section->lines.end(); ++iter)
{
std::string line = StripSpaces(*iter);
if (remove_comments)
{
int commentPos = (int)line.find('#');
if (commentPos == 0)
{
continue;
}
if (commentPos != (int)std::string::npos)
{
line = StripSpaces(line.substr(0, commentPos));
}
}
lines.push_back(line);
}
return true;
}
static void
ParseLine(char *line,char *var, char *data)
/*
** This routine divides the line into two parts. The variable, and
** the 'string'. If the line is a comment, the 'data' variable will
** contain the line and 'var' will be empty.
*/
{char *str;
StripSpaces(line);
*data='\0';
*var='\0';
if ((line[0]==';') || (line[0]=='%') || (line[0]=='#'))
{
strcpy(data,line);
return;
}
strcpy(var,line);
str=strpbrk(var," =\t");
if (str!=NULL)
{
strcpy(data,str);
*str='\0';
if ((*data==' ') || (*data=='\t')) StripSpaces(data);
if (*data=='=') {*data=' ';StripSpaces(data);}
}
}
// Return a list of all lines in a section
bool IniFile::GetLines(const std::string& sectionName, std::vector<std::string>* lines, const bool remove_comments) const
{
const Section* section = GetSection(sectionName);
if (!section)
return false;
lines->clear();
for (std::string line : section->lines)
{
line = StripSpaces(line);
if (remove_comments)
{
size_t commentPos = line.find('#');
if (commentPos == 0)
{
continue;
}
if (commentPos != std::string::npos)
{
line = StripSpaces(line.substr(0, commentPos));
}
}
lines->push_back(line);
}
return true;
}
bool IniFile::Section::GetLines(std::vector<std::string>* lines, const bool remove_comments) const
{
for (const std::string& line : m_lines)
{
std::string stripped_line = StripSpaces(line);
if (remove_comments)
{
size_t commentPos = stripped_line.find('#');
if (commentPos == 0)
{
continue;
}
if (commentPos != std::string::npos)
{
stripped_line = StripSpaces(stripped_line.substr(0, commentPos));
}
}
lines->push_back(std::move(stripped_line));
}
return true;
}
void DOS_Shell::CMD_CHOICE(char * args){
HELP("CHOICE");
static char defchoice[3] = {'y','n',0};
char *rem = NULL, *ptr;
bool optN = ScanCMDBool(args,"N");
bool optS = ScanCMDBool(args,"S"); //Case-sensitive matching
ScanCMDBool(args,"T"); //Default Choice after timeout
if (args) {
char *last = strchr(args,0);
StripSpaces(args);
rem = ScanCMDRemain(args);
if (rem && *rem && (tolower(rem[1]) != 'c')) {
WriteOut(MSG_Get("SHELL_ILLEGAL_SWITCH"),rem);
return;
}
if (args == rem) args = strchr(rem,0)+1;
if (rem) rem += 2;
if(rem && rem[0]==':') rem++; /* optional : after /c */
if (args > last) args = NULL;
}
if (!rem || !*rem) rem = defchoice; /* No choices specified use YN */
ptr = rem;
Bit8u c;
if(!optS) while ((c = *ptr)) *ptr++ = (char)toupper(c); /* When in no case-sensitive mode. make everything upcase */
if(args && *args ) {
StripSpaces(args);
size_t argslen = strlen(args);
if(argslen>1 && args[0] == '"' && args[argslen-1] =='"') {
args[argslen-1] = 0; //Remove quotes
args++;
}
WriteOut(args);
}
/* Show question prompt of the form [a,b]? where a b are the choice values */
if (!optN) {
if(args && *args) WriteOut(" ");
WriteOut("[");
size_t len = strlen(rem);
for(size_t t = 1; t < len; t++) {
WriteOut("%c,",rem[t-1]);
}
WriteOut("%c]?",rem[len-1]);
}
Bit16u n=1;
do {
DOS_ReadFile (STDIN,&c,&n);
} while (!c || !(ptr = strchr(rem,(optS?c:toupper(c)))));
c = optS?c:(Bit8u)toupper(c);
DOS_WriteFile (STDOUT,&c, &n);
dos.return_code = (Bit8u)(ptr-rem+1);
}
void DOS_Shell::CMD_ECHO(char * args){
if (!*args) {
if (echo) { WriteOut(MSG_Get("SHELL_CMD_ECHO_ON"));}
else { WriteOut(MSG_Get("SHELL_CMD_ECHO_OFF"));}
return;
}
char buffer[512];
char* pbuffer = buffer;
safe_strncpy(buffer,args,512);
StripSpaces(pbuffer);
if (strcasecmp(pbuffer,"OFF")==0) {
echo=false;
return;
}
if (strcasecmp(pbuffer,"ON")==0) {
echo=true;
return;
}
if(strcasecmp(pbuffer,"/?")==0) { HELP("ECHO"); }
args++;//skip first character. either a slash or dot or space
size_t len = strlen(args); //TODO check input of else ook nodig is.
if(len && args[len - 1] == '\r') {
LOG(LOG_MISC,LOG_WARN)("Hu ? carriage return already present. Is this possible?");
WriteOut("%s\n",args);
} else WriteOut("%s\r\n",args);
}
bool IniFile::Section::Get(const char* key, std::vector<std::string>& values)
{
std::string temp;
bool retval = Get(key, &temp, 0);
if (!retval || temp.empty())
{
return false;
}
// ignore starting , if any
size_t subStart = temp.find_first_not_of(",");
size_t subEnd;
// split by ,
while (subStart != std::string::npos) {
// Find next ,
subEnd = temp.find_first_of(",", subStart);
if (subStart != subEnd)
// take from first char until next ,
values.push_back(StripSpaces(temp.substr(subStart, subEnd - subStart)));
// Find the next non , char
subStart = temp.find_first_not_of(",", subEnd);
}
return true;
}
void DOS_Shell::CMD_TYPE(char * args) {
HELP("TYPE");
StripSpaces(args);
if (!*args) {
WriteOut(MSG_Get("SHELL_SYNTAXERROR"));
return;
}
Bit16u handle;
char * word;
nextfile:
word=StripArg(args);
if (!DOS_OpenFile(word,0,&handle)) {
WriteOut(MSG_Get("SHELL_CMD_FILE_NOT_FOUND"),word);
return;
}
Bit16u n;Bit8u c;
do {
n=1;
DOS_ReadFile(handle,&c,&n);
if (c==0x1a) break; // stop at EOF
DOS_WriteFile(STDOUT,&c,&n);
} while (n);
DOS_CloseFile(handle);
if (*args) goto nextfile;
}
bool Toolbox::IsInteger(const std::string& str)
{
std::string s = StripSpaces(str);
if (s.size() == 0)
{
return false;
}
size_t pos = 0;
if (s[0] == '-')
{
if (s.size() == 1)
{
return false;
}
pos = 1;
}
while (pos < s.size())
{
if (!isdigit(s[pos]))
{
return false;
}
pos++;
}
return true;
}
void SimpleParametersCategory(int num_measures, char *llog, statistics stats, FILE **fOut)
{
int i, j;
char lkk1[LONGSTRINGSIZE], lkk2[LONGSTRINGSIZE], lkk3[LONGSTRINGSIZE];
llog[0]=58; /* ':' */
j=1;
for (i = 1; i <= (num_measures); i=i+2) {
ReadSubKey(lkk1, llog, &j, ':', ':', 0);
StripSpaces(lkk1);
ReadSubKey(lkk2, llog, &j, ':', ':', 0);
StripSpaces(lkk2);
sprintf(lkk3, "%s:#%s#:%s:%E:%E:LIN_DOUBLE:OPT", lkk1, lkk1, lkk2, stats.min[i], stats.max[i]);
fprintf(*fOut, "%s\n", lkk3);
}
}
bool IniFile::Section::Get(const std::string& key, std::vector<std::string>* out) const
{
std::string temp;
bool retval = Get(key, &temp);
if (!retval || temp.empty())
{
return false;
}
// ignore starting comma, if any
size_t subStart = temp.find_first_not_of(",");
// split by comma
while (subStart != std::string::npos)
{
// Find next comma
size_t subEnd = temp.find(',', subStart);
if (subStart != subEnd)
{
// take from first char until next comma
out->push_back(StripSpaces(temp.substr(subStart, subEnd - subStart)));
}
// Find the next non-comma char
subStart = temp.find_first_not_of(",", subEnd);
}
return true;
}
void DOS_Shell::CMD_CHDIR(char * args) {
HELP("CHDIR");
StripSpaces(args);
char sargs[CROSS_LEN];
if (*args && !DOS_GetSFNPath(args,sargs,false)) {
WriteOut(MSG_Get("SHELL_ILLEGAL_PATH"));
return;
}
Bit8u drive = DOS_GetDefaultDrive()+'A';
char dir[DOS_PATHLENGTH];
if (!*args) {
DOS_GetCurrentDir(0,dir,true);
WriteOut("%c:\\%s\n",drive,dir);
} else if(strlen(args) == 2 && args[1]==':') {
Bit8u targetdrive = (args[0] | 0x20)-'a' + 1;
unsigned char targetdisplay = *reinterpret_cast<unsigned char*>(&args[0]);
if(!DOS_GetCurrentDir(targetdrive,dir,true)) {
if(drive == 'Z') {
WriteOut(MSG_Get("SHELL_EXECUTE_DRIVE_NOT_FOUND"),toupper(targetdisplay));
} else {
WriteOut(MSG_Get("SHELL_ILLEGAL_PATH"));
}
return;
}
WriteOut("%c:\\%s\n",toupper(targetdisplay),dir);
if(drive == 'Z')
WriteOut(MSG_Get("SHELL_CMD_CHDIR_HINT"),toupper(targetdisplay));
} else if (!DOS_ChangeDir(sargs)) {
/* Changedir failed. Check if the filename is longer then 8 and/or contains spaces */
std::string temps(args),slashpart;
std::string::size_type separator = temps.find_first_of("\\/");
if(!separator) {
slashpart = temps.substr(0,1);
temps.erase(0,1);
}
separator = temps.find_first_of("\\/");
if(separator != std::string::npos) temps.erase(separator);
separator = temps.find_first_of("\"");
if(separator != std::string::npos) temps.erase(separator);
separator = temps.rfind('.');
if(separator != std::string::npos) temps.erase(separator);
separator = temps.find(' ');
if(separator != std::string::npos) {/* Contains spaces */
temps.erase(separator);
if(temps.size() >6) temps.erase(6);
temps += "~1";
WriteOut(MSG_Get("SHELL_CMD_CHDIR_HINT_2"),temps.insert(0,slashpart).c_str());
} else {
if (drive == 'Z') {
WriteOut(MSG_Get("SHELL_CMD_CHDIR_HINT_3"));
} else {
WriteOut(MSG_Get("SHELL_CMD_CHDIR_ERROR"),args);
}
}
}
}
void IniFile::ParseLine(const std::string& line, std::string* keyOut, std::string* valueOut)
{
if (line[0] == '#')
return;
size_t firstEquals = line.find("=", 0);
if (firstEquals != std::string::npos)
{
// Yes, a valid line!
*keyOut = StripSpaces(line.substr(0, firstEquals));
if (valueOut)
{
*valueOut = StripQuotes(StripSpaces(line.substr(firstEquals + 1, std::string::npos)));
}
}
}
//===============================================================================================
// FUNCTION: GetRemaining
// PURPOSE: Return the remaining text.
//
LPSTR CTextLineParser::GetRemaining()
{
MEMBERASSERT();
if (!m_pszNext || !m_pszNext[0])
return NULL;
if (m_cSeperator != ' ')
return StripSpaces(m_pszNext);
return m_pszNext;
}
void USBDeviceAddToWhitelistDialog::AddUSBDeviceToWhitelist()
{
const std::string vid_string = StripSpaces(device_vid_textbox->text().toStdString());
const std::string pid_string = StripSpaces(device_pid_textbox->text().toStdString());
if (!IsValidUSBIDString(vid_string))
{
// i18n: Here, VID means Vendor ID (for a USB device).
ModalMessageBox vid_warning_box(this);
vid_warning_box.setIcon(QMessageBox::Warning);
vid_warning_box.setWindowTitle(tr("USB Whitelist Error"));
// i18n: Here, VID means Vendor ID (for a USB device).
vid_warning_box.setText(tr("The entered VID is invalid."));
vid_warning_box.setStandardButtons(QMessageBox::Ok);
vid_warning_box.exec();
return;
}
if (!IsValidUSBIDString(pid_string))
{
// i18n: Here, PID means Product ID (for a USB device).
ModalMessageBox pid_warning_box(this);
pid_warning_box.setIcon(QMessageBox::Warning);
pid_warning_box.setWindowTitle(tr("USB Whitelist Error"));
// i18n: Here, PID means Product ID (for a USB device).
pid_warning_box.setText(tr("The entered PID is invalid."));
pid_warning_box.setStandardButtons(QMessageBox::Ok);
pid_warning_box.exec();
return;
}
const u16 vid = static_cast<u16>(std::stoul(vid_string, nullptr, 16));
const u16 pid = static_cast<u16>(std::stoul(pid_string, nullptr, 16));
if (SConfig::GetInstance().IsUSBDeviceWhitelisted({vid, pid}))
{
ModalMessageBox::critical(this, tr("Error"), tr("This USB device is already whitelisted."));
return;
}
SConfig::GetInstance().m_usb_passthrough_devices.emplace(vid, pid);
SConfig::GetInstance().SaveSettings();
accept();
}
void DOS_Shell::CMD_RMDIR(char * args) {
HELP("RMDIR");
StripSpaces(args);
char * rem=ScanCMDRemain(args);
if (rem) {
WriteOut(MSG_Get("SHELL_ILLEGAL_SWITCH"),rem);
return;
}
if (!DOS_RemoveDir(args)) {
WriteOut(MSG_Get("SHELL_CMD_RMDIR_ERROR"),args);
}
}
//===============================================================================================
// FUNCTION: GetNextItem
// PURPOSE: Returns a pointer to the next data item.
//
LPSTR CTextLineParser::GetNextItem(BOOL bCollectSeperators)
{
MEMBERASSERT();
if (!m_pszNext)
return NULL;
if (!m_pszNext[0])
{
m_pszNext = NULL;
return "";
}
LPSTR pszStart = m_pszNext;
if (m_cSeperator != ' ')
pszStart = StripSpaces(m_pszNext);
LPSTR pszEnd = pszStart;
if (*pszStart=='"')
{
pszEnd = strchr(++pszStart, '"');
if (pszEnd && *pszEnd)
*pszEnd++ = '\0';
}
if (pszEnd)
pszEnd = strchr(pszEnd, m_cSeperator);
if (pszEnd)
{
*pszEnd++ = '\0';
if (bCollectSeperators)
while (*pszEnd==m_cSeperator)
*pszEnd++ = '\0';
}
m_pszNext = pszEnd;
if (m_cSeperator != ' ')
pszStart = StripSpaces(pszStart);
return pszStart;
}
void DOS_Shell::CMD_RENAME(char * args){
HELP("RENAME");
StripSpaces(args);
if (!*args) {SyntaxError();return;}
if ((strchr(args,'*')!=NULL) || (strchr(args,'?')!=NULL) ) { WriteOut(MSG_Get("SHELL_CMD_NO_WILD"));return;}
char * arg1=StripArg(args);
StripSpaces(args);
if (!*args) {SyntaxError();return;}
char* slash = strrchr(arg1,'\\');
if (slash) {
/* If directory specified (crystal caves installer)
* rename from c:\X : rename c:\abc.exe abc.shr.
* File must appear in C:\
* Ren X:\A\B C => ren X:\A\B X:\A\C */
char dir_source[DOS_PATHLENGTH + 4] = {0}; //not sure if drive portion is included in pathlength
//Copy first and then modify, makes GCC happy
safe_strncpy(dir_source,arg1,DOS_PATHLENGTH + 4);
char* dummy = strrchr(dir_source,'\\');
if (!dummy) { //Possible due to length
WriteOut(MSG_Get("SHELL_ILLEGAL_PATH"));
return;
}
dummy++;
*dummy = 0;
//Maybe check args for directory, as I think that isn't allowed
//dir_source and target are introduced for when we support multiple files being renamed.
char target[DOS_PATHLENGTH+CROSS_LEN + 5] = {0};
strcpy(target,dir_source);
strncat(target,args,CROSS_LEN);
DOS_Rename(arg1,target);
} else {
DOS_Rename(arg1,args);
}
}
std::string evdevDevice::Button::GetName() const
{
// Buttons below 0x100 are mostly keyboard keys, and the names make sense
if (m_code < 0x100)
{
const char* name = libevdev_event_code_get_name(EV_KEY, m_code);
if (name)
return StripSpaces(name);
}
// But controllers use codes above 0x100, and the standard label often doesn't match.
// We are better off with Button 0 and so on.
return "Button " + std::to_string(m_index);
}
std::string
NetPlayLaunchConfig::GetTraversalHostFromIniConfig(const IniFile::Section& netplay_section)
{
std::string host;
netplay_section.Get("TraversalServer", &host, DEFAULT_TRAVERSAL_HOST);
host = StripSpaces(host);
if (host.empty())
return DEFAULT_TRAVERSAL_HOST;
return host;
}
void DOS_Shell::CMD_SET(char * args) {
HELP("SET");
StripSpaces(args);
std::string line;
if (!*args) {
/* No command line show all environment lines */
Bitu count=GetEnvCount();
for (Bitu a=0;a<count;a++) {
if (GetEnvNum(a,line)) WriteOut("%s\n",line.c_str());
}
return;
}
//There are args:
char * pcheck = args;
while ( *pcheck && (*pcheck == ' ' || *pcheck == '\t')) pcheck++;
if (*pcheck && strlen(pcheck) >3 && (strncasecmp(pcheck,"/p ",3) == 0)) E_Exit("Set /P is not supported. Use Choice!");
char * p=strpbrk(args, "=");
if (!p) {
if (!GetEnvStr(args,line)) WriteOut(MSG_Get("SHELL_CMD_SET_NOT_SET"),args);
WriteOut("%s\n",line.c_str());
} else {
*p++=0;
/* parse p for envirionment variables */
char parsed[CMD_MAXLINE];
char* p_parsed = parsed;
while(*p) {
if(*p != '%') *p_parsed++ = *p++; //Just add it (most likely path)
else if( *(p+1) == '%') {
*p_parsed++ = '%'; p += 2; //%% => %
} else {
char * second = strchr(++p,'%');
if(!second) continue; *second++ = 0;
std::string temp;
if (GetEnvStr(p,temp)) {
std::string::size_type equals = temp.find('=');
if (equals == std::string::npos) continue;
strcpy(p_parsed,temp.substr(equals+1).c_str());
p_parsed += strlen(p_parsed);
}
p = second;
}
}
*p_parsed = 0;
/* Try setting the variable */
if (!SetEnv(args,parsed)) {
WriteOut(MSG_Get("SHELL_CMD_SET_OUT_OF_SPACE"));
}
}
}
evdevDevice::evdevDevice(const std::string& devnode) : m_devfile(devnode)
{
// The device file will be read on one of the main threads, so we open in non-blocking mode.
m_fd = open(devnode.c_str(), O_RDWR | O_NONBLOCK);
int ret = libevdev_new_from_fd(m_fd, &m_dev);
if (ret != 0)
{
// This useally fails because the device node isn't an evdev device, such as /dev/input/js0
m_initialized = false;
close(m_fd);
return;
}
m_name = StripSpaces(libevdev_get_name(m_dev));
// Controller buttons (and keyboard keys)
int num_buttons = 0;
for (int key = 0; key < KEY_MAX; key++)
if (libevdev_has_event_code(m_dev, EV_KEY, key))
AddInput(new Button(num_buttons++, key, m_dev));
// Absolute axis (thumbsticks)
int num_axis = 0;
for (int axis = 0; axis < 0x100; axis++)
if (libevdev_has_event_code(m_dev, EV_ABS, axis))
{
AddAnalogInputs(new Axis(num_axis, axis, false, m_dev),
new Axis(num_axis, axis, true, m_dev));
num_axis++;
}
// Force feedback
if (libevdev_has_event_code(m_dev, EV_FF, FF_PERIODIC))
{
for (auto type : {FF_SINE, FF_SQUARE, FF_TRIANGLE, FF_SAW_UP, FF_SAW_DOWN})
if (libevdev_has_event_code(m_dev, EV_FF, type))
AddOutput(new ForceFeedback(type, m_dev));
}
if (libevdev_has_event_code(m_dev, EV_FF, FF_RUMBLE))
{
AddOutput(new ForceFeedback(FF_RUMBLE, m_dev));
}
// TODO: Add leds as output devices
m_initialized = true;
m_interesting = num_axis >= 2 || num_buttons >= 8;
}
std::string GetDeviceName(const LPDIRECTINPUTDEVICE8 device)
{
DIPROPSTRING str = {};
str.diph.dwSize = sizeof(str);
str.diph.dwHeaderSize = sizeof(str.diph);
str.diph.dwHow = DIPH_DEVICE;
std::string result;
if (SUCCEEDED(device->GetProperty(DIPROP_PRODUCTNAME, &str.diph)))
{
result = StripSpaces(UTF16ToUTF8(str.wsz));
}
return result;
}
void IniFile::Section::Set(const char* key, const char* newValue)
{
std::string value, commented;
std::string* line = GetLine(key, &value, &commented);
if (line)
{
// Change the value - keep the key and comment
*line = StripSpaces(key) + " = " + newValue + commented;
}
else
{
// The key did not already exist in this section - let's add it.
lines.push_back(std::string(key) + " = " + newValue);
}
}
void DOS_Shell::CMD_DELETE(char * args) {
HELP("DELETE");
/* Command uses dta so set it to our internal dta */
RealPt save_dta=dos.dta();
dos.dta(dos.tables.tempdta);
char * rem=ScanCMDRemain(args);
if (rem) {
WriteOut(MSG_Get("SHELL_ILLEGAL_SWITCH"),rem);
return;
}
/* If delete accept switches mind the space infront of them. See the dir /p code */
char full[DOS_PATHLENGTH],sfull[DOS_PATHLENGTH+2];
char buffer[CROSS_LEN];
args = ExpandDot(args,buffer);
StripSpaces(args);
if (!DOS_Canonicalize(args,full)) { WriteOut(MSG_Get("SHELL_ILLEGAL_PATH"));return; }
//TODO Maybe support confirmation for *.* like dos does.
char spath[DOS_PATHLENGTH],sargs[DOS_PATHLENGTH];
if (!DOS_GetSFNPath(args,spath,false)) {
WriteOut(MSG_Get("SHELL_CMD_DEL_ERROR"),args);
return;
}
sprintf(sargs,"\"%s\"",spath);
bool res=DOS_FindFirst(sargs,0xffff & ~DOS_ATTR_VOLUME);
if (!res) {
WriteOut(MSG_Get("SHELL_CMD_DEL_ERROR"),args);
dos.dta(save_dta);
return;
}
//end can't be 0, but if it is we'll get a nice crash, who cares :)
char * end=strrchr(full,'\\')+1;*end=0;
char name[DOS_NAMELENGTH_ASCII],lname[LFN_NAMELENGTH+1];
Bit32u size;Bit16u time,date;Bit8u attr;
DOS_DTA dta(dos.dta());
while (res) {
dta.GetResult(name,lname,size,date,time,attr);
if (!(attr & (DOS_ATTR_DIRECTORY|DOS_ATTR_READ_ONLY))) {
strcpy(end,name);
strcpy(sfull,full);
if (uselfn) sprintf(sfull,"\"%s\"",full);
if (!DOS_UnlinkFile(sfull)) WriteOut(MSG_Get("SHELL_CMD_DEL_ERROR"),full);
}
res=DOS_FindNext();
}
dos.dta(save_dta);
}
void DSPDebuggerLLE::OnAddrBoxChange(wxCommandEvent& event)
{
wxString txt = m_addr_txtctrl->GetValue();
auto text = StripSpaces(WxStrToStr(txt));
if (text.size())
{
u32 addr;
sscanf(text.c_str(), "%04x", &addr);
if (JumpToAddress(addr))
m_addr_txtctrl->SetBackgroundColour(*wxWHITE);
else
m_addr_txtctrl->SetBackgroundColour(*wxRED);
}
event.Skip();
}
void DSPDebuggerLLE::OnAddrBoxChange(wxCommandEvent& event)
{
wxTextCtrl* pAddrCtrl = (wxTextCtrl*)m_Toolbar->FindControl(ID_ADDRBOX);
wxString txt = pAddrCtrl->GetValue();
auto text = StripSpaces(WxStrToStr(txt));
if (text.size())
{
u32 addr;
sscanf(text.c_str(), "%04x", &addr);
if (JumpToAddress(addr))
pAddrCtrl->SetBackgroundColour(*wxWHITE);
else
pAddrCtrl->SetBackgroundColour(*wxRED);
}
event.Skip();
}
void ComplexParametersCategory(char *llog, statistics stats, FILE **fOut, FILE **fcfg)
{
int i, j;
char lkk1[LONGSTRINGSIZE], lkk2[LONGSTRINGSIZE];
fgets2(lkk, LONGSTRINGSIZE, *fcfg);
while ((lkk[0] != '#') && (lkk[0] != '\0') && (!feof(*fcfg))) {
i=strpos2(lkk, ":OPT", 1);
if (lkk[0]=='*') /*if the line is comment out, simply ignore it*/
i=0;
if (i) { /* line with OPT */
j=1;
ReadSubKey(lkk1, lkk, &j, '#', '#', 5); /* lkk1=symbol */
lkk2[0]='\0';
i=0;
j=1;
while ( (strcmp (lkk1, lkk2)) && (j<strlen(llog) ) ) {
i++;
ReadSubKey(lkk2, llog, &j, ':', ':', 0);
StripSpaces(lkk2);
}
if (j==strlen(llog)) {
printf("auxfunc_log.c - ComplexParametersCategory -- Wrong config opened.\n");
exit(EXIT_FAILURE);
}
ReadSubKey(lkk2, llog, &j, ':', ':', 0); /*the measured value for the previously text*/
i++; /*the correct position of the value*/
j=1;
ReadSubKey(lkk1, lkk, &j, ':', ':', 0);
strsub(lkk1, lkk, 1, j);
sprintf(lkk2, "%s:%E:%E", lkk2, stats.min[i], stats.max[i]);
strcat(lkk1, lkk2);
ReadSubKey(lkk2, lkk, &j, ':', ':', 0);
ReadSubKey(lkk2, lkk, &j, ':', ':', 0);
ReadSubKey(lkk2, lkk, &j, ':', ':', 0);
strsub(lkk2, lkk, j, (int)strlen(lkk));
strcat(lkk1, lkk2);
fprintf(*fOut, "%s\n", lkk1);
} else { /* line with --- */
fprintf(*fOut, "%s\n", lkk);
}
fgets2(lkk, LONGSTRINGSIZE, *fcfg);
}
}
void CCodeWindow::OnAddrBoxChange(wxCommandEvent& event)
{
if (!GetToolBar()) return;
wxTextCtrl* pAddrCtrl = (wxTextCtrl*)GetToolBar()->FindControl(IDM_ADDRBOX);
wxString txt = pAddrCtrl->GetValue();
std::string text(WxStrToStr(txt));
text = StripSpaces(text);
if (text.size() == 8)
{
u32 addr;
sscanf(text.c_str(), "%08x", &addr);
JumpToAddress(addr);
}
event.Skip(1);
}