const String& wordbreak /* = "\n" */,

bool cut /* = false */) {

Array args = Array::Create();

args.append(str);

args.append(width);

args.append(wordbreak);

args.append(cut);

return vm_call_user_func("wordwrap", args);

TRACE(2, "DebuggerClient::onSignal\n");

if (m_inputState == TakingInterrupt) {

if (m_sigCount == 0) {

usageLogEvent("signal start");

info("Pausing program execution, please wait...");

} else if (m_sigCount == 1) {

usageLogEvent("signal wait");

help("Still attempting to pause program execution...");

help(" Sometimes this takes a few seconds, so give it a chance,");

help(" or press ctrl-c again to give up and terminate the debugger.");

} else {

usageLogEvent("signal quit");

error("Debugger is quitting.");

if (!getStaticDebuggerClient().isLocal()) {

error(" Note: the program may still be running on the server.");

}

quit(); // NB: the machine is running, so can't send a real CmdQuit.

return;

}

m_sigCount++;

m_sigNum = CmdSignal::SignalBreak;

} else {

rl_line_buffer[0] = '\0';

#ifndef USE_EDITLINE

rl_free_line_state();

rl_cleanup_after_signal();

#endif

rl_redisplay();

}

TRACE(2, "DebuggerClient::pollSignal\n");

if (m_scriptMode) {

print(".....Debugger client still waiting for server response.....");

}

int ret = m_sigNum;

m_sigNum = CmdSignal::SignalNone;

return ret;

ReadlineApp() {

TRACE(2, "ReadlineApp::ReadlineApp\n");

DebuggerClient::AdjustScreenMetrics();

rl_attempted_completion_function = debugger_completion;

rl_basic_word_break_characters = PHP_WORD_BREAK_CHARACTERS;

#ifndef USE_EDITLINE

rl_catch_signals = 0;

#endif

signal(SIGINT, debugger_signal_handler);

TRACE(3, "ReadlineApp::ReadlineApp, about to call read_history\n");

read_history((Process::GetHomeDirectory() +

DebuggerClient::HistoryFileName).c_str());

TRACE(3, "ReadlineApp::ReadlineApp, done calling read_history\n");

}

~ReadlineApp() {

TRACE(2, "ReadlineApp::~ReadlineApp\n");

write_history((Process::GetHomeDirectory() +

DebuggerClient::HistoryFileName).c_str());

}

ReadlineWaitCursor()

: m_thread(this, &ReadlineWaitCursor::animate), m_waiting(true) {

TRACE(2, "ReadlineWaitCursor::ReadlineWaitCursor\n");

m_thread.start();

}

~ReadlineWaitCursor() {

TRACE(2, "ReadlineWaitCursor::~ReadlineWaitCursor\n");

m_waiting = false;

m_thread.waitForEnd();

}

void animate() {

if (rl_point <= 0) return;

auto p = rl_point - 1;

auto orig = rl_line_buffer[p];

while (m_waiting) {

frame('|', p); frame('/', p); frame('-', p); frame('\\', p);

rl_line_buffer[p] = orig;

rl_redisplay();

}

}

AsyncFunc<ReadlineWaitCursor> m_thread;

bool m_waiting;

void frame(char ch, int point) {

rl_line_buffer[point] = ch;

rl_redisplay();

usleep(100000);

}

TRACE(2, "DebuggerClient::LoadColors\n");

HelpColor = LoadColor(hdf["Help"], "BROWN");

InfoColor = LoadColor(hdf["Info"], "GREEN");

OutputColor = LoadColor(hdf["Output"], "CYAN");

ErrorColor = LoadColor(hdf["Error"], "RED");

ItemNameColor = LoadColor(hdf["ItemName"], "GRAY");

HighlightForeColor = LoadColor(hdf["HighlightForeground"], "RED");

HighlightBgColor = LoadBgColor(hdf["HighlightBackground"], "GRAY");

Hdf code = hdf["Code"];

LoadCodeColor(CodeColorKeyword, code["Keyword"], "CYAN");

LoadCodeColor(CodeColorComment, code["Comment"], "RED");

LoadCodeColor(CodeColorString, code["String"], "GREEN");

LoadCodeColor(CodeColorVariable, code["Variable"], "BROWN");

LoadCodeColor(CodeColorHtml, code["Html"], "GRAY");

LoadCodeColor(CodeColorTag, code["Tag"], "MAGENTA");

LoadCodeColor(CodeColorDeclaration, code["Declaration"], "BLUE");

LoadCodeColor(CodeColorConstant, code["Constant"], "MAGENTA");

LoadCodeColor(CodeColorLineNo, code["LineNo"], "GRAY");

const char *defaultName) {

TRACE(2, "DebuggerClient::LoadCodeColor\n");

const char *color = LoadColor(hdf, defaultName);

DefaultCodeColors[index * 2] = color;

DefaultCodeColors[index * 2 + 1] = color ? ANSI_COLOR_END : nullptr;

TRACE(2, "DebuggerClient::Start\n");

SmartPtr<Socket> ret = getStaticDebuggerClient().connectLocal();

getStaticDebuggerClient().start(options);

return ret;

TRACE(2, "DebuggerClient::Stop\n");

if (debugger_client) {

debugger_client.reset();

}

TRACE(2, "entered: DebuggerClient::AdjustScreenMetrics\n");

int rows = 0; int cols = 0;

rl_get_screen_size(&rows, &cols);

if (rows > 0 && cols > 0) {

LineWidth = cols - 4;

ScrollBlockSize = CodeBlockSize = rows - (rows >> 2);

}

TRACE(2, "leaving: DebuggerClient::AdjustScreenMetrics\n");

TRACE(2, "DebuggerClient::IsValidNumber\n");

if (arg.empty()) return false;

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

if (!isdigit(arg[i])) {

return false;

}

}

return true;

char format /* = 'd' */) {

TRACE(2, "DebuggerClient::FormatVariable\n");

String value;

if (maxlen <= 0) {

try {

VariableSerializer::Type t =

format == 'r' ? VariableSerializer::Type::PrintR :

format == 'v' ? VariableSerializer::Type::VarDump :

VariableSerializer::Type::DebuggerDump;

VariableSerializer vs(t, 0, 2);

value = vs.serialize(v, true);

} catch (StringBufferLimitException &e) {

value = "Serialization limit reached";

} catch (...) {

assert(false);

throw;

}

} else {

VariableSerializer vs(VariableSerializer::Type::DebuggerDump, 0, 2);

value = vs.serializeWithLimit(v, maxlen+1);

}

if (maxlen <= 0 || value.length() <= maxlen) {

return value;

}

StringBuffer sb;

sb.append(value.substr(0, maxlen));

sb.append(" ...(omitted)");

return sb.detach();

int *nameLen /* = NULL */) {

TRACE(2, "DebuggerClient::FormatInfoVec\n");

// vertical align names

int maxlen = 0;

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

int len = strlen(info[i].first);

if (len > maxlen) maxlen = len;

}

// print

StringBuffer sb;

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

if (ItemNameColor) sb.append(ItemNameColor);

string name = info[i].first;

name += ": ";

sb.append(name.substr(0, maxlen + 4));

if (ItemNameColor) sb.append(ANSI_COLOR_END);

if (OutputColor) sb.append(OutputColor);

sb.append(info[i].second);

if (OutputColor) sb.append(ANSI_COLOR_END);

sb.append("\n");

}

if (nameLen) *nameLen = maxlen + 4;

return sb.detach();

TRACE(2, "DebuggerClient::FormatTitle\n");

String dash = f_str_repeat(BOX_H, (LineWidth - strlen(title)) / 2 - 4);

StringBuffer sb;

sb.append("\n");

sb.append(" ");

sb.append(dash);

sb.append(" "); sb.append(title); sb.append(" ");

sb.append(dash);

sb.append("\n");

return sb.detach();

: m_tutorial(0), m_scriptMode(false),

m_logFile(""), m_logFileHandler(nullptr),

m_mainThread(this, &DebuggerClient::run), m_stopped(false),

m_inputState(TakingCommand),

m_sigNum(CmdSignal::SignalNone), m_sigCount(0),

m_acLen(0), m_acIndex(0), m_acPos(0), m_acLiveListsDirty(true),

m_threadId(0), m_listLine(0), m_listLineFocus(0),

m_stacktraceAsync(false), m_frame(0),

m_unknownCmd(false) {

TRACE(2, "DebuggerClient::DebuggerClient\n");

Debugger::InitUsageLogging();

TRACE(2, "DebuggerClient::closeAllConnections\n");

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

m_machines[i]->m_thrift.close();

}

TRACE(2, "DebuggerClient::connect\n");

assert((!m_machines.empty() && m_machines[0]->m_name == LocalPrompt));

// First check for an existing connect, and reuse that.

for (unsigned int i = 1; i < m_machines.size(); i++) {

if (f_gethostbyname(m_machines[i]->m_name) ==

f_gethostbyname(host)) {

switchMachine(m_machines[i]);

return false;

}

}

return connectRemote(host, port);

TRACE(2, "DebuggerClient::connectRPC\n");

assert(!m_machines.empty());

DMachineInfoPtr local = m_machines[0];

assert(local->m_name == LocalPrompt);

local->m_rpcHost = host;

local->m_rpcPort = port;

switchMachine(local);

m_rpcHost = "rpc:" + host;

usageLogEvent("RPC connect", m_rpcHost);

return !local->m_interrupting;

TRACE(2, "DebuggerClient::disconnect\n");

assert(!m_machines.empty());

DMachineInfoPtr local = m_machines[0];

assert(local->m_name == LocalPrompt);

local->m_rpcHost.clear();

local->m_rpcPort = 0;

switchMachine(local);

return !local->m_interrupting;

TRACE(2, "DebuggerClient::switchMachine\n");

m_rpcHost.clear();

machine->m_initialized = false; // even if m_machine == machine

if (m_machine != machine) {

m_machine = machine;

m_sandboxes.clear();

m_threads.clear();

m_threadId = 0;

m_breakpoint.reset();

m_matched.clear();

m_listFile.clear();

m_listLine = 0;

m_listLineFocus = 0;

m_stacktrace.reset();

m_frame = 0;

}

TRACE(2, "DebuggerClient::connectLocal\n");

int fds[2];

if (socketpair(AF_UNIX, SOCK_STREAM, 0, fds) != 0) {

throw Exception("unable to create socket pair for local debugging");

}

SmartPtr<Socket> socket1(new Socket(fds[0], AF_UNIX));

SmartPtr<Socket> socket2(new Socket(fds[1], AF_UNIX));

socket1->unregister();

socket2->unregister();

DMachineInfoPtr machine(new DMachineInfo());

machine->m_sandboxAttached = true;

machine->m_name = LocalPrompt;

machine->m_thrift.create(socket1);

assert(m_machines.empty());

m_machines.push_back(machine);

switchMachine(machine);

return socket2;

TRACE(2, "DebuggerClient::connectRemote\n");

if (port <= 0) {

port = RuntimeOption::DebuggerServerPort;

}

info("Connecting to %s:%d...", host.c_str(), port);

if (tryConnect(host, port, false)) {

return true;

}

error("Unable to connect to %s:%d.", host.c_str(), port);

return false;

TRACE(2, "DebuggerClient::reconnect\n");

assert(m_machine);

string &host = m_machine->m_name;

int port = m_machine->m_port;

if (port <= 0) {

return false;

}

info("Re-connecting to %s:%d...", host.c_str(), port);

m_machine->m_thrift.close(); // Close the old socket, it may still be open.

if (tryConnect(host, port, true)) {

return true;

}

error("Still unable to connect to %s:%d.", host.c_str(), port);

return false;

bool clearmachines) {

struct addrinfo *ai;

struct addrinfo hint;

memset(&hint, 0, sizeof(hint));

hint.ai_family = AF_UNSPEC;

hint.ai_socktype = SOCK_STREAM;

if (RuntimeOption::DebuggerDisableIPv6) {

hint.ai_family = AF_INET;

}

if (getaddrinfo(host.c_str(), nullptr, &hint, &ai)) {

return false;

}

SCOPE_EXIT {

freeaddrinfo(ai);

};

/* try possible families (v4, v6) until we get a connection */

struct addrinfo *cur;

for (cur = ai; cur; cur = ai->ai_next) {

Socket *sock = new Socket(socket(cur->ai_family, cur->ai_socktype, 0),

cur->ai_family, cur->ai_addr->sa_data, port);

sock->unregister();

Resource obj(sock); // Destroy sock if we don't connect.

if (f_socket_connect(sock, String(host), port)) {

if (clearmachines) {

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

if (m_machines[i] == m_machine) {

m_machines.erase(m_machines.begin() + i);

break;

}

}

}

DMachineInfoPtr machine(new DMachineInfo());

machine->m_name = host;

machine->m_port = port;

machine->m_thrift.create(SmartPtr<Socket>(sock));

m_machines.push_back(machine);

switchMachine(machine);

return true;

}

}

return false;

TRACE(2, "DebuggerClient::getPrompt\n");

if (NoPrompt || !RuntimeOption::EnableDebuggerPrompt) {

return "";

}

string *name = &m_machine->m_name;

if (!m_rpcHost.empty()) {

name = &m_rpcHost;

}

if (m_inputState == TakingCode) {

string prompt = " ";

for (unsigned int i = 2; i < name->size() + 2; i++) {

prompt += '.';

}

prompt += ' ';

return prompt;

}

return *name + "> ";

TRACE(2, "DebuggerClient::init\n");

m_options = options;

if (!options.configFName.empty()) {

m_configFileName = options.configFName;

}

if (options.user.empty())

m_options.user = Process::GetCurrentUser();

usageLogEvent("init");

loadConfig();

if (m_scriptMode) {

print("running in script mode, pid=%d\n",

(int32_t)Process::GetProcessId());

}

if (!options.cmds.empty()) {

RuntimeOption::EnableDebuggerColor = false;

RuntimeOption::EnableDebuggerPrompt = false;

s_use_utf8 = false;

}

if (UseColor && RuntimeOption::EnableDebuggerColor) Debugger::SetTextColors();

if (!NoPrompt && RuntimeOption::EnableDebuggerPrompt) {

info("Welcome to HipHop Debugger!");

info("Type \"help\" or \"?\" for a complete list of commands.\n");

}

if (!options.host.empty()) {

connectRemote(options.host, options.port);

} else {

if (options.fileName.empty()) {

help("Note: no server specified, debugging local scripts only.");

help("If you want to connect to a server, launch with \"-h\" or use:");

help(" [m]achine [c]onnect <servername>\n");

}

}

TRACE(2, "DebuggerClient::start\n");

init(options);

m_mainThread.start();

TRACE(2, "DebuggerClient::run\n");

StackTraceNoHeap::AddExtraLogging("IsDebugger", "True");

ReadlineApp app;

TRACE(3, "DebuggerClient::run, about to call playMacro\n");

playMacro("startup");

if (!m_options.cmds.empty()) {

m_macroPlaying = MacroPtr(new Macro());

m_macroPlaying->m_cmds = m_options.cmds;

m_macroPlaying->m_cmds.push_back("q");

m_macroPlaying->m_index = 0;

}

hphp_session_init();

ExecutionContext *context = hphp_context_init();

if (m_options.extension.empty()) {

hphp_invoke_simple("", true); // warm-up only

} else {

hphp_invoke_simple(m_options.extension);

}

while (true) {

bool reconnect = false;

try {

eventLoop(TopLevel, DebuggerCommand::KindOfNone, "Main client loop");

} catch (DebuggerClientExitException &e) { /* normal exit */

} catch (DebuggerServerLostException &e) {

// Loss of connection

TRACE_RB(1, "DebuggerClient::run: server lost exception\n");

usageLogEvent("DebuggerServerLostException", m_commandCanonical);

reconnect = true;

} catch (DebuggerProtocolException &e) {

// Bad or unexpected data. Give reconnect a shot, it could help...

TRACE_RB(1, "DebuggerClient::run: protocol exception\n");

usageLogEvent("DebuggerProtocolException", m_commandCanonical);

reconnect = true;

} catch (...) {

TRACE_RB(1, "DebuggerClient::run: unknown exception\n");

usageLogEvent("UnknownException", m_commandCanonical);

Logger::Error("Unhandled exception, exiting.");

}

// Note: it's silly to try to reconnect when stopping, or if we have a

// problem while quitting.

if (reconnect && !m_stopped && (m_commandCanonical != "quit")) {

usageLogEvent("reconnect attempt", m_commandCanonical);

if (DebuggerClient::reconnect()) {

usageLogEvent("reconnect success", m_commandCanonical);

continue;

}

usageLogEvent("reconnect failed", m_commandCanonical);

Logger::Error("Unable to reconnect to server, exiting.");

}

break;

}

usageLogEvent("exit");

// Closing all proxy connections will force the local proxy to pop out of

// it's wait, and eventually exit the main thread.

closeAllConnections();

hphp_context_exit(context, false);

hphp_session_exit();

TRACE(2, "DebuggerClient::updateLiveLists\n");

ReadlineWaitCursor waitCursor;

CmdInfo::UpdateLiveLists(*this);

m_acLiveListsDirty = false;

TRACE(2, "DebuggerClient::promptFunctionPrototype\n");

if (m_acProtoTypePrompted) return;

m_acProtoTypePrompted = true;

const char *p0 = rl_line_buffer;

int len = strlen(p0);

if (len < 2) return;

const char *pLast = p0 + len - 1;

while (pLast > p0 && isspace(*pLast)) --pLast;

if (pLast == p0 || *pLast-- != '(') return;

while (pLast > p0 && isspace(*pLast)) --pLast;

const char *p = pLast;

while (p >= p0 && (isalnum(*p) || *p == '_')) --p;

if (p == pLast) return;

string cls;

string func(p + 1, pLast - p);

if (p > p0 && *p-- == ':' && *p-- == ':') {

pLast = p;

while (p >= p0 && (isalnum(*p) || *p == '_')) --p;

if (pLast > p) {

cls = string(p + 1, pLast - p);

}

}

String output = highlight_code(CmdInfo::GetProtoType(*this, cls, func));

print("\n%s", output.data());

rl_forced_update_display();

TRACE(2, "DebuggerClient::setCompletion\n");

if (m_inputState == TakingCommand) {

parseCommand(rl_line_buffer);

if (*text) {

if (!m_args.empty()) {

m_args.resize(m_args.size() - 1);

} else {

m_command.clear();

}

}

}

return true;

TRACE(2, "DebuggerClient::addCompletion(AutoComplete type)\n");

if (type < 0 || type >= AutoCompleteCount) {

Logger::Error("Invalid auto completion enum: %d", type);

return;

}

if (type == AutoCompleteCode) {

addCompletion(AutoCompleteVariables);

addCompletion(AutoCompleteConstants);

addCompletion(AutoCompleteClasses);

addCompletion(AutoCompleteFunctions);

addCompletion(AutoCompleteClassMethods);

addCompletion(AutoCompleteClassProperties);

addCompletion(AutoCompleteClassConstants);

addCompletion(AutoCompleteKeyword);

} else if (type == AutoCompleteKeyword) {

addCompletion(PHP_KEYWORDS);

} else {

m_acLists.push_back((const char **)type);

}

if (type == AutoCompleteFunctions || type == AutoCompleteClassMethods) {

promptFunctionPrototype();

}

std::string const &text) {

TRACE(2, "DebuggerClient::getAllCompletions\n");

std::vector<std::string> res;

if (m_acLiveListsDirty) {

updateLiveLists();

}

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

const std::vector<std::string> &items = m_acLiveLists[i];

for (size_t j = 0; j < items.size(); ++j) {

const char *p = items[j].c_str();

if (strncasecmp(p, text.c_str(), text.length()) == 0) {

res.push_back(std::string(p));

}

}

}

return res;

TRACE(2, "DebuggerClient::first_non_whitespace\n");

while (*s && isspace(*s)) s++;

return *s;

TRACE(2, "DebuggerClient::initializeMachine\n");

// set/clear intercept for RPC thread

if (!m_machines.empty() && m_machine == m_machines[0]) {