String HHVM_FUNCTION(uniqid, const String& prefix /* = null_string */,
bool more_entropy /* = false */) {
if (!more_entropy) {
Transport *transport = g_context->getTransport();
if (transport) {
transport->incuSleepTime(1);
}
usleep(1);
}
struct timeval tv;
gettimeofday((struct timeval *)&tv, NULL);
int sec = (int)tv.tv_sec;
int usec = (int)(tv.tv_usec % 0x100000);
String uniqid(prefix.size() + 64, ReserveString);
auto ptr = uniqid.mutableData();
// StringData::capacity() returns the buffer size without the null
// terminator. snprintf expects a the buffer capacity including room
// for the null terminator, writes the null termintor, and returns
// the full length not counting the null terminator.
auto capacity = uniqid.capacity() + 1;
int64_t len;
if (more_entropy) {
len = snprintf(ptr, capacity, "%s%08x%05x%.8F",
prefix.c_str(), sec, usec, math_combined_lcg() * 10);
} else {
len = snprintf(ptr, capacity, "%s%08x%05x",
prefix.c_str(), sec, usec);
}
uniqid.setSize(len);
return uniqid;
}
String HHVM_FUNCTION(uniqid, const String& prefix /* = null_string */,
bool more_entropy /* = false */) {
if (!more_entropy) {
Transport *transport = g_context->getTransport();
if (transport) {
transport->incuSleepTime(1);
}
usleep(1);
}
struct timeval tv;
gettimeofday((struct timeval *)&tv, NULL);
int sec = (int)tv.tv_sec;
int usec = (int)(tv.tv_usec % 0x100000);
String uniqid(prefix.size() + 64, ReserveString);
auto ptr = uniqid.bufferSlice().ptr;
auto capacity = uniqid.get()->capacity();
int64_t len;
if (more_entropy) {
len = snprintf(ptr, capacity, "%s%08x%05x%.8F",
prefix.c_str(), sec, usec, math_combined_lcg() * 10);
} else {
len = snprintf(ptr, capacity, "%s%08x%05x",
prefix.c_str(), sec, usec);
}
uniqid.setSize(len);
return uniqid;
}
String f_uniqid(const String& prefix /* = null_string */,
bool more_entropy /* = false */) {
if (!more_entropy) {
Transport *transport = g_context->getTransport();
if (transport) {
transport->incuSleepTime(1);
}
usleep(1);
}
struct timeval tv;
gettimeofday((struct timeval *)&tv, NULL);
int sec = (int)tv.tv_sec;
int usec = (int)(tv.tv_usec % 0x100000);
char uniqid[256];
if (more_entropy) {
snprintf(uniqid, sizeof(uniqid), "%s%08x%05x%.8F",
prefix.c_str(), sec, usec, math_combined_lcg() * 10);
} else {
snprintf(uniqid, sizeof(uniqid), "%s%08x%05x",
prefix.c_str(), sec, usec);
}
return String(uniqid, CopyString);
}
String f_uniqid(CStrRef prefix /* = null_string */,
bool more_entropy /* = false */) {
if (!more_entropy) {
usleep(1);
}
struct timeval tv;
gettimeofday((struct timeval *)&tv, NULL);
int sec = (int)tv.tv_sec;
int usec = (int)(tv.tv_usec % 0x100000);
char uniqid[256];
if (more_entropy) {
snprintf(uniqid, sizeof(uniqid), "%s%08x%05x%.8F",
(const char *)prefix, sec, usec, math_combined_lcg() * 10);
} else {
snprintf(uniqid, sizeof(uniqid), "%s%08x%05x",
(const char *)prefix, sec, usec);
}
return String(uniqid, CopyString);
}
int64_t HHVM_FUNCTION(rand,
int64_t min /* = 0 */,
const Variant& max /* = null_variant */) {
#if defined(__APPLE__) || defined(_MSC_VER)
if (!s_rand_is_seeded) {
#else
if (s_state.state != RandomBuf::RequestInit) {
#endif
randinit(math_generate_seed());
}
int64_t number;
#ifdef __APPLE__
number = random();
#elif defined(_MSC_VER)
number = rand();
#else
int32_t numberIn;
random_r(&s_state.data, &numberIn);
number = numberIn;
#endif
int64_t int_max = max.isNull() ? RAND_MAX : max.toInt64();
if (min != 0 || int_max != RAND_MAX) {
RAND_RANGE(number, min, int_max, RAND_MAX);
}
return number;
}
int64_t HHVM_FUNCTION(mt_getrandmax) { return MT_RAND_MAX;}
void HHVM_FUNCTION(mt_srand,
const Variant& seed /* = null_variant */) {
if (seed.isNull()) {
return math_mt_srand(math_generate_seed());
}
if (seed.isNumeric(true)) {
math_mt_srand(seed.toInt32());
} else {
raise_warning("mt_srand() expects parameter 1 to be long");
}
}
int64_t HHVM_FUNCTION(mt_rand,
int64_t min /* = 0 */,
const Variant& max /* = null_variant */) {
return math_mt_rand(min, max.isNull() ? RAND_MAX : max.toInt64());
}
double HHVM_FUNCTION(lcg_value) { return math_combined_lcg();}
Variant HHVM_FUNCTION(intdiv, int64_t numerator, int64_t divisor) {
if (divisor == 0) {
SystemLib::throwDivisionByZeroErrorObject(Strings::DIVISION_BY_ZERO);
} else if (divisor == -1 &&
numerator == std::numeric_limits<int64_t>::min()) {
SystemLib::throwArithmeticErrorObject(
"Division of PHP_INT_MIN by -1 is not an integer");
}
return numerator/divisor;
}
///////////////////////////////////////////////////////////////////////////////
const StaticString s_PHP_ROUND_HALF_UP("PHP_ROUND_HALF_UP");
const StaticString s_PHP_ROUND_HALF_DOWN("PHP_ROUND_HALF_DOWN");
const StaticString s_PHP_ROUND_HALF_EVEN("PHP_ROUND_HALF_EVEN");
const StaticString s_PHP_ROUND_HALF_ODD("PHP_ROUND_HALF_ODD");
#define ICONST(nm) \
Native::registerConstant<KindOfInt64>(makeStaticString(#nm), k_##nm) \
#define DCONST(nm) \
Native::registerConstant<KindOfDouble>(makeStaticString("M_"#nm), k_M_##nm) \
void StandardExtension::requestInitMath() {
#if !defined(__APPLE__) && !defined(_MSC_VER)
if (s_state.state == RandomBuf::RequestInit) {
s_state.state = RandomBuf::ThreadInit;
}
#endif
}
void StandardExtension::initMath() {
ICONST(PHP_ROUND_HALF_UP);
ICONST(PHP_ROUND_HALF_DOWN);
ICONST(PHP_ROUND_HALF_EVEN);
ICONST(PHP_ROUND_HALF_ODD);
DCONST(PI);
DCONST(1_PI);
DCONST(2_PI);
DCONST(2_SQRTPI);
DCONST(E);
DCONST(EULER);
DCONST(LN10);
DCONST(LN2);
DCONST(LNPI);
DCONST(LOG10E);
DCONST(LOG2E);
DCONST(PI_2);
DCONST(PI_4);
DCONST(SQRT1_2);
DCONST(SQRT2);
DCONST(SQRT3);
DCONST(SQRTPI);
HHVM_FE(min);
HHVM_FE(max);
HHVM_FE(abs);
HHVM_FE(is_finite);
HHVM_FE(is_infinite);
HHVM_FE(is_nan);
HHVM_FE(ceil);
HHVM_FE(floor);
HHVM_FE(round);
HHVM_FE(deg2rad);
HHVM_FE(rad2deg);
HHVM_FE(decbin);
HHVM_FE(dechex);
HHVM_FE(decoct);
HHVM_FE(bindec);
HHVM_FE(hexdec);
HHVM_FE(octdec);
HHVM_FE(base_convert);
HHVM_FE(pow);
HHVM_FE(exp);
HHVM_FE(expm1);
HHVM_FE(log10);
HHVM_FE(log1p);
HHVM_FE(log);
HHVM_FE(cos);
HHVM_FE(cosh);
HHVM_FE(sin);
HHVM_FE(sinh);
HHVM_FE(tan);
HHVM_FE(tanh);
HHVM_FE(acos);
HHVM_FE(acosh);
HHVM_FE(asin);
HHVM_FE(asinh);
HHVM_FE(atan);
HHVM_FE(atanh);
HHVM_FE(atan2);
HHVM_FE(hypot);
HHVM_FE(fmod);
HHVM_FE(sqrt);
HHVM_FE(getrandmax);
HHVM_FE(srand);
HHVM_FE(rand);
HHVM_FE(mt_getrandmax);
HHVM_FE(mt_srand);
HHVM_FE(mt_rand);
HHVM_FE(lcg_value);
HHVM_FE(intdiv);
loadSystemlib("std_math");
}
double f_lcg_value() { return math_combined_lcg();}