void wm_set_name(Display *display, Window shell_window,
string title, string icon)
{
strip_space(title);
strip_space(icon);
if (!title.empty())
XStoreName(display, shell_window, title.chars());
if (!icon.empty())
XSetIconName(display, shell_window, icon.chars());
}
void wm_set_name(Widget shell, string title, string icon)
{
strip_space(title);
strip_space(icon);
XtVaSetValues(shell,
XmNiconName, icon.chars(),
XmNtitle, title.chars(),
XtPointer(0));
#if 0 // This should be done by the shell.
wm_set_name(XtDisplay(shell), XtWindow(shell), title, icon);
#endif
}
// Add command COMMAND to history.
void UndoBuffer::add_command(const string& command, bool exec)
{
string c = command;
strip_space(c);
if (c.empty())
return;
string command_key = exec ? UB_EXEC_COMMAND : UB_COMMAND;
if (!undoing)
{
// Regular command
add_status(command_key, c + "\n" + collector[command_key]);
return;
}
// We're called from undo or redo via process_command() -
// replace currently executed command by its undo command.
#if LOG_UNDO_BUFFER
std::clog << "Adding " << command_key << " = " << quote(command) << "\n";
#endif
assert (history.size() > 0);
assert (current_entry >= 0 && current_entry < history.size());
UndoBufferEntry& entry = history[current_entry];
if (entry.has(command_key))
entry[command_key].prepend(c + '\n');
else
entry[command_key] = c;
done();
}
// store scene to sdcard at name
void files_store_scene_name(const char* name, u8 ext) {
//u32 i;
void* fp;
char namebuf[64] = SCENES_PATH;
u8* pScene;
app_pause();
strcat(namebuf, name);
if(ext) {
// weird..
strip_space(namebuf, 32);
strcat(namebuf, ".scn");
}
print_dbg("\r\n opening scene file for writing: ");
print_dbg(namebuf);
// fill the scene RAM buffer from current state of system
scene_write_buf();
// open FP for writing
fp = fl_fopen(namebuf, "wb");
pScene = (u8*)sceneData;
fl_fwrite((const void*)pScene, sizeof(sceneData_t), 1, fp);
fl_fclose(fp);
// rescan
list_scan(&sceneList, SCENES_PATH);
delay_ms(10);
app_resume();
}
void BreakPoint::process_jdb(string& info_output)
{
int colon = info_output.index(':');
if (colon >= 0)
{
string class_name = info_output.before(colon);
int line_no = get_positive_nr(info_output.after(colon));
if (line_no >= 0 && !class_name.empty())
{
// Strip JDB 1.2 info like `breakpoint', etc.
strip_space(class_name);
int last_space = class_name.index(" ", -1);
if (last_space > 0)
class_name = class_name.after(last_space);
myfile_name = class_name;
myline_nr = line_no;
// Kill this line
int beginning_of_line = colon;
while (beginning_of_line >= 0 &&
info_output[beginning_of_line] != '\n')
beginning_of_line--;
beginning_of_line++;
int next_nl = info_output.index('\n', colon);
if (next_nl >= 0)
info_output = info_output.before(beginning_of_line)
+ info_output.from(next_nl);
else
info_output = info_output.before(beginning_of_line);
}
}
}
static void update_sources(Widget sources, Widget filter)
{
StatusDelay delay("Getting sources");
get_gdb_sources(all_sources);
String pattern_s = XmTextFieldGetString(filter);
string pattern = pattern_s;
XtFree(pattern_s);
strip_space(pattern);
if (pattern.empty())
pattern = "*";
XmTextFieldSetString(filter, XMST(pattern.chars()));
StringArray labels;
uniquify(all_sources, labels);
// Sort and remove duplicates
sort(labels, all_sources);
uniq(labels, all_sources);
// Filter pattern
filter_sources(labels, all_sources, pattern);
// Now set the selection.
bool *selected = new bool[labels.size()];
for (int i = 0; i < labels.size(); i++)
selected[i] = false;
setLabelList(sources, labels.values(),
selected, labels.size(), false, false);
delete[] selected;
}
std::string getFTSEndpoint()
{
const char* path[2] = {"/etc/glite-sd2cache-cron.conf","/opt/glite/etc/glite-sd2cache-cron.conf"};
string line;
vector<std::string>::iterator myVectorIterator;
std::string fts = "";
std::string result = "";
for(int index=0; index<2; index++){
string ifname(path[index]);
ifstream in(ifname.c_str());
if(!in){
continue;
}
string line;
while (!in.eof()) {
getline(in, line);
line = strip_space(line);
if (line.length() && line[0] != '#') {
size_t pos = line.find("=");
if (pos != string::npos) {
string key = strip_space(line.substr(0, pos));
string value = strip_space(line.substr(pos + 1));
ftsendpoint.insert(make_pair(key, value));
}
}
}
map <string, string> ::const_iterator iter = ftsendpoint.find("FTS_HOST");
if (iter != ftsendpoint.end()) {
fts = ftsendpoint.find("FTS_HOST")->second;
if (fts.length() == 0)
fts = "";
}
}
if(fts.length() > 0)
{
fts.erase(0, 1);
fts.erase(fts.length()-1, fts.length());
result = "https://";
result += fts;
result += ":8443/glite-data-transfer-fts/services/FileTransfer";
}
return result;
}
// If the name has the form (PREFIX)(INDEX)(SUFFIX), return INDEX
string DispValue::index(const string& prefix, const string& suffix) const
{
string idx = full_name();
idx = idx.from(int(prefix.length()));
idx = idx.before(int(idx.length() - suffix.length()));
strip_space(idx);
return idx;
}
void write_scn(void) {
char str[128];
memset(str, '\0', 64);
strcpy(str, workingDir);
strcat( str, scene_get_name());
strip_space(str, 64);
strcat(str, ".scn");
printf("\r\n writing .scn binary; name: %s", str);
files_store_scene_name(str);
}
// Get assigned variable
string get_assign_variable(const string& _cmd)
{
string cmd = _cmd;
strip_space(cmd);
if (cmd.contains(":="))
cmd = cmd.before(":=");
else
cmd = cmd.before('='); // Remove assignment and assigned value
if (cmd.contains("set var", 0))
cmd = cmd.after(' '); // Special case `set variable': two-word cmd
if (cmd.contains(' '))
cmd = cmd.after(' '); // Return argument
strip_space(cmd);
return cmd;
}
// True if ARG has the form `FILE:LINE'
bool is_file_pos(const string& arg)
{
#if RUNTIME_REGEX
static regex rxfilepos("[^:]*:[1-9][0-9]*");
#endif
string a = arg;
strip_space(a);
return a.matches(rxfilepos);
}
static Boolean_t
node_name(tgt_node_t *x, const xmlChar *n)
{
assert(x->x_state == NodeAlloc);
if ((n == NULL) || (strlen((char *)n) == 0))
return (False);
x->x_state = NodeName;
x->x_name = strip_space((char *)n);
return (True);
}
void write_json(void) {
char str[128];
memset(str, '\0', 64);
strcpy(str, workingDir);
strcat( str, scene_get_name());
strip_space(str, 64);
strcat(str, ".json");
printf("\r\n writing %s...", str);
net_write_json_native(str);
printf("\r\n done.");
}
static Boolean_t
node_value(tgt_node_t *x, const xmlChar *n, Boolean_t do_strip)
{
assert(x->x_state == NodeName);
if ((n == NULL) || (strlen((char *)n) == NULL))
return (False);
x->x_state = NodeValue;
x->x_value = (do_strip == True) ?
strip_space((char *)n) : strdup((char *)n);
return (True);
}
// Forward Gnuplot error messages to DDD status line
static void SetStatusHP(Agent *, void *client_data, void *call_data)
{
PlotWindowInfo *plot = (PlotWindowInfo *)client_data;
DataLength* dl = (DataLength *) call_data;
string s(dl->data, dl->length);
(void) plot; // Use it
#if 0
if (!plot->active)
{
// Probably an invocation problem
post_gdb_message(s);
return;
}
#endif
if (plot->command != 0)
{
string msg = s;
strip_space(msg);
MString xmsg = tb(msg);
XmCommandError(plot->command, xmsg.xmstring());
}
while (!s.empty())
{
string line;
if (s.contains('\n'))
line = s.before('\n');
else
line = s;
s = s.after('\n');
strip_space(line);
if (!line.empty())
set_status(line);
}
}
void write_gv(void) {
char str[128];
void* fp;
memset(str, '\0', 64);
strcpy(str, workingDir);
strcat( str, scene_get_name());
strip_space(str, 64);
strcat(str, ".gv");
fp = fopen(str, "w");
net_write_dot(fp);
fclose(fp);
}
// store scene to sdcard at name
void files_store_scene_name(const char* name, u8 ext) {
//u32 i;
void* fp;
char namebuf[64] = SCENES_PATH;
u8* pScene;
app_pause();
strcat(namebuf, name);
if(ext) {
// weird..
strip_space(namebuf, 32);
strcat(namebuf, ".scn");
}
print_dbg("\r\n opening scene file for writing: ");
print_dbg(namebuf);
// fill the scene RAM buffer from current state of system
scene_write_buf();
print_dbg("\r\n filled scene binary buffer");
// open FP for writing
fp = fl_fopen(namebuf, "wb");
print_dbg("\r\n opened file for binary write at 0x");
print_dbg_hex((u32)fp);
pScene = (u8*)sceneData;
print_dbg("\r\n writing data from scene buffer at 0x");
print_dbg_hex((u32)pScene);
print_dbg(", size : ");
print_dbg_hex(sizeof(sceneData_t));
// dump the scene data to debug output...
fl_fwrite((const void*)pScene, sizeof(sceneData_t), 1, fp);
fl_fclose(fp);
print_dbg("\r\n ... finished writing, closed file pointer");
// rescan
list_scan(&sceneList, SCENES_PATH);
delay_ms(10);
print_dbg("\r\n re-scanned scene file list and waited.");
app_resume();
}
string display_history_filter(const string& cmd)
{
if (cmd.contains("graph display ", 0))
{
string arg = cmd.after("graph display ");
if (arg.contains("dependent on"))
arg = arg.before("dependent on");
if (arg.contains("now or"))
arg = arg.before("now or");
if (arg.contains("when in"))
arg = arg.before("when in");
strip_space(arg);
// Strip format stuff
while (arg.contains('/', 0))
arg = arg.after(' ');
strip_space(arg);
return arg;
}
return "";
}
string watch_history_filter(const string& cmd)
{
string arg;
if (try_arg(cmd, gdb->watch_command("", WATCH_CHANGE), arg) ||
try_arg(cmd, gdb->watch_command("", WATCH_READ), arg) ||
try_arg(cmd, gdb->watch_command("", WATCH_WRITE), arg) ||
try_arg(cmd, gdb->watch_command("", WATCH_ACCESS), arg))
{
strip_space(arg);
return arg;
}
return "";
}
// Action descriptions
string UndoBuffer::action(const string& command)
{
string c = command;
while (c.contains(REMAP_COMMAND, 0))
c = c.after('\n');
if (c.contains("graph ", 0))
c = c.after("graph ");
if (c.contains(' '))
c = c.before(' ');
strip_space(c);
c.capitalize();
return c;
}
string set_history_filter(const string& cmd)
{
string arg;
if (cmd.contains(" = "))
arg = cmd.after(" = ");
else if (cmd.contains(" := "))
arg = cmd.after(" := ");
if (!arg.empty())
{
strip_space(arg);
return arg;
}
return "";
}
static bool try_arg(const string& cmd, const string& prefix_, string& arg)
{
if (prefix_.empty())
return false; // No such command
string prefix( prefix_ );
if (!prefix.contains(" ", -1))
prefix += " ";
if (cmd.contains(prefix, 0))
{
arg = cmd.after(prefix);
strip_space(arg);
// Strip format stuff
while (arg.contains('/', 0))
arg = arg.after(' ');
if (arg.contains("'", 0))
{
// Quoted arg -- add as unquoted
arg = unquote(arg);
return true;
}
else if (is_file_pos(arg))
{
// FILE:LINE arg -- ignore
return false;
}
else if (arg.matches(rxint))
{
// LINE arg -- ignore
return false;
}
else
{
// Other arg -- add unchanged
return true;
}
}
// Bad prefix -- ignore
return false;
}
void get_cfg_name(char *src, char *name, const char sep)
{
char buf[NAME_MAX];
char *begin = src;
char *end = strchr(src, sep);
size_t nlen;
if (!end) {
fprintf(stderr, "No valid separator in 'get_cfg_name()': %c\n",
sep);
exit(EXIT_FAILURE);
}
nlen = end - begin;
if (nlen > NAME_MAX - 1) {
fprintf(stderr, "String too large in 'get_cfg_name()': %lu\n",
nlen);
exit(EXIT_FAILURE);
}
strncpy(buf, begin, nlen);
buf[nlen] = '\0';
strip_space(buf);
strcpy(name, buf);
} // get_cfg_name()
void get_cfg_value(char *src, char *val, const char sep)
{
char buf[NAME_MAX];
char *begin = strchr(src, sep);
if (!begin) {
fprintf(stderr, "No valid separator in 'get_cfg_value()': %c\n",
sep);
exit(EXIT_FAILURE);
}
begin++; // get past sep
char *end = begin + strlen(src) - 1;
size_t nlen;
nlen = end - begin;
if (nlen > NAME_MAX - 1) {
fprintf(stderr, "String too large in 'get_cfg_value()': %lu\n",
nlen);
exit(EXIT_FAILURE);
}
strncpy(buf, begin, nlen);
buf[nlen] = '\0';
strip_space(buf);
strcpy(val, buf);
} // get_cfg_value()
string break_history_filter(const string& cmd)
{
string arg;
if (try_arg(cmd, "break", arg) ||
try_arg(cmd, "tbreak", arg) ||
try_arg(cmd, "clear", arg) ||
try_arg(cmd, "stop in", arg) ||
try_arg(cmd, "stop at", arg) ||
try_arg(cmd, "b", arg) ||
try_arg(cmd, "ba", arg))
{
strip_space(arg);
if (arg.contains(" if "))
arg = arg.before(" if ");
if (arg.contains(" -if "))
arg = arg.before(" -if ");
if (arg.contains(" {if "))
arg = arg.before(" {if ");
return arg;
}
return "";
}
char *
normalize_path(const char *path) {
size_t nslashes;
char *buf,
*dotdot,
*p;
int do_loop;
const char *dotdot_str = "..",
*slash_dotdot_str = "/..";
const size_t dotdot_str_len = sizeof(dotdot_str) - 1,
slash_dotdot_str_len = sizeof(slash_dotdot_str) - 1;
assert(path);
buf = strip_space(path);
if (*buf == '\0') {
free(buf);
return strdup("/");
}
do {
do_loop = 0;
/* first, get rid of slases in the end,
* as well as repeating slashes
*/
p = strrchr(buf, '\0');
while (*--p == '/' && p > buf) /* we handled the "" case above, so it's ok to *--p */
*p = '\0';
for (p = buf; p = strchr(p, '/'); ++p) {
for (nslashes = 1; *(p + nslashes) == '/'; ++nslashes)
/* empty */;
if (nslashes > 1)
memmove(p, p + nslashes - 1, strlen(p + nslashes - 1) + 1);
}
/* now take care of ".." */
while (dotdot = strstr(buf, slash_dotdot_str)) {
/* while dealing with .. we might introduce
* repeating slashes, so loop the outer loop
* once more...
*/
do_loop = 1;
if (dotdot == buf) {
free(buf);
return strdup("/");
} else if (p = rstrchr(buf, dotdot - 1, '/')) {
memmove(p, dotdot + slash_dotdot_str_len, strlen(dotdot + slash_dotdot_str_len) + 1);
} else {
free(buf);
return strdup("/");
}
}
for (dotdot = buf; dotdot = strstr(dotdot, dotdot_str); dotdot += dotdot_str_len) {
if (dotdot == buf || *(dotdot - 1) != '/') {
free(buf);
return strdup("/");
}
}
if (!strchr(buf, '/')) {
free(buf);
return strdup("/");
}
} while (do_loop);
return buf;
}
void document_propertiest::get_code(
const source_locationt &source_location,
std::string &dest)
{
dest="";
const irep_idt &file=source_location.get_file();
const irep_idt &line=source_location.get_line();
if(file=="" || line=="") return;
std::ifstream in(id2string(file));
if(!in)
{
dest+="ERROR: unable to open ";
dest+=id2string(file);
dest+="\n";
return;
}
int line_int=unsafe_string2int(id2string(line));
int line_start=line_int-3,
line_end=line_int+3;
if(line_start<=1) line_start=1;
// skip line_start-1 lines
for(int l=0; l<line_start-1; l++)
{
std::string tmp;
std::getline(in, tmp);
}
// read till line_end
std::list<linet> lines;
for(int l=line_start; l<=line_end && in; l++)
{
lines.push_back(linet());
std::string &line=lines.back().text;
std::getline(in, line);
if(!line.empty() && line[line.size()-1]=='\r')
line.resize(line.size()-1);
lines.back().line_number=l;
}
// remove empty lines at the end and at the beginning
for(std::list<linet>::iterator it=lines.begin();
it!=lines.end();)
{
if(is_empty(it->text))
it=lines.erase(it);
else
break;
}
for(std::list<linet>::iterator it=lines.end();
it!=lines.begin();)
{
it--;
if(is_empty(it->text))
it=lines.erase(it);
else
break;
}
// strip space
strip_space(lines);
// build dest
for(std::list<linet>::iterator it=lines.begin();
it!=lines.end(); it++)
{
std::string line_no=std::to_string(it->line_number);
std::string tmp;
switch(format)
{
case LATEX:
while(line_no.size()<4)
line_no=" "+line_no;
line_no+" ";
tmp+=escape_latex(it->text, true);
if(it->line_number==line_int)
tmp="{\\ttb{}"+tmp+"}";
break;
case HTML:
while(line_no.size()<4)
line_no=" "+line_no;
line_no+" ";
tmp+=escape_html(it->text);
if(it->line_number==line_int)
tmp="<em>"+tmp+"</em>";
break;
}
dest+=tmp+"\n";
}
}
// Get information on current debuggee
ProgramInfo::ProgramInfo()
: file(NO_GDB_ANSWER),
core(NO_GDB_ANSWER),
pid(0),
attached(false),
running(false),
state()
{
if (source_view->have_exec_pos())
{
state = "has stopped";
running = true;
}
else
{
state = "is not being run";
running = false;
}
switch(gdb->type())
{
case GDB:
case PYDB:
case DBG:
{
string ans;
if (gdb->is_windriver_gdb())
{
// Windriver GDB (VxWorks).
// VxWorks allows multiple dynamically relocatable
// programs to be loaded simultaneously. Before a program
// is run, the 'info source' command can report
// information from a source file not related to the
// program just downloaded for debugging. (The WindRiver
// version of gdb does not support the 'info files'
// command.)
// In order to tell DDD that there is indeed a source file
// available, we need to first see if a program has
// already been started. If so, then the 'info source'
// command can be used.
// Otherwise, the 'info sources' command is used, and the
// first file in the list is used, assuming it is related
// to the current program that was downloaded.
// See if the program has been run first
ans = gdb_question("info frame");
if (ans == NO_GDB_ANSWER)
break;
file = "";
if (ans.contains("No stack"))
{
// Then try using info sources and use first file listed
ans = gdb_question("info sources");
if (ans == NO_GDB_ANSWER)
break;
if (ans.contains("Source files for which "
"symbols have been read in:"))
{
file = ans.after("\n");
file = file.before(" ");
file = unquote(file);
}
}
else
{
// Try using `info source'.
ans = gdb_question("info source");
if (ans == NO_GDB_ANSWER)
break;
if (ans.contains("Current source file is "))
{
file = ans.after("Current source file is ");
file = file.before(".\n");
file = unquote(file);
}
}
}
else
{
// Ordinary GDB.
ans = gdb_question("info files");
if (ans == NO_GDB_ANSWER)
break;
file = "";
if (ans.contains("Symbols from "))
{
file = ans.after("Symbols from ");
file = file.before(".\n");
file = unquote(file);
}
}
core = "";
if (ans.contains("core dump"))
{
core = ans.after("core dump");
core = core.after('`');
core = core.before("',");
}
if (ans.contains("process "))
{
string p = ans.after("process ");
pid = atoi(p.chars());
}
attached = ans.contains("attached process ");
ans = gdb_question("info program");
if (ans == NO_GDB_ANSWER)
break;
if (ans.contains("not being run"))
running = false;
else if (ans.contains("\nIt stopped "))
{
state = ans.from("\nIt stopped ");
state = "has " + state.after("\nIt ");
state = state.before('.');
running = true;
}
break;
}
case DBX:
{
if (gdb->is_ladebug())
{
string ans = gdb_question("show process");
// typical answers:
// 1:no process
// There are no processes being debugged.
// 2: process has been paused.
// Current Process: localhost:26177 (a.out) paused.
// 3: process terminated
// Current Process: localhost:13614 (ddd) terminated.
// TODO: treat the terminated case
if (ans != NO_GDB_ANSWER &&
!ans.contains("no processes being debugged"))
{
if (ans.contains("Current Process: "))
{
ans = ans.after(": ");
{
string p = ans.after(":");
p = p.before(" ");
pid = atoi(p.chars());
}
ans = ans.after(" (");
file = ans.before(")");
ans = ans.after(") ");
running = ans.contains("paused");
// ladebug always creates a process.
// It may be "loaded" or attached.
attached = true;
}
}
}
// AD TODO: shouldn't it be an "else" ?
string ans = gdb_question(gdb->debug_command());
if (ans != NO_GDB_ANSWER)
{
if (ans.contains("Current givenfile is ", 0))
ans = ans.after("Current givenfile is ");
else if (ans.contains("Debugging: ", 0))
ans = ans.after(": ");
strip_space(ans);
if (!ans.contains(' ')) // Sanity check
file = ans;
}
break;
}
case XDB:
break; // FIXME
case PERL:
// Use the program we were invoked with
file = gdb->program();
if (file.matches(rxint))
file = ""; // Invoked with a constant expression
if (file.empty())
{
// Not invoked with a program? Use the current file, then.
file = source_view->file_of_cursor();
file = file.before(":");
}
core = "";
break;
case BASH:
// Use the program we were invoked with
file = gdb->program();
if (file.matches(rxint))
file = ""; // Invoked with a constant expression
if (file.empty())
{
// Not invoked with a program? Use the current file, then.
file = source_view->file_of_cursor();
file = file.before(":");
}
core = "";
break;
case JDB:
// Just use the current class.
file = source_view->line_of_cursor();
file = file.before(":");
core = "";
// Save whether JDB's VM is running
static int last_jdb_pid = -1;
static bool jvm_running = false;
if (gdb->pid() != last_jdb_pid)
{
// New JDB: reset info
jvm_running = false;
last_jdb_pid = gdb->pid();
}
// The VM is running iff the prompt contains a backtrace
// level ("[n]").
if (!jvm_running && gdb->prompt().contains("["))
jvm_running = true;
running = jvm_running;
break;
}
if (file == NO_GDB_ANSWER)
{
// As a fallback, get core file and executable from argument list.
// Works only on local file system and is more a guess.
char **argv = saved_argv();
int argc = 0;
while (argv[argc] != 0)
argc++;
for (int i = argc - 1; i > 0 && file == NO_GDB_ANSWER; i--)
{
// All debuggers supported by DDD have [EXEC [CORE]] as
// their last arguments.
string arg = argv[i];
if (is_core_file(arg))
core = arg;
else if (is_debuggee_file(arg))
file = arg;
}
}
if (file != NO_GDB_ANSWER)
add_to_recent(file);
}
void BreakPoint::process_perl(string& info_output)
{
// Format: [FILE:]
// LINE_NO: LINE
// INFO 1
// INFO 2 ...
if (!info_output.contains(' ', 0))
{
const string first_line = info_output.before('\n');
if (first_line.contains(':', -1))
{
// Get leading file name
myfile_name = first_line.before(':');
info_output = info_output.after('\n');
}
}
static const StringArray empty;
mycommands = empty;
myline_nr = atoi(info_output.chars());
info_output = info_output.after('\n');
bool break_seen = false;
while (info_output.contains(" ", 0))
{
string info = info_output.before('\n');
info_output = info_output.after('\n');
strip_space(info);
if (info.contains("break if ", 0))
{
string cond = info.after(" if ");
while (cond.contains('(', 0) && cond.contains(')', -1))
cond = unquote(cond);
if (cond == "1")
cond = "";
mycondition = cond;
break_seen = true;
}
else if (info.contains("action: ", 0))
{
string commands = info.after(':');
strip_space(commands);
if (commands.contains("d " + itostring(line_nr())))
mydispo = BPDEL; // Temporary breakpoint
string command = "";
while (!commands.empty())
{
const string token = read_token(commands);
if (token != ";")
command += token;
if (token == ";" || commands.empty())
{
strip_space(command);
if (!command.empty())
{
mycommands += command;
command = "";
}
}
}
}
else
{
myinfos += info + '\n';
}
}
if (!break_seen)
mytype = ACTIONPOINT;
}
void BreakPoint::process_xdb(string& info_output)
{
// Strip leading `:'.
// Bob Wiegand <*****@*****.**>
if (info_output.contains(':', 0))
info_output = info_output.after(0);
strip_leading_space(info_output);
// Skip `count: N'
if (info_output.contains("count:", 0))
{
info_output = info_output.after("count:");
strip_leading_space(info_output);
string count = info_output.before(rxblanks_or_tabs);
info_output = info_output.after(rxblanks_or_tabs);
myignore_count = atoi(count.chars());
}
// Check for `Active' or `Suspended' and strip them
// Bob Wiegand <*****@*****.**>
if (info_output.contains("Active", 0))
{
info_output = info_output.after("Active");
myenabled = true;
}
else if (info_output.contains("Suspended", 0))
{
info_output = info_output.after("Suspended");
myenabled = false;
}
// Get function name and position
info_output = info_output.after(rxblanks_or_tabs);
myfunc = info_output.before(": ");
const string pos = dbx_lookup(myfunc);
if (!pos.empty())
{
myfile_name = pos.before(":");
}
info_output = info_output.after(": ");
myline_nr = get_positive_nr(info_output);
info_output = info_output.after('\n');
// Examine commands for condition
string commands = info_output;
strip_leading_space(commands);
if (commands.contains('{', 0))
{
// A condition has the form `{if COND {} {Q; c}}'.
if (commands.contains("{if ", 0))
{
string cond = commands.after("{if ");
cond = cond.before('{');
strip_space(cond);
mycondition = cond;
}
// Skip this line, too
info_output = info_output.after('\n');
}
}
