DebuggerCommand::sendImpl(thrift);

thrift.write(m_type);

thrift.write(m_symbol);

thrift.write(m_info);

if (m_acLiveLists) {

thrift.write(true);

thrift.write((int8_t)DebuggerClient::AutoCompleteCount);

for (int i = 0; i < DebuggerClient::AutoCompleteCount; i++) {

thrift.write(m_acLiveLists[i]);

}

} else {

thrift.write(false);

}

DebuggerCommand::recvImpl(thrift);

thrift.read(m_type);

thrift.read(m_symbol);

thrift.read(m_info);

bool hasLists;

thrift.read(hasLists);

if (hasLists) {

m_acLiveLists = DebuggerClient::CreateNewLiveLists();

int8_t count;

thrift.read(count);

for (int i = 0; i < count; i++) {

if (i < DebuggerClient::AutoCompleteCount) {

thrift.read(m_acLiveLists[i]);

} else {

vector<std::string> future;

thrift.read(future);

}

}

}

client.addCompletion(DebuggerClient::AutoCompleteFunctions);

client.addCompletion(DebuggerClient::AutoCompleteClasses);

client.addCompletion(DebuggerClient::AutoCompleteClassMethods);

client.addCompletion(DebuggerClient::AutoCompleteClassProperties);

client.addCompletion(DebuggerClient::AutoCompleteClassConstants);

client.helpTitle("Info Command");

client.helpCmds(

"info", "displays current function's info",

"info {cls}", "displays declaration of this class",

"info {function}", "displays declaration of this function",

"info {cls::method}", "displays declaration of this method",

"info {cls::constant}", "displays declaration of this constant",

"info {cls::$property}", "displays declaration of this property",

nullptr

);

client.helpBody(

"Use this command to display declaration of a symbol."

);

assert(client.argCount() == 0);

BreakPointInfoPtr bpi = client.getCurrentLocation();

if (bpi) {

m_symbol = bpi->getClass();

m_type = KindOfClass;

if (m_symbol.empty()) {

m_symbol = bpi->getFunction();

m_type = KindOfFunction;

}

}

return !m_symbol.empty();

assert(client.argCount() == 1);

string symbol = client.argValue(1);

size_t pos = symbol.find("::");

if (pos != string::npos) {

m_symbol = String(symbol.substr(0, pos));

m_type = KindOfClass;

subsymbol = symbol.substr(pos + 2);

} else if (symbol.size() > 2 && symbol.substr(symbol.size() - 2) == "()") {

m_symbol = symbol.substr(0, symbol.size() - 2);

m_type = KindOfFunction;

} else {

m_symbol = String(symbol);

m_type = KindOfUnknown;

}

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

string subsymbol;

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

if (!parseZeroArg(client)) {

client.error("There is no current function or method to look up.");

client.tutorial(

"You can only use '[i]nfo' without a symbol name when you are running "

"your program and it breaks at a function or a class method. It will "

"then look up information about that function or method."

);

return;

}

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

parseOneArg(client, subsymbol);

} else {

help(client);

return;

}

CmdInfoPtr cmd = client.xend<CmdInfo>(this);

Array info = cmd->m_info;

if (info.empty()) {

client.info("(specified symbol cannot be found)");

} else {

for (ArrayIter iter(info); iter; ++iter) {

StringBuffer sb;

PrintInfo(client, sb, iter.second().toArray(), subsymbol);

client.code(sb.detach());

}

}

CmdInfo cmd;

cmd.m_type = KindOfLiveLists;

CmdInfoPtr res = client.xend<CmdInfo>(&cmd);

client.setLiveLists(res->m_acLiveLists);

const std::string &func) {

CmdInfo cmd;

cmd.m_type = KindOfFunction;

if (cls.empty()) {

cmd.m_symbol = String(func);

} else {

cmd.m_symbol = String(cls) + "::" + String(func);

}

CmdInfoPtr res = client.xend<CmdInfo>(&cmd);

Array info = res->m_info;

if (!info.empty()) {

info = info[0];

if (info.exists(s_params)) {

StringBuffer sb;

sb.printf("function %s%s(%s);\n",

info[s_ref].toBoolean() ? "&" : "",

info[s_name].toString().data(),

GetParams(info[s_params].toArray(),

info[s_varg].toBoolean()).data());

return sb.detach();

}

}

return String();

if (m_type == KindOfLiveLists) {

std::vector<String> tmpAcLiveLists[DebuggerClient::AutoCompleteCount];

m_acLiveLists = DebuggerClient::CreateNewLiveLists();

try {

ClassInfo::GetSymbolNames(

tmpAcLiveLists[DebuggerClient::AutoCompleteClasses],

tmpAcLiveLists[DebuggerClient::AutoCompleteFunctions],

tmpAcLiveLists[DebuggerClient::AutoCompleteConstants],

&tmpAcLiveLists[DebuggerClient::AutoCompleteClassMethods],

&tmpAcLiveLists[DebuggerClient::AutoCompleteClassProperties],

&tmpAcLiveLists[DebuggerClient::AutoCompleteClassConstants]);

} catch (Exception &e) {

Logger::Error("Caught exception %s, auto-complete lists incomplete",

e.getMessage().c_str());

} catch(...) {

Logger::Error("Caught unknown exception, auto-complete lists incomplete");

}

int tempList[] = {DebuggerClient::AutoCompleteClasses,

DebuggerClient::AutoCompleteFunctions,

DebuggerClient::AutoCompleteConstants,

DebuggerClient::AutoCompleteClassMethods,

DebuggerClient::AutoCompleteClassProperties,

DebuggerClient::AutoCompleteClassConstants};

for (unsigned int i = 0 ; i < sizeof(tempList)/sizeof(int); ++i) {

for (unsigned int j = 0 ; j < tmpAcLiveLists[tempList[i]].size(); ++j) {

m_acLiveLists[tempList[i]].push_back(

tmpAcLiveLists[tempList[i]][j]->toCPPString());

}

}

Array variables = g_vmContext->getLocalDefinedVariables(0);

variables += CmdVariable::GetGlobalVariables();

vector<std::string> &vars =

m_acLiveLists[DebuggerClient::AutoCompleteVariables];

vars.reserve(variables.size());

for (ArrayIter iter(variables); iter; ++iter) {

vars.push_back("$" + iter.first().toString()->toCPPString());

}

return proxy.sendToClient(this);

}

if (m_type == KindOfUnknown || m_type == KindOfClass) {

try {

Array ret = f_hphp_get_class_info(m_symbol);

if (!ret.empty()) {

m_info.append(ret);

}

} catch (...) {}

}

if (m_type == KindOfUnknown || m_type == KindOfFunction) {

try {

Array ret = f_hphp_get_function_info(m_symbol);

if (!ret.empty()) {

m_info.append(ret);

}

} catch (...) {}

}

return proxy.sendToClient(this);

if (info[s_doc].isString()) {

String doc = info[s_doc].toString();

int space1 = 0; // best guess

int space2 = 3; // best guess

Variant matches1, matches2;

Variant ret1 = preg_match("#^( *)/\\*#s", doc, matches1);

Variant ret2 = preg_match("#\n( *)\\*#s", doc, matches2);

if (!same(ret1, false) && !same(ret2, false)) {

// we have perfect doc comment blocks, so we can re-adjust spaces

space1 = matches1[1].toString().size();

space2 = matches2[1].toString().size();

}

String spaces = f_str_repeat(" ", space2 - space1 - 1);

sb.printf("%s%s\n", spaces.data(), doc.data());

}

CArrRef info) {

if (!info[s_internal].toBoolean()) {

String file = info[s_file].toString();

int line1 = info[s_line1].toInt32();

int line2 = info[s_line2].toInt32();

if (file.empty() && line1 == 0 && line2 == 0) {

sb.printf("// (source unknown)\n");

} else if (line1 == 0 && line2 == 0) {

sb.printf("// defined in %s\n", file.data());

} else if (line1 && line2 && line1 != line2) {

sb.printf("// defined on line %d to %d of %s\n", line1, line2,

file.data());

client.setListLocation(file.data(), line1 - 1, false);

} else {

int line = line1 ? line1 : line2;

sb.printf("// defined on line %d of %s\n", line, file.data());

client.setListLocation(file.data(), line - 1, false);

}

}

PrintDocComments(sb, info);

bool detailed /* = false */) {

StringBuffer args;

for (ArrayIter iter(params); iter; ++iter) {

if (!args.empty()) {

args.append(", ");

}

Array arg = iter.second().toArray();

if (!arg[s_type].toString().empty()) {

args.append(arg[s_type].toString());

args.append(' ');

}

if (arg[s_ref].toBoolean()) {

args.append('&');

}

args.append('$');

args.append(arg[s_name].toString());

if (arg.exists(s_default)) {

args.append(" = ");

Variant defValue = arg[s_default];

String defText = arg[s_defaultText].toString();

if (!defText.empty()) {

args.append(defText);

} else if (defValue.isObject()) {

// ClassInfo was not able to serialize the value, so ext_reflection

// prepared a stdClass error object. We should fall back to display

// the original PHP text, if there.

Object obj{defValue.asCell()->m_data.pobj};

args.append(obj->o_get(s_msg).toString());

} else if (detailed) {

args.append(DebuggerClient::FormatVariable(arg[s_default], -1));

} else {

args.append(DebuggerClient::FormatVariable(arg[s_default]));

}

}

}

if (varg) {

if (!args.empty()) {

args.append(", ");

}

args.append("...");

}

return args.detach();

if (info[name].toBoolean()) {

return name + " ";

}

return empty_string;

for (ArrayIter iter(symbols); iter; ++iter) {

String key = iter.first().toString();

if (strcasecmp(key.data(), symbol.c_str()) == 0) {

return key;

}

}

return String();

const std::string &subsymbol) {

String key = FindSubSymbol(info[s_constants].toArray(), subsymbol);

if (!key.isNull()) {

sb.printf(" const %s = %s;\n", key.data(),

DebuggerClient::FormatVariable

(info[s_constants][key], -1).data());

return true;

}

return false;

const std::string &subsymbol) {

String key = FindSubSymbol(info[s_properties].toArray(),

subsymbol[0] == '$' ?

subsymbol.substr(1) : subsymbol);

if (!key.isNull()) {

Array prop = info[s_properties][key].toArray();

PrintDocComments(sb, prop);

sb.printf(" %s %s$%s;\n",

prop[s_access].toString().data(),

GetModifier(prop, s_static).data(),

prop[s_name].toString().data());

return true;

}

key = FindSubSymbol(info[s_private_properties].toArray(),

subsymbol[0] == '$' ?

subsymbol.substr(1) : subsymbol);

if (!key.isNull()) {

Array prop = info[s_private_properties][key].toArray();

PrintDocComments(sb, prop);

sb.printf(" private %s$%s;\n",

GetModifier(prop, s_static).data(),

prop[s_name].toString().data());

return true;

}

return false;

std::string subsymbol) {

if (subsymbol.size() > 2 && subsymbol.substr(subsymbol.size() - 2) == "()") {

subsymbol = subsymbol.substr(0, subsymbol.size() - 2);

}

String key = FindSubSymbol(info[s_methods].toArray(), subsymbol);

if (!key.isNull()) {

Array func = info[s_methods][key].toArray();

PrintHeader(client, sb, func);

sb.printf("%s %s%s%sfunction %s::%s%s(%s);\n",

func[s_access].toString().data(),

GetModifier(func, s_static).data(),

GetModifier(func, s_final).data(),

GetModifier(func, s_abstract).data(),

info[s_name].toString().data(),

func[s_ref].toBoolean() ? "&" : "",

func[s_name].toString().data(),

GetParams(func[s_params].toArray(),

func[s_varg].toBoolean(), true).data());

if (func[s_type_profiling].toArray().size() != 0) {

sb.printf("Type profile:\n%s",

GetTypeProfilingInfo(func[s_type_profiling].toArray(),

func[s_params].toArray()).data());

}

return true;

}

return false;

StringBuffer param;

Array arg = params[index].toArray();

if (arg[s_ref].toBoolean()) {

param.append('&');

}

param.append('$');

param.append(arg[s_name].toString());

return param.detach();

StringBuffer profile;

int index = 0;

StringBuffer args;

for (ArrayIter iter(profilingArray); iter; ++iter) {

profile.append(" ");

if (index == 0) {

profile.append("ReturnValue");

} else {

profile.append(GetParam(params, index - 1));

}

profile.append(":\n");

Array param = iter.second().toArray();

int type_number = 0;

for (ArrayIter type_count(param); type_count; ++type_count) {

profile.append(" ");

String type = type_count.first().toString();

profile.printf("%s: %f", type.data(),

type_count.second().toDouble()* 100);

profile.append("%\n");

type_number++;

if (type_number > 10) {

profile.append("...\n");

break;

}

}

index++;

}

return profile.detach();

const std::string &subsymbol) {

if (info.exists(s_params)) {

PrintHeader(client, sb, info);

sb.printf("function %s%s(%s);\n",

info[s_ref].toBoolean() ? "&" : "",

info[s_name].toString().data(),

GetParams(info[s_params].toArray(),

info[s_varg].toBoolean()).data());

if (info[s_type_profiling].toArray().size() != 0) {

sb.printf("Type profile:\n%s",

GetTypeProfilingInfo(info[s_type_profiling].toArray(),

info[s_params].toArray()).data());

}

return;

}

bool found = false;

if (!subsymbol.empty()) {

if (TryConstant(sb, info, subsymbol)) found = true;

if (TryProperty(sb, info, subsymbol)) found = true;

if (TryMethod(client, sb, info, subsymbol)) found = true;

if (found) return;

client.info("Specified symbol cannot be found. Here the whole class:\n");

}

PrintHeader(client, sb, info);

StringBuffer parents;

String parent = info[s_parent].toString();

if (!parent.empty()) {

parents.append("extends ");

parents.append(parent);

parents.append(' ');

}

if (!info[s_interfaces].toArray().empty()) {

parents.append("implements ");

bool first = true;

for (ArrayIter iter(info[s_interfaces].toArray()); iter; ++iter) {

if (first) {

first = false;

} else {

parents.append(", ");

}

parents.append(iter.first().toString());

}

parents.append(' ');

}

parent = parents.detach();

sb.printf("%s%s%s %s %s{\n",

GetModifier(info, s_final).data(),

GetModifier(info, s_abstract).data(),

info[s_interface].toBoolean() ? "interface" : "class",

info[s_name].toString().data(),

parent.data());

if (!info[s_constants].toArray().empty()) {

sb.printf(" // constants\n");

for (ArrayIter iter(info[s_constants].toArray()); iter; ++iter) {

sb.printf(" const %s = %s;\n",

iter.first().toString().data(),

DebuggerClient::FormatVariable(iter.second()).data());

}

}

if (!info[s_properties].toArray().empty() ||

!info[s_private_properties].toArray().empty()) {

sb.printf(" // properties\n");

for (ArrayIter iter(info[s_properties].toArray()); iter; ++iter) {

Array prop = iter.second().toArray();

sb.printf(" %s%s %s$%s;\n",

prop[s_doc].toBoolean() ? "[doc] " : "",

prop[s_access].toString().data(),

GetModifier(prop, s_static).data(),

prop[s_name].toString().data());

}

for (ArrayIter iter(info[s_private_properties].toArray()); iter; ++iter) {

Array prop = iter.second().toArray();

sb.printf(" %sprivate %s$%s;\n",

prop[s_doc].toBoolean() ? "[doc] " : "",

GetModifier(prop, s_static).data(),

prop[s_name].toString().data());

}

}

if (!info[s_methods].toArray().empty()) {

sb.printf(" // methods\n");

for (ArrayIter iter(info[s_methods].toArray()); iter; ++iter) {

Array func = iter.second().toArray();

sb.printf(" %s%s %s%s%sfunction %s%s(%s);\n",

func[s_doc].toBoolean() ? "[doc] " : "",

func[s_access].toString().data(),

GetModifier(func, s_static).data(),

GetModifier(func, s_final).data(),

GetModifier(func, s_abstract).data(),

func[s_ref].toBoolean() ? "&" : "",

func[s_name].toString().data(),

GetParams(func[s_params].toArray(),

func[s_varg].toBoolean()).data());

}

}

sb.printf("}\n");