wellton/hhvm
1
0
Fork 0
Código Issues Pull Requests Ações Pacotes Projetos Versões Wiki Atividade

Litstr must die, episode I.

Ver Código-Fonte 
Converted lots of callsites to StaticString, removed a few
dead overloaded litstr functions.
Esse commit está contido em:
smith
2013-04-15 19:03:16 -07:00
commit de Sara Golemon
pai 1097d2dcb5
commit 98466ea3fd
27 arquivos alterados com 291 adições e 171 exclusões
Baixar Arquivo de Patch Baixar Arquivo de Diff Expandir todos os arquivos Colapsar todos os arquivos
hphp/runtime/base/array/array_init.h
-10
Ver Arquivo
@@ -152,16 +152,6 @@ public:
return *this;
}
ArrayInit &set(litstr name, RefResult v, bool keyConverted = false) {
String key(name);
if (keyConverted) {
m_data->setRef(key, variant(v), false);
} else {
m_data->setRef(key.toKey(), variant(v), false);
}
return *this;
}
ArrayInit &set(CStrRef name, RefResult v, bool keyConverted = false) {
if (keyConverted) {
m_data->setRef(name, variant(v), false);
hphp/runtime/base/builtin_functions.cpp
-15
Ver Arquivo
@@ -933,9 +933,6 @@ bool isset(CArrRef v, CObjRef offset) {
bool isset(CArrRef v, CStrRef offset, bool isString /* = false */) {
return isset(v.rvalAtRef(offset, AccessFlags::IsKey(isString)));
}
bool isset(CArrRef v, litstr offset, bool isString /* = false */) {
return isset(v.rvalAtRef(offset, AccessFlags::IsKey(isString)));
}
bool isset(CArrRef v, CVarRef offset) {
return isset(v.rvalAtRef(offset));
}
@@ -991,18 +988,6 @@ bool isset(CVarRef v, CVarRef offset) {
}
return false;
}
bool isset(CVarRef v, litstr offset, bool isString /* = false */) {
Variant::TypedValueAccessor tva = v.getTypedAccessor();
if (LIKELY(Variant::GetAccessorType(tva) == KindOfArray)) {
return isset(Variant::GetAsArray(tva).rvalAtRef(
offset, AccessFlags::IsKey(isString)));
}
if (Variant::GetAccessorType(tva) == KindOfObject ||
Variant::IsString(tva)) {
return isset(v, Variant(offset));
}
return false;
}
bool isset(CVarRef v, CStrRef offset, bool isString /* = false */) {
Variant::TypedValueAccessor tva = v.getTypedAccessor();
hphp/runtime/base/builtin_functions.h
+3 -2
Ver Arquivo
@@ -259,7 +259,6 @@ bool isset(CVarRef v, double offset);
bool isset(CVarRef v, CArrRef offset);
bool isset(CVarRef v, CObjRef offset);
bool isset(CVarRef v, CVarRef offset);
bool isset(CVarRef v, litstr offset, bool isString = false);
bool isset(CVarRef v, CStrRef offset, bool isString = false);
bool isset(CArrRef v, int64_t offset);
@@ -269,7 +268,6 @@ inline bool isset(CArrRef v, double offset) { return isset(v, (int64_t)offset);
bool isset(CArrRef v, CArrRef offset);
bool isset(CArrRef v, CObjRef offset);
bool isset(CArrRef v, CVarRef offset);
bool isset(CArrRef v, litstr offset, bool isString = false);
bool isset(CArrRef v, CStrRef offset, bool isString = false);
inline Variant unset(Variant &v) { v.unset(); return uninit_null();}
@@ -293,6 +291,9 @@ inline bool is_array(CVarRef v) { return v.is(KindOfArray);}
inline bool is_object(CVarRef var) {
return var.is(KindOfObject) && !var.isResource();
}
inline bool is_empty_string(CVarRef v) {
return v.isString() && v.getStringData()->empty();
}
///////////////////////////////////////////////////////////////////////////////
// special variable contexts
hphp/runtime/base/execution_context.cpp
+14 -8
Ver Arquivo
@@ -441,10 +441,13 @@ void BaseExecutionContext::resetCurrentBuffer() {
///////////////////////////////////////////////////////////////////////////////
// program executions
static const StaticString s_name("name");
static const StaticString s_args("args");
void BaseExecutionContext::registerShutdownFunction(CVarRef function,
Array arguments,
ShutdownType type) {
Array callback = CREATE_MAP2("name", function, "args", arguments);
Array callback = CREATE_MAP2(s_name, function, s_args, arguments);
Variant &funcs = m_shutdowns.lvalAt(type);
funcs.append(callback);
}
@@ -517,7 +520,7 @@ void BaseExecutionContext::onRequestShutdown() {
void BaseExecutionContext::executeFunctions(CArrRef funcs) {
for (ArrayIter iter(funcs); iter; ++iter) {
Array callback = iter.second();
vm_call_user_func(callback["name"], callback["args"]);
vm_call_user_func(callback[s_name], callback[s_args]);
}
}
@@ -592,6 +595,9 @@ private:
int m_originalState;
};
static StaticString s_file("file");
static StaticString s_line("line");
void BaseExecutionContext::handleError(const std::string &msg,
int errnum,
bool callUserHandler,
@@ -640,8 +646,8 @@ void BaseExecutionContext::handleError(const std::string &msg,
if (RuntimeOption::InjectedStackTrace) {
if (!bt.empty()) {
Array top = bt.rvalAt(0).toArray();
if (top.exists("file")) file = top.rvalAt("file").toString();
if (top.exists("line")) line = top.rvalAt("line");
if (top.exists(s_file)) file = top.rvalAt(s_file).toString();
if (top.exists(s_line)) line = top.rvalAt(s_line);
}
}
@@ -670,8 +676,8 @@ bool BaseExecutionContext::callUserErrorHandler(const Exception &e, int errnum,
backtrace = arr;
Array top = backtrace.rvalAt(0);
if (!top.isNull()) {
errfile = top.rvalAt("file");
errline = top.rvalAt("line").toInt64();
errfile = top.rvalAt(s_file);
errline = top.rvalAt(s_line).toInt64();
}
}
}
@@ -707,8 +713,8 @@ bool BaseExecutionContext::onFatalError(const Exception &e) {
Array bt = ee->getBackTrace();
if (!bt.empty()) {
Array top = bt.rvalAt(0).toArray();
if (top.exists("file")) file = top.rvalAt("file").toString();
if (top.exists("line")) line = top.rvalAt("line");
if (top.exists(s_file)) file = top.rvalAt(s_file).toString();
if (top.exists(s_line)) line = top.rvalAt(s_line);
}
}
}
hphp/runtime/base/file/bzip2_file.cpp
+4 -1
Ver Arquivo
@@ -59,12 +59,15 @@ String BZ2File::errstr() {
return BZ2_bzerror(m_bzFile, &errnum);
}
static const StaticString s_errno("errno");
static const StaticString s_errstr("errstr");
Variant BZ2File::error() {
assert(m_bzFile);
int errnum;
const char * errstr;
errstr = BZ2_bzerror(m_bzFile, &errnum);
return CREATE_MAP2("errno", errnum, "errstr", String(errstr));
return CREATE_MAP2(s_errno, errnum, s_errstr, String(errstr));
}
bool BZ2File::flush() {
hphp/runtime/base/file/http_stream_wrapper.cpp
+23 -13
Ver Arquivo
@@ -24,6 +24,14 @@
namespace HPHP {
///////////////////////////////////////////////////////////////////////////////
static const StaticString s_GET("GET");
static const StaticString s_method("method");
static const StaticString s_http("http");
static const StaticString s_header("header");
static const StaticString s_max_redirects("max_redirects");
static const StaticString s_timeout("timeout");
static const StaticString s_content("content");
File* HttpStreamWrapper::open(CStrRef filename, CStrRef mode,
int options, CVarRef context) {
if (RuntimeOption::ServerHttpSafeMode) {
@@ -36,33 +44,35 @@ File* HttpStreamWrapper::open(CStrRef filename, CStrRef mode,
}
std::unique_ptr<UrlFile> file;
StreamContext *ctx = !context.isObject() ? nullptr :
StreamContext *ctx = !context.isObject() ? nullptr :
context.toObject().getTyped<StreamContext>();
if (!ctx || ctx->m_options.isNull() || ctx->m_options["http"].isNull()) {
if (!ctx || ctx->m_options.isNull() || ctx->m_options[s_http].isNull()) {
file = std::unique_ptr<UrlFile>(NEWOBJ(UrlFile)());
} else {
Array opts = ctx->m_options["http"];
String method = "GET";
if (opts.exists("method")) {
method = opts["method"].toString();
Array opts = ctx->m_options[s_http];
String method = s_GET;
if (opts.exists(s_method)) {
method = opts[s_method].toString();
}
Array headers;
if (opts.exists("header")) {
Array lines = StringUtil::Explode(opts["header"].toString(), "\r\n");
if (opts.exists(s_header)) {
Array lines = StringUtil::Explode(opts[s_header].toString(), "\r\n");
for (ArrayIter it(lines); it; ++it) {
Array parts = StringUtil::Explode(it.second().toString(), ": ");
headers.set(parts.rvalAt(0), parts.rvalAt(1));
}
}
if (opts.exists("user_agent") && !headers.exists("User-Agent")) {
headers.set("User-Agent", opts["user_agent"]);
static const StaticString s_user_agent("user_agent");
static const StaticString s_User_Agent("User-Agent");
if (opts.exists(s_user_agent) && !headers.exists(s_User_Agent)) {
headers.set(s_User_Agent, opts[s_user_agent]);
}
int max_redirs = 20;
if (opts.exists("max_redirects")) max_redirs = opts["max_redirects"];
if (opts.exists(s_max_redirects)) max_redirs = opts[s_max_redirects];
int timeout = -1;
if (opts.exists("timeout")) timeout = opts["timeout"];
if (opts.exists(s_timeout)) timeout = opts[s_timeout];
file = std::unique_ptr<UrlFile>(NEWOBJ(UrlFile)(method.data(), headers,
opts["content"].toString(),
opts[s_content].toString(),
max_redirs, timeout));
}
bool ret = file->open(filename, mode);
hphp/runtime/base/file/ssl_socket.cpp
+37 -18
Ver Arquivo
@@ -42,6 +42,9 @@ int SSLSocket::GetSSLExDataIndex() {
return s_ex_data_index;
}
static const StaticString s_allow_self_signed("allow_self_signed");
static const StaticString s_verify_depth("verify_depth");
static int verify_callback(int preverify_ok, X509_STORE_CTX *ctx) {
int ret = preverify_ok;
@@ -58,12 +61,12 @@ static int verify_callback(int preverify_ok, X509_STORE_CTX *ctx) {
/* if allow_self_signed is set, make sure that verification succeeds */
if (err == X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT &&
stream->getContext()["allow_self_signed"].toBoolean()) {
stream->getContext()[s_allow_self_signed].toBoolean()) {
ret = 1;
}
/* check the depth */
Variant vdepth = stream->getContext()["verify_depth"];
Variant vdepth = stream->getContext()[s_verify_depth];
if (vdepth.toBoolean() && depth > vdepth.toInt64()) {
ret = 0;
X509_STORE_CTX_set_error(ctx, X509_V_ERR_CERT_CHAIN_TOO_LONG);
@@ -72,10 +75,12 @@ static int verify_callback(int preverify_ok, X509_STORE_CTX *ctx) {
return ret;
}
static const StaticString s_passphrase("passphrase");
static int passwd_callback(char *buf, int num, int verify, void *data) {
/* TODO: could expand this to make a callback into PHP user-space */
SSLSocket *stream = (SSLSocket *)data;
String passphrase = stream->getContext()["passphrase"];
String passphrase = stream->getContext()[s_passphrase];
if (!passphrase.empty() && passphrase.size() < num - 1) {
memcpy(buf, passphrase.data(), passphrase.size() + 1);
return passphrase.size();
@@ -83,17 +88,23 @@ static int passwd_callback(char *buf, int num, int verify, void *data) {
return 0;
}
static const StaticString s_verify_peer("verify_peer");
static const StaticString s_cafile("cafile");
static const StaticString s_capath("capath");
static const StaticString s_ciphers("ciphers");
static const StaticString s_local_cert("local_cert");
SSL *SSLSocket::createSSL(SSL_CTX *ctx) {
ERR_clear_error();
/* look at options in the stream and set appropriate verification flags */
if (m_context["verify_peer"].toBoolean()) {
if (m_context[s_verify_peer].toBoolean()) {
/* turn on verification callback */
SSL_CTX_set_verify(ctx, SSL_VERIFY_PEER, verify_callback);
/* CA stuff */
String cafile = m_context["cafile"];
String capath = m_context["capath"];
String cafile = m_context[s_cafile];
String capath = m_context[s_capath];
if (!cafile.empty() || !capath.empty()) {
if (!SSL_CTX_load_verify_locations(ctx, cafile.data(), capath.data())) {
@@ -103,7 +114,7 @@ SSL *SSLSocket::createSSL(SSL_CTX *ctx) {
}
}
int64_t depth = m_context["verify_depth"].toInt64();
int64_t depth = m_context[s_verify_depth].toInt64();
if (depth) {
SSL_CTX_set_verify_depth(ctx, depth);
}
@@ -112,18 +123,18 @@ SSL *SSLSocket::createSSL(SSL_CTX *ctx) {
}
/* callback for the passphrase (for localcert) */
if (!m_context["passphrase"].toString().empty()) {
if (!m_context[s_passphrase].toString().empty()) {
SSL_CTX_set_default_passwd_cb_userdata(ctx, this);
SSL_CTX_set_default_passwd_cb(ctx, passwd_callback);
}
String cipherlist = m_context["ciphers"].toString();
String cipherlist = m_context[s_ciphers].toString();
if (cipherlist.empty()) {
cipherlist = "DEFAULT";
}
SSL_CTX_set_cipher_list(ctx, cipherlist.data());
String certfile = m_context["local_cert"].toString();
String certfile = m_context[s_local_cert].toString();
if (!certfile.empty()) {
String resolved_path_buff = File::TranslatePath(certfile);
if (!resolved_path_buff.empty()) {
@@ -428,9 +439,11 @@ bool SSLSocket::setupCrypto(SSLSocket *session /* = NULL */) {
return true;
}
static const StaticString s_CN_match("CN_match");
bool SSLSocket::applyVerificationPolicy(X509 *peer) {
/* verification is turned off */
if (!m_context["verify_peer"].toBoolean()) {
if (!m_context[s_verify_peer].toBoolean()) {
return true;
}
@@ -445,7 +458,7 @@ bool SSLSocket::applyVerificationPolicy(X509 *peer) {
/* fine */
break;
case X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT:
if (m_context["allow_self_signed"].toBoolean()) {
if (m_context[s_allow_self_signed].toBoolean()) {
/* allowed */
break;
}
@@ -459,11 +472,12 @@ bool SSLSocket::applyVerificationPolicy(X509 *peer) {
/* if the cert passed the usual checks, apply our own local policies now */
/* Does the common name match ? (used primarily for https://) */
String cnmatch = m_context["CN_match"].toString();
String cnmatch = m_context[s_CN_match].toString();
if (!cnmatch.empty()) {
X509_NAME *name = X509_get_subject_name(peer);
char buf[1024];
int name_len = X509_NAME_get_text_by_NID(name, NID_commonName, buf, sizeof(buf));
int name_len = X509_NAME_get_text_by_NID(name, NID_commonName, buf,
sizeof(buf));
if (name_len < 0) {
raise_warning("Unable to locate peer certificate CN");
@@ -493,6 +507,11 @@ bool SSLSocket::applyVerificationPolicy(X509 *peer) {
return true;
}
static const StaticString s_capture_peer_cert("capture_peer_cert");
static const StaticString s_peer_certificate("peer_certificate");
static const StaticString s_capture_peer_cert_chain("capture_peer_cert_chain");
static const StaticString s_peer_certificate_chain("peer_certificate_chain");
bool SSLSocket::enableCrypto(bool activate /* = true */) {
if (activate && !m_ssl_active) {
double timeout = m_connect_timeout;
@@ -551,13 +570,13 @@ bool SSLSocket::enableCrypto(bool activate /* = true */) {
/* allow the script to capture the peer cert
* and/or the certificate chain */
if (m_context["capture_peer_cert"].toBoolean()) {
if (m_context[s_capture_peer_cert].toBoolean()) {
Object cert(new Certificate(peer_cert));
m_context.set("peer_certificate", cert);
m_context.set(s_peer_certificate, cert);
peer_cert = nullptr;
}
if (m_context["capture_peer_cert_chain"].toBoolean()) {
if (m_context[s_capture_peer_cert_chain].toBoolean()) {
Array arr;
STACK_OF(X509) *chain = SSL_get_peer_cert_chain(m_handle);
if (chain) {
@@ -566,7 +585,7 @@ bool SSLSocket::enableCrypto(bool activate /* = true */) {
arr.append(Object(new Certificate(mycert)));
}
}
m_context.set("peer_certificate_chain", arr);
m_context.set(s_peer_certificate_chain, arr);
}
}
hphp/runtime/base/server/rpc_request_handler.cpp
+5 -2
Ver Arquivo
@@ -152,6 +152,9 @@ void RPCRequestHandler::handleRequest(Transport *transport) {
HttpProtocol::ClearRecord(ret, tmpfile);
}
static const StaticString s_output("output");
static const StaticString s_return("return");
bool RPCRequestHandler::executePHPFunction(Transport *transport,
SourceRootInfo &sourceRootInfo) {
// reset timeout counter
@@ -276,8 +279,8 @@ bool RPCRequestHandler::executePHPFunction(Transport *transport,
case 1: response = m_context->obDetachContents(); break;
case 2:
response =
f_json_encode(CREATE_MAP2("output", m_context->obDetachContents(),
"return", f_json_encode(funcRet)));
f_json_encode(CREATE_MAP2(s_output, m_context->obDetachContents(),
s_return, f_json_encode(funcRet)));
break;
case 3: response = f_serialize(funcRet); break;
}
hphp/runtime/base/server/server_stats.cpp
+7 -4
Ver Arquivo
@@ -953,6 +953,9 @@ void ServerStats::StartNetworkProfile() {
}
}
static const StaticString s_ct("ct");
static const StaticString s_wt("wt");
Array ServerStats::EndNetworkProfile() {
s_profile_network = false;
Lock lock(s_lock, false);
@@ -966,8 +969,8 @@ Array ServerStats::EndNetworkProfile() {
for (IOStatusMap::const_iterator iter = status.begin();
iter != status.end(); ++iter) {
ret.set(String(iter->first),
CREATE_MAP2("ct", iter->second.count,
"wt", iter->second.wall_time));
CREATE_MAP2(s_ct, iter->second.count,
s_wt, iter->second.wall_time));
}
status.clear();
}
@@ -1217,8 +1220,8 @@ Array ServerStats::getThreadIOStatuses() {
for (IOStatusMap::const_iterator iter = status.begin();
iter != status.end(); ++iter) {
ret.set(String(iter->first),
CREATE_MAP2("ct", iter->second.count,
"wt", iter->second.wall_time));
CREATE_MAP2(s_ct, iter->second.count,
s_wt, iter->second.wall_time));
}
status.clear();
return ret;
hphp/runtime/base/util/extended_logger.cpp
+22 -16
Ver Arquivo
@@ -128,6 +128,12 @@ void ExtendedLogger::Log(LogLevelType level, CArrRef stackTrace,
}
}
static const StaticString s_class("class");
static const StaticString s_function("function");
static const StaticString s_file("file");
static const StaticString s_type("type");
static const StaticString s_line("line");
void ExtendedLogger::PrintStackTrace(FILE *f, CArrRef stackTrace,
bool escape /* = false */,
bool escapeMore /* = false */) {
@@ -138,17 +144,17 @@ void ExtendedLogger::PrintStackTrace(FILE *f, CArrRef stackTrace,
}
Array frame = it.second().toArray();
fprintf(f, " #%d ", i);
if (frame.exists("function")) {
if (frame.exists("class")) {
fprintf(f, "%s%s%s(), called ", frame["class"].toString().c_str(),
frame["type"].toString().c_str(),
frame["function"].toString().c_str());
if (frame.exists(s_function)) {
if (frame.exists(s_class)) {
fprintf(f, "%s%s%s(), called ", frame[s_class].toString().c_str(),
frame[s_type].toString().c_str(),
frame[s_function].toString().c_str());
} else {
fprintf(f, "%s(), called ", frame["function"].toString().c_str());
fprintf(f, "%s(), called ", frame[s_function].toString().c_str());
}
}
fprintf(f, "at [%s:%" PRId64 "]", frame["file"].toString().c_str(),
frame["line"].toInt64());
fprintf(f, "at [%s:%" PRId64 "]", frame[s_file].toString().c_str(),
frame[s_line].toInt64());
}
fprintf(f, escapeMore ? "\\n" : "\n");
fflush(f);
@@ -161,19 +167,19 @@ std::string ExtendedLogger::StringOfFrame(CArrRef frame, int i, bool escape) {
ss << (escape ? "\\n" : "\n");
}
ss << " #" << i << " ";
if (frame.exists("function")) {
if (frame.exists("class")) {
ss << frame["class"].toString().c_str()
<< frame["type"].toString().c_str()
<< frame["function"].toString().c_str()
if (frame.exists(s_function)) {
if (frame.exists(s_class)) {
ss << frame[s_class].toString().c_str()
<< frame[s_type].toString().c_str()
<< frame[s_function].toString().c_str()
<< "(), called ";
} else {
ss << frame["function"].toString().c_str()
ss << frame[s_function].toString().c_str()
<< "(), called ";
}
}
ss << "at [" << frame["file"].toString().c_str()
<< ":" << frame["line"].toInt64() << "]";
ss << "at [" << frame[s_file].toString().c_str()
<< ":" << frame[s_line].toInt64() << "]";
return ss.str();
}
hphp/runtime/base/util/http_client.cpp
+18 -11
Ver Arquivo
@@ -101,6 +101,13 @@ int HttpClient::post(const char *url, const char *data, int size,
return impl(url, data, size, response, requestHeaders, responseHeaders);
}
static const StaticString s_ssl("ssl");
static const StaticString s_verify_peer("verify_peer");
static const StaticString s_capath("capath");
static const StaticString s_cafile("cafile");
static const StaticString s_local_cert("local_cert");
static const StaticString s_passphrase("passphrase");
int HttpClient::impl(const char *url, const char *data, int size,
StringBuffer &response, const HeaderMap *requestHeaders,
std::vector<String> *responseHeaders) {
@@ -184,27 +191,27 @@ int HttpClient::impl(const char *url, const char *data, int size,
curl_easy_setopt(cp, CURLOPT_WRITEHEADER, (void*)this);
}
if (m_stream_context_options["ssl"].isArray()) {
const Array ssl = m_stream_context_options["ssl"].toArray();
if (ssl["verify_peer"].toBoolean()) {
if (m_stream_context_options[s_ssl].isArray()) {
const Array ssl = m_stream_context_options[s_ssl].toArray();
if (ssl[s_verify_peer].toBoolean()) {
curl_easy_setopt(cp, CURLOPT_SSL_VERIFYPEER, 1);
}
if (ssl.exists("capath")) {
if (ssl.exists(s_capath)) {
curl_easy_setopt(cp, CURLOPT_CAPATH,
ssl["capath"].toString().data());
ssl[s_capath].toString().data());
}
if (ssl.exists("cafile")) {
if (ssl.exists(s_cafile)) {
curl_easy_setopt(cp, CURLOPT_CAINFO,
ssl["cafile"].toString().data());
ssl[s_cafile].toString().data());
}
if (ssl.exists("local_cert")) {
if (ssl.exists(s_local_cert)) {
curl_easy_setopt(cp, CURLOPT_SSLKEY,
ssl["local_cert"].toString().data());
ssl[s_local_cert].toString().data());
curl_easy_setopt(cp, CURLOPT_SSLKEYTYPE, "PEM");
}
if (ssl.exists("passphrase")) {
if (ssl.exists(s_passphrase)) {
curl_easy_setopt(cp, CURLOPT_KEYPASSWD,
ssl["passphrase"].toString().data());
ssl[s_passphrase].toString().data());
}
}
hphp/runtime/base/util/string_buffer.cpp
+1 -1
Ver Arquivo
@@ -74,7 +74,7 @@ String StringBuffer::detachImpl() {
m_cap = 0;
return String(str); // causes incref
}
return String("");
return empty_string;
}
String StringBuffer::copy() {
hphp/runtime/eval/debugger/cmd/cmd_machine.cpp
+9 -4
Ver Arquivo
@@ -174,15 +174,20 @@ bool CmdMachine::AttachSandbox(DebuggerClient *client,
return cmdMachine->m_succeed;
}
static const StaticString s_host("host");
static const StaticString s_port("port");
static const StaticString s_auth("auth");
static const StaticString s_timeout("timeout");
void CmdMachine::UpdateIntercept(DebuggerClient *client,
const std::string &host, int port) {
CmdMachine cmd;
cmd.m_body = "rpc";
cmd.m_rpcConfig = CREATE_MAP4
("host", String(host),
"port", port ? port : RuntimeOption::DebuggerDefaultRpcPort,
"auth", String(RuntimeOption::DebuggerDefaultRpcAuth),
"timeout", RuntimeOption::DebuggerDefaultRpcTimeout);
(s_host, String(host),
s_port, port ? port : RuntimeOption::DebuggerDefaultRpcPort,
s_auth, String(RuntimeOption::DebuggerDefaultRpcAuth),
s_timeout, RuntimeOption::DebuggerDefaultRpcTimeout);
client->xend<CmdMachine>(&cmd);
}
hphp/runtime/ext/ext_apc.cpp
+3 -1
Ver Arquivo
@@ -225,8 +225,10 @@ Variant f_apc_exists(CVarRef key, int64_t cache_id /* = 0 */) {
return s_apc_store[cache_id].exists(key.toString());
}
static const StaticString s_start_time("start_time");
Variant f_apc_cache_info(int64_t cache_id /* = 0 */, bool limited /* = false */) {
return CREATE_MAP1("start_time", start_time());
return CREATE_MAP1(s_start_time, start_time());
}
Array f_apc_sma_info(bool limited /* = false */) {
hphp/runtime/ext/ext_domdocument.cpp
+7 -4
Ver Arquivo
@@ -305,6 +305,9 @@ static void dom_normalize(xmlNodePtr nodep) {
}
}
static StaticString s_query("query");
static StaticString s_namespaces("namespaces");
static Variant dom_canonicalization(xmlNodePtr nodep, CStrRef file,
bool exclusive, bool with_comments,
CVarRef xpath_array, CVarRef ns_prefixes,
@@ -342,11 +345,11 @@ static Variant dom_canonicalization(xmlNodePtr nodep, CStrRef file,
// xpath query from xpath_array
Array arr = xpath_array.toArray();
String xquery;
if (!arr.exists("query")) {
if (!arr.exists(s_query)) {
raise_warning("'query' missing from xpath array");
return false;
}
Variant tmp = arr.rvalAt("query");
Variant tmp = arr.rvalAt(s_query);
if (!tmp.isString()) {
raise_warning("'query' is not a string");
return false;
@@ -354,8 +357,8 @@ static Variant dom_canonicalization(xmlNodePtr nodep, CStrRef file,
xquery = tmp.toString();
ctxp = xmlXPathNewContext(docp);
ctxp->node = nodep;
if (arr.exists("namespaces")) {
Variant tmp = arr.rvalAt("namespaces");
if (arr.exists(s_namespaces)) {
Variant tmp = arr.rvalAt(s_namespaces);
if (tmp.isArray()) {
for (ArrayIter it = tmp.toArray().begin(); !it; ++it) {
Variant prefix = it.first();
hphp/runtime/ext/ext_error.cpp
+3 -2
Ver Arquivo
@@ -55,6 +55,7 @@ static const StaticString s_type("type");
static const StaticString s_function("function");
static const StaticString s_file("file");
static const StaticString s_line("line");
static const StaticString s_message("message");
String debug_string_backtrace(bool skip) {
if (RuntimeOption::InjectedStackTrace) {
@@ -95,8 +96,8 @@ Array f_error_get_last() {
if (lastError.isNull()) {
return (ArrayData *)NULL;
}
return CREATE_MAP2("message", g_context->getLastError(),
"type", g_context->getLastErrorNumber());
return CREATE_MAP2(s_message, g_context->getLastError(),
s_type, g_context->getLastErrorNumber());
}
bool f_error_log(CStrRef message, int message_type /* = 0 */,
hphp/runtime/ext/ext_fb.cpp
+8 -2
Ver Arquivo
@@ -1560,6 +1560,12 @@ void f_fb_set_exit_callback(CVarRef function) {
g_context->setExitCallback(function);
}
static const StaticString s_flush_stats("flush_stats");
static const StaticString s_chunk_stats("chunk_stats");
static const StaticString s_total("total");
static const StaticString s_sent("sent");
static const StaticString s_time("time");
Array f_fb_get_flush_stat() {
Transport *transport = g_context->getTransport();
if (transport) {
@@ -1570,8 +1576,8 @@ Array f_fb_get_flush_stat() {
int sent = transport->getResponseSentSize();
int64_t time = transport->getFlushTime();
return CREATE_MAP2(
"flush_stats", CREATE_MAP3("total", total, "sent", sent, "time", time),
"chunk_stats", chunkStats);
s_flush_stats, CREATE_MAP3(s_total, total, s_sent, sent, s_time, time),
s_chunk_stats, chunkStats);
}
return NULL;
}
hphp/runtime/ext/ext_function.cpp
+9 -5
Ver Arquivo
@@ -34,11 +34,12 @@ namespace HPHP {
using HPHP::VM::ActRec;
using HPHP::VM::Transl::CallerFrame;
static const StaticString s_internal("internal");
static const StaticString s_user("user");
Array f_get_defined_functions() {
Array ret;
ret.set("internal", ClassInfo::GetSystemFunctions());
ret.set("user", ClassInfo::GetUserFunctions());
return ret;
return CREATE_MAP2(s_internal, ClassInfo::GetSystemFunctions(),
s_user, ClassInfo::GetUserFunctions());
}
bool f_function_exists(CStrRef function_name, bool autoload /* = true */) {
@@ -172,6 +173,9 @@ Variant f_call_user_func_array_rpc(CStrRef host, int port, CStrRef auth,
return f_call_user_func_rpc(0, host, port, auth, timeout, function, params);
}
static const StaticString s_func("func");
static const StaticString s_args("args");
Variant f_call_user_func_rpc(int _argc, CStrRef host, int port, CStrRef auth,
int timeout, CVarRef function,
CArrRef _argv /* = null_array */) {
@@ -190,7 +194,7 @@ Variant f_call_user_func_rpc(int _argc, CStrRef host, int port, CStrRef auth,
url += "/call_user_func_serialized?auth=";
url += auth.data();
Array blob = CREATE_MAP2("func", function, "args", _argv);
Array blob = CREATE_MAP2(s_func, function, s_args, _argv);
String message = f_serialize(blob);
vector<string> headers;
hphp/runtime/ext/ext_hash.cpp
+4 -4
Ver Arquivo
@@ -166,7 +166,7 @@ static Variant php_hash_do_hash(CStrRef algo, CStrRef data, bool isfilename,
ops->hash_init(context);
if (isfilename) {
for (Variant chunk = f_fread(f, 1024); !same(chunk, "");
for (Variant chunk = f_fread(f, 1024); !is_empty_string(chunk);
chunk = f_fread(f, 1024)) {
String schunk = chunk.toString();
ops->hash_update(context, (unsigned char *)schunk.data(), schunk.size());
@@ -257,7 +257,7 @@ static Variant php_hash_do_hash_hmac(CStrRef algo, CStrRef data,
char *K = prepare_hmac_key(ops, context, key);
if (isfilename) {
for (Variant chunk = f_fread(f, 1024); !same(chunk, "");
for (Variant chunk = f_fread(f, 1024); !is_empty_string(chunk);
chunk = f_fread(f, 1024)) {
String schunk = chunk.toString();
ops->hash_update(context, (unsigned char *)schunk.data(), schunk.size());
@@ -327,7 +327,7 @@ bool f_hash_update_file(CObjRef init_context, CStrRef filename,
}
HashContext *hash = init_context.getTyped<HashContext>();
for (Variant chunk = f_fread(f, 1024); !same(chunk, "");
for (Variant chunk = f_fread(f, 1024); !is_empty_string(chunk);
chunk = f_fread(f, 1024)) {
String schunk = chunk.toString();
hash->ops->hash_update(hash->context, (unsigned char *)schunk.data(),
@@ -342,7 +342,7 @@ int64_t f_hash_update_stream(CObjRef context, CObjRef handle,
int didread = 0;
while (length) {
Variant chunk = f_fread(handle, length > 0 ? length : 1024);
if (same(chunk, "")) {
if (is_empty_string(chunk)) {
return didread;
}
String schunk = chunk.toString();
hphp/runtime/ext/ext_image.cpp
+1 -1
Ver Arquivo
@@ -756,7 +756,7 @@ static int php_read_APP(CObjRef stream, unsigned int marker, Variant &info) {
length -= 2; /* length includes itself */
buffer = f_fread(stream, (long)length);
if (same(buffer, "")) {
if (is_empty_string(buffer)) {
return 0;
}
hphp/runtime/ext/ext_memcached.cpp
+66 -31
Ver Arquivo
@@ -368,6 +368,10 @@ bool c_Memcached::getMultiImpl(CStrRef server_key, CArrRef keys,
keysCopy.size()));
}
static const StaticString s_key("key");
static const StaticString s_value("value");
static const StaticString s_cas("cas");
bool c_Memcached::fetchImpl(memcached_result_st &result, Array &item) {
memcached_return status;
if (!memcached_fetch_result(&m_impl->memcached, &result, &status)) {
@@ -386,7 +390,7 @@ bool c_Memcached::fetchImpl(memcached_result_st &result, Array &item) {
String sKey(key, keyLength, CopyString);
double cas = (double) memcached_result_cas(&result);
item = CREATE_MAP3("key", sKey, "value", value, "cas", cas);
item = CREATE_MAP3(s_key, sKey, s_value, value, s_cas, cas);
return true;
}
@@ -595,12 +599,17 @@ bool c_Memcached::t_addservers(CArrRef servers) {
}
namespace {
static const StaticString s_host("host");
static const StaticString s_port("port");
static const StaticString s_weight("weight");
memcached_return_t doServerListCallback(const memcached_st *ptr,
memcached_server_instance_st server, void *context) {
Array *returnValue = (Array*) context;
returnValue->append(CREATE_MAP3("host", String(server->hostname, CopyString),
"port", (int32_t)server->port,
"weight", (int32_t)server->weight));
returnValue->append(CREATE_MAP3(s_host, String(server->hostname, CopyString),
s_port, (int32_t)server->port,
s_weight, (int32_t)server->weight));
return MEMCACHED_SUCCESS;
}
}
@@ -627,9 +636,9 @@ Variant c_Memcached::t_getserverbykey(CStrRef server_key) {
return false;
}
Array returnValue = CREATE_MAP3("host", String(server->hostname, CopyString),
"port", (int32_t)server->port,
"weight", (int32_t)server->weight);
Array returnValue = CREATE_MAP3(s_host, String(server->hostname, CopyString),
s_port, (int32_t)server->port,
s_weight, (int32_t)server->weight);
return returnValue;
}
@@ -639,6 +648,32 @@ struct StatsContext {
Array returnValue;
};
static const StaticString s_pid("pid");
static const StaticString s_uptime("uptime");
static const StaticString s_threads("threads");
static const StaticString s_time("time");
static const StaticString s_pointer_size("pointer_size");
static const StaticString s_rusage_user_seconds("rusage_user_seconds");
static const StaticString s_rusage_user_microseconds("rusage_user_microseconds");
static const StaticString s_rusage_system_seconds("rusage_system_seconds");
static const StaticString
s_rusage_system_microseconds("rusage_system_microseconds");
static const StaticString s_curr_items("curr_items");
static const StaticString s_total_items("total_items");
static const StaticString s_limit_maxbytes("limit_maxbytes");
static const StaticString s_curr_connections("curr_connections");
static const StaticString s_total_connections("total_connections");
static const StaticString s_connection_structures("connection_structures");
static const StaticString s_bytes("bytes");
static const StaticString s_cmd_get("cmd_get");
static const StaticString s_cmd_set("cmd_set");
static const StaticString s_get_hits("get_hits");
static const StaticString s_get_misses("get_misses");
static const StaticString s_evictions("evictions");
static const StaticString s_bytes_read("bytes_read");
static const StaticString s_bytes_written("bytes_written");
static const StaticString s_version("version");
memcached_return_t doStatsCallback(const memcached_st *ptr,
memcached_server_instance_st server, void *inContext) {
StatsContext *context = (StatsContext*) inContext;
@@ -648,32 +683,32 @@ memcached_return_t doStatsCallback(const memcached_st *ptr,
ssize_t i = context->returnValue.size();
context->returnValue.set(String(key, CopyString), Array(ArrayInit(24)
.set("pid", (int64_t)stats[i].pid)
.set("uptime", (int64_t)stats[i].uptime)
.set("threads", (int64_t)stats[i].threads)
.set("time", (int64_t)stats[i].time)
.set("pointer_size", (int64_t)stats[i].pointer_size)
.set("rusage_user_seconds", (int64_t)stats[i].rusage_user_seconds)
.set("rusage_user_microseconds", (int64_t)stats[i]
.set(s_pid, (int64_t)stats[i].pid)
.set(s_uptime, (int64_t)stats[i].uptime)
.set(s_threads, (int64_t)stats[i].threads)
.set(s_time, (int64_t)stats[i].time)
.set(s_pointer_size, (int64_t)stats[i].pointer_size)
.set(s_rusage_user_seconds, (int64_t)stats[i].rusage_user_seconds)
.set(s_rusage_user_microseconds, (int64_t)stats[i]
.rusage_user_microseconds)
.set("rusage_system_seconds", (int64_t)stats[i].rusage_system_seconds)
.set("rusage_system_microseconds", (int64_t)stats[i]
.set(s_rusage_system_seconds, (int64_t)stats[i].rusage_system_seconds)
.set(s_rusage_system_microseconds, (int64_t)stats[i]
.rusage_system_microseconds)
.set("curr_items", (int64_t)stats[i].curr_items)
.set("total_items", (int64_t)stats[i].total_items)
.set("limit_maxbytes", (int64_t)stats[i].limit_maxbytes)
.set("curr_connections", (int64_t)stats[i].curr_connections)
.set("total_connections", (int64_t)stats[i].total_connections)
.set("connection_structures", (int64_t)stats[i].connection_structures)
.set("bytes", (int64_t)stats[i].bytes)
.set("cmd_get", (int64_t)stats[i].cmd_get)
.set("cmd_set", (int64_t)stats[i].cmd_set)
.set("get_hits", (int64_t)stats[i].get_hits)
.set("get_misses", (int64_t)stats[i].get_misses)
.set("evictions", (int64_t)stats[i].evictions)
.set("bytes_read", (int64_t)stats[i].bytes_read)
.set("bytes_written", (int64_t)stats[i].bytes_written)
.set("version", String(stats[i].version, CopyString))
.set(s_curr_items, (int64_t)stats[i].curr_items)
.set(s_total_items, (int64_t)stats[i].total_items)
.set(s_limit_maxbytes, (int64_t)stats[i].limit_maxbytes)
.set(s_curr_connections, (int64_t)stats[i].curr_connections)
.set(s_total_connections, (int64_t)stats[i].total_connections)
.set(s_connection_structures, (int64_t)stats[i].connection_structures)
.set(s_bytes, (int64_t)stats[i].bytes)
.set(s_cmd_get, (int64_t)stats[i].cmd_get)
.set(s_cmd_set, (int64_t)stats[i].cmd_set)
.set(s_get_hits, (int64_t)stats[i].get_hits)
.set(s_get_misses, (int64_t)stats[i].get_misses)
.set(s_evictions, (int64_t)stats[i].evictions)
.set(s_bytes_read, (int64_t)stats[i].bytes_read)
.set(s_bytes_written, (int64_t)stats[i].bytes_written)
.set(s_version, String(stats[i].version, CopyString))
.create()));
return MEMCACHED_SUCCESS;
hphp/runtime/ext/ext_misc.cpp
+8 -3
Ver Arquivo
@@ -226,6 +226,9 @@ void f_usleep(int micro_seconds) {
usleep(micro_seconds);
}
static const StaticString s_seconds("seconds");
static const StaticString s_nanoseconds("nanoseconds");
Variant f_time_nanosleep(int seconds, int nanoseconds) {
if (seconds < 0) {
throw_invalid_argument("seconds: cannot be negative");
@@ -245,8 +248,8 @@ Variant f_time_nanosleep(int seconds, int nanoseconds) {
return true;
}
if (errno == EINTR) {
return CREATE_MAP2("seconds", (int64_t)rem.tv_sec,
"nanoseconds", (int64_t)rem.tv_nsec);
return CREATE_MAP2(s_seconds, (int64_t)rem.tv_sec,
s_nanoseconds, (int64_t)rem.tv_nsec);
}
return false;
}
@@ -351,8 +354,10 @@ String f_token_name(int64_t token) {
return "UNKNOWN";
}
static const StaticString s_marauder("I solemnly swear that I am up to no good.");
Variant f_hphp_process_abort(CVarRef magic) {
if (magic.equal("I solemnly swear that I am up to no good.")) {
if (magic.equal(s_marauder)) {
*((int*)0) = 0xdead;
}
return null_variant;
hphp/runtime/ext/ext_options.cpp
+23 -5
Ver Arquivo
@@ -565,7 +565,25 @@ Array f_getopt(CStrRef options, CVarRef longopts /* = null_variant */) {
///////////////////////////////////////////////////////////////////////////////
#define PHP_RUSAGE_PARA(a) #a, (int64_t)usg.a
static const StaticString s_ru_oublock("ru_oublock");
static const StaticString s_ru_inblock("ru_inblock");
static const StaticString s_ru_msgsnd("ru_msgsnd");
static const StaticString s_ru_msgrcv("ru_msgrcv");
static const StaticString s_ru_maxrss("ru_maxrss");
static const StaticString s_ru_ixrss("ru_ixrss");
static const StaticString s_ru_idrss("ru_idrss");
static const StaticString s_ru_minflt("ru_minflt");
static const StaticString s_ru_majflt("ru_majflt");
static const StaticString s_ru_nsignals("ru_nsignals");
static const StaticString s_ru_nvcsw("ru_nvcsw");
static const StaticString s_ru_nivcsw("ru_nivcsw");
static const StaticString s_ru_nswap("ru_nswap");
static const StaticString s_ru_utime_tv_usec("ru_utime.tv_usec");
static const StaticString s_ru_utime_tv_sec("ru_utime.tv_sec");
static const StaticString s_ru_stime_tv_usec("ru_stime.tv_usec");
static const StaticString s_ru_stime_tv_sec("ru_stime.tv_sec");
#define PHP_RUSAGE_PARA(a) s_ ## a, (int64_t)usg.a
Array f_getrusage(int who /* = 0 */) {
struct rusage usg;
memset(&usg, 0, sizeof(struct rusage));
@@ -588,10 +606,10 @@ Array f_getrusage(int who /* = 0 */) {
set(PHP_RUSAGE_PARA(ru_nvcsw)).
set(PHP_RUSAGE_PARA(ru_nivcsw)).
set(PHP_RUSAGE_PARA(ru_nswap)).
set(PHP_RUSAGE_PARA(ru_utime.tv_usec)).
set(PHP_RUSAGE_PARA(ru_utime.tv_sec)).
set(PHP_RUSAGE_PARA(ru_stime.tv_usec)).
set(PHP_RUSAGE_PARA(ru_stime.tv_sec)).
set(s_ru_utime_tv_usec, (int64_t)usg.ru_utime.tv_usec).
set(s_ru_utime_tv_sec, (int64_t)usg.ru_utime.tv_sec).
set(s_ru_stime_tv_usec, (int64_t)usg.ru_stime.tv_usec).
set(s_ru_stime_tv_sec, (int64_t)usg.ru_stime.tv_sec).
create());
}
hphp/runtime/ext/ext_stream.cpp
+4 -1
Ver Arquivo
@@ -225,12 +225,15 @@ bool f_stream_set_blocking(CObjRef stream, int mode) {
return fcntl(file->fd(), F_SETFL, flags) != -1;
}
static const StaticString s_sec("sec");
static const StaticString s_usec("usec");
bool f_stream_set_timeout(CObjRef stream, int seconds,
int microseconds /* = 0 */) {
if (stream.getTyped<Socket>(false, true)) {
return f_socket_set_option
(stream, SOL_SOCKET, SO_RCVTIMEO,
CREATE_MAP2("sec", seconds, "usec", microseconds));
CREATE_MAP2(s_sec, seconds, s_usec, microseconds));
}
return false;
}
hphp/runtime/ext/mailparse/mime.cpp
+3 -1
Ver Arquivo
@@ -496,10 +496,12 @@ MimePart *MimePart::getParent() {
return m_parent.getTyped<MimePart>();
}
static const StaticString s_headers("headers");
Variant MimePart::getPartData() {
Array ret = Array::Create();
ret.set("headers", m_headers);
ret.set(s_headers, m_headers);
ret.set("starting-pos", m_startpos);
ret.set("starting-pos-body", m_bodystart);
hphp/runtime/ext/soap/xml.cpp
+4 -1
Ver Arquivo
@@ -69,6 +69,9 @@ static void soap_ignorableWhitespace(void *ctx, const xmlChar *ch, int len) {
static void soap_Comment(void *ctx, const xmlChar *value) {
}
static StaticString s_http("http");
static StaticString s_timeout("timeout");
xmlDocPtr soap_xmlParseFile(const char *filename) {
String cache_key("HPHP.SOAP.WSDL.");
cache_key += filename;
@@ -76,7 +79,7 @@ xmlDocPtr soap_xmlParseFile(const char *filename) {
Variant content = f_apc_fetch(cache_key);
if (same(content, false)) {
Variant stream = File::Open(filename, "rb", 0, f_stream_context_create(
CREATE_MAP1("http", CREATE_MAP1("timeout", 1000))));
CREATE_MAP1(s_http, CREATE_MAP1(s_timeout, 1000))));
if (!same(stream, false)) {
content = f_stream_get_contents(stream);
if (!same(content, false)) {
hphp/test/test_ext_array.cpp
+5 -5
Ver Arquivo
@@ -448,7 +448,7 @@ bool TestExtArray::test_array_map() {
bool TestExtArray::test_array_merge_recursive() {
{
Variant a1 = Array::Create();
Variant a2 = CREATE_MAP1("key1", ref(a1));
Variant a2 = CREATE_MAP1(String("key1"), ref(a1));
a1 = f_array_merge_recursive(a1, a2);
}
{
@@ -540,8 +540,8 @@ bool TestExtArray::test_array_merge() {
}
{
Variant v = 1;
Array a = CREATE_MAP1("one", 1);
Array b = CREATE_MAP1("two", ref(v));
Array a = CREATE_MAP1(String("one"), 1);
Array b = CREATE_MAP1(String("two"), ref(v));
Array r = f_array_merge(2, a, CREATE_VECTOR1(b));
v = 2;
VS(f_print_r(r, true),
@@ -640,8 +640,8 @@ bool TestExtArray::test_array_replace() {
}
{
Variant v = 1;
Array a = CREATE_MAP1("one", 1);
Array b = CREATE_MAP1("two", ref(v));
Array a = CREATE_MAP1(String("one"), 1);
Array b = CREATE_MAP1(String("two"), ref(v));
Array r = f_array_replace(2, a, CREATE_VECTOR1(b));
v = 2;
VS(f_print_r(r, true),