void CmdBreak::setClientOutput(DebuggerClient *client) {
// Output an array of current breakpoints including exceptions
client->setOutputType(DebuggerClient::OTValues);
Array values;
m_breakpoints = client->getBreakPoints();
for (int i = 0; i < (int)m_breakpoints->size(); i++) {
BreakPointInfoPtr bpi = m_breakpoints->at(i);
Array breakpoint;
breakpoint.set(s_id, bpi->index());
breakpoint.set(s_state, bpi->state(false));
if (bpi->m_interrupt == ExceptionThrown) {
breakpoint.set(s_is_exception, true);
breakpoint.set(s_exception_class, bpi->getExceptionClass());
} else {
breakpoint.set(s_is_exception, false);
breakpoint.set(s_file, bpi->m_file);
breakpoint.set(s_line1, bpi->m_line1);
breakpoint.set(s_line2, bpi->m_line2);
breakpoint.set(s_namespace, bpi->getNamespace());
breakpoint.set(s_func, bpi->getFunction());
breakpoint.set(s_class, bpi->getClass());
}
breakpoint.set(s_url, bpi->m_url);
breakpoint.set(s_use_regex, bpi->m_regex);
breakpoint.set(s_clause_type, bpi->m_check ? s_if : s_ampamp);
breakpoint.set(s_clause, bpi->m_clause);
breakpoint.set(s_desc, bpi->desc());
values.append(breakpoint);
}
client->setOTValues(values);
}
bool CmdBreak::validate(DebuggerClient *client, BreakPointInfoPtr bpi,
int index) {
++index;
if (client->arg(index, "if")) {
bpi->setClause(client->lineRest(++index), true);
} else if (client->arg(index, "&&")) {
bpi->setClause(client->lineRest(++index), false);
}
if (bpi->valid()) {
m_breakpoints = client->getBreakPoints();
for (int i = 0; i < (int)m_breakpoints->size(); i++) {
if ((*m_breakpoints)[i]->same(bpi)) {
client->error("Breakpoint was already set previously.");
return true;
}
}
m_breakpoints->push_back(bpi);
updateImpl(client);
client->info("Breakpoint %d set %s", bpi->index(), bpi->desc().c_str());
return true;
}
if (!bpi->m_url.empty()) {
client->error("@{url} cannot be specified alone.");
} else {
client->error("Breakpoint was not set in right format.");
}
return false;
}
bool CmdBreak::processList(DebuggerClient *client) {
m_breakpoints = client->getBreakPoints();
for (int i = 0; i < (int)m_breakpoints->size(); i++) {
BreakPointInfoPtr bpi = m_breakpoints->at(i);
client->print(" %d\t%s %s", bpi->index(), bpi->state(true).c_str(),
bpi->desc().c_str());
}
if (m_breakpoints->empty()) {
client->tutorial(
"Use '[b]reak ?|[h]elp' to read how to set breakpoints. "
);
} else {
client->tutorial(
"Use '[b]reak [c]lear {index}|[a]ll' to remove breakpoint(s). "
"Use '[b]reak [t]oggle {index}|[a]ll' to change their states."
);
}
return true;
}
void CmdInterrupt::onClient(DebuggerClient &client) {
client.setCurrentLocation(m_threadId, m_bpi);
if (!client.getDebuggerClientSmallStep()) {
// Adjust line and char if it's not small stepping
if (m_bpi->m_line1 == m_bpi->m_line2) {
m_bpi->m_char1 = 1;
m_bpi->m_char2 = 100;
}
}
client.setMatchedBreakPoints(m_matched);
switch (m_interrupt) {
case SessionStarted:
if (!m_program.empty()) {
client.info("Program %s loaded. Type '[r]un' or '[c]ontinue' to go.",
m_program.c_str());
m_bpi->m_file = m_program;
}
break;
case SessionEnded:
if (!m_program.empty()) {
client.info("Program %s exited normally.", m_program.c_str());
}
break;
case RequestStarted:
if (!m_program.empty()) {
client.info("Web request %s started.", m_program.c_str());
}
break;
case RequestEnded:
if (!m_program.empty()) {
client.info("Web request %s ended.", m_program.c_str());
}
break;
case PSPEnded:
if (!m_program.empty()) {
client.info("Post-Send Processing for %s was ended.",
m_program.c_str());
}
break;
case HardBreakPoint:
case BreakPointReached:
case ExceptionThrown: {
bool found = false;
bool toggled = false;
auto *bps = client.getBreakPoints();
for (unsigned int i = 0; i < m_matched.size(); i++) {
BreakPointInfoPtr bpm = m_matched[i];
BreakPointInfoPtr bp;
int index = 0;
for (; index < (int)bps->size(); index++) {
if (bpm->same((*bps)[index])) {
bp = (*bps)[index];
break;
}
}
if (bp) {
found = true;
if (bp->m_state == BreakPointInfo::Once) {
bp->m_state = BreakPointInfo::Disabled;
toggled = true;
}
if (m_interrupt == BreakPointReached ||
m_interrupt == HardBreakPoint) {
client.info("Breakpoint %d reached %s", bp->index(),
m_bpi->site().c_str());
client.shortCode(m_bpi);
} else {
if (m_bpi->m_exceptionClass == BreakPointInfo::ErrorClassName) {
client.info("Breakpoint %d reached: An error occurred %s",
bp->index(), m_bpi->site().c_str());
client.shortCode(m_bpi);
client.error("Error Message: %s",
m_bpi->m_exceptionObject.c_str());
} else {
client.info("Breakpoint %d reached: Throwing %s %s",
bp->index(),
m_bpi->m_exceptionClass.c_str(),
m_bpi->site().c_str());
client.shortCode(m_bpi);
if (client.getLogFileHandler()) {
client.output(m_bpi->m_exceptionObject);
}
}
}
if (!bpm->m_output.empty()) {
client.print(bpm->m_output);
}
}
}
if (toggled) {
CmdBreak::SendClientBreakpointListToServer(client);
}
if (!found) {
if (m_interrupt == HardBreakPoint) {
// for HardBreakPoint, default the frame to the caller
client.setFrame(1);
}
client.info("Break %s", m_bpi->site().c_str());
client.shortCode(m_bpi);
}
break;
}
}
if (!m_errorMsg.empty()) {
client.error(m_errorMsg);
}
// watches
switch (m_interrupt) {
case SessionStarted:
case RequestStarted:
break;
default: {
DebuggerClient::WatchPtrVec &watches = client.getWatches();
for (int i = 0; i < (int)watches.size(); i++) {
if (i > 0) client.output("%s", "");
client.info("Watch %d: %s =", i + 1, watches[i]->second.c_str());
Variant v = CmdPrint().processWatch(client, watches[i]->first,
watches[i]->second);
client.output(CmdPrint::FormatResult(watches[i]->first, v));
}
}
}
}
bool CmdBreak::processUpdate(DebuggerClient *client) {
m_breakpoints = client->getBreakPoints();
if (m_breakpoints->empty()) {
client->error("There is no breakpoint to clear or toggle.");
client->tutorial(
"Use '[b]reak ?|[h]elp' to read how to set breakpoints. "
);
return true;
}
if (client->argCount() == 1) {
BreakPointInfoPtrVec *matched = client->getMatchedBreakPoints();
BreakPointInfoPtrVec *bps = client->getBreakPoints();
bool found = false;
for (unsigned int i = 0; i < matched->size(); i++) {
BreakPointInfoPtr bpm = (*matched)[i];
BreakPointInfoPtr bp;
int index = 0;
for (; index < (int)bps->size(); index++) {
if (bpm->same((*bps)[index])) {
bp = (*bps)[index];
break;
}
}
if (bp) {
const char *action;
if (hasClearArg(client)) {
action = "cleared";
bps->erase(bps->begin() + index);
} else if (hasEnableArg(client)) {
action = "updated";
bp->setState(BreakPointInfo::Always);
} else if (hasDisableArg(client)) {
action = "updated";
bp->setState(BreakPointInfo::Disabled);
} else {
assert(hasToggleArg(client));
action = "updated";
bp->toggle();
}
client->info("Breakpoint %d is %s %s", bp->index(),
action, bp->site().c_str());
found = true;
}
}
if (found) {
updateImpl(client);
return true;
}
client->error("There is no current breakpoint to clear or toggle.");
return true;
}
if (client->arg(2, "all")) {
if (hasClearArg(client)) {
m_breakpoints->clear();
updateImpl(client);
client->info("All breakpoints are cleared.");
return true;
}
for (unsigned int i = 0; i < m_breakpoints->size(); i++) {
BreakPointInfoPtr bpi = (*m_breakpoints)[i];
if (hasEnableArg(client)) {
bpi->setState(BreakPointInfo::Always);
}
else if (hasDisableArg(client)) {
bpi->setState(BreakPointInfo::Disabled);
}
else {
assert(hasToggleArg(client));
bpi->toggle();
}
}
updateImpl(client);
return processList(client);
}
string snum = client->argValue(2);
if (!DebuggerClient::IsValidNumber(snum)) {
client->error("'[b]reak [c]lear|[t]oggle' needs an {index} argument.");
client->tutorial(
"You will have to run '[b]reak [l]ist' first to see a list of valid "
"numbers or indices to specify."
);
return true;
}
int index = -1;
int num = atoi(snum.c_str());
for (unsigned int i = 0; i < m_breakpoints->size(); i++) {
if (m_breakpoints->at(i)->index() == num) {
index = i;
break;
}
}
if (index < 0) {
client->error("\"%s\" is not a valid breakpoint index. Choose one from "
"this list:", snum.c_str());
processList(client);
return true;
}
BreakPointInfoPtr bpi = (*m_breakpoints)[index];
if (hasClearArg(client)) {
m_breakpoints->erase(m_breakpoints->begin() + index);
updateImpl(client);
client->info("Breakpoint %d cleared %s", bpi->index(),
bpi->desc().c_str());
} else if (hasEnableArg(client)) {
bpi->setState(BreakPointInfo::Always);
updateImpl(client);
client->info("Breakpoint %d's state is changed to %s.", bpi->index(),
bpi->state(false).c_str());
} else if (hasDisableArg(client)) {
bpi->setState(BreakPointInfo::Disabled);
updateImpl(client);
client->info("Breakpoint %d's state is changed to %s.", bpi->index(),
bpi->state(false).c_str());
} else {
assert(hasToggleArg(client));
bpi->toggle();
updateImpl(client);
client->info("Breakpoint %d's state is changed to %s.", bpi->index(),
bpi->state(false).c_str());
}
return true;
}
bool CmdInterrupt::onClient(DebuggerClient *client) {
client->setCurrentLocation(m_threadId, m_bpi);
client->setMatchedBreakPoints(m_matched);
switch (m_interrupt) {
case SessionEnded:
case RequestEnded:
case PSPEnded:
if (m_pendingJump) {
client->error("Your jump point cannot be reached. You may only jump "
"to certain parallel or outer execution points.");
}
break;
}
switch (m_interrupt) {
case SessionStarted:
if (!m_program.empty()) {
client->info("Program %s loaded. Type '[r]un' or '[c]ontinue' to go.",
m_program.c_str());
m_bpi->m_file = m_program;
}
break;
case SessionEnded:
if (!m_program.empty()) {
client->info("Program %s exited normally.", m_program.c_str());
}
break;
case RequestStarted:
if (!m_program.empty()) {
client->info("Web request %s started.", m_program.c_str());
}
break;
case RequestEnded:
if (!m_program.empty()) {
client->info("Web request %s ended.", m_program.c_str());
}
break;
case PSPEnded:
if (!m_program.empty()) {
client->info("Post-Send Processing for %s was ended.",
m_program.c_str());
}
break;
case HardBreakPoint:
case BreakPointReached:
case ExceptionThrown: {
bool found = false;
bool toggled = false;
BreakPointInfoPtrVec *bps = client->getBreakPoints();
for (unsigned int i = 0; i < m_matched.size(); i++) {
BreakPointInfoPtr bpm = m_matched[i];
BreakPointInfoPtr bp;
int index = 0;
for (; index < (int)bps->size(); index++) {
if (bpm->same((*bps)[index])) {
bp = (*bps)[index];
break;
}
}
if (bp) {
found = true;
if (bp->m_state == BreakPointInfo::Once) {
bp->m_state = BreakPointInfo::Disabled;
toggled = true;
}
if (m_interrupt == BreakPointReached ||
m_interrupt == HardBreakPoint) {
client->info("Breakpoint %d reached %s", bp->index(),
m_bpi->site().c_str());
client->shortCode(m_bpi);
} else {
if (m_bpi->m_exceptionClass == BreakPointInfo::ErrorClassName) {
client->info("Breakpoint %d reached: An error occurred %s",
bp->index(), m_bpi->site().c_str());
client->shortCode(m_bpi);
client->error("Error Message: %s",
m_bpi->m_exceptionObject.c_str());
} else {
client->info("Breakpoint %d reached: Throwing %s %s",
bp->index(),
m_bpi->m_exceptionClass.c_str(),
m_bpi->site().c_str());
client->shortCode(m_bpi);
client->output(m_bpi->m_exceptionObject);
}
}
if (!bpm->m_output.empty()) {
client->print(bpm->m_output);
}
}
}
if (toggled) {
CmdBreak().update(client);
}
if (!found) {
client->info("Break %s", m_bpi->site().c_str());
client->shortCode(m_bpi);
}
break;
}
}
if (!m_errorMsg.empty()) {
client->error(m_errorMsg);
}
// watches
switch (m_interrupt) {
case SessionStarted:
case RequestStarted:
break;
default: {
DebuggerClient::WatchPtrVec &watches = client->getWatches();
for (int i = 0; i < (int)watches.size(); i++) {
if (i > 0) client->output("");
client->info("Watch %d: %s =", i + 1, watches[i]->second.c_str());
CmdPrint().processWatch(client, watches[i]->first, watches[i]->second);
}
}
}
return true;
}