From c646a300027d52e7dbec4077d9807a0865478bf8 Mon Sep 17 00:00:00 2001 From: smith Date: Wed, 17 Apr 2013 08:26:05 -0700 Subject: [PATCH] Litstr must die, episode III. Many callsites of Array.set(litstr, ...) --- hphp/runtime/base/execution_context.cpp | 19 +-- hphp/runtime/base/hardware_counter.cpp | 10 +- hphp/runtime/base/time/datetime.cpp | 175 +++++++++++++++--------- hphp/runtime/base/time/timestamp.cpp | 17 ++- hphp/runtime/base/time/timezone.cpp | 17 ++- hphp/runtime/ext/ext_apache.cpp | 29 ++-- hphp/runtime/ext/ext_apc.cpp | 81 ++++++----- hphp/runtime/ext/ext_curl.cpp | 139 ++++++++++++------- hphp/runtime/ext/ext_datetime.cpp | 72 +++++++--- hphp/runtime/ext/ext_debugger.cpp | 26 ++-- hphp/runtime/ext/ext_fb.cpp | 15 +- hphp/runtime/ext/ext_file.cpp | 92 ++++++++----- hphp/runtime/ext/ext_hotprofiler.cpp | 38 +++-- hphp/runtime/ext/ext_iconv.cpp | 26 ++-- hphp/runtime/ext/ext_image.cpp | 110 +++++++++------ hphp/runtime/ext/ext_imagesprite.cpp | 44 +++--- hphp/runtime/ext/ext_intl.cpp | 20 +-- hphp/runtime/ext/ext_ldap.cpp | 17 ++- hphp/runtime/ext/ext_mailparse.cpp | 19 ++- hphp/runtime/ext/ext_mb.cpp | 58 +++++--- hphp/runtime/ext/ext_network.cpp | 126 +++++++++++------ hphp/runtime/ext/ext_openssl.cpp | 62 ++++++--- hphp/runtime/ext/ext_output.cpp | 23 ++-- hphp/runtime/ext/ext_pdo.cpp | 13 +- hphp/runtime/ext/ext_posix.cpp | 78 +++++++---- hphp/runtime/ext/ext_process.cpp | 29 ++-- hphp/runtime/ext/ext_server.cpp | 6 +- hphp/runtime/ext/ext_session.cpp | 22 +-- hphp/runtime/ext/ext_simplexml.cpp | 27 ++-- hphp/runtime/ext/ext_socket.cpp | 47 ++++--- hphp/runtime/ext/ext_spl.cpp | 119 ++++++++-------- hphp/runtime/ext/ext_sqlite3.cpp | 11 +- hphp/runtime/ext/ext_string.cpp | 32 ++++- hphp/runtime/ext/ext_url.cpp | 15 +- hphp/runtime/ext/ext_xml.cpp | 21 +-- hphp/runtime/ext/pdo_mysql.cpp | 29 ++-- hphp/runtime/ext/pdo_sqlite.cpp | 26 ++-- 37 files changed, 1068 insertions(+), 642 deletions(-) diff --git a/hphp/runtime/base/execution_context.cpp b/hphp/runtime/base/execution_context.cpp index 6a11efcc7..d13f18f1d 100644 --- a/hphp/runtime/base/execution_context.cpp +++ b/hphp/runtime/base/execution_context.cpp @@ -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::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) { diff --git a/hphp/runtime/base/hardware_counter.cpp b/hphp/runtime/base/hardware_counter.cpp index e99a7bbf1..9a1973e7f 100644 --- a/hphp/runtime/base/hardware_counter.cpp +++ b/hphp/runtime/base/hardware_counter.cpp @@ -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()); diff --git a/hphp/runtime/base/time/datetime.cpp b/hphp/runtime/base/time/datetime.cpp index 7864f0e5f..b0194f0db 100644 --- a/hphp/runtime/base/time/datetime.cpp +++ b/hphp/runtime/base/time/datetime.cpp @@ -104,11 +104,40 @@ SmartObject 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 DateTime::diff(SmartObject 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; } diff --git a/hphp/runtime/base/time/timestamp.cpp b/hphp/runtime/base/time/timestamp.cpp index b2514b08b..c87dbd073 100644 --- a/hphp/runtime/base/time/timestamp.cpp +++ b/hphp/runtime/base/time/timestamp.cpp @@ -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() { diff --git a/hphp/runtime/base/time/timezone.cpp b/hphp/runtime/base/time/timezone.cpp index 0f36fce8a..7c2dbe84a 100644 --- a/hphp/runtime/base/time/timezone.cpp +++ b/hphp/runtime/base/time/timezone.cpp @@ -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; } diff --git a/hphp/runtime/ext/ext_apache.cpp b/hphp/runtime/ext/ext_apache.cpp index b5a9cc832..8d8e03b08 100644 --- a/hphp/runtime/ext/ext_apache.cpp +++ b/hphp/runtime/ext/ext_apache.cpp @@ -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() { diff --git a/hphp/runtime/ext/ext_apc.cpp b/hphp/runtime/ext/ext_apc.cpp index d7ae78c75..391c21ffd 100644 --- a/hphp/runtime/ext/ext_apc.cpp +++ b/hphp/runtime/ext/ext_apc.cpp @@ -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; diff --git a/hphp/runtime/ext/ext_curl.cpp b/hphp/runtime/ext/ext_curl.cpp index ecc6b4761..21c273586 100644 --- a/hphp/runtime/ext/ext_curl.cpp +++ b/hphp/runtime/ext/ext_curl.cpp @@ -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 &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(); } /////////////////////////////////////////////////////////////////////////////// diff --git a/hphp/runtime/ext/ext_datetime.cpp b/hphp/runtime/ext/ext_datetime.cpp index 5fc31ba11..db9795f1b 100644 --- a/hphp/runtime/ext/ext_datetime.cpp +++ b/hphp/runtime/ext/ext_datetime.cpp @@ -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(); } diff --git a/hphp/runtime/ext/ext_debugger.cpp b/hphp/runtime/ext/ext_debugger.cpp index b50c33964..eb93b32dd 100644 --- a/hphp/runtime/ext/ext_debugger.cpp +++ b/hphp/runtime/ext/ext_debugger.cpp @@ -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() { diff --git a/hphp/runtime/ext/ext_fb.cpp b/hphp/runtime/ext/ext_fb.cpp index caf5d980b..8a15df65a 100644 --- a/hphp/runtime/ext/ext_fb.cpp +++ b/hphp/runtime/ext/ext_fb.cpp @@ -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 */, diff --git a/hphp/runtime/ext/ext_file.cpp b/hphp/runtime/ext/ext_file.cpp index 07bb396d9..5d9fbb43d 100644 --- a/hphp/runtime/ext/ext_file.cpp +++ b/hphp/runtime/ext/ext_file.cpp @@ -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); } diff --git a/hphp/runtime/ext/ext_hotprofiler.cpp b/hphp/runtime/ext/ext_hotprofiler.cpp index d21869785..5b1429c77 100644 --- a/hphp/runtime/ext/ext_hotprofiler.cpp +++ b/hphp/runtime/ext/ext_hotprofiler.cpp @@ -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 @@ -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 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; diff --git a/hphp/runtime/ext/ext_iconv.cpp b/hphp/runtime/ext/ext_iconv.cpp index 6e874b3d4..9b8743b6c 100644 --- a/hphp/runtime/ext/ext_iconv.cpp +++ b/hphp/runtime/ext/ext_iconv.cpp @@ -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; diff --git a/hphp/runtime/ext/ext_image.cpp b/hphp/runtime/ext/ext_image.cpp index e8a487b38..b1ce3b62e 100644 --- a/hphp/runtime/ext/ext_image.cpp +++ b/hphp/runtime/ext/ext_image.cpp @@ -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()->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, diff --git a/hphp/runtime/ext/ext_imagesprite.cpp b/hphp/runtime/ext/ext_imagesprite.cpp index c0c19bf25..fa6f21c1f 100644 --- a/hphp/runtime/ext/ext_imagesprite.cpp +++ b/hphp/runtime/ext/ext_imagesprite.cpp @@ -611,6 +611,12 @@ Object c_ImageSprite::t_loadimages(bool block /* = false */) { std::vector, \ 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); diff --git a/hphp/runtime/ext/ext_intl.cpp b/hphp/runtime/ext/ext_intl.cpp index 7bdd76d06..07b713086 100644 --- a/hphp/runtime/ext/ext_intl.cpp +++ b/hphp/runtime/ext/ext_intl.cpp @@ -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 diff --git a/hphp/runtime/ext/ext_ldap.cpp b/hphp/runtime/ext/ext_ldap.cpp index d95fd1803..9f66d7cc1 100644 --- a/hphp/runtime/ext/ext_ldap.cpp +++ b/hphp/runtime/ext/ext_ldap.cpp @@ -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; } diff --git a/hphp/runtime/ext/ext_mailparse.cpp b/hphp/runtime/ext/ext_mailparse.cpp index f967ba081..79083142f 100644 --- a/hphp/runtime/ext/ext_mailparse.cpp +++ b/hphp/runtime/ext/ext_mailparse.cpp @@ -195,6 +195,10 @@ Array f_mailparse_msg_get_structure(CObjRef mimemail) { return mimemail.getTyped()->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(); 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 */ diff --git a/hphp/runtime/ext/ext_mb.cpp b/hphp/runtime/ext/ext_mb.cpp index 70d1d4bb7..e8d16433d 100644 --- a/hphp/runtime/ext/ext_mb.cpp +++ b/hphp/runtime/ext/ext_mb.cpp @@ -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; } diff --git a/hphp/runtime/ext/ext_network.cpp b/hphp/runtime/ext/ext_network.cpp index 35c83528e..0281be395 100644 --- a/hphp/runtime/ext/ext_network.cpp +++ b/hphp/runtime/ext/ext_network.cpp @@ -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; } diff --git a/hphp/runtime/ext/ext_openssl.cpp b/hphp/runtime/ext/ext_openssl.cpp index f4fb3cfeb..8764dfb31 100644 --- a/hphp/runtime/ext/ext_openssl.cpp +++ b/hphp/runtime/ext/ext_openssl.cpp @@ -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()->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; diff --git a/hphp/runtime/ext/ext_output.cpp b/hphp/runtime/ext/ext_output.cpp index 932437eae..b21dd69e8 100644 --- a/hphp/runtime/ext/ext_output.cpp +++ b/hphp/runtime/ext/ext_output.cpp @@ -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 */) { diff --git a/hphp/runtime/ext/ext_pdo.cpp b/hphp/runtime/ext/ext_pdo.cpp index ea89f5593..b685c0a2b 100644 --- a/hphp/runtime/ext/ext_pdo.cpp +++ b/hphp/runtime/ext/ext_pdo.cpp @@ -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()) { diff --git a/hphp/runtime/ext/ext_posix.cpp b/hphp/runtime/ext/ext_posix.cpp index 91e14b7eb..27ad7fc52 100644 --- a/hphp/runtime/ext/ext_posix.cpp +++ b/hphp/runtime/ext/ext_posix.cpp @@ -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; } diff --git a/hphp/runtime/ext/ext_process.cpp b/hphp/runtime/ext/ext_process.cpp index ef49c8152..8bb8788ce 100644 --- a/hphp/runtime/ext/ext_process.cpp +++ b/hphp/runtime/ext/ext_process.cpp @@ -831,6 +831,15 @@ int64_t f_proc_close(CObjRef process) { return process.getTyped()->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(); @@ -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) { diff --git a/hphp/runtime/ext/ext_server.cpp b/hphp/runtime/ext/ext_server.cpp index 535e877c6..5f777f4e9 100644 --- a/hphp/runtime/ext/ext_server.cpp +++ b/hphp/runtime/ext/ext_server.cpp @@ -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); } } diff --git a/hphp/runtime/ext/ext_session.cpp b/hphp/runtime/ext/ext_session.cpp index de0ee90b6..e486c395b 100644 --- a/hphp/runtime/ext/ext_session.cpp +++ b/hphp/runtime/ext/ext_session.cpp @@ -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 */) { diff --git a/hphp/runtime/ext/ext_simplexml.cpp b/hphp/runtime/ext/ext_simplexml.cpp index 53c1e359c..114272ab9 100644 --- a/hphp/runtime/ext/ext_simplexml.cpp +++ b/hphp/runtime/ext/ext_simplexml.cpp @@ -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; } diff --git a/hphp/runtime/ext/ext_socket.cpp b/hphp/runtime/ext/ext_socket.cpp index 519266da8..9aa22f9ae 100644 --- a/hphp/runtime/ext/ext_socket.cpp +++ b/hphp/runtime/ext/ext_socket.cpp @@ -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(); 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(); @@ -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); } diff --git a/hphp/runtime/ext/ext_spl.cpp b/hphp/runtime/ext/ext_spl.cpp index d80544787..26141ba22 100644 --- a/hphp/runtime/ext/ext_spl.cpp +++ b/hphp/runtime/ext/ext_spl.cpp @@ -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, ...) { diff --git a/hphp/runtime/ext/ext_sqlite3.cpp b/hphp/runtime/ext/ext_sqlite3.cpp index 172c03264..0539358dd 100644 --- a/hphp/runtime/ext/ext_sqlite3.cpp +++ b/hphp/runtime/ext/ext_sqlite3.cpp @@ -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() { diff --git a/hphp/runtime/ext/ext_string.cpp b/hphp/runtime/ext/ext_string.cpp index c64f939ee..11378e6a0 100644 --- a/hphp/runtime/ext/ext_string.cpp +++ b/hphp/runtime/ext/ext_string.cpp @@ -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("&"); + 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("&", "&"); + ret.set(s_amp, s_ampsemi); break; } diff --git a/hphp/runtime/ext/ext_url.cpp b/hphp/runtime/ext/ext_url.cpp index dd9266e59..28de8dd45 100644 --- a/hphp/runtime/ext/ext_url.cpp +++ b/hphp/runtime/ext/ext_url.cpp @@ -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) { diff --git a/hphp/runtime/ext/ext_xml.cpp b/hphp/runtime/ext/ext_xml.cpp index 94f5a6370..ae3bbdc7d 100644 --- a/hphp/runtime/ext/ext_xml.cpp +++ b/hphp/runtime/ext/ext_xml.cpp @@ -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; } diff --git a/hphp/runtime/ext/pdo_mysql.cpp b/hphp/runtime/ext/pdo_mysql.cpp index 29384a47e..0e670494d 100644 --- a/hphp/runtime/ext/pdo_mysql.cpp +++ b/hphp/runtime/ext/pdo_mysql.cpp @@ -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; } diff --git a/hphp/runtime/ext/pdo_sqlite.cpp b/hphp/runtime/ext/pdo_sqlite.cpp index a4898f57f..28fea5777 100644 --- a/hphp/runtime/ext/pdo_sqlite.cpp +++ b/hphp/runtime/ext/pdo_sqlite.cpp @@ -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; }