if (format == nullptr) {

String sret = DebuggerClient::FormatVariable(ret, -1);

return string(sret.data(), sret.size());

}

if (strcmp(format, "r") == 0) {

String sret = DebuggerClient::FormatVariable(ret, -1, 'r');

return string(sret.data(), sret.size());

}

if (strcmp(format, "v") == 0) {

String sret = DebuggerClient::FormatVariable(ret, -1, 'v');

return string(sret.data(), sret.size());

}

if (strcmp(format, "dec") == 0 ||

strcmp(format, "unsigned") == 0 ||

ret.isInteger()) {

int64_t nret = ret.toInt64();

char buf[64];

if (strcmp(format, "hex") == 0 || strcmp(format, "x") == 0) {

snprintf(buf, sizeof(buf), "%" PRIx64, nret);

return buf;

}

if (strcmp(format, "oct") == 0) {

snprintf(buf, sizeof(buf), "%" PRIo64, nret);

return buf;

}

if (strcmp(format, "dec") == 0) {

snprintf(buf, sizeof(buf), "%" PRId64, nret);

return buf;

}

if (strcmp(format, "unsigned") == 0) {

snprintf(buf, sizeof(buf), "%" PRIu64, nret);

return buf;

}

if (strcmp(format, "time") == 0) {

StringBuffer sb;

DateTime dt(nret);

sb.append("RFC822: ");

sb.append(dt.toString(DateTime::DateFormat::RFC822));

sb.append("\nRFC850: ");

sb.append(dt.toString(DateTime::DateFormat::RFC850));

sb.append("\nRFC1036: ");

sb.append(dt.toString(DateTime::DateFormat::RFC1036));

sb.append("\nRFC1123/RSS: ");

sb.append(dt.toString(DateTime::DateFormat::RFC1123));

sb.append("\nRFC2822: ");

sb.append(dt.toString(DateTime::DateFormat::RFC2822));

sb.append("\nRFC3339/ATOM/W3C: ");

sb.append(dt.toString(DateTime::DateFormat::RFC3339));

sb.append("\nISO8601: ");

sb.append(dt.toString(DateTime::DateFormat::ISO8601));

sb.append("\nCookie: ");

sb.append(dt.toString(DateTime::DateFormat::Cookie));

sb.append("\nHttpHeader: ");

sb.append(dt.toString(DateTime::DateFormat::HttpHeader));

return sb.data();

}

assert(false);

}

String sret = DebuggerClient::FormatVariable(ret, -1);

if (strcmp(format, "hex") == 0 || strcmp(format, "x") == 0 ||

strcmp(format, "oct") == 0) {

StringBuffer sb;

for (int i = 0; i < sret.size(); i++) {

char ch = sret[i];

if (isprint(ch)) {

sb.append(ch);

} else {

char buf[6];

if (strcmp(format, "oct") == 0) {

snprintf(buf, sizeof(buf), "\\%03o", ch);

} else {

snprintf(buf, sizeof(buf), "\\x%02x", ch);

}

sb.append(buf);

}

}

return sb.data() ? sb.data() : "";

}

if (strcmp(format, "time") == 0) {

DateTime dt;

int64_t ts = -1;

if (dt.fromString(ret.toString(), SmartResource<TimeZone>())) {

bool err;

ts = dt.toTimeStamp(err);

}

return String(ts).data();

}

assert(false);

return "";

DebuggerCommand::sendImpl(thrift);

if (m_printLevel > 0) {

g_context->setDebuggerPrintLevel(m_printLevel);

}

{

String sdata;

DebuggerWireHelpers::WireSerialize(m_ret, sdata);

thrift.write(sdata);

}

if (m_printLevel > 0) {

g_context->setDebuggerPrintLevel(-1);

}

thrift.write(m_output);

thrift.write(m_frame);

thrift.write(m_bypassAccessCheck);

thrift.write(m_printLevel);

thrift.write(m_noBreak);

DebuggerCommand::recvImpl(thrift);

{

String sdata;

thrift.read(sdata);

int error = DebuggerWireHelpers::WireUnserialize(sdata, m_ret);

if (error) {

m_ret = uninit_null();

}

if (error == DebuggerWireHelpers::HitLimit) {

m_wireError = "Hit unserialization limit. "

"Try with smaller print level";

}

}

thrift.read(m_output);

thrift.read(m_frame);

thrift.read(m_bypassAccessCheck);

thrift.read(m_printLevel);

thrift.read(m_noBreak);

if (client.arg(1, "clear")) {

client.addCompletion("all");

return;

}

client.addCompletion(DebuggerClient::AutoCompleteCode);

if (client.argCount() == 0) {

client.addCompletion(Formats);

client.addCompletion("always");

client.addCompletion("list");

client.addCompletion("clear");

} else if (client.argCount() == 1 && client.arg(1, "always")) {

client.addCompletion(Formats);

}

client.helpTitle("Print Command");

client.helpCmds(

"[p]rint {php}", "prints result of PHP code",

"[p]rint r {php}", "prints result of PHP code, (print_r)",

"[p]rint v {php}", "prints result of PHP code, (var_dump)",

"[p]rint x {php}", "prints hex encoded string or number",

"[p]rint [h]ex {php}", "prints hex encoded string or number",

"[p]rint [o]ct {php}", "prints octal encoded string or number",

"[p]rint [d]ec {php}", "prints as signed integer",

"[p]rint [u]nsigned {php}", "prints as unsigned integer",

"[p]rint [t]ime {php}", "converts between time and timestamp",

"", "",

"[p]rint [a]lways {above}", "adds a watch expression at break",

"[p]rint [l]ist", "lists watch expressions",

"[p]rint [c]lear {index}", "clears a watch expression",

"[p]rint [c]lear [a]ll", "clears all watch expressions",

nullptr

);

client.helpBody(

"Prints result of an expression in certain format. If '[a]lways' is "

"specified, the expression will be added to a watch list. At every break, "

"either at a breakpoint or caused by step commands, these expressions "

"will be evaluated and printed out."

);

DebuggerClient::WatchPtrVec &watches = client.getWatches();

for (int i = 0; i < (int)watches.size(); i++) {

client.print(" %d %s %s", i + 1,

StringUtil::Pad(watches[i]->first, 8, " ",

StringUtil::PadType::Left).data(),

watches[i]->second.c_str());

}

if (watches.empty()) {

client.tutorial(

"Use '[p]rint [a]lways ...' to set new watch expressions. "

"Use '[p]rint ?|[h]elp' to read how to set them. "

);

} else {

client.tutorial(

"Use '[p]rint [c]lear {index}|[a]ll' to remove watch expression(s). "

);

}

DebuggerClient::WatchPtrVec &watches = client.getWatches();

if (watches.empty()) {

client.error("There is no watch expression to clear.");

client.tutorial(

"Use '[p]rint [a]lways ...' to set new watch expressions. "

"Use '[p]rint ?|[h]elp' to read how to set them. "

);

return;

}

if (client.arg(2, "all")) {

watches.clear();

client.info("All watch expressions are cleared.");

return;

}

string snum = client.argValue(2);

if (!DebuggerClient::IsValidNumber(snum)) {

client.error("'[p]rint [c]lear' needs an {index} argument.");

client.tutorial(

"You will have to run '[p]rint [l]ist' first to see a list of valid "

"numbers or indices to specify."

);

return;

}

int num = atoi(snum.c_str()) - 1;

if (num < 0 || num >= (int)watches.size()) {

client.error("\"%s\" is not a valid index. Choose one from this list:",

snum.c_str());

processList(client);

return;

}

watches.erase(watches.begin() + num);

const std::string &php) {

m_body = php;

m_frame = client.getFrame();

m_noBreak = true;

CmdPrintPtr res = client.xend<CmdPrint>(this);

if (!res->m_output.empty()) {

client.output(res->m_output);

}

return res->m_ret;

if (!m_output.empty()) {

client.output(m_output);

}

client.output(m_ret.toString());

if (DebuggerCommand::displayedHelp(client)) return;

if (client.argCount() == 0) {

help(client);

return;

}

int index = 1;

if (client.arg(1, "always")) {

m_isForWatch = true;

if (client.argCount() == 1) {

client.error("'[p]rint [a]lways' needs an expression to watch.");

return;

}

index++;

} else if (client.arg(1, "list")) {

m_isForWatch = true;

processList(client);

return;

} else if (client.arg(1, "clear")) {

m_isForWatch = true;

processClear(client);

return;

}

const char *format = nullptr;

for (const char **fmt = Formats; *fmt; fmt++) {

if (client.arg(index, *fmt)) {

format = *fmt;

index++;

break;

}

}

m_body = client.lineRest(index);

if (m_isForWatch) {

client.addWatch(format, m_body);

return;

}

m_bypassAccessCheck = client.getDebuggerClientBypassCheck();

m_printLevel = client.getDebuggerClientPrintLevel();

assert(m_printLevel <= 0 || m_printLevel >= DebuggerClient::MinPrintLevel);

m_frame = client.getFrame();

CmdPrintPtr res = client.xendWithNestedExecution<CmdPrint>(this);

m_output = res->m_output;

m_ret = res->m_ret;

if (!m_output.empty()) {

client.output(m_output);

}

client.output(FormatResult(format, m_ret));

PCFilter* locSave = g_vmContext->m_lastLocFilter;

g_vmContext->m_lastLocFilter = new PCFilter();

g_vmContext->setDebuggerBypassCheck(m_bypassAccessCheck);

{

EvalBreakControl eval(m_noBreak);

bool failed;

m_ret =

proxy.ExecutePHP(DebuggerProxy::MakePHPReturn(m_body),

m_output, m_frame, failed,

DebuggerProxy::ExecutePHPFlagsAtInterrupt |

(!proxy.isLocal() ? DebuggerProxy::ExecutePHPFlagsLog :

DebuggerProxy::ExecutePHPFlagsNone));

}

g_vmContext->setDebuggerBypassCheck(false);

delete g_vmContext->m_lastLocFilter;

g_vmContext->m_lastLocFilter = locSave;

return proxy.sendToClient(this);