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

Litstr must die, episode III.

Ver Código-Fonte 
Many callsites of Array.set(litstr, ...)
Esse commit está contido em:
smith
2013-04-17 08:26:05 -07:00
commit de Sara Golemon
pai 71a6e2b628
commit c646a30002
37 arquivos alterados com 1068 adições e 642 exclusões
Baixar Arquivo de Patch Baixar Arquivo de Diff Expandir todos os arquivos Colapsar todos os arquivos
hphp/runtime/base/execution_context.cpp
+11 -8
Ver Arquivo
@@ -366,6 +366,12 @@ int BaseExecutionContext::obGetLevel() {
return m_buffers.size() - m_protectedLevel;
}
static const StaticString s_level("level");
static const StaticString s_type("type");
static const StaticString s_name("name");
static const StaticString s_args("args");
static const StaticString s_default_output_handler("default output handler");
Array BaseExecutionContext::obGetStatus(bool full) {
Array ret = Array::Create();
std::list<OutputBuffer*>::const_iterator iter = m_buffers.begin();
@@ -373,13 +379,13 @@ Array BaseExecutionContext::obGetStatus(bool full) {
int level = 0;
for (; iter != m_buffers.end(); ++iter, ++level) {
Array status;
status.set("level", level);
status.set(s_level, level);
if (level < m_protectedLevel) {
status.set("type", 1);
status.set("name", "default output handler");
status.set(s_type, 1);
status.set(s_name, s_default_output_handler);
} else {
status.set("type", 0);
status.set("name", (*iter)->handler);
status.set(s_type, 0);
status.set(s_name, (*iter)->handler);
}
if (full) {
@@ -435,9 +441,6 @@ 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) {
hphp/runtime/base/hardware_counter.cpp
+7 -3
Ver Arquivo
@@ -389,11 +389,15 @@ void HardwareCounter::ClearPerfEvents() {
s_counter->clearPerfEvents();
}
static const StaticString s_instructions("instructions");
static const StaticString s_loads("loads");
static const StaticString s_stores("stores");
void HardwareCounter::getPerfEvents(Array& ret) {
ret.set("instructions", getInstructionCount());
ret.set(s_instructions, getInstructionCount());
if (!m_countersSet) {
ret.set("loads", getLoadCount());
ret.set("stores", getStoreCount());
ret.set(s_loads, getLoadCount());
ret.set(s_stores, getStoreCount());
}
for (unsigned i = 0; i < m_counters.size(); i++) {
ret.set(m_counters[i]->m_desc->data(), m_counters[i]->read());
hphp/runtime/base/time/datetime.cpp
+108 -67
Ver Arquivo
@@ -104,11 +104,40 @@ SmartObject<DateTime> DateTime::Current(bool utc /* = false */) {
return NEWOBJ(DateTime)(time(0), utc);
}
static const StaticString s_year("year");
static const StaticString s_month("month");
static const StaticString s_day("day");
static const StaticString s_hour("hour");
static const StaticString s_minute("minute");
static const StaticString s_second("second");
static const StaticString s_zone("zone");
static const StaticString s_zone_type("zone_type");
static const StaticString s_fraction("fraction");
static const StaticString s_warning_count("warning_count");
static const StaticString s_warnings("warnings");
static const StaticString s_error_count("error_count");
static const StaticString s_errors("errors");
static const StaticString s_is_localtime("is_localtime");
static const StaticString s_is_dst("is_dst");
static const StaticString s_tz_abbr("tz_abbr");
static const StaticString s_tz_id("tz_id");
static const StaticString s_weekday("weekday");
static const StaticString s_relative("relative");
static const StaticString s_tm_sec("tm_sec");
static const StaticString s_tm_min("tm_min");
static const StaticString s_tm_hour("tm_hour");
static const StaticString s_tm_mday("tm_mday");
static const StaticString s_tm_mon("tm_mon");
static const StaticString s_tm_year("tm_year");
static const StaticString s_tm_wday("tm_wday");
static const StaticString s_tm_yday("tm_yday");
static const StaticString s_unparsed("unparsed");
#define PHP_DATE_PARSE_DATE_SET_TIME_ELEMENT(name, elem) \
if ((int)parsed_time->elem == -99999) { \
ret.set(#name, false); \
ret.set(name, false); \
} else { \
ret.set(#name, (int)parsed_time->elem); \
ret.set(name, (int)parsed_time->elem); \
}
Array DateTime::Parse(CStrRef datetime) {
@@ -118,51 +147,51 @@ Array DateTime::Parse(CStrRef datetime) {
TimeZone::GetDatabase());
Array ret;
PHP_DATE_PARSE_DATE_SET_TIME_ELEMENT(year, y);
PHP_DATE_PARSE_DATE_SET_TIME_ELEMENT(month, m);
PHP_DATE_PARSE_DATE_SET_TIME_ELEMENT(day, d);
PHP_DATE_PARSE_DATE_SET_TIME_ELEMENT(hour, h);
PHP_DATE_PARSE_DATE_SET_TIME_ELEMENT(minute, i);
PHP_DATE_PARSE_DATE_SET_TIME_ELEMENT(second, s);
PHP_DATE_PARSE_DATE_SET_TIME_ELEMENT(s_year, y);
PHP_DATE_PARSE_DATE_SET_TIME_ELEMENT(s_month, m);
PHP_DATE_PARSE_DATE_SET_TIME_ELEMENT(s_day, d);
PHP_DATE_PARSE_DATE_SET_TIME_ELEMENT(s_hour, h);
PHP_DATE_PARSE_DATE_SET_TIME_ELEMENT(s_minute, i);
PHP_DATE_PARSE_DATE_SET_TIME_ELEMENT(s_second, s);
if (parsed_time->f == -99999) {
ret.set("fraction", false);
ret.set(s_fraction, false);
} else {
ret.set("fraction", parsed_time->f);
ret.set(s_fraction, parsed_time->f);
}
setLastErrors(error);
{
Array warnings = DateTime::getLastWarnings();
ret.set("warning_count", warnings.size());
ret.set("warnings", warnings);
ret.set(s_warning_count, warnings.size());
ret.set(s_warnings, warnings);
}
{
Array errors = DateTime::getLastErrors();
ret.set("error_count", errors.size());
ret.set("errors", errors);
ret.set(s_error_count, errors.size());
ret.set(s_errors, errors);
}
ret.set("is_localtime", (bool)parsed_time->is_localtime);
ret.set(s_is_localtime, (bool)parsed_time->is_localtime);
if (parsed_time->is_localtime) {
PHP_DATE_PARSE_DATE_SET_TIME_ELEMENT(zone_type, zone_type);
PHP_DATE_PARSE_DATE_SET_TIME_ELEMENT(s_zone_type, zone_type);
switch (parsed_time->zone_type) {
case TIMELIB_ZONETYPE_OFFSET:
PHP_DATE_PARSE_DATE_SET_TIME_ELEMENT(zone, z);
ret.set("is_dst", (bool)parsed_time->dst);
PHP_DATE_PARSE_DATE_SET_TIME_ELEMENT(s_zone, z);
ret.set(s_is_dst, (bool)parsed_time->dst);
break;
case TIMELIB_ZONETYPE_ID:
if (parsed_time->tz_abbr) {
ret.set("tz_abbr", String(parsed_time->tz_abbr, CopyString));
ret.set(s_tz_abbr, String(parsed_time->tz_abbr, CopyString));
}
if (parsed_time->tz_info) {
ret.set("tz_id", String(parsed_time->tz_info->name, CopyString));
ret.set(s_tz_id, String(parsed_time->tz_info->name, CopyString));
}
break;
case TIMELIB_ZONETYPE_ABBR:
PHP_DATE_PARSE_DATE_SET_TIME_ELEMENT(zone, z);
ret.set("is_dst", (bool)parsed_time->dst);
ret.set("tz_abbr", String(parsed_time->tz_abbr, CopyString));
PHP_DATE_PARSE_DATE_SET_TIME_ELEMENT(s_zone, z);
ret.set(s_is_dst, (bool)parsed_time->dst);
ret.set(s_tz_abbr, String(parsed_time->tz_abbr, CopyString));
break;
}
}
@@ -170,20 +199,20 @@ Array DateTime::Parse(CStrRef datetime) {
{
Array element;
if (parsed_time->have_relative) {
element.set("year", parsed_time->relative.y);
element.set("month", parsed_time->relative.m);
element.set("day", parsed_time->relative.d);
element.set("hour", parsed_time->relative.h);
element.set("minute", parsed_time->relative.i);
element.set("second", parsed_time->relative.s);
element.set(s_year, parsed_time->relative.y);
element.set(s_month, parsed_time->relative.m);
element.set(s_day, parsed_time->relative.d);
element.set(s_hour, parsed_time->relative.h);
element.set(s_minute, parsed_time->relative.i);
element.set(s_second, parsed_time->relative.s);
#if defined(TIMELIB_VERSION)
if (parsed_time->relative.have_weekday_relative) {
#else
if (parsed_time->have_weekday_relative) {
#endif
element.set("weekday", parsed_time->relative.weekday);
element.set(s_weekday, parsed_time->relative.weekday);
}
ret.set("relative", element);
ret.set(s_relative, element);
}
}
@@ -199,17 +228,17 @@ Array DateTime::Parse(CStrRef ts, CStrRef format) {
return Array();
}
Array ret;
ret.set("tm_sec", parsed_time.tm_sec);
ret.set("tm_min", parsed_time.tm_min);
ret.set("tm_hour", parsed_time.tm_hour);
ret.set("tm_mday", parsed_time.tm_mday);
ret.set("tm_mon", parsed_time.tm_mon);
ret.set("tm_year", parsed_time.tm_year);
ret.set("tm_wday", parsed_time.tm_wday);
ret.set("tm_yday", parsed_time.tm_yday);
ret.set("unparsed", String(unparsed_part, CopyString));
return ret;
ArrayInit ret(9);
ret.set(s_tm_sec, parsed_time.tm_sec);
ret.set(s_tm_min, parsed_time.tm_min);
ret.set(s_tm_hour, parsed_time.tm_hour);
ret.set(s_tm_mday, parsed_time.tm_mday);
ret.set(s_tm_mon, parsed_time.tm_mon);
ret.set(s_tm_year, parsed_time.tm_year);
ret.set(s_tm_wday, parsed_time.tm_wday);
ret.set(s_tm_yday, parsed_time.tm_yday);
ret.set(s_unparsed, String(unparsed_part, CopyString));
return ret.create();
}
///////////////////////////////////////////////////////////////////////////////
@@ -764,6 +793,18 @@ SmartObject<DateInterval> DateTime::diff(SmartObject<DateTime> datetime2, bool a
///////////////////////////////////////////////////////////////////////////////
// sun
static const StaticString s_sunrise("sunrise");
static const StaticString s_sunset("sunset");
static const StaticString s_transit("transit");
static const StaticString s_civil_twilight_begin("civil_twilight_begin");
static const StaticString s_civil_twilight_end("civil_twilight_end");
static const StaticString s_nautical_twilight_begin("nautical_twilight_begin");
static const StaticString s_nautical_twilight_end("nautical_twilight_end");
static const StaticString
s_astronomical_twilight_begin("astronomical_twilight_begin");
static const StaticString
s_astronomical_twilight_end("astronomical_twilight_end");
Array DateTime::getSunInfo(double latitude, double longitude) const {
Array ret;
timelib_sll sunrise, sunset, transit;
@@ -775,18 +816,18 @@ Array DateTime::getSunInfo(double latitude, double longitude) const {
&sunrise, &sunset, &transit);
switch (rs) {
case -1: /* always below */
ret.set("sunrise", false);
ret.set("sunset", false);
ret.set(s_sunrise, false);
ret.set(s_sunset, false);
break;
case 1: /* always above */
ret.set("sunrise", true);
ret.set("sunset", true);
ret.set(s_sunrise, true);
ret.set(s_sunset, true);
break;
default:
ret.set("sunrise", sunrise);
ret.set("sunset", sunset);
ret.set(s_sunrise, sunrise);
ret.set(s_sunset, sunset);
}
ret.set("transit", transit);
ret.set(s_transit, transit);
/* Get civil twilight */
rs = timelib_astro_rise_set_altitude(m_time.get(), longitude, latitude,
@@ -795,16 +836,16 @@ Array DateTime::getSunInfo(double latitude, double longitude) const {
&transit);
switch (rs) {
case -1: /* always below */
ret.set("civil_twilight_begin", false);
ret.set("civil_twilight_end", false);
ret.set(s_civil_twilight_begin, false);
ret.set(s_civil_twilight_end, false);
break;
case 1: /* always above */
ret.set("civil_twilight_begin", true);
ret.set("civil_twilight_end", true);
ret.set(s_civil_twilight_begin, true);
ret.set(s_civil_twilight_end, true);
break;
default:
ret.set("civil_twilight_begin", sunrise);
ret.set("civil_twilight_end", sunset);
ret.set(s_civil_twilight_begin, sunrise);
ret.set(s_civil_twilight_end, sunset);
}
/* Get nautical twilight */
@@ -814,16 +855,16 @@ Array DateTime::getSunInfo(double latitude, double longitude) const {
&transit);
switch (rs) {
case -1: /* always below */
ret.set("nautical_twilight_begin", false);
ret.set("nautical_twilight_end", false);
ret.set(s_nautical_twilight_begin, false);
ret.set(s_nautical_twilight_end, false);
break;
case 1: /* always above */
ret.set("nautical_twilight_begin", true);
ret.set("nautical_twilight_end", true);
ret.set(s_nautical_twilight_begin, true);
ret.set(s_nautical_twilight_end, true);
break;
default:
ret.set("nautical_twilight_begin", sunrise);
ret.set("nautical_twilight_end", sunset);
ret.set(s_nautical_twilight_begin, sunrise);
ret.set(s_nautical_twilight_end, sunset);
}
/* Get astronomical twilight */
@@ -833,16 +874,16 @@ Array DateTime::getSunInfo(double latitude, double longitude) const {
&transit);
switch (rs) {
case -1: /* always below */
ret.set("astronomical_twilight_begin", false);
ret.set("astronomical_twilight_end", false);
ret.set(s_astronomical_twilight_begin, false);
ret.set(s_astronomical_twilight_end, false);
break;
case 1: /* always above */
ret.set("astronomical_twilight_begin", true);
ret.set("astronomical_twilight_end", true);
ret.set(s_astronomical_twilight_begin, true);
ret.set(s_astronomical_twilight_end, true);
break;
default:
ret.set("astronomical_twilight_begin", sunrise);
ret.set("astronomical_twilight_end", sunset);
ret.set(s_astronomical_twilight_begin, sunrise);
ret.set(s_astronomical_twilight_end, sunset);
}
return ret;
}
hphp/runtime/base/time/timestamp.cpp
+11 -6
Ver Arquivo
@@ -33,6 +33,11 @@ double TimeStamp::CurrentSecond() {
return (double)tp.tv_sec + (double)tp.tv_usec / 1000000;
}
static const StaticString s_sec("sec");
static const StaticString s_usec("usec");
static const StaticString s_minuteswest("minuteswest");
static const StaticString s_dsttime("dsttime");
Array TimeStamp::CurrentTime() {
struct timeval tp;
gettimeofday(&tp, nullptr);
@@ -40,14 +45,14 @@ Array TimeStamp::CurrentTime() {
timelib_time_offset *offset =
timelib_get_time_zone_info(tp.tv_sec, TimeZone::Current()->get());
Array ret;
ret.set("sec", (int)tp.tv_sec);
ret.set("usec", (int)tp.tv_usec);
ret.set("minuteswest", (int)(-offset->offset / 60));
ret.set("dsttime", (int)offset->is_dst);
ArrayInit ret(4);
ret.set(s_sec, (int)tp.tv_sec);
ret.set(s_usec, (int)tp.tv_usec);
ret.set(s_minuteswest, (int)(-offset->offset / 60));
ret.set(s_dsttime, (int)offset->is_dst);
timelib_time_offset_dtor(offset);
return ret;
return ret.create();
}
String TimeStamp::CurrentMicroTime() {
hphp/runtime/base/time/timezone.cpp
+10 -7
Ver Arquivo
@@ -156,20 +156,23 @@ Array TimeZone::GetNames() {
return ret;
}
static const StaticString s_dst("dst");
static const StaticString s_offset("offset");
static const StaticString s_timezone_id("timezone_id");
Array TimeZone::GetAbbreviations() {
Array ret;
for (const timelib_tz_lookup_table *entry =
timelib_timezone_abbreviations_list(); entry->name; entry++) {
Array element;
element.set("dst", (bool)entry->type);
element.set("offset", entry->gmtoffset);
ArrayInit element(3);
element.set(s_dst, (bool)entry->type);
element.set(s_offset, entry->gmtoffset);
if (entry->full_tz_name) {
element.set("timezone_id", String(entry->full_tz_name, AttachLiteral));
element.set(s_timezone_id, String(entry->full_tz_name, AttachLiteral));
} else {
element.set("timezone_id", uninit_null());
element.set(s_timezone_id, uninit_null());
}
ret.lvalAt(entry->name).append(element);
ret.lvalAt(entry->name).append(element.create());
}
return ret;
}
hphp/runtime/ext/ext_apache.cpp
+16 -13
Ver Arquivo
@@ -81,31 +81,34 @@ bool f_virtual(CStrRef filename) {
throw NotSupportedException(__func__, "apache is not in use");
}
Variant f_apache_get_config() {
Array ret;
int workers, queued;
static const StaticString s_restart_time("restart_time");
static const StaticString s_max_clients("max_clients");
static const StaticString s_active_clients("active_clients");
static const StaticString s_queued_requests("queued_requests");
static const StaticString s_child_status("child_status");
workers = queued = 0;
Variant f_apache_get_config() {
int workers = 0, queued = 0;
if (HttpServer::Server) {
workers = HttpServer::Server->getPageServer()->getActiveWorker();
queued = HttpServer::Server->getPageServer()->getQueuedJobs();
}
ret.set("restart_time", HttpServer::StartTime);
ret.set("max_clients", RuntimeOption::ServerThreadCount);
ret.set("active_clients", workers);
ret.set("queued_requests", queued);
return ret;
ArrayInit ret(4);
ret.set(s_restart_time, HttpServer::StartTime);
ret.set(s_max_clients, RuntimeOption::ServerThreadCount);
ret.set(s_active_clients, workers);
ret.set(s_queued_requests, queued);
return ret.create();
}
Variant f_apache_get_scoreboard() {
Array ret;
Array child_status;
for (int i = 0; i < RuntimeOption::ServerThreadCount; i++) {
child_status.set(i, 2);
}
ret.set("child_status", child_status);
return ret;
ArrayInit ret(1);
ret.set(s_child_status, child_status);
return ret.create();
}
Variant f_apache_get_rewrite_rules() {
hphp/runtime/ext/ext_apc.cpp
+45 -36
Ver Arquivo
@@ -955,6 +955,15 @@ static double my_time() {
return t;
}
static const StaticString s_total("total");
static const StaticString s_current("current");
static const StaticString s_filename("filename");
static const StaticString s_name("name");
static const StaticString s_done("done");
static const StaticString s_temp_filename("temp_filename");
static const StaticString s_cancel_upload("cancel_upload");
static const StaticString s_rate("rate");
#define RFC1867_TRACKING_KEY_MAXLEN 63
#define RFC1867_NAME_MAXLEN 63
#define RFC1867_FILENAME_MAXLEN 127
@@ -1028,14 +1037,14 @@ int apc_rfc1867_progress(apc_rfc1867_data *rfc1867ApcData,
len = strlen(data->name);
if (len > RFC1867_NAME_MAXLEN) len = RFC1867_NAME_MAXLEN;
rfc1867ApcData->name = string(data->name, len);
Array track;
track.set("total", rfc1867ApcData->content_length);
track.set("current", rfc1867ApcData->bytes_processed);
track.set("filename", rfc1867ApcData->filename);
track.set("name", rfc1867ApcData->name);
track.set("done", 0);
track.set("start_time", rfc1867ApcData->start_time);
f_apc_store(rfc1867ApcData->tracking_key, track, 3600);
ArrayInit track(6);
track.set(s_total, rfc1867ApcData->content_length);
track.set(s_current, rfc1867ApcData->bytes_processed);
track.set(s_filename, rfc1867ApcData->filename);
track.set(s_name, rfc1867ApcData->name);
track.set(s_done, 0);
track.set(s_start_time, rfc1867ApcData->start_time);
f_apc_store(rfc1867ApcData->tracking_key, track.create(), 3600);
}
break;
@@ -1050,14 +1059,14 @@ int apc_rfc1867_progress(apc_rfc1867_data *rfc1867ApcData,
Variant v;
if (s_apc_store[0].get(rfc1867ApcData->tracking_key, v)) {
if (v.is(KindOfArray)) {
Array track;
track.set("total", rfc1867ApcData->content_length);
track.set("current", rfc1867ApcData->bytes_processed);
track.set("filename", rfc1867ApcData->filename);
track.set("name", rfc1867ApcData->name);
track.set("done", 0);
track.set("start_time", rfc1867ApcData->start_time);
f_apc_store(rfc1867ApcData->tracking_key, track, 3600);
ArrayInit track(6);
track.set(s_total, rfc1867ApcData->content_length);
track.set(s_current, rfc1867ApcData->bytes_processed);
track.set(s_filename, rfc1867ApcData->filename);
track.set(s_name, rfc1867ApcData->name);
track.set(s_done, 0);
track.set(s_start_time, rfc1867ApcData->start_time);
f_apc_store(rfc1867ApcData->tracking_key, track.create(), 3600);
}
rfc1867ApcData->prev_bytes_processed =
rfc1867ApcData->bytes_processed;
@@ -1073,16 +1082,16 @@ int apc_rfc1867_progress(apc_rfc1867_data *rfc1867ApcData,
rfc1867ApcData->bytes_processed = data->post_bytes_processed;
rfc1867ApcData->cancel_upload = data->cancel_upload;
rfc1867ApcData->temp_filename = data->temp_filename;
Array track;
track.set("total", rfc1867ApcData->content_length);
track.set("current", rfc1867ApcData->bytes_processed);
track.set("filename", rfc1867ApcData->filename);
track.set("name", rfc1867ApcData->name);
track.set("temp_filename", rfc1867ApcData->temp_filename, CopyString);
track.set("cancel_upload", rfc1867ApcData->cancel_upload);
track.set("done", 0);
track.set("start_time", rfc1867ApcData->start_time);
f_apc_store(rfc1867ApcData->tracking_key, track, 3600);
ArrayInit track(8);
track.set(s_total, rfc1867ApcData->content_length);
track.set(s_current, rfc1867ApcData->bytes_processed);
track.set(s_filename, rfc1867ApcData->filename);
track.set(s_name, rfc1867ApcData->name);
track.set(s_temp_filename, rfc1867ApcData->temp_filename, CopyString);
track.set(s_cancel_upload, rfc1867ApcData->cancel_upload);
track.set(s_done, 0);
track.set(s_start_time, rfc1867ApcData->start_time);
f_apc_store(rfc1867ApcData->tracking_key, track.create(), 3600);
}
break;
@@ -1097,16 +1106,16 @@ int apc_rfc1867_progress(apc_rfc1867_data *rfc1867ApcData,
} else {
rfc1867ApcData->rate =
8.0*rfc1867ApcData->bytes_processed; /* Too quick */
Array track;
track.set("total", rfc1867ApcData->content_length);
track.set("current", rfc1867ApcData->bytes_processed);
track.set("rate", rfc1867ApcData->rate);
track.set("filename", rfc1867ApcData->filename);
track.set("name", rfc1867ApcData->name);
track.set("cancel_upload", rfc1867ApcData->cancel_upload);
track.set("done", 1);
track.set("start_time", rfc1867ApcData->start_time);
f_apc_store(rfc1867ApcData->tracking_key, track, 3600);
ArrayInit track(8);
track.set(s_total, rfc1867ApcData->content_length);
track.set(s_current, rfc1867ApcData->bytes_processed);
track.set(s_rate, rfc1867ApcData->rate);
track.set(s_filename, rfc1867ApcData->filename);
track.set(s_name, rfc1867ApcData->name);
track.set(s_cancel_upload, rfc1867ApcData->cancel_upload);
track.set(s_done, 1);
track.set(s_start_time, rfc1867ApcData->start_time);
f_apc_store(rfc1867ApcData->tracking_key, track.create(), 3600);
}
}
break;
hphp/runtime/ext/ext_curl.cpp
+90 -49
Ver Arquivo
@@ -95,9 +95,8 @@ public:
// overriding ResourceData
virtual CStrRef o_getClassNameHook() const { return s_class_name; }
CurlResource(CStrRef url) : m_exception(NULL),
m_phpException(false),
m_emptyPost(true) {
explicit CurlResource(CStrRef url)
: m_exception(nullptr), m_phpException(false), m_emptyPost(true) {
m_cp = curl_easy_init();
m_url = url;
@@ -143,7 +142,8 @@ public:
}
}
CurlResource(CurlResource *src) : m_exception(NULL), m_phpException(false) {
explicit CurlResource(CurlResource *src)
: m_exception(nullptr), m_phpException(false) {
assert(src && src != this);
assert(!src->m_exception);
@@ -764,21 +764,31 @@ Variant f_curl_copy_handle(CObjRef ch) {
return NEWOBJ(CurlResource)(curl);
}
static const StaticString s_version_number("version_number");
static const StaticString s_age("age");
static const StaticString s_features("features");
static const StaticString s_ssl_version_number("ssl_version_number");
static const StaticString s_version("version");
static const StaticString s_host("host");
static const StaticString s_ssl_version("ssl_version");
static const StaticString s_libz_version("libz_version");
static const StaticString s_protocols("protocols");
Variant f_curl_version(int uversion /* = k_CURLVERSION_NOW */) {
curl_version_info_data *d = curl_version_info((CURLversion)uversion);
if (d == NULL) {
return false;
}
Array ret;
ret.set("version_number", (int)d->version_num);
ret.set("age", d->age);
ret.set("features", d->features);
ret.set("ssl_version_number", d->ssl_version_num);
ret.set("version", d->version);
ret.set("host", d->host);
ret.set("ssl_version", d->ssl_version);
ret.set("libz_version", d->libz_version);
ArrayInit ret(9);
ret.set(s_version_number, (int)d->version_num);
ret.set(s_age, d->age);
ret.set(s_features, d->features);
ret.set(s_ssl_version_number, d->ssl_version_num);
ret.set(s_version, d->version);
ret.set(s_host, d->host);
ret.set(s_ssl_version, d->ssl_version);
ret.set(s_libz_version, d->libz_version);
// Add an array of protocols
char **p = (char **) d->protocols;
@@ -786,9 +796,8 @@ Variant f_curl_version(int uversion /* = k_CURLVERSION_NOW */) {
while (*p != NULL) {
protocol_list.append(String(*p++, CopyString));
}
ret.set("protocols", protocol_list);
return ret;
ret.set(s_protocols, protocol_list);
return ret.create();
}
bool f_curl_setopt(CObjRef ch, int option, CVarRef value) {
@@ -816,6 +825,29 @@ Variant f_curl_exec(CObjRef ch) {
return curl->execute();
}
static const StaticString s_url("url");
static const StaticString s_content_type("content_type");
static const StaticString s_http_code("http_code");
static const StaticString s_header_size("header_size");
static const StaticString s_request_size("request_size");
static const StaticString s_filetime("filetime");
static const StaticString s_ssl_verify_result("ssl_verify_result");
static const StaticString s_redirect_count("redirect_count");
static const StaticString s_local_port("local_port");
static const StaticString s_total_time("total_time");
static const StaticString s_namelookup_time("namelookup_time");
static const StaticString s_connect_time("connect_time");
static const StaticString s_pretransfer_time("pretransfer_time");
static const StaticString s_size_upload("size_upload");
static const StaticString s_size_download("size_download");
static const StaticString s_speed_download("speed_download");
static const StaticString s_speed_upload("speed_upload");
static const StaticString s_download_content_length("download_content_length");
static const StaticString s_upload_content_length("upload_content_length");
static const StaticString s_starttransfer_time("starttransfer_time");
static const StaticString s_redirect_time("redirect_time");
static const StaticString s_request_header("request_header");
Variant f_curl_getinfo(CObjRef ch, int opt /* = 0 */) {
CHECK_RESOURCE(curl);
CURL *cp = curl->get();
@@ -827,82 +859,82 @@ Variant f_curl_getinfo(CObjRef ch, int opt /* = 0 */) {
Array ret;
if (curl_easy_getinfo(cp, CURLINFO_EFFECTIVE_URL, &s_code) == CURLE_OK) {
ret.set("url", String(s_code, CopyString));
ret.set(s_url, String(s_code, CopyString));
}
if (curl_easy_getinfo(cp, CURLINFO_CONTENT_TYPE, &s_code) == CURLE_OK) {
if (s_code != NULL) {
ret.set("content_type", String(s_code, CopyString));
ret.set(s_content_type, String(s_code, CopyString));
} else {
ret.set("content_type", uninit_null());
ret.set(s_content_type, uninit_null());
}
}
if (curl_easy_getinfo(cp, CURLINFO_HTTP_CODE, &l_code) == CURLE_OK) {
ret.set("http_code", l_code);
ret.set(s_http_code, l_code);
}
if (curl_easy_getinfo(cp, CURLINFO_HEADER_SIZE, &l_code) == CURLE_OK) {
ret.set("header_size", l_code);
ret.set(s_header_size, l_code);
}
if (curl_easy_getinfo(cp, CURLINFO_REQUEST_SIZE, &l_code) == CURLE_OK) {
ret.set("request_size", l_code);
ret.set(s_request_size, l_code);
}
if (curl_easy_getinfo(cp, CURLINFO_FILETIME, &l_code) == CURLE_OK) {
ret.set("filetime", l_code);
ret.set(s_filetime, l_code);
}
if (curl_easy_getinfo(cp, CURLINFO_SSL_VERIFYRESULT, &l_code) ==
CURLE_OK) {
ret.set("ssl_verify_result", l_code);
ret.set(s_ssl_verify_result, l_code);
}
if (curl_easy_getinfo(cp, CURLINFO_REDIRECT_COUNT, &l_code) == CURLE_OK) {
ret.set("redirect_count", l_code);
ret.set(s_redirect_count, l_code);
}
#if LIBCURL_VERSION_NUM >= 0x071500
if (curl_easy_getinfo(cp, CURLINFO_LOCAL_PORT, &l_code) == CURLE_OK) {
ret.set("local_port", l_code);
ret.set(s_local_port, l_code);
}
#endif
if (curl_easy_getinfo(cp, CURLINFO_TOTAL_TIME, &d_code) == CURLE_OK) {
ret.set("total_time", d_code);
ret.set(s_total_time, d_code);
}
if (curl_easy_getinfo(cp, CURLINFO_NAMELOOKUP_TIME, &d_code) == CURLE_OK) {
ret.set("namelookup_time", d_code);
ret.set(s_namelookup_time, d_code);
}
if (curl_easy_getinfo(cp, CURLINFO_CONNECT_TIME, &d_code) == CURLE_OK) {
ret.set("connect_time", d_code);
ret.set(s_connect_time, d_code);
}
if (curl_easy_getinfo(cp, CURLINFO_PRETRANSFER_TIME, &d_code) ==
CURLE_OK) {
ret.set("pretransfer_time", d_code);
ret.set(s_pretransfer_time, d_code);
}
if (curl_easy_getinfo(cp, CURLINFO_SIZE_UPLOAD, &d_code) == CURLE_OK) {
ret.set("size_upload", d_code);
ret.set(s_size_upload, d_code);
}
if (curl_easy_getinfo(cp, CURLINFO_SIZE_DOWNLOAD, &d_code) == CURLE_OK) {
ret.set("size_download", d_code);
ret.set(s_size_download, d_code);
}
if (curl_easy_getinfo(cp, CURLINFO_SPEED_DOWNLOAD, &d_code) == CURLE_OK) {
ret.set("speed_download", d_code);
ret.set(s_speed_download, d_code);
}
if (curl_easy_getinfo(cp, CURLINFO_SPEED_UPLOAD, &d_code) == CURLE_OK) {
ret.set("speed_upload", d_code);
ret.set(s_speed_upload, d_code);
}
if (curl_easy_getinfo(cp, CURLINFO_CONTENT_LENGTH_DOWNLOAD, &d_code) ==
CURLE_OK) {
ret.set("download_content_length", d_code);
ret.set(s_download_content_length, d_code);
}
if (curl_easy_getinfo(cp, CURLINFO_CONTENT_LENGTH_UPLOAD, &d_code) ==
CURLE_OK) {
ret.set("upload_content_length", d_code);
ret.set(s_upload_content_length, d_code);
}
if (curl_easy_getinfo(cp, CURLINFO_STARTTRANSFER_TIME, &d_code) ==
CURLE_OK) {
ret.set("starttransfer_time", d_code);
ret.set(s_starttransfer_time, d_code);
}
if (curl_easy_getinfo(cp, CURLINFO_REDIRECT_TIME, &d_code) == CURLE_OK) {
ret.set("redirect_time", d_code);
ret.set(s_redirect_time, d_code);
}
String header = curl->getHeader();
if (!header.empty()) {
ret.set("request_header", header);
ret.set(s_request_header, header);
}
return ret;
}
@@ -1209,6 +1241,12 @@ Variant f_fb_curl_multi_fdset(CObjRef mh,
return r;
}
static const StaticString s_msg("msg");
static const StaticString s_result("result");
static const StaticString s_handle("handle");
static const StaticString s_headers("headers");
static const StaticString s_requests("requests");
Variant f_curl_multi_info_read(CObjRef mh,
VRefParam msgs_in_queue /* = null */) {
CHECK_MULTI_RESOURCE(curlm);
@@ -1222,11 +1260,11 @@ Variant f_curl_multi_info_read(CObjRef mh,
msgs_in_queue = queued_msgs;
Array ret;
ret.set("msg", tmp_msg->msg);
ret.set("result", tmp_msg->data.result);
ret.set(s_msg, tmp_msg->msg);
ret.set(s_result, tmp_msg->data.result);
Object curle = curlm->find(tmp_msg->easy_handle);
if (!curle.isNull()) {
ret.set("handle", curle);
ret.set(s_handle, curle);
}
return ret;
}
@@ -1248,7 +1286,7 @@ public:
// overriding ResourceData
virtual CStrRef o_getClassNameHook() const { return s_class_name; }
LibEventHttpHandle(LibEventHttpClientPtr client) : m_client(client) {
explicit LibEventHttpHandle(LibEventHttpClientPtr client) : m_client(client) {
}
~LibEventHttpHandle() {
@@ -1314,22 +1352,25 @@ static LibEventHttpClientPtr prepare_client
return client;
}
static const StaticString s_code("code");
static const StaticString s_response("response");
static Array prepare_response(LibEventHttpClientPtr client) {
int len = 0;
char *res = client->recv(len); // block on return
Array ret = Array::Create();
ret.set("code", client->getCode());
ret.set("response", String(res, len, AttachString));
ArrayInit ret(4);
ret.set(s_code, client->getCode());
ret.set(s_response, String(res, len, AttachString));
Array headers = Array::Create();
const vector<string> &responseHeaders = client->getResponseHeaders();
for (unsigned int i = 0; i < responseHeaders.size(); i++) {
headers.append(String(responseHeaders[i]));
}
ret.set("headers", headers);
ret.set("requests", client->getRequests());
return ret;
ret.set(s_headers, headers);
ret.set(s_requests, client->getRequests());
return ret.create();
}
///////////////////////////////////////////////////////////////////////////////
hphp/runtime/ext/ext_datetime.cpp
+52 -20
Ver Arquivo
@@ -89,15 +89,20 @@ String c_DateTime::t_format(CStrRef format) {
return m_dt->toString(format, false);
}
static const StaticString s_warning_count("warning_count");
static const StaticString s_warnings("warnings");
static const StaticString s_error_count("error_count");
static const StaticString s_errors("errors");
Array c_DateTime::ti_getlasterrors(const char* cls ) {
Array errors = DateTime::getLastErrors();
Array warnings = DateTime::getLastWarnings();
Array ret = Array::Create();
ret.add("warning_count", warnings.size());
ret.add("warnings", warnings);
ret.add("error_count", errors.size());
ret.add("errors", errors);
ret.add(s_warning_count, warnings.size());
ret.add(s_warnings, warnings);
ret.add(s_error_count, errors.size());
ret.add(s_errors, errors);
return ret;
}
@@ -228,16 +233,25 @@ void c_DateInterval::t___construct(CStrRef interval_spec) {
}
}
static const StaticString s_y("y");
static const StaticString s_m("m");
static const StaticString s_d("d");
static const StaticString s_h("h");
static const StaticString s_i("i");
static const StaticString s_s("s");
static const StaticString s_invert("invert");
static const StaticString s_days("days");
Variant c_DateInterval::t___get(Variant member) {
if (member.isString()) {
if (member.same("y")) return m_di->getYears();
if (member.same("m")) return m_di->getMonths();
if (member.same("d")) return m_di->getDays();
if (member.same("h")) return m_di->getHours();
if (member.same("i")) return m_di->getMinutes();
if (member.same("s")) return m_di->getSeconds();
if (member.same("invert")) return m_di->isInverted();
if (member.same("days")) {
if (member.same(s_y)) return m_di->getYears();
if (member.same(s_m)) return m_di->getMonths();
if (member.same(s_d)) return m_di->getDays();
if (member.same(s_h)) return m_di->getHours();
if (member.same(s_i)) return m_di->getMinutes();
if (member.same(s_s)) return m_di->getSeconds();
if (member.same(s_invert)) return m_di->isInverted();
if (member.same(s_days)) {
if (m_di->haveTotalDays()) {
return m_di->getTotalDays();
} else {
@@ -253,17 +267,35 @@ Variant c_DateInterval::t___get(Variant member) {
Variant c_DateInterval::t___set(Variant member, Variant value) {
if (member.isString()) {
if (member.same("y")) { m_di->setYears(value.toInt64()); return uninit_null(); }
if (member.same("m")) { m_di->setMonths(value.toInt64()); return uninit_null(); }
if (member.same("d")) { m_di->setDays(value.toInt64()); return uninit_null(); }
if (member.same("h")) { m_di->setHours(value.toInt64()); return uninit_null(); }
if (member.same("i")) { m_di->setMinutes(value.toInt64()); return uninit_null(); }
if (member.same("s")) { m_di->setSeconds(value.toInt64()); return uninit_null(); }
if (member.same("invert")) {
if (member.same(s_y)) {
m_di->setYears(value.toInt64());
return uninit_null();
}
if (member.same(s_m)) {
m_di->setMonths(value.toInt64());
return uninit_null();
}
if (member.same(s_d)) {
m_di->setDays(value.toInt64());
return uninit_null();
}
if (member.same(s_h)) {
m_di->setHours(value.toInt64());
return uninit_null();
}
if (member.same(s_i)) {
m_di->setMinutes(value.toInt64());
return uninit_null();
}
if (member.same(s_s)) {
m_di->setSeconds(value.toInt64());
return uninit_null();
}
if (member.same(s_invert)) {
m_di->setInverted(value.toBoolean());
return uninit_null();
}
if (member.same("days")) {
if (member.same(s_days)) {
m_di->setTotalDays(value.toInt64());
return uninit_null();
}
hphp/runtime/ext/ext_debugger.cpp
+16 -10
Ver Arquivo
@@ -317,18 +317,24 @@ Variant c_DebuggerClientCmdUser::t_xend(CObjRef cmd) {
return ret->getUserCommand();
}
static const StaticString s_file("file");
static const StaticString s_line("line");
static const StaticString s_namespace("namespace");
static const StaticString s_class("class");
static const StaticString s_function("function");
static const StaticString s_text("text");
Variant c_DebuggerClientCmdUser::t_getcurrentlocation() {
BreakPointInfoPtr bpi = m_client->getCurrentLocation();
Array ret(Array::Create());
if (bpi) {
ret.set("file", String(bpi->m_file));
ret.set("line", (int64_t)bpi->m_line1);
ret.set("namespace", String(bpi->getNamespace()));
ret.set("class", String(bpi->getClass()));
ret.set("function", String(bpi->getFunction()));
ret.set("text", String(bpi->site()));
}
return ret;
if (!bpi) return Array::Create();
ArrayInit ret(6);
ret.set(s_file, String(bpi->m_file));
ret.set(s_line, (int64_t)bpi->m_line1);
ret.set(s_namespace, String(bpi->getNamespace()));
ret.set(s_class, String(bpi->getClass()));
ret.set(s_function, String(bpi->getFunction()));
ret.set(s_text, String(bpi->site()));
return ret.create();
}
Variant c_DebuggerClientCmdUser::t_getstacktrace() {
hphp/runtime/ext/ext_fb.cpp
+9 -6
Ver Arquivo
@@ -1010,9 +1010,14 @@ Variant f_fb_compact_unserialize(CVarRef thing, VRefParam success,
///////////////////////////////////////////////////////////////////////////////
static const StaticString s_affected("affected");
static const StaticString s_result("result");
static const StaticString s_error("error");
static const StaticString s_errno("errno");
static void output_dataset(Array &ret, int affected, DBDataSet &ds,
const DBConn::ErrorInfoMap &errors) {
ret.set("affected", affected);
ret.set(s_affected, affected);
Array rows;
MYSQL_FIELD *fields = ds.getFields();
@@ -1026,7 +1031,7 @@ static void output_dataset(Array &ret, int affected, DBDataSet &ds,
}
rows.append(row);
}
ret.set("result", rows);
ret.set(s_result, rows);
if (!errors.empty()) {
Array error, codes;
@@ -1035,8 +1040,8 @@ static void output_dataset(Array &ret, int affected, DBDataSet &ds,
error.set(iter->first, String(iter->second.msg));
codes.set(iter->first, iter->second.code);
}
ret.set("error", error);
ret.set("errno", codes);
ret.set(s_error, error);
ret.set(s_errno, codes);
}
}
@@ -1142,8 +1147,6 @@ Array f_fb_parallel_query(CArrRef sql_map, int max_thread /* = 50 */,
return ret;
}
static const StaticString s_error("error");
Array f_fb_crossall_query(CStrRef sql, int max_thread /* = 50 */,
bool retry_query_on_fail /* = true */,
int connect_timeout /* = -1 */,
hphp/runtime/ext/ext_file.cpp
+54 -38
Ver Arquivo
@@ -94,38 +94,49 @@ static bool check_error(const char *function, int line, bool ret) {
return ret;
}
static const StaticString s_dev("dev");
static const StaticString s_ino("ino");
static const StaticString s_mode("mode");
static const StaticString s_nlink("nlink");
static const StaticString s_uid("uid");
static const StaticString s_gid("gid");
static const StaticString s_rdev("rdev");
static const StaticString s_size("size");
static const StaticString s_atime("atime");
static const StaticString s_mtime("mtime");
static const StaticString s_ctime("ctime");
static const StaticString s_blksize("blksize");
static const StaticString s_blocks("blocks");
Array stat_impl(struct stat *stat_sb) {
Array ret;
ret.append((int64_t)stat_sb->st_dev);
ret.append((int64_t)stat_sb->st_ino);
ret.append((int64_t)stat_sb->st_mode);
ret.append((int64_t)stat_sb->st_nlink);
ret.append((int64_t)stat_sb->st_uid);
ret.append((int64_t)stat_sb->st_gid);
ret.append((int64_t)stat_sb->st_rdev);
ret.append((int64_t)stat_sb->st_size);
ret.append((int64_t)stat_sb->st_atime);
ret.append((int64_t)stat_sb->st_mtime);
ret.append((int64_t)stat_sb->st_ctime);
ret.append((int64_t)stat_sb->st_blksize);
ret.append((int64_t)stat_sb->st_blocks);
ret.set("dev", (int64_t)stat_sb->st_dev);
ret.set("ino", (int64_t)stat_sb->st_ino);
ret.set("mode", (int64_t)stat_sb->st_mode);
ret.set("nlink", (int64_t)stat_sb->st_nlink);
ret.set("uid", (int64_t)stat_sb->st_uid);
ret.set("gid", (int64_t)stat_sb->st_gid);
ret.set("rdev", (int64_t)stat_sb->st_rdev);
ret.set("size", (int64_t)stat_sb->st_size);
ret.set("atime", (int64_t)stat_sb->st_atime);
ret.set("mtime", (int64_t)stat_sb->st_mtime);
ret.set("ctime", (int64_t)stat_sb->st_ctime);
ret.set("blksize", (int64_t)stat_sb->st_blksize);
ret.set("blocks", (int64_t)stat_sb->st_blocks);
return ret;
ArrayInit ret(26);
ret.set((int64_t)stat_sb->st_dev);
ret.set((int64_t)stat_sb->st_ino);
ret.set((int64_t)stat_sb->st_mode);
ret.set((int64_t)stat_sb->st_nlink);
ret.set((int64_t)stat_sb->st_uid);
ret.set((int64_t)stat_sb->st_gid);
ret.set((int64_t)stat_sb->st_rdev);
ret.set((int64_t)stat_sb->st_size);
ret.set((int64_t)stat_sb->st_atime);
ret.set((int64_t)stat_sb->st_mtime);
ret.set((int64_t)stat_sb->st_ctime);
ret.set((int64_t)stat_sb->st_blksize);
ret.set((int64_t)stat_sb->st_blocks);
ret.set(s_dev, (int64_t)stat_sb->st_dev);
ret.set(s_ino, (int64_t)stat_sb->st_ino);
ret.set(s_mode, (int64_t)stat_sb->st_mode);
ret.set(s_nlink, (int64_t)stat_sb->st_nlink);
ret.set(s_uid, (int64_t)stat_sb->st_uid);
ret.set(s_gid, (int64_t)stat_sb->st_gid);
ret.set(s_rdev, (int64_t)stat_sb->st_rdev);
ret.set(s_size, (int64_t)stat_sb->st_size);
ret.set(s_atime, (int64_t)stat_sb->st_atime);
ret.set(s_mtime, (int64_t)stat_sb->st_mtime);
ret.set(s_ctime, (int64_t)stat_sb->st_ctime);
ret.set(s_blksize, (int64_t)stat_sb->st_blksize);
ret.set(s_blocks, (int64_t)stat_sb->st_blocks);
return ret.create();
}
///////////////////////////////////////////////////////////////////////////////
@@ -825,15 +836,20 @@ Variant f_realpath(CStrRef path) {
#define PHP_PATHINFO_EXTENSION 4
#define PHP_PATHINFO_FILENAME 8
static const StaticString s_dirname("dirname");
static const StaticString s_basename("basename");
static const StaticString s_extension("extension");
static const StaticString s_filename("filename");
Variant f_pathinfo(CStrRef path, int opt /* = 15 */) {
Array ret;
ArrayInit ret(4);
if ((opt & PHP_PATHINFO_DIRNAME) == PHP_PATHINFO_DIRNAME) {
String dirname = f_dirname(path);
if (opt == PHP_PATHINFO_DIRNAME) {
return dirname;
}
ret.set("dirname", dirname);
ret.set(s_dirname, dirname);
}
String basename = f_basename(path);
@@ -841,7 +857,7 @@ Variant f_pathinfo(CStrRef path, int opt /* = 15 */) {
if (opt == PHP_PATHINFO_BASENAME) {
return basename;
}
ret.set("basename", basename);
ret.set(s_basename, basename);
}
if ((opt & PHP_PATHINFO_EXTENSION) == PHP_PATHINFO_EXTENSION) {
@@ -853,7 +869,7 @@ Variant f_pathinfo(CStrRef path, int opt /* = 15 */) {
if (opt == PHP_PATHINFO_EXTENSION) {
return extension;
}
ret.set("extension", extension);
ret.set(s_extension, extension);
}
if ((opt & PHP_PATHINFO_FILENAME) == PHP_PATHINFO_FILENAME) {
@@ -867,10 +883,10 @@ Variant f_pathinfo(CStrRef path, int opt /* = 15 */) {
if (opt == PHP_PATHINFO_FILENAME) {
return filename;
}
ret.set("filename", filename);
ret.set(s_filename, filename);
}
return ret;
return ret.create();
}
Variant f_disk_free_space(CStrRef directory) {
@@ -1247,7 +1263,7 @@ bool f_chroot(CStrRef directory) {
class Directory : public SweepableResourceData {
public:
Directory(DIR *handle) : dir(handle) {
explicit Directory(DIR *handle) : dir(handle) {
assert(handle);
}
hphp/runtime/ext/ext_hotprofiler.cpp
+23 -15
Ver Arquivo
@@ -226,8 +226,7 @@ class esyscall {
public:
int num;
esyscall(const char *syscall_name)
{
explicit esyscall(const char *syscall_name) {
num = -1;
char format[strlen(syscall_name) + sizeof(" %d")];
sprintf(format, "%s %%d", syscall_name);
@@ -520,6 +519,15 @@ enum Flag {
TrackMalloc = 0x80,
};
static const StaticString s_ct("ct");
static const StaticString s_wt("wt");
static const StaticString s_cpu("cpu");
static const StaticString s_mu("mu");
static const StaticString s_pmu("pmu");
static const StaticString s_alloc("alloc");
static const StaticString s_free("free");
static const StaticString s_compressed_trace("(compressed_trace)");
/**
* Maintain profiles of a running stack.
*/
@@ -582,20 +590,20 @@ public:
static void returnVals(phpret& ret, const Name& name, const Counts& counts,
int flags, int64_t MHz)
{
Array arr;
arr.set("ct", counts.count);
arr.set("wt", to_usec(counts.wall_time, MHz));
ArrayInit arr(5);
arr.set(s_ct, counts.count);
arr.set(s_wt, to_usec(counts.wall_time, MHz));
if (flags & TrackCPU) {
arr.set("cpu", to_usec(counts.cpu, MHz, true));
arr.set(s_cpu, to_usec(counts.cpu, MHz, true));
}
if (flags & TrackMemory) {
arr.set("mu", counts.memory);
arr.set("pmu", counts.peak_memory);
arr.set(s_mu, counts.memory);
arr.set(s_pmu, counts.peak_memory);
} else if (flags & TrackMalloc) {
arr.set("alloc", counts.memory);
arr.set("free", counts.peak_memory);
arr.set(s_alloc, counts.memory);
arr.set(s_free, counts.peak_memory);
}
ret.set(String(name), arr);
ret.set(String(name), arr.create());
}
template<class phpret, class StatsMap>
@@ -799,7 +807,7 @@ private:
public:
public:
HierarchicalProfiler(int flags) : m_flags(flags) {
explicit HierarchicalProfiler(int flags) : m_flags(flags) {
}
virtual void beginFrameEx() {
@@ -1089,8 +1097,8 @@ public:
typedef hphp_hash_map<std::string, CountMap, string_hash> StatsMap;
StatsMap m_stats; // outcome
TraceProfiler(int flags) : Profiler(), nTrace(0),
full(false), m_flags(flags) {
explicit TraceProfiler(int flags)
: Profiler(), nTrace(0), full(false), m_flags(flags) {
if (pthread_mutex_trylock(&s_in_use)) {
m_successful = false;
} else {
@@ -1181,7 +1189,7 @@ public:
if (m_flags & GetTrace) {
String traceData;
packTraceData(fmap, traceData, m_MHz);
ret.set("(compressed_trace)", traceData);
ret.set(s_compressed_trace, traceData);
fprintf(stderr, "%d bytes\n", traceData.size());
}
CountMap trace_buffer;
hphp/runtime/ext/ext_iconv.cpp
+16 -10
Ver Arquivo
@@ -1698,27 +1698,33 @@ Variant f_iconv_mime_decode_headers(CStrRef encoded_headers,
return ret;
}
static const StaticString s_input_encoding("input_encoding");
static const StaticString s_output_encoding("output_encoding");
static const StaticString s_internal_encoding("internal_encoding");
static const StaticString s_all("all");
Variant f_iconv_get_encoding(CStrRef type /* = "all" */) {
if (type == "all") {
if (type == s_all) {
Array ret;
ret.set("input_encoding", ICONVG(input_encoding));
ret.set("output_encoding", ICONVG(output_encoding));
ret.set("internal_encoding", ICONVG(internal_encoding));
ret.set(s_input_encoding, ICONVG(input_encoding));
ret.set(s_output_encoding, ICONVG(output_encoding));
ret.set(s_internal_encoding, ICONVG(internal_encoding));
return ret;
}
if (type == "input_encoding") return ICONVG(input_encoding);
if (type == "output_encoding") return ICONVG(output_encoding);
if (type == "internal_encoding") return ICONVG(internal_encoding);
if (type == s_input_encoding) return ICONVG(input_encoding);
if (type == s_output_encoding) return ICONVG(output_encoding);
if (type == s_internal_encoding) return ICONVG(internal_encoding);
return false;
}
bool f_iconv_set_encoding(CStrRef type, CStrRef charset) {
if (!validate_charset(charset)) return false;
if (type == "input_encoding") {
if (type == s_input_encoding) {
ICONVG(input_encoding) = charset;
} else if (type == "output_encoding") {
} else if (type == s_output_encoding) {
ICONVG(output_encoding) = charset;
} else if (type == "internal_encoding") {
} else if (type == s_internal_encoding) {
ICONVG(internal_encoding) = charset;
} else {
return false;
hphp/runtime/ext/ext_image.cpp
+68 -42
Ver Arquivo
@@ -1574,6 +1574,10 @@ String f_image_type_to_extension(int imagetype,
}
}
static const StaticString s_bits("bits");
static const StaticString s_channels("channels");
static const StaticString s_mime("mime");
Variant f_getimagesize(CStrRef filename, VRefParam imageinfo /* = null */) {
int itype = 0;
struct gfxinfo *result = NULL;
@@ -1581,7 +1585,6 @@ Variant f_getimagesize(CStrRef filename, VRefParam imageinfo /* = null */) {
imageinfo = uninit_null();
}
Array ret;
Variant stream = f_fopen(filename, "rb");
if (same(stream, false)) {
raise_warning("failed to open stream: %s", filename.c_str());
@@ -1644,6 +1647,7 @@ Variant f_getimagesize(CStrRef filename, VRefParam imageinfo /* = null */) {
f_fclose(stream);
if (result) {
ArrayInit ret(7);
ret.set(0, (int64_t)result->width);
ret.set(1, (int64_t)result->height);
ret.set(2, itype);
@@ -1653,14 +1657,14 @@ Variant f_getimagesize(CStrRef filename, VRefParam imageinfo /* = null */) {
ret.set(3, String(temp, CopyString));
if (temp) IM_FREE(temp);
if (result->bits != 0) {
ret.set("bits", (int64_t)result->bits);
ret.set(s_bits, (int64_t)result->bits);
}
if (result->channels != 0) {
ret.set("channels", (int64_t)result->channels);
ret.set(s_channels, (int64_t)result->channels);
}
ret.set("mime", (char*)php_image_type_to_mime_type(itype));
ret.set(s_mime, (char*)php_image_type_to_mime_type(itype));
IM_FREE(result);
return ret;
return ret.create();
} else {
return false;
}
@@ -2924,68 +2928,85 @@ static Variant php_imagettftext_common(int mode, int extended,
}
#endif /* ENABLE_GD_TTF */
static const StaticString s_GD_Version("GD Version");
static const StaticString s_FreeType_Support("FreeType Support");
static const StaticString s_FreeType_Linkage("FreeType Linkage");
static const StaticString s_with_freetype("with freetype");
static const StaticString s_with_TTF_library("with TTF library");
static const StaticString s_with_unknown_library("with unknown library");
static const StaticString s_T1Lib_Support("T1Lib_Support");
static const StaticString s_GIF_Read_Support("GIF Read Support");
static const StaticString s_GIF_Create_Support("GIF Create Support");
static const StaticString s_JPG_Support("JPG Support");
static const StaticString s_PNG_Support("PNG Support");
static const StaticString s_WBMP_Support("WBMP Support");
static const StaticString s_XPM_Support("XPM Support");
static const StaticString s_XBM_Support("XBM Support");
static const StaticString
s_JIS_mapped_Japanese_Font_Support("JIS-mapped Japanese Font Support");
Array f_gd_info() {
Array ret;
ret.set("GD Version", PHP_GD_VERSION_STRING);
ret.set(s_GD_Version, PHP_GD_VERSION_STRING);
#ifdef ENABLE_GD_TTF
ret.set("FreeType Support", true);
ret.set(s_FreeType_Support, true);
#if HAVE_LIBFREETYPE
ret.set("FreeType Linkage", "with freetype");
ret.set(s_FreeType_Linkage, s_with_freetype);
#elif HAVE_LIBTTF
ret.set("FreeType Linkage", "with TTF library");
ret.set(s_FreeType_Linkage, s_with_TTF_library);
#else
ret.set("FreeType Linkage", "with unknown library");
ret.set(s_FreeType_Linkage, s_with_unknown_library);
#endif
#else
ret.set("FreeType Support", false);
ret.set(s_FreeType_Support, false);
#endif
#ifdef HAVE_LIBT1
ret.set("T1Lib Support", true);
ret.set(s_T1Lib_Support, true);
#else
ret.set("T1Lib Support", false);
ret.set(s_T1Lib_Support, false);
#endif
#ifdef HAVE_GD_GIF_READ
ret.set("GIF Read Support", true);
ret.set(s_GIF_Read_Support, true);
#else
ret.set("GIF Read Support", false);
ret.set(s_GIF_Read_Support, false);
#endif
#ifdef HAVE_GD_GIF_CREATE
ret.set("GIF Create Support", true);
ret.set(s_GIF_Create_Support, true);
#else
ret.set("GIF Create Support", false);
ret.set(s_GIF_Create_Support, false);
#endif
#ifdef HAVE_GD_JPG
ret.set("JPG Support", true);
ret.set(s_JPG_Support, true);
#else
ret.set("JPG Support", false);
ret.set(s_JPG_Support, false);
#endif
#ifdef HAVE_GD_PNG
ret.set("PNG Support", true);
ret.set(s_PNG_Support, true);
#else
ret.set("PNG Support", false);
ret.set(s_PNG_Support, false);
#endif
#ifdef HAVE_GD_WBMP
ret.set("WBMP Support", true);
ret.set(s_WBMP_Support, true);
#else
ret.set("WBMP Support", false);
ret.set(s_WBMP_Support, false);
#endif
#if defined(HAVE_GD_XPM) && defined(HAVE_GD_BUNDLED)
ret.set("XPM Support", true);
ret.set(s_XPM_Support, true);
#else
ret.set("XPM Support", false);
ret.set(s_XPM_Support, false);
#endif
#ifdef HAVE_GD_XBM
ret.set("XBM Support", true);
ret.set(s_XBM_Support, true);
#else
ret.set("XBM Support", false);
ret.set(s_XBM_Support, false);
#endif
#if defined(USE_GD_JISX0208) && defined(HAVE_GD_BUNDLED)
ret.set("JIS-mapped Japanese Font Support", true);
ret.set(s_JIS_mapped_Japanese_Font_Support, true);
#else
ret.set("JIS-mapped Japanese Font Support", false);
ret.set(s_JIS_mapped_Japanese_Font_Support, false);
#endif
return ret;
}
@@ -3729,31 +3750,36 @@ Variant f_imagecolorset(CObjRef image, int index,
}
}
static const StaticString s_red("red");
static const StaticString s_green("green");
static const StaticString s_blue("blue");
static const StaticString s_alpha("alpha");
Variant f_imagecolorsforindex(CObjRef image, int index) {
Array ret;
gdImagePtr im = image.getTyped<Image>()->get();
if (!im) return false;
#if HAVE_LIBGD20
if ((index >= 0 && gdImageTrueColor(im)) ||
(!gdImageTrueColor(im) && index >= 0 &&
index < gdImageColorsTotal(im))) {
ret.set("red", gdImageRed(im,index));
ret.set("green", gdImageGreen(im,index));
ret.set("blue", gdImageBlue(im,index));
ret.set("alpha", gdImageAlpha(im,index));
ArrayInit ret(4);
ret.set(s_red, gdImageRed(im,index));
ret.set(s_green, gdImageGreen(im,index));
ret.set(s_blue, gdImageBlue(im,index));
ret.set(s_alpha, gdImageAlpha(im,index));
return ret.create();
}
#else
if (col >= 0 && col < gdImageColorsTotal(im)) {
ret.set("red", im->red[col]);
ret.set("green", im->green[col]);
ret.set("blue", im->blue[col]);
ArrayInit ret(3);
ret.set(s_red, im->red[col]);
ret.set(s_green, im->green[col]);
ret.set(s_blue, im->blue[col]);
return ret.create();
}
#endif
else {
raise_warning("Color index %d out of range", index);
return false;
}
return ret;
raise_warning("Color index %d out of range", index);
return false;
}
bool f_imagegammacorrect(CObjRef image, double inputgamma,
hphp/runtime/ext/ext_imagesprite.cpp
+22 -22
Ver Arquivo
@@ -611,6 +611,12 @@ Object c_ImageSprite::t_loadimages(bool block /* = false */) {
std::vector<ImageSprite::Block*>, \
ImageSprite::BlockAreaComparator>
static const StaticString s_x("x");
static const StaticString s_y("y");
static const StaticString s_id("id");
static const StaticString s_images("images");
static const StaticString s_sprite("sprite");
void c_ImageSprite::map() {
if (same(m_current, true)) {
return;
@@ -966,27 +972,27 @@ void c_ImageSprite::map() {
for(; iter != end; iter++) {
ImageSprite::Image *img = *iter;
Array map;
map.set("x", img->m_x);
map.set("y", img->m_y);
map.set("width", img->m_width);
map.set("height", img->m_height);
map.set("id", f_crc32(img->m_path));
map.set("padding_top", img->m_padding[IMAGESPRITE_PAD_TOP]);
map.set("padding_right", img->m_padding[IMAGESPRITE_PAD_RIGHT]);
map.set("padding_bottom", img->m_padding[IMAGESPRITE_PAD_BOTTOM]);
map.set("padding_left", img->m_padding[IMAGESPRITE_PAD_LEFT]);
map.set("flush_left", img->m_flush[IMAGESPRITE_FLUSH_LEFT]);
map.set("flush_right", img->m_flush[IMAGESPRITE_FLUSH_RIGHT]);
image_map.set(img->m_path, map);
ArrayInit map(11);
map.set(s_x, img->m_x);
map.set(s_y, img->m_y);
map.set(s_width, img->m_width);
map.set(s_height, img->m_height);
map.set(s_id, f_crc32(img->m_path));
map.set(s_padding_top, img->m_padding[IMAGESPRITE_PAD_TOP]);
map.set(s_padding_right, img->m_padding[IMAGESPRITE_PAD_RIGHT]);
map.set(s_padding_bottom, img->m_padding[IMAGESPRITE_PAD_BOTTOM]);
map.set(s_padding_left, img->m_padding[IMAGESPRITE_PAD_LEFT]);
map.set(s_flush_left, img->m_flush[IMAGESPRITE_FLUSH_LEFT]);
map.set(s_flush_right, img->m_flush[IMAGESPRITE_FLUSH_RIGHT]);
image_map.set(img->m_path, map.create());
}
m_width = width;
m_height = height;
m_mapping.set("images", image_map);
m_mapping.set("width", width);
m_mapping.set("height", height);
m_mapping.set(s_images, image_map);
m_mapping.set(s_width, width);
m_mapping.set(s_height, height);
m_current = true;
}
@@ -1067,9 +1073,6 @@ String c_ImageSprite::t_output(CStrRef output_file /* = null_string*/,
}
}
static const StaticString s_x("x");
static const StaticString s_y("y");
String c_ImageSprite::t_css(CStrRef css_namespace,
CStrRef sprite_file /* = null_string */,
CStrRef output_file /* = null_string */,
@@ -1141,9 +1144,6 @@ String c_ImageSprite::t_css(CStrRef css_namespace,
}
}
static const StaticString s_images("images");
static const StaticString s_sprite("sprite");
Array c_ImageSprite::t_geterrors() {
Array ret = Array::Create();
ret.set(s_images, m_img_errors);
hphp/runtime/ext/ext_intl.cpp
+12 -8
Ver Arquivo
@@ -735,6 +735,11 @@ enum {
};
#ifdef HAVE_46_API
static const StaticString s_result("result");
static const StaticString s_isTransitionalDifferent("isTransitionalDifferent");
static const StaticString s_errors("errors");
static Variant php_intl_idn_to_46(CStrRef domain, int64_t options, IdnVariant idn_variant, VRefParam idna_info, int mode) {
int32_t converted_capacity;
char *converted = NULL;
@@ -768,17 +773,16 @@ static Variant php_intl_idn_to_46(CStrRef domain, int64_t options, IdnVariant id
}
// Set up the array returned in idna_info.
Array arr;
arr.set("result", result);
arr.set("isTransitionalDifferent", info.isTransitionalDifferent);
arr.set("errors", (long)info.errors);
idna_info = arr; // As in Zend, the previous value of idn_variant is overwritten, not modified.
ArrayInit arr(3);
arr.set(s_result, result);
arr.set(s_isTransitionalDifferent, info.isTransitionalDifferent);
arr.set(s_errors, (long)info.errors);
// As in Zend, the previous value of idn_variant is overwritten, not modified.
idna_info = arr.create();
if (info.errors == 0) {
return result;
} else {
return false;
}
return false;
}
#endif
hphp/runtime/ext/ext_ldap.cpp
+10 -7
Ver Arquivo
@@ -487,6 +487,9 @@ static int _ldap_rebind_proc(LDAP *ldap, const char *url, ber_tag_t req,
return ret.toInt64();
}
static const StaticString s_count("count");
static const StaticString s_dn("dn");
static void get_attributes(Array &ret, LDAP *ldap,
LDAPMessage *ldap_result_entry, bool to_lower) {
int num_attrib = 0;
@@ -499,7 +502,7 @@ static void get_attributes(Array &ret, LDAP *ldap,
int num_values = ldap_count_values_len(ldap_value);
Array tmp;
tmp.set("count", num_values);
tmp.set(s_count, num_values);
for (int i = 0; i < num_values; i++) {
tmp.append(String(ldap_value[i]->bv_val, ldap_value[i]->bv_len,
CopyString));
@@ -519,7 +522,7 @@ static void get_attributes(Array &ret, LDAP *ldap,
ber_free(ber, 0);
}
ret.set("count", num_attrib);
ret.set(s_count, num_attrib);
}
///////////////////////////////////////////////////////////////////////////////
@@ -568,7 +571,7 @@ Variant f_ldap_explode_dn(CStrRef dn, int with_attrib) {
int count = i;
Array ret;
ret.set("count", count);
ret.set(s_count, count);
for (i = 0; i < count; i++) {
ret.append(String(ldap_value[i], CopyString));
}
@@ -1014,7 +1017,7 @@ Variant f_ldap_get_entries(CObjRef link, CObjRef result) {
int num_entries = ldap_count_entries(ldap, res->data);
Array ret;
ret.set("count", num_entries);
ret.set(s_count, num_entries);
if (num_entries == 0) {
return uninit_null();
}
@@ -1030,7 +1033,7 @@ Variant f_ldap_get_entries(CObjRef link, CObjRef result) {
get_attributes(tmp1, ldap, ldap_result_entry, true);
char *dn = ldap_get_dn(ldap, ldap_result_entry);
tmp1.set("dn", String(dn, CopyString));
tmp1.set(s_dn, String(dn, CopyString));
ldap_memfree(dn);
ret.set(num_entries, tmp1);
@@ -1039,7 +1042,7 @@ Variant f_ldap_get_entries(CObjRef link, CObjRef result) {
ldap_result_entry = ldap_next_entry(ldap, ldap_result_entry);
}
ret.set("count", num_entries);
ret.set(s_count, num_entries);
return ret;
}
@@ -1235,7 +1238,7 @@ Variant f_ldap_get_values_len(CObjRef link, CObjRef result_entry,
ret.append(String(ldap_value_len[i]->bv_val, ldap_value_len[i]->bv_len,
CopyString));
}
ret.set("count", num_values);
ret.set(s_count, num_values);
ldap_value_free_len(ldap_value_len);
return ret;
}
hphp/runtime/ext/ext_mailparse.cpp
+13 -6
Ver Arquivo
@@ -195,6 +195,10 @@ Array f_mailparse_msg_get_structure(CObjRef mimemail) {
return mimemail.getTyped<MimePart>()->getStructure();
}
static const StaticString s_display("display");
static const StaticString s_address("address");
static const StaticString s_is_group("is_group");
Array f_mailparse_rfc822_parse_addresses(CStrRef addresses) {
php_rfc822_tokenized_t *toks =
php_mailparse_rfc822_tokenize(addresses.data(), 1);
@@ -204,12 +208,12 @@ Array f_mailparse_rfc822_parse_addresses(CStrRef addresses) {
for (int i = 0; i < addrs->naddrs; i++) {
Array item = Array::Create();
if (addrs->addrs[i].name) {
item.set("display", String(addrs->addrs[i].name, CopyString));
item.set(s_display, String(addrs->addrs[i].name, CopyString));
}
if (addrs->addrs[i].address) {
item.set("address", String(addrs->addrs[i].address, CopyString));
item.set(s_address, String(addrs->addrs[i].address, CopyString));
}
item.set("is_group", (bool)addrs->addrs[i].is_group);
item.set(s_is_group, (bool)addrs->addrs[i].is_group);
ret.append(item);
}
@@ -340,6 +344,9 @@ static size_t mailparse_do_uudecode(File *instream, File *outstream) {
return file_size;
}
static const StaticString s_filename("filename");
static const StaticString s_origfilename("origfilename");
Variant f_mailparse_uudecode_all(CObjRef fp) {
File *instream = fp.getTyped<File>();
instream->rewind();
@@ -371,20 +378,20 @@ Variant f_mailparse_uudecode_all(CObjRef fp) {
/* create an initial item representing the file with all uuencoded
parts removed */
Array item = Array::Create();
item.set("filename", String(((TempFile*)outstream)->getName()));
item.set(s_filename, String(((TempFile*)outstream)->getName()));
return_value.append(item);
}
/* add an item */
Array item = Array::Create();
item.set("origfilename", String(origfilename, CopyString));
item.set(s_origfilename, String(origfilename, CopyString));
/* create a temp file for the data */
File *partstream = NEWOBJ(TempFile)(false);
Object deleter(partstream);
if (partstream) {
nparts++;
item.set("filename", String(((TempFile*)partstream)->getName()));
item.set(s_filename, String(((TempFile*)partstream)->getName()));
return_value.append(item);
/* decode it */
hphp/runtime/ext/ext_mb.cpp
+38 -20
Ver Arquivo
@@ -1618,6 +1618,24 @@ Variant f_mb_encode_numericentity(CStrRef str, CVarRef convmap,
return php_mb_numericentity_exec(str, convmap, encoding, 0);
}
static const StaticString s_internal_encoding("internal_encoding");
static const StaticString s_http_input("http_input");
static const StaticString s_http_output("http_output");
static const StaticString s_mail_charset("mail_charset");
static const StaticString s_mail_header_encoding("mail_header_encoding");
static const StaticString s_mail_body_encoding("mail_body_encoding");
static const StaticString s_illegal_chars("illegal_chars");
static const StaticString s_encoding_translation("encoding_translation");
static const StaticString s_On("On");
static const StaticString s_Off("Off");
static const StaticString s_language("language");
static const StaticString s_detect_order("detect_order");
static const StaticString s_substitute_character("substitute_character");
static const StaticString s_strict_detection("strict_detection");
static const StaticString s_none("none");
static const StaticString s_long("long");
static const StaticString s_entity("entity");
Variant f_mb_get_info(CStrRef type /* = null_string */) {
const mbfl_language *lang = mbfl_no2language(MBSTRG(current_language));
mbfl_no_encoding *entry;
@@ -1628,36 +1646,36 @@ Variant f_mb_get_info(CStrRef type /* = null_string */) {
Array ret;
if ((name = (char *)mbfl_no_encoding2name
(MBSTRG(current_internal_encoding))) != NULL) {
ret.set("internal_encoding", String(name, CopyString));
ret.set(s_internal_encoding, String(name, CopyString));
}
if ((name = (char *)mbfl_no_encoding2name
(MBSTRG(http_input_identify))) != NULL) {
ret.set("http_input", String(name, CopyString));
ret.set(s_http_input, String(name, CopyString));
}
if ((name = (char *)mbfl_no_encoding2name
(MBSTRG(current_http_output_encoding))) != NULL) {
ret.set("http_output", String(name, CopyString));
ret.set(s_http_output, String(name, CopyString));
}
if (lang != NULL) {
if ((name = (char *)mbfl_no_encoding2name
(lang->mail_charset)) != NULL) {
ret.set("mail_charset", String(name, CopyString));
ret.set(s_mail_charset, String(name, CopyString));
}
if ((name = (char *)mbfl_no_encoding2name
(lang->mail_header_encoding)) != NULL) {
ret.set("mail_header_encoding", String(name, CopyString));
ret.set(s_mail_header_encoding, String(name, CopyString));
}
if ((name = (char *)mbfl_no_encoding2name
(lang->mail_body_encoding)) != NULL) {
ret.set("mail_body_encoding", String(name, CopyString));
ret.set(s_mail_body_encoding, String(name, CopyString));
}
}
ret.set("illegal_chars", MBSTRG(illegalchars));
ret.set("encoding_translation",
MBSTRG(encoding_translation) ? "On" : "Off");
ret.set(s_illegal_chars, MBSTRG(illegalchars));
ret.set(s_encoding_translation,
MBSTRG(encoding_translation) ? s_On : s_Off);
if ((name = (char *)mbfl_no_language2name
(MBSTRG(current_language))) != NULL) {
ret.set("language", String(name, CopyString));
ret.set(s_language, String(name, CopyString));
}
n = MBSTRG(current_detect_order_list_size);
entry = MBSTRG(current_detect_order_list);
@@ -1670,23 +1688,23 @@ Variant f_mb_get_info(CStrRef type /* = null_string */) {
entry++;
n--;
}
ret.set("detect_order", row);
ret.set(s_detect_order, row);
}
switch (MBSTRG(current_filter_illegal_mode)) {
case MBFL_OUTPUTFILTER_ILLEGAL_MODE_NONE:
ret.set("substitute_character", "none");
ret.set(s_substitute_character, s_none);
break;
case MBFL_OUTPUTFILTER_ILLEGAL_MODE_LONG:
ret.set("substitute_character", "long");
ret.set(s_substitute_character, s_long);
break;
case MBFL_OUTPUTFILTER_ILLEGAL_MODE_ENTITY:
ret.set("substitute_character", "entity");
ret.set(s_substitute_character, s_entity);
break;
default:
ret.set("substitute_character",
ret.set(s_substitute_character,
MBSTRG(current_filter_illegal_substchar));
}
ret.set("strict_detection", MBSTRG(strict_detection) ? "On" : "Off");
ret.set(s_strict_detection, MBSTRG(strict_detection) ? s_On : s_Off);
return ret;
} else if (strcasecmp(type.data(), "internal_encoding") == 0) {
if ((name = (char *)mbfl_no_encoding2name
@@ -1747,18 +1765,18 @@ Variant f_mb_get_info(CStrRef type /* = null_string */) {
} else if (strcasecmp(type.data(), "substitute_character") == 0) {
if (MBSTRG(current_filter_illegal_mode) ==
MBFL_OUTPUTFILTER_ILLEGAL_MODE_NONE) {
return "none";
return s_none;
} else if (MBSTRG(current_filter_illegal_mode) ==
MBFL_OUTPUTFILTER_ILLEGAL_MODE_LONG) {
return "long";
return s_long;
} else if (MBSTRG(current_filter_illegal_mode) ==
MBFL_OUTPUTFILTER_ILLEGAL_MODE_ENTITY) {
return "entity";
return s_entity;
} else {
return MBSTRG(current_filter_illegal_substchar);
}
} else if (strcasecmp(type.data(), "strict_detection") == 0) {
return MBSTRG(strict_detection) ? "On" : "Off";
return MBSTRG(strict_detection) ? s_On : s_Off;
}
return false;
}
hphp/runtime/ext/ext_network.cpp
+84 -42
Ver Arquivo
@@ -366,6 +366,48 @@ typedef union {
u_char qb2[65536];
} querybuf;
static const StaticString s_host("host");
static const StaticString s_type("type");
static const StaticString s_ip("ip");
static const StaticString s_pri("pri");
static const StaticString s_weight("weight");
static const StaticString s_port("port");
static const StaticString s_order("order");
static const StaticString s_pref("pref");
static const StaticString s_target("target");
static const StaticString s_cpu("cpu");
static const StaticString s_os("os");
static const StaticString s_txt("txt");
static const StaticString s_mname("mname");
static const StaticString s_rname("rname");
static const StaticString s_serial("serial");
static const StaticString s_refresh("refresh");
static const StaticString s_retry("retry");
static const StaticString s_expire("expire");
static const StaticString s_minimum_ttl("minimum-ttl");
static const StaticString s_ipv6("ipv6");
static const StaticString s_masklen("masklen");
static const StaticString s_chain("chain");
static const StaticString s_flags("flags");
static const StaticString s_services("services");
static const StaticString s_regex("regex");
static const StaticString s_replacement("replacement");
static const StaticString s_class("class");
static const StaticString s_ttl("ttl");
static const StaticString s_A("A");
static const StaticString s_MX("MX");
static const StaticString s_CNAME("CNAME");
static const StaticString s_NS("NS");
static const StaticString s_PTR("PTR");
static const StaticString s_HINFO("HINFO");
static const StaticString s_TXT("TXT");
static const StaticString s_SOA("SOA");
static const StaticString s_AAAA("AAAA");
static const StaticString s_A6("A6");
static const StaticString s_SRV("SRV");
static const StaticString s_NAPTR("NAPTR");
static const StaticString s_IN("IN");
static unsigned char *php_parserr(unsigned char *cp, querybuf *answer,
int type_to_fetch, bool store,
@@ -398,56 +440,56 @@ static unsigned char *php_parserr(unsigned char *cp, querybuf *answer,
return cp;
}
subarray.set("host", String(name, CopyString));
subarray.set(s_host, String(name, CopyString));
switch (type) {
case DNS_T_A:
subarray.set("type", "A");
subarray.set(s_type, s_A);
snprintf(name, sizeof(name), "%d.%d.%d.%d", cp[0], cp[1], cp[2], cp[3]);
subarray.set("ip", String(name, CopyString));
subarray.set(s_ip, String(name, CopyString));
cp += dlen;
break;
case DNS_T_MX:
subarray.set("type", "MX");
subarray.set(s_type, s_MX);
GETSHORT(n, cp);
subarray.set("pri", n);
subarray.set(s_pri, n);
/* no break; */
case DNS_T_CNAME:
if (type == DNS_T_CNAME) {
subarray.set("type", "CNAME");
subarray.set(s_type, s_CNAME);
}
/* no break; */
case DNS_T_NS:
if (type == DNS_T_NS) {
subarray.set("type", "NS");
subarray.set(s_type, s_NS);
}
/* no break; */
case DNS_T_PTR:
if (type == DNS_T_PTR) {
subarray.set("type", "PTR");
subarray.set(s_type, s_PTR);
}
n = dn_expand(answer->qb2, answer->qb2+65536, cp, name, (sizeof name) - 2);
if (n < 0) {
return NULL;
}
cp += n;
subarray.set("target", String(name, CopyString));
subarray.set(s_target, String(name, CopyString));
break;
case DNS_T_HINFO:
/* See RFC 1010 for values */
subarray.set("type", "HINFO");
subarray.set(s_type, s_HINFO);
n = *cp & 0xFF;
cp++;
subarray.set("cpu", String((const char *)cp, n, CopyString));
subarray.set(s_cpu, String((const char *)cp, n, CopyString));
cp += n;
n = *cp & 0xFF;
cp++;
subarray.set("os", String((const char *)cp, n, CopyString));
subarray.set(s_os, String((const char *)cp, n, CopyString));
cp += n;
break;
case DNS_T_TXT: {
int ll = 0;
subarray.set("type", "TXT");
subarray.set(s_type, s_TXT);
String s = String(dlen, ReserveString);
tp = (unsigned char *)s.mutableSlice().ptr;
@@ -459,33 +501,33 @@ static unsigned char *php_parserr(unsigned char *cp, querybuf *answer,
s.setSize(dlen);
cp += dlen;
subarray.set("txt", s);
subarray.set(s_txt, s);
break;
}
case DNS_T_SOA:
subarray.set("type", "SOA");
subarray.set(s_type, s_SOA);
n = dn_expand(answer->qb2, answer->qb2+65536, cp, name, (sizeof name) -2);
if (n < 0) {
return NULL;
}
cp += n;
subarray.set("mname", String(name, CopyString));
subarray.set(s_mname, String(name, CopyString));
n = dn_expand(answer->qb2, answer->qb2+65536, cp, name, (sizeof name) -2);
if (n < 0) {
return NULL;
}
cp += n;
subarray.set("rname", String(name, CopyString));
subarray.set(s_rname, String(name, CopyString));
GETLONG(n, cp);
subarray.set("serial", n);
subarray.set(s_serial, n);
GETLONG(n, cp);
subarray.set("refresh", n);
subarray.set(s_refresh, n);
GETLONG(n, cp);
subarray.set("retry", n);
subarray.set(s_retry, n);
GETLONG(n, cp);
subarray.set("expire", n);
subarray.set(s_expire, n);
GETLONG(n, cp);
subarray.set("minimum-ttl", n);
subarray.set(s_minimum_ttl, n);
break;
case DNS_T_AAAA:
tp = (unsigned char *)name;
@@ -517,15 +559,15 @@ static unsigned char *php_parserr(unsigned char *cp, querybuf *answer,
tp++;
}
tp[0] = '\0';
subarray.set("type", "AAAA");
subarray.set("ipv6", String(name, CopyString));
subarray.set(s_type, s_AAAA);
subarray.set(s_ipv6, String(name, CopyString));
break;
case DNS_T_A6:
p = cp;
subarray.set("type", "A6");
subarray.set(s_type, s_A6);
n = ((int)cp[0]) & 0xFF;
cp++;
subarray.set("masklen", n);
subarray.set(s_masklen, n);
tp = (unsigned char *)name;
if (n > 15) {
have_v6_break = 1;
@@ -585,7 +627,7 @@ static unsigned char *php_parserr(unsigned char *cp, querybuf *answer,
tp++;
}
tp[0] = '\0';
subarray.set("ipv6", String(name, CopyString));
subarray.set(s_ipv6, String(name, CopyString));
if (cp < p + dlen) {
n = dn_expand(answer->qb2, answer->qb2+65536, cp, name,
(sizeof name) - 2);
@@ -593,52 +635,52 @@ static unsigned char *php_parserr(unsigned char *cp, querybuf *answer,
return NULL;
}
cp += n;
subarray.set("chain", String(name, CopyString));
subarray.set(s_chain, String(name, CopyString));
}
break;
case DNS_T_SRV:
subarray.set("type", "SRV");
subarray.set(s_type, s_SRV);
GETSHORT(n, cp);
subarray.set("pri", n);
subarray.set(s_pri, n);
GETSHORT(n, cp);
subarray.set("weight", n);
subarray.set(s_weight, n);
GETSHORT(n, cp);
subarray.set("port", n);
subarray.set(s_port, n);
n = dn_expand(answer->qb2, answer->qb2+65536, cp, name, (sizeof name) - 2);
if (n < 0) {
return NULL;
}
cp += n;
subarray.set("target", String(name, CopyString));
subarray.set(s_target, String(name, CopyString));
break;
case DNS_T_NAPTR:
subarray.set("type", "NAPTR");
subarray.set(s_type, s_NAPTR);
GETSHORT(n, cp);
subarray.set("order", n);
subarray.set(s_order, n);
GETSHORT(n, cp);
subarray.set("pref", n);
subarray.set(s_pref, n);
n = (cp[0] & 0xFF);
subarray.set("flags", String((const char *)(++cp), n, CopyString));
subarray.set(s_flags, String((const char *)(++cp), n, CopyString));
cp += n;
n = (cp[0] & 0xFF);
subarray.set("services", String((const char *)(++cp), n, CopyString));
subarray.set(s_services, String((const char *)(++cp), n, CopyString));
cp += n;
n = (cp[0] & 0xFF);
subarray.set("regex", String((const char *)(++cp), n, CopyString));
subarray.set(s_regex, String((const char *)(++cp), n, CopyString));
cp += n;
n = dn_expand(answer->qb2, answer->qb2+65536, cp, name, (sizeof name) - 2);
if (n < 0) {
return NULL;
}
cp += n;
subarray.set("replacement", String(name, CopyString));
subarray.set(s_replacement, String(name, CopyString));
break;
default:
cp += dlen;
}
subarray.set("class", "IN");
subarray.set("ttl", (int)ttl);
subarray.set(s_class, s_IN);
subarray.set(s_ttl, (int)ttl);
return cp;
}
hphp/runtime/ext/ext_openssl.cpp
+40 -22
Ver Arquivo
@@ -108,7 +108,7 @@ IMPLEMENT_DEFAULT_EXTENSION(openssl);
class Key : public SweepableResourceData {
public:
EVP_PKEY *m_key;
Key(EVP_PKEY *key) : m_key(key) { assert(m_key);}
explicit Key(EVP_PKEY *key) : m_key(key) { assert(m_key);}
~Key() { if (m_key) EVP_PKEY_free(m_key);}
static StaticString s_class_name;
@@ -249,7 +249,7 @@ StaticString Key::s_class_name("OpenSSL key");
class CSRequest : public SweepableResourceData {
public:
X509_REQ *m_csr;
CSRequest(X509_REQ *csr) : m_csr(csr) { assert(m_csr);}
explicit CSRequest(X509_REQ *csr) : m_csr(csr) { assert(m_csr);}
~CSRequest() { if (m_csr) X509_REQ_free(m_csr);}
static StaticString s_class_name;
@@ -1230,6 +1230,10 @@ bool f_openssl_pkcs12_export(CVarRef x509, VRefParam out, CVarRef priv_key,
return ret;
}
static const StaticString s_cert("cert");
static const StaticString s_pkey("pkey");
static const StaticString s_extracerts("extracerts");
bool f_openssl_pkcs12_read(CStrRef pkcs12, VRefParam certs, CStrRef pass) {
Variant &vcerts = certs;
bool ret = false;
@@ -1250,8 +1254,8 @@ bool f_openssl_pkcs12_read(CStrRef pkcs12, VRefParam certs, CStrRef pass) {
if (PEM_write_bio_X509(bio_out, cert)) {
BUF_MEM *bio_buf;
BIO_get_mem_ptr(bio_out, &bio_buf);
vcerts.set("cert", String((char*)bio_buf->data, bio_buf->length,
CopyString));
vcerts.set(s_cert, String((char*)bio_buf->data, bio_buf->length,
CopyString));
}
BIO_free(bio_out);
@@ -1259,8 +1263,8 @@ bool f_openssl_pkcs12_read(CStrRef pkcs12, VRefParam certs, CStrRef pass) {
if (PEM_write_bio_PrivateKey(bio_out, pkey, NULL, NULL, 0, 0, NULL)) {
BUF_MEM *bio_buf;
BIO_get_mem_ptr(bio_out, &bio_buf);
vcerts.set("pkey", String((char*)bio_buf->data, bio_buf->length,
CopyString));
vcerts.set(s_pkey, String((char*)bio_buf->data, bio_buf->length,
CopyString));
}
BIO_free(bio_out);
@@ -1278,7 +1282,7 @@ bool f_openssl_pkcs12_read(CStrRef pkcs12, VRefParam certs, CStrRef pass) {
}
if (ca) {
sk_X509_free(ca);
vcerts.set("extracerts", extracerts);
vcerts.set(s_extracerts, extracerts);
}
ret = true;
PKCS12_free(p12);
@@ -1627,6 +1631,21 @@ void f_openssl_pkey_free(CObjRef key) {
// do nothing
}
static const StaticString s_bits("bits");
static const StaticString s_key("key");
static const StaticString s_type("type");
static const StaticString s_name("name");
static const StaticString s_hash("hash");
static const StaticString s_version("version");
static const StaticString s_serialNumber("serialNumber");
static const StaticString s_validFrom("validFrom");
static const StaticString s_validTo("validTo");
static const StaticString s_validFrom_time_t("validFrom_time_t");
static const StaticString s_validTo_time_t("validTo_time_t");
static const StaticString s_alias("alias");
static const StaticString s_purposes("purposes");
static const StaticString s_extensions("extensions");
Array f_openssl_pkey_get_details(CObjRef key) {
EVP_PKEY *pkey = key.getTyped<Key>()->m_key;
BIO *out = BIO_new(BIO_s_mem());
@@ -1635,8 +1654,8 @@ Array f_openssl_pkey_get_details(CObjRef key) {
unsigned int pbio_len = BIO_get_mem_data(out, &pbio);
Array ret;
ret.set("bits", EVP_PKEY_bits(pkey));
ret.set("key", String(pbio, pbio_len, CopyString));
ret.set(s_bits, EVP_PKEY_bits(pkey));
ret.set(s_key, String(pbio, pbio_len, CopyString));
long ktype = -1;
switch (EVP_PKEY_type(pkey->type)) {
case EVP_PKEY_RSA:
@@ -1650,7 +1669,7 @@ Array f_openssl_pkey_get_details(CObjRef key) {
case EVP_PKEY_EC: ktype = k_OPENSSL_KEYTYPE_EC; break;
#endif
}
ret.set("type", ktype);
ret.set(s_type, ktype);
BIO_free(out);
return ret;
}
@@ -2167,7 +2186,7 @@ Variant f_openssl_x509_parse(CVarRef x509cert, bool shortnames /* = true */) {
Array ret;
if (cert->name) {
ret.set("name", String(cert->name, CopyString));
ret.set(s_name, String(cert->name, CopyString));
}
add_assoc_name_entry(ret, "subject", X509_get_subject_name(cert),
shortnames);
@@ -2175,26 +2194,25 @@ Variant f_openssl_x509_parse(CVarRef x509cert, bool shortnames /* = true */) {
{
char buf[32];
snprintf(buf, sizeof(buf), "%08lx", X509_subject_name_hash(cert));
ret.set("hash", String(buf, CopyString));
ret.set(s_hash, String(buf, CopyString));
}
add_assoc_name_entry(ret, "issuer", X509_get_issuer_name(cert), shortnames);
ret.set("version", X509_get_version(cert));
ret.set(s_version, X509_get_version(cert));
ret.set("serialNumber", String
ret.set(s_serialNumber, String
(i2s_ASN1_INTEGER(NULL, X509_get_serialNumber(cert)), AttachString));
ASN1_STRING *str = X509_get_notBefore(cert);
ret.set("validFrom", String((char*)str->data, str->length, CopyString));
ret.set(s_validFrom, String((char*)str->data, str->length, CopyString));
str = X509_get_notAfter(cert);
ret.set("validTo", String((char*)str->data, str->length, CopyString));
ret.set("validFrom_time_t", asn1_time_to_time_t(X509_get_notBefore(cert)));
ret.set("validTo_time_t", asn1_time_to_time_t(X509_get_notAfter(cert)));
ret.set(s_validTo, String((char*)str->data, str->length, CopyString));
ret.set(s_validFrom_time_t, asn1_time_to_time_t(X509_get_notBefore(cert)));
ret.set(s_validTo_time_t, asn1_time_to_time_t(X509_get_notAfter(cert)));
char *tmpstr = (char *)X509_alias_get0(cert, NULL);
if (tmpstr) {
ret.set("alias", String(tmpstr, CopyString));
ret.set(s_alias, String(tmpstr, CopyString));
}
/* NOTE: the purposes are added as integer keys - the keys match up to
@@ -2215,7 +2233,7 @@ Variant f_openssl_x509_parse(CVarRef x509cert, bool shortnames /* = true */) {
subitem.set(id, subsub);
}
ret.set("purposes", subitem);
ret.set(s_purposes, subitem);
}
{
Array subitem;
@@ -2244,7 +2262,7 @@ Variant f_openssl_x509_parse(CVarRef x509cert, bool shortnames /* = true */) {
}
BIO_free(bio_out);
}
ret.set("extensions", subitem);
ret.set(s_extensions, subitem);
}
return ret;
hphp/runtime/ext/ext_output.cpp
+14 -9
Ver Arquivo
@@ -123,6 +123,11 @@ static String ts_microtime(const timespec &ts) {
return String(ret, CopyString);
}
static const StaticString s_queue("queue");
static const StaticString s_process_wall("process-wall");
static const StaticString s_process_cpu("process-cpu");
static const StaticString s_process_inst("process-inst");
Variant f_hphp_get_timers(bool get_as_float /* = true */) {
Transport *transport = g_context->getTransport();
if (transport == NULL) {
@@ -134,18 +139,18 @@ Variant f_hphp_get_timers(bool get_as_float /* = true */) {
const timespec &tsCpu = transport->getCpuTime();
const int64_t &instStart = transport->getInstructions();
Array ret;
ArrayInit ret(4);
if (get_as_float) {
ret.set("queue", ts_float(tsQueue));
ret.set("process-wall", ts_float(tsWall));
ret.set("process-cpu", ts_float(tsCpu));
ret.set(s_queue, ts_float(tsQueue));
ret.set(s_process_wall, ts_float(tsWall));
ret.set(s_process_cpu, ts_float(tsCpu));
} else {
ret.set("queue", ts_microtime(tsQueue));
ret.set("process-wall", ts_microtime(tsWall));
ret.set("process-cpu", ts_microtime(tsCpu));
ret.set(s_queue, ts_microtime(tsQueue));
ret.set(s_process_wall, ts_microtime(tsWall));
ret.set(s_process_cpu, ts_microtime(tsCpu));
}
ret.set("process-inst", instStart);
return ret;
ret.set(s_process_inst, instStart);
return ret.create();
}
Variant f_hphp_output_global_state(bool serialize /* = true */) {
hphp/runtime/ext/ext_pdo.cpp
+9 -4
Ver Arquivo
@@ -453,19 +453,24 @@ public:
};
static PDOErrorHash s_err_hash;
static const StaticString s_code("code");
static const StaticString s_message("message");
static const StaticString s_errorInfo("errorInfo");
static const StaticString s_PDOException("PDOException");
void throw_pdo_exception(CVarRef code, CVarRef info, const char *fmt, ...) {
ObjectData *obj = SystemLib::AllocPDOExceptionObject();
obj->o_set("code", code, "PDOException");
obj->o_set(s_code, code, s_PDOException);
va_list ap;
va_start(ap, fmt);
string msg;
Util::string_vsnprintf(msg, fmt, ap);
obj->o_set("message", String(msg), "PDOException");
obj->o_set(s_message, String(msg), s_PDOException);
va_end(ap);
if (!info.isNull()) {
obj->o_set("errorInfo", info, "PDOException");
obj->o_set(s_errorInfo, info, s_PDOException);
}
throw Object(obj);
}
@@ -605,7 +610,7 @@ static bool valid_statement_class(sp_PDOConnection dbh, CVarRef opt,
PDO_HANDLE_DBH_ERR(dbh);
return false;
}
HPHP::VM::Class* cls = HPHP::VM::Unit::loadClass(clsname.get());
HPHP::VM::Class* cls = HPHP::VM::Unit::loadClass(clsname.get());
if (cls) {
const HPHP::VM::Func* method = cls->getDeclaredCtor();
if (method && method->isPublic()) {
hphp/runtime/ext/ext_posix.cpp
+50 -28
Ver Arquivo
@@ -68,6 +68,15 @@ int64_t f_posix_getgid() {
return getgid();
}
static const StaticString s_name("name");
static const StaticString s_passwd("passwd");
static const StaticString s_members("members");
static const StaticString s_uid("uid");
static const StaticString s_gid("gid");
static const StaticString s_gecos("gecos");
static const StaticString s_dir("dir");
static const StaticString s_shell("shell");
static Variant php_posix_group_to_array(int gid,
CStrRef gname = null_variant) {
// Don't pass a gid *and* a gname to this.
@@ -103,12 +112,12 @@ static Variant php_posix_group_to_array(int gid,
members.append(String(gr.gr_mem[count], CopyString));
}
Array ret;
ret.set("name", String(gr.gr_name, CopyString));
ret.set("passwd", String(gr.gr_passwd, CopyString));
ret.set("members", members);
ret.set("gid", (int)gr.gr_gid);
return ret;
ArrayInit ret(4);
ret.set(s_name, String(gr.gr_name, CopyString));
ret.set(s_passwd, String(gr.gr_passwd, CopyString));
ret.set(s_members, members);
ret.set(s_gid, (int)gr.gr_gid);
return ret.create();
}
Variant f_posix_getgrgid(int gid) {
@@ -189,15 +198,15 @@ static Variant php_posix_passwd_to_array(int uid,
return false;
}
Array ret;
ret.set("name", String(pw.pw_name, CopyString));
ret.set("passwd", String(pw.pw_passwd, CopyString));
ret.set("uid", (int)pw.pw_uid);
ret.set("gid", (int)pw.pw_gid);
ret.set("gecos", String(pw.pw_gecos, CopyString));
ret.set("dir", String(pw.pw_dir, CopyString));
ret.set("shell", String(pw.pw_shell, CopyString));
return ret;
ArrayInit ret(7);
ret.set(s_name, String(pw.pw_name, CopyString));
ret.set(s_passwd, String(pw.pw_passwd, CopyString));
ret.set(s_uid, (int)pw.pw_uid);
ret.set(s_gid, (int)pw.pw_gid);
ret.set(s_gecos, String(pw.pw_gecos, CopyString));
ret.set(s_dir, String(pw.pw_dir, CopyString));
ret.set(s_shell, String(pw.pw_shell, CopyString));
return ret.create();
}
Variant f_posix_getpwnam(CStrRef username) {
@@ -353,6 +362,12 @@ String f_posix_strerror(int errnum) {
return String(Util::safe_strerror(errnum));
}
static const StaticString s_ticks("ticks");
static const StaticString s_utime("utime");
static const StaticString s_stime("stime");
static const StaticString s_cutime("cutime");
static const StaticString s_cstime("cstime");
Variant f_posix_times() {
struct tms t;
clock_t ticks = times(&t);
@@ -360,13 +375,13 @@ Variant f_posix_times() {
return false;
}
Array ret;
ret.set("ticks", (int)ticks); /* clock ticks */
ret.set("utime", (int)t.tms_utime); /* user time */
ret.set("stime", (int)t.tms_stime); /* system time */
ret.set("cutime", (int)t.tms_cutime); /* user time of children */
ret.set("cstime", (int)t.tms_cstime); /* system time of children */
return ret;
ArrayInit ret(5);
ret.set(s_ticks, (int)ticks); /* clock ticks */
ret.set(s_utime, (int)t.tms_utime); /* user time */
ret.set(s_stime, (int)t.tms_stime); /* system time */
ret.set(s_cutime, (int)t.tms_cutime); /* user time of children */
ret.set(s_cstime, (int)t.tms_cstime); /* system time of children */
return ret.create();
}
Variant f_posix_ttyname(CVarRef fd) {
@@ -383,6 +398,13 @@ Variant f_posix_ttyname(CVarRef fd) {
return ttyname.setSize(strlen(p));
}
static const StaticString s_sysname("sysname");
static const StaticString s_nodename("nodename");
static const StaticString s_release("release");
static const StaticString s_version("version");
static const StaticString s_machine("machine");
static const StaticString s_domainname("domainname");
Variant f_posix_uname() {
struct utsname u;
if (uname(&u) < 0) {
@@ -390,13 +412,13 @@ Variant f_posix_uname() {
}
Array ret;
ret.set("sysname", String(u.sysname, CopyString));
ret.set("nodename", String(u.nodename, CopyString));
ret.set("release", String(u.release, CopyString));
ret.set("version", String(u.version, CopyString));
ret.set("machine", String(u.machine, CopyString));
ret.set(s_sysname, String(u.sysname, CopyString));
ret.set(s_nodename, String(u.nodename, CopyString));
ret.set(s_release, String(u.release, CopyString));
ret.set(s_version, String(u.version, CopyString));
ret.set(s_machine, String(u.machine, CopyString));
#if defined(_GNU_SOURCE) && !defined(__APPLE__) && !defined(__FreeBSD__)
ret.set("domainname", String(u.domainname, CopyString));
ret.set(s_domainname, String(u.domainname, CopyString));
#endif
return ret;
}
hphp/runtime/ext/ext_process.cpp
+19 -10
Ver Arquivo
@@ -831,6 +831,15 @@ int64_t f_proc_close(CObjRef process) {
return process.getTyped<ChildProcess>()->close();
}
static const StaticString s_command("command");
static const StaticString s_pid("pid");
static const StaticString s_running("running");
static const StaticString s_signaled("signaled");
static const StaticString s_stopped("stopped");
static const StaticString s_exitcode("exitcode");
static const StaticString s_termsig("termsig");
static const StaticString s_stopsig("stopsig");
Array f_proc_get_status(CObjRef process) {
ChildProcess *proc = process.getTyped<ChildProcess>();
@@ -859,16 +868,16 @@ Array f_proc_get_status(CObjRef process) {
running = false;
}
Array ret;
ret.set("command", proc->command);
ret.set("pid", proc->child);
ret.set("running", running);
ret.set("signaled", signaled);
ret.set("stopped", stopped);
ret.set("exitcode", exitcode);
ret.set("termsig", termsig);
ret.set("stopsig", stopsig);
return ret;
ArrayInit ret(8);
ret.set(s_command, proc->command);
ret.set(s_pid, proc->child);
ret.set(s_running, running);
ret.set(s_signaled, signaled);
ret.set(s_stopped, stopped);
ret.set(s_exitcode, exitcode);
ret.set(s_termsig, termsig);
ret.set(s_stopsig, stopsig);
return ret.create();
}
bool f_proc_nice(int increment) {
hphp/runtime/ext/ext_server.cpp
+4 -2
Ver Arquivo
@@ -111,6 +111,8 @@ bool f_pagelet_server_is_enabled() {
return PageletServer::Enabled();
}
static const StaticString s_Host("Host");
Object f_pagelet_server_task_start(CStrRef url,
CArrRef headers /* = null_array */,
CStrRef post_data /* = null_string */,
@@ -119,9 +121,9 @@ Object f_pagelet_server_task_start(CStrRef url,
Transport *transport = g_context->getTransport();
if (transport) {
remote_host = transport->getRemoteHost();
if (!headers.exists("Host") && RuntimeOption::SandboxMode) {
if (!headers.exists(s_Host) && RuntimeOption::SandboxMode) {
Array tmp = headers;
tmp.set("Host", transport->getHeader("Host"));
tmp.set(s_Host, transport->getHeader("Host"));
return PageletServer::TaskStart(url, tmp, remote_host, post_data, files);
}
}
hphp/runtime/ext/ext_session.cpp
+14 -8
Ver Arquivo
@@ -757,7 +757,7 @@ static UserSessionModule s_user_session_module;
class SessionSerializer {
public:
SessionSerializer(const char *name) : m_name(name) {
explicit SessionSerializer(const char *name) : m_name(name) {
RegisteredSerializers.push_back(this);
}
virtual ~SessionSerializer() {}
@@ -1303,14 +1303,20 @@ void f_session_set_cookie_params(int64_t lifetime,
}
}
static const StaticString s_lifetime("lifetime");
static const StaticString s_path("path");
static const StaticString s_domain("domain");
static const StaticString s_secure("secure");
static const StaticString s_httponly("httponly");
Array f_session_get_cookie_params() {
Array ret = Array::Create();
ret.set("lifetime", PS(cookie_lifetime));
ret.set("path", String(PS(cookie_path)));
ret.set("domain", String(PS(cookie_domain)));
ret.set("secure", PS(cookie_secure));
ret.set("httponly", PS(cookie_httponly));
return ret;
ArrayInit ret(5);
ret.set(s_lifetime, PS(cookie_lifetime));
ret.set(s_path, String(PS(cookie_path)));
ret.set(s_domain, String(PS(cookie_domain)));
ret.set(s_secure, PS(cookie_secure));
ret.set(s_httponly, PS(cookie_httponly));
return ret.create();
}
String f_session_name(CStrRef newname /* = null_string */) {
hphp/runtime/ext/ext_simplexml.cpp
+18 -9
Ver Arquivo
@@ -539,6 +539,8 @@ String c_SimpleXMLElement::t_getname() {
return String();
}
static const StaticString s_attributes("@attributes");
Object c_SimpleXMLElement::t_attributes(CStrRef ns /* = "" */,
bool is_prefix /* = false */) {
if (m_is_attribute) {
@@ -557,7 +559,7 @@ Object c_SimpleXMLElement::t_attributes(CStrRef ns /* = "" */,
} else {
elem->m_attributes.assignRef(m_attributes);
}
elem->m_children.set("@attributes", elem->m_attributes);
elem->m_children.set(s_attributes, elem->m_attributes);
}
return obj;
}
@@ -828,7 +830,7 @@ Variant c_SimpleXMLElement::t___set(Variant name, Variant value) {
Object child = create_element(m_doc, newnode, ns, false);
if (m_is_attribute) {
m_attributes.set(name, child);
m_children.set("@attributes", m_attributes);
m_children.set(s_attributes, m_attributes);
} else {
m_children.set(name, child);
}
@@ -864,7 +866,7 @@ Array c_SimpleXMLElement::o_toArray() const {
return m_children;
}
Array ret;
ret.set("@attributes", m_attributes);
ret.set(s_attributes, m_attributes);
ret += m_children;
return ret;
}
@@ -1187,14 +1189,21 @@ static void libxml_error_handler(void *userData, xmlErrorPtr error) {
}
}
static const StaticString s_level("level");
static const StaticString s_code("code");
static const StaticString s_column("column");
static const StaticString s_message("message");
static const StaticString s_file("file");
static const StaticString s_line("line");
static Object create_libxmlerror(xmlError &error) {
Object ret(NEWOBJ(c_LibXMLError)());
ret->o_set("level", error.level);
ret->o_set("code", error.code);
ret->o_set("column", error.int2);
ret->o_set("message", String(error.message, CopyString));
ret->o_set("file", String(error.file, CopyString));
ret->o_set("line", error.line);
ret->o_set(s_level, error.level);
ret->o_set(s_code, error.code);
ret->o_set(s_column, error.int2);
ret->o_set(s_message, String(error.message, CopyString));
ret->o_set(s_file, String(error.file, CopyString));
ret->o_set(s_line, error.line);
return ret;
}
hphp/runtime/ext/ext_socket.cpp
+28 -19
Ver Arquivo
@@ -370,6 +370,11 @@ bool f_socket_create_pair(int domain, int type, int protocol, VRefParam fd) {
return true;
}
static const StaticString s_l_onoff("l_onoff");
static const StaticString s_l_linger("l_linger");
static const StaticString s_sec("sec");
static const StaticString s_usec("usec");
Variant f_socket_get_option(CObjRef socket, int level, int optname) {
Socket *sock = socket.getTyped<Socket>();
Array ret;
@@ -386,8 +391,8 @@ Variant f_socket_get_option(CObjRef socket, int level, int optname) {
return false;
}
ret.set("l_onoff", linger_val.l_onoff);
ret.set("l_linger", linger_val.l_linger);
ret.set(s_l_onoff, linger_val.l_onoff);
ret.set(s_l_linger, linger_val.l_linger);
}
break;
@@ -400,8 +405,8 @@ Variant f_socket_get_option(CObjRef socket, int level, int optname) {
SOCKET_ERROR(sock, "unable to retrieve socket option", errno);
return false;
}
ret.set("sec", (int)tv.tv_sec);
ret.set("usec", (int)tv.tv_usec);
ret.set(s_sec, (int)tv.tv_sec);
ret.set(s_usec, (int)tv.tv_usec);
}
break;
@@ -457,11 +462,6 @@ bool f_socket_set_nonblock(CObjRef socket) {
return sock->setBlocking(false);
}
static const StaticString s_l_onoff("l_onoff");
static const StaticString s_l_linger("l_linger");
static const StaticString s_sec("sec");
static const StaticString s_usec("usec");
bool f_socket_set_option(CObjRef socket, int level, int optname,
CVarRef optval) {
Socket *sock = socket.getTyped<Socket>();
@@ -1110,6 +1110,15 @@ String ipaddr_convert(struct sockaddr *addr, int addrlen) {
return String(buffer, CopyString);
}
static const StaticString s_family("family");
static const StaticString s_socktype("socktype");
static const StaticString s_protocol("protocol");
static const StaticString s_address("address");
static const StaticString s_port("port");
static const StaticString s_flow_info("flow_info");
static const StaticString s_scope_id("scope_id");
static const StaticString s_sockaddr("sockaddr");
Variant f_getaddrinfo(CStrRef host, CStrRef port, int family /* = 0 */,
int socktype /* = 0 */, int protocol /* = 0 */,
int flags /* = 0 */) {
@@ -1147,9 +1156,9 @@ Variant f_getaddrinfo(CStrRef host, CStrRef port, int family /* = 0 */,
Array data = Array::Create();
Array sockinfo = Array::Create();
data.set("family", res->ai_family);
data.set("socktype", res->ai_socktype);
data.set("protocol", res->ai_protocol);
data.set(s_family, res->ai_family);
data.set(s_socktype, res->ai_socktype);
data.set(s_protocol, res->ai_protocol);
switch (res->ai_addr->sa_family) {
case AF_INET:
@@ -1158,8 +1167,8 @@ Variant f_getaddrinfo(CStrRef host, CStrRef port, int family /* = 0 */,
String buffer = ipaddr_convert(res->ai_addr, sizeof(*a));
if (!buffer.empty()) {
a = (struct sockaddr_in *)res->ai_addr;
sockinfo.set("address", buffer);
sockinfo.set("port", ntohs(a->sin_port));
sockinfo.set(s_address, buffer);
sockinfo.set(s_port, ntohs(a->sin_port));
}
break;
}
@@ -1169,16 +1178,16 @@ Variant f_getaddrinfo(CStrRef host, CStrRef port, int family /* = 0 */,
String buffer = ipaddr_convert(res->ai_addr, sizeof(*a));
if (!buffer.empty()) {
a = (struct sockaddr_in6 *)res->ai_addr;
sockinfo.set("address", buffer);
sockinfo.set("port", ntohs(a->sin6_port));
sockinfo.set("flow_info", (int32_t)a->sin6_flowinfo);
sockinfo.set("scope_id", (int32_t)a->sin6_scope_id);
sockinfo.set(s_address, buffer);
sockinfo.set(s_port, ntohs(a->sin6_port));
sockinfo.set(s_flow_info, (int32_t)a->sin6_flowinfo);
sockinfo.set(s_scope_id, (int32_t)a->sin6_scope_id);
}
break;
}
}
data.set("sockaddr", (sockinfo.empty() ? NULL : sockinfo));
data.set(s_sockaddr, (sockinfo.empty() ? nullptr : sockinfo));
ret.append(data);
}
hphp/runtime/ext/ext_spl.cpp
+62 -57
Ver Arquivo
@@ -34,65 +34,70 @@ static StaticString s_next("next");
static StaticString s_current("current");
static StaticString s_key("key");
#define SPL_ADD_CLASS(cls) ret.set(#cls, #cls)
static const StaticString spl_classes[] = {
StaticString("AppendIterator"),
StaticString("ArrayIterator"),
StaticString("ArrayObject"),
StaticString("BadFunctionCallException"),
StaticString("BadMethodCallException"),
StaticString("CachingIterator"),
StaticString("Countable"),
StaticString("DirectoryIterator"),
StaticString("DomainException"),
StaticString("EmptyIterator"),
StaticString("FilesystemIterator"),
StaticString("FilterIterator"),
StaticString("GlobIterator"),
StaticString("InfiniteIterator"),
StaticString("InvalidArgumentException"),
StaticString("IteratorIterator"),
StaticString("LengthException"),
StaticString("LimitIterator"),
StaticString("LogicException"),
StaticString("MultipleIterator"),
StaticString("NoRewindIterator"),
StaticString("OuterIterator"),
StaticString("OutOfBoundsException"),
StaticString("OutOfRangeException"),
StaticString("OverflowException"),
StaticString("ParentIterator"),
StaticString("RangeException"),
StaticString("RecursiveArrayIterator"),
StaticString("RecursiveCachingIterator"),
StaticString("RecursiveDirectoryIterator"),
StaticString("RecursiveFilterIterator"),
StaticString("RecursiveIterator"),
StaticString("RecursiveIteratorIterator"),
StaticString("RecursiveRegexIterator"),
StaticString("RecursiveTreeIterator"),
StaticString("RegexIterator"),
StaticString("RuntimeException"),
StaticString("SeekableIterator"),
StaticString("SplDoublyLinkedList"),
StaticString("SplFileInfo"),
StaticString("SplFileObject"),
StaticString("SplFixedArray"),
StaticString("SplHeap"),
StaticString("SplMinHeap"),
StaticString("SplMaxHeap"),
StaticString("SplObjectStorage"),
StaticString("SplObserver"),
StaticString("SplPriorityQueue"),
StaticString("SplQueue"),
StaticString("SplStack"),
StaticString("SplSubject"),
StaticString("SplTempFileObject"),
StaticString("UnderflowException"),
StaticString("UnexpectedValueException"),
};
Array f_spl_classes() {
Array ret;
SPL_ADD_CLASS(AppendIterator);
SPL_ADD_CLASS(ArrayIterator);
SPL_ADD_CLASS(ArrayObject);
SPL_ADD_CLASS(BadFunctionCallException);
SPL_ADD_CLASS(BadMethodCallException);
SPL_ADD_CLASS(CachingIterator);
SPL_ADD_CLASS(Countable);
SPL_ADD_CLASS(DirectoryIterator);
SPL_ADD_CLASS(DomainException);
SPL_ADD_CLASS(EmptyIterator);
SPL_ADD_CLASS(FilesystemIterator);
SPL_ADD_CLASS(FilterIterator);
SPL_ADD_CLASS(GlobIterator);
SPL_ADD_CLASS(InfiniteIterator);
SPL_ADD_CLASS(InvalidArgumentException);
SPL_ADD_CLASS(IteratorIterator);
SPL_ADD_CLASS(LengthException);
SPL_ADD_CLASS(LimitIterator);
SPL_ADD_CLASS(LogicException);
SPL_ADD_CLASS(MultipleIterator);
SPL_ADD_CLASS(NoRewindIterator);
SPL_ADD_CLASS(OuterIterator);
SPL_ADD_CLASS(OutOfBoundsException);
SPL_ADD_CLASS(OutOfRangeException);
SPL_ADD_CLASS(OverflowException);
SPL_ADD_CLASS(ParentIterator);
SPL_ADD_CLASS(RangeException);
SPL_ADD_CLASS(RecursiveArrayIterator);
SPL_ADD_CLASS(RecursiveCachingIterator);
SPL_ADD_CLASS(RecursiveDirectoryIterator);
SPL_ADD_CLASS(RecursiveFilterIterator);
SPL_ADD_CLASS(RecursiveIterator);
SPL_ADD_CLASS(RecursiveIteratorIterator);
SPL_ADD_CLASS(RecursiveRegexIterator);
SPL_ADD_CLASS(RecursiveTreeIterator);
SPL_ADD_CLASS(RegexIterator);
SPL_ADD_CLASS(RuntimeException);
SPL_ADD_CLASS(SeekableIterator);
SPL_ADD_CLASS(SplDoublyLinkedList);
SPL_ADD_CLASS(SplFileInfo);
SPL_ADD_CLASS(SplFileObject);
SPL_ADD_CLASS(SplFixedArray);
SPL_ADD_CLASS(SplHeap);
SPL_ADD_CLASS(SplMinHeap);
SPL_ADD_CLASS(SplMaxHeap);
SPL_ADD_CLASS(SplObjectStorage);
SPL_ADD_CLASS(SplObserver);
SPL_ADD_CLASS(SplPriorityQueue);
SPL_ADD_CLASS(SplQueue);
SPL_ADD_CLASS(SplStack);
SPL_ADD_CLASS(SplSubject);
SPL_ADD_CLASS(SplTempFileObject);
SPL_ADD_CLASS(UnderflowException);
SPL_ADD_CLASS(UnexpectedValueException);
return ret;
const size_t num_classes = sizeof(spl_classes) / sizeof(spl_classes[0]);
ArrayInit ret(num_classes);
for (size_t i = 0; i < num_classes; ++i) {
ret.set(spl_classes[i], spl_classes[i]);
}
return ret.create();
}
void throw_spl_exception(const char *fmt, ...) {
hphp/runtime/ext/ext_sqlite3.cpp
+7 -4
Ver Arquivo
@@ -249,11 +249,14 @@ bool c_SQLite3::t_exec(CStrRef sql) {
return true;
}
static const StaticString s_versionString("versionString");
static const StaticString s_versionNumber("versionNumber");
Array c_SQLite3::t_version() {
Array ret;
ret.set("versionString", String((char*)sqlite3_libversion(), CopyString));
ret.set("versionNumber", (int64_t)sqlite3_libversion_number());
return ret;
ArrayInit ret(2);
ret.set(s_versionString, String((char*)sqlite3_libversion(), CopyString));
ret.set(s_versionNumber, (int64_t)sqlite3_libversion_number());
return ret.create();
}
int64_t c_SQLite3::t_lastinsertrowid() {
hphp/runtime/ext/ext_string.cpp
+27 -5
Ver Arquivo
@@ -1011,6 +1011,25 @@ Variant f_setlocale(int _argc, int category, CVarRef locale, CArrRef _argv /* =
return false;
}
static const StaticString s_decimal_point("decimal_point");
static const StaticString s_thousands_sep("thousands_sep");
static const StaticString s_int_curr_symbol("int_curr_symbol");
static const StaticString s_currency_symbol("currency_symbol");
static const StaticString s_mon_decimal_point("mon_decimal_point");
static const StaticString s_mon_thousands_sep("mon_thousands_sep");
static const StaticString s_positive_sign("positive_sign");
static const StaticString s_negative_sign("negative_sign");
static const StaticString s_int_frac_digits("int_frac_digits");
static const StaticString s_frac_digits("frac_digits");
static const StaticString s_p_cs_precedes("p_cs_precedes");
static const StaticString s_p_sep_by_space("p_sep_by_space");
static const StaticString s_n_cs_precedes("n_cs_precedes");
static const StaticString s_n_sep_by_space("n_sep_by_space");
static const StaticString s_p_sign_posn("p_sign_posn");
static const StaticString s_n_sign_posn("n_sign_posn");
static const StaticString s_grouping("grouping");
static const StaticString s_mon_grouping("mon_grouping");
Array f_localeconv() {
struct lconv currlocdata;
{
@@ -1020,7 +1039,7 @@ Array f_localeconv() {
}
Array ret;
#define SET_LOCALE_STRING(x) ret.set(#x, String(currlocdata.x, CopyString))
#define SET_LOCALE_STRING(x) ret.set(s_ ## x, String(currlocdata.x, CopyString))
SET_LOCALE_STRING(decimal_point);
SET_LOCALE_STRING(thousands_sep);
SET_LOCALE_STRING(int_curr_symbol);
@@ -1029,7 +1048,7 @@ Array f_localeconv() {
SET_LOCALE_STRING(mon_thousands_sep);
SET_LOCALE_STRING(positive_sign);
SET_LOCALE_STRING(negative_sign);
#define SET_LOCALE_INTEGER(x) ret.set(#x, currlocdata.x)
#define SET_LOCALE_INTEGER(x) ret.set(s_ ## x, currlocdata.x)
SET_LOCALE_INTEGER(int_frac_digits);
SET_LOCALE_INTEGER(frac_digits);
SET_LOCALE_INTEGER(p_cs_precedes);
@@ -1046,14 +1065,14 @@ Array f_localeconv() {
for (int i = 0; i < len; i++) {
grouping.set(i, currlocdata.grouping[i]);
}
ret.set("grouping", grouping);
ret.set(s_grouping, grouping);
/* Grab the monetary grouping data out of the array */
len = strlen(currlocdata.mon_grouping);
for (int i = 0; i < len; i++) {
mon_grouping.set(i, currlocdata.mon_grouping[i]);
}
ret.set("mon_grouping", mon_grouping);
ret.set(s_mon_grouping, mon_grouping);
return ret;
}
@@ -1087,6 +1106,9 @@ static const HtmlBasicEntity basic_entities[] = {
{ 0, NULL, 0, 0 }
};
static const StaticString s_amp("&");
static const StaticString s_ampsemi("&amp;");
Array f_get_html_translation_table(int table /* = 0 */, int quote_style /* = k_ENT_COMPAT */) {
static entity_charset charset = determine_charset(nullptr); // get default one
char ind[2]; ind[1] = 0;
@@ -1130,7 +1152,7 @@ Array f_get_html_translation_table(int table /* = 0 */, int quote_style /* = k_E
ind[0] = (unsigned char)basic_entities[j].charcode;
ret.set(String(ind, 2, CopyString), basic_entities[j].entity);
}
ret.set("&", "&amp;");
ret.set(s_amp, s_ampsemi);
break;
}
hphp/runtime/ext/ext_url.cpp
+12 -3
Ver Arquivo
@@ -195,6 +195,15 @@ Variant f_http_build_query(CVarRef formdata,
///////////////////////////////////////////////////////////////////////////////
static const StaticString s_scheme("scheme");
static const StaticString s_host("host");
static const StaticString s_user("user");
static const StaticString s_pass("pass");
static const StaticString s_path("path");
static const StaticString s_query("query");
static const StaticString s_fragment("fragment");
static const StaticString s_port("port");
#define RETURN_COMPONENT(name) \
if (resource.name != NULL) { \
String ret(resource.name, AttachString); \
@@ -204,7 +213,7 @@ Variant f_http_build_query(CVarRef formdata,
#define SET_COMPONENT(name) \
if (resource.name != NULL) { \
ret.set(#name, String(resource.name, AttachString)); \
ret.set(s_ ## name, String(resource.name, AttachString)); \
resource.name = NULL; \
} \
@@ -245,7 +254,7 @@ Variant f_parse_url(CStrRef url, int component /* = -1 */) {
return uninit_null();
}
Array ret;
ArrayInit ret(8);
SET_COMPONENT(scheme);
SET_COMPONENT(host);
SET_COMPONENT(user);
@@ -256,7 +265,7 @@ Variant f_parse_url(CStrRef url, int component /* = -1 */) {
if (resource.port) {
ret.set("port", (int64_t)resource.port);
}
return ret;
return ret.create();
}
String f_rawurldecode(CStrRef str) {
hphp/runtime/ext/ext_xml.cpp
+12 -9
Ver Arquivo
@@ -362,6 +362,12 @@ static void _xml_add_to_info(XmlParser *parser, char *name) {
parser->curtag++;
}
static const StaticString s_type("type");
static const StaticString s_complete("complete");
static const StaticString s_tag("tag");
static const StaticString s_close("close");
static const StaticString s_level("level");
void _xml_endElementHandler(void *userData, const XML_Char *name) {
XmlParser *parser = (XmlParser *)userData;
char *tag_name;
@@ -379,19 +385,16 @@ void _xml_endElementHandler(void *userData, const XML_Char *name) {
}
if (!parser->data.isNull()) {
Array tag;
if (parser->lastwasopen) {
parser->ctag.set("type","complete");
parser->ctag.set(s_type, s_complete);
} else {
tag = Array::Create();
ArrayInit tag(3);
_xml_add_to_info(parser,((char*)tag_name) + parser->toffset);
tag.set("tag",String(((char*)tag_name) + parser->toffset, CopyString));
tag.set("type","close");
tag.set("level",parser->level);
parser->data.append(tag);
tag.set(s_tag, String(((char*)tag_name) + parser->toffset, CopyString));
tag.set(s_type, s_close);
tag.set(s_level, parser->level);
parser->data.append(tag.create());
}
parser->lastwasopen = 0;
}
hphp/runtime/ext/pdo_mysql.cpp
+19 -10
Ver Arquivo
@@ -1147,6 +1147,16 @@ bool PDOMySqlStatement::paramHook(PDOBoundParam *param,
return true;
}
static const StaticString s_mysql_def("mysql:def");
static const StaticString s_not_null("not_null");
static const StaticString s_primary_key("primary_key");
static const StaticString s_multiple_key("multiple_key");
static const StaticString s_unique_key("unique_key");
static const StaticString s_blob("blob");
static const StaticString s_native_type("native_type");
static const StaticString s_flags("flags");
static const StaticString s_table("table");
bool PDOMySqlStatement::getColumnMeta(int64_t colno, Array &return_value) {
if (!m_result) {
return false;
@@ -1161,30 +1171,29 @@ bool PDOMySqlStatement::getColumnMeta(int64_t colno, Array &return_value) {
const MYSQL_FIELD *F = m_fields + colno;
if (F->def) {
ret.set("mysql:def", String(F->def, CopyString));
ret.set(s_mysql_def, String(F->def, CopyString));
}
if (IS_NOT_NULL(F->flags)) {
flags.append("not_null");
flags.append(s_not_null);
}
if (IS_PRI_KEY(F->flags)) {
flags.append("primary_key");
flags.append(s_primary_key);
}
if (F->flags & MULTIPLE_KEY_FLAG) {
flags.append("multiple_key");
flags.append(s_multiple_key);
}
if (F->flags & UNIQUE_KEY_FLAG) {
flags.append("unique_key");
flags.append(s_unique_key);
}
if (IS_BLOB(F->flags)) {
flags.append("blob");
flags.append(s_blob);
}
const char *str = type_to_name_native(F->type);
if (str) {
ret.set("native_type", str);
ret.set(s_native_type, str);
}
ret.set("flags", flags);
ret.set("table", String(F->table, CopyString));
ret.set(s_flags, flags);
ret.set(s_table, String(F->table, CopyString));
return true;
}
hphp/runtime/ext/pdo_sqlite.cpp
+18 -8
Ver Arquivo
@@ -550,6 +550,16 @@ bool PDOSqliteStatement::paramHook(PDOBoundParam *param,
return true;
}
static const StaticString s_native_type("native_type");
static const StaticString s_null("null");
static const StaticString s_double("double");
static const StaticString s_blob("blob");
static const StaticString s_string("string");
static const StaticString s_integer("integer");
static const StaticString s_sqlite_decl_type("sqlite:decl_type");
static const StaticString s_table("table");
static const StaticString s_flags("flags");
bool PDOSqliteStatement::getColumnMeta(int64_t colno, Array &ret) {
if (!m_stmt) {
return false;
@@ -563,26 +573,26 @@ bool PDOSqliteStatement::getColumnMeta(int64_t colno, Array &ret) {
ret = Array::Create();
Array flags = Array::Create();
switch (sqlite3_column_type(m_stmt, colno)) {
case SQLITE_NULL: ret.set("native_type", "null"); break;
case SQLITE_FLOAT: ret.set("native_type", "double"); break;
case SQLITE_BLOB: flags.append("blob");
case SQLITE_TEXT: ret.set("native_type", "string"); break;
case SQLITE_INTEGER: ret.set("native_type", "integer"); break;
case SQLITE_NULL: ret.set(s_native_type, s_null); break;
case SQLITE_FLOAT: ret.set(s_native_type, s_double); break;
case SQLITE_BLOB: flags.append(s_blob);
case SQLITE_TEXT: ret.set(s_native_type, s_string); break;
case SQLITE_INTEGER: ret.set(s_native_type, s_integer); break;
}
const char *str = sqlite3_column_decltype(m_stmt, colno);
if (str) {
ret.set("sqlite:decl_type", String((char *)str, CopyString));
ret.set(s_sqlite_decl_type, String((char *)str, CopyString));
}
#ifdef SQLITE_ENABLE_COLUMN_METADATA
str = sqlite3_column_table_name(m_stmt, colno);
if (str) {
ret.set("table", String((char *)str, CopyString));
ret.set(s_table, String((char *)str, CopyString));
}
#endif
ret.set("flags", flags);
ret.set(s_flags, flags);
return true;
}