static PHP_FUNCTION(global_name) {
char *name = NULL;
int name_len = 0;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s!", &name, &name_len) == FAILURE) {
return;
}
if (GLOBAL_G(name)) {
if (name) {
/* GLOBAL_G(name) is about to be overwritten,
* so we can give its current value away
*/
RETVAL_STRINGL(GLOBAL_G(name), GLOBAL_G(name_len), 0);
} else {
/* Read-only operation, so we need to make a new copy */
RETVAL_STRINGL(GLOBAL_G(name), GLOBAL_G(name_len), 1);
}
}
if (name) {
GLOBAL_G(name) = estrndup(name, name_len);
GLOBAL_G(name_len) = name_len;
}
}
/* {{{ Qconf::getHostNative( .. )
*/
static PHP_METHOD(Qconf, getHostNative)
{
char *path, *idc;
size_t path_len, idc_len;
int i;
long get_flags = QCONF_WAIT;
int ret = 0;
string_vector_t nodes;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|sl", &path, &path_len, &idc, &idc_len, &get_flags) == FAILURE)
{
RETURN_NULL();
}
ret = init_string_vector(&nodes);
if (QCONF_OK != ret)
{
RETVAL_NULL();
}
if (QCONF_NOWAIT == get_flags)
{
ret = qconf_aget_batch_keys_native(path, &nodes, idc);
}
else
{
ret = qconf_get_batch_keys_native(path, &nodes, idc);
}
if (QCONF_OK == ret)
{
if (nodes.count == 0)
{
RETVAL_STRINGL("", 0, 1);
}
else
{
unsigned int r = rand() % nodes.count;
size_t node_len = strlen(nodes.data[r]);
RETVAL_STRINGL(nodes.data[r], node_len, 1);
}
destroy_string_vector(&nodes);
}
else
{
RETVAL_NULL();
}
return;
}
/* {{{ proto string SolrUtils::queryPhrase(string unescaped)
Prepares a phrase from an unescaped lucene string. */
PHP_METHOD(SolrUtils, queryPhrase)
{
solr_char_t *unescaped = NULL;
solr_string_t sbuilder;
long int unescaped_length = 0;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &unescaped, &unescaped_length) == FAILURE) {
RETURN_FALSE;
}
if (!unescaped_length) {
RETURN_NULL();
}
memset(&sbuilder, 0, sizeof(solr_string_t));
solr_string_appendc(&sbuilder, '"');
solr_escape_query_chars(&sbuilder, unescaped, unescaped_length);
solr_string_appendc(&sbuilder, '"');
RETVAL_STRINGL(sbuilder.str, sbuilder.len, 1);
solr_string_free(&sbuilder);
}
/* {{{ proto string MarkdownDocument::transformFragment(string $markdown_fragment [, int $flags = 0 ]) */
PHP_METHOD(markdowndoc, transformFragment)
{
char *markdown;
int markdown_len;
long flags = 0;
char *out = NULL;
int out_len;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|l",
&markdown, &markdown_len, &flags) == FAILURE) {
RETURN_FALSE;
}
if (markdown_len == 0) {
RETURN_EMPTY_STRING();
}
out_len = mkd_line(markdown, markdown_len, &out, (mkd_flag_t) flags);
if (out_len < 0) {
zend_throw_exception(spl_ce_RuntimeException,
"Error parsing the fragment", 0 TSRMLS_CC);
RETVAL_FALSE;
} else {
RETVAL_STRINGL(out, out_len, 0);
}
if (Z_TYPE_P(return_value) == IS_BOOL && out != NULL) {
efree(out);
}
}
U_CFUNC PHP_FUNCTION(intltz_get_id)
{
TIMEZONE_METHOD_INIT_VARS;
if (zend_parse_method_parameters(ZEND_NUM_ARGS(), getThis(), "O",
&object, TimeZone_ce_ptr) == FAILURE) {
intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
"intltz_get_id: bad arguments", 0);
RETURN_FALSE;
}
TIMEZONE_METHOD_FETCH_OBJECT;
UnicodeString id_us;
to->utimezone->getID(id_us);
char *id = NULL;
int id_len = 0;
intl_convert_utf16_to_utf8(&id, &id_len,
id_us.getBuffer(), id_us.length(), TIMEZONE_ERROR_CODE_P(to));
INTL_METHOD_CHECK_STATUS(to, "intltz_get_id: Could not convert id to UTF-8");
RETVAL_STRINGL(id, id_len);
//???
efree(id);
}
U_CFUNC PHP_FUNCTION(intltz_get_equivalent_id)
{
char *str_id;
size_t str_id_len;
zend_long index;
intl_error_reset(NULL);
if (zend_parse_parameters(ZEND_NUM_ARGS(), "sl",
&str_id, &str_id_len, &index) == FAILURE ||
index < (zend_long)INT32_MIN || index > (zend_long)INT32_MAX) {
intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
"intltz_get_equivalent_id: bad arguments", 0);
RETURN_FALSE;
}
UErrorCode status = UErrorCode();
UnicodeString id;
if (intl_stringFromChar(id, str_id, str_id_len, &status) == FAILURE) {
intl_error_set(NULL, status,
"intltz_get_equivalent_id: could not convert time zone id to UTF-16", 0);
RETURN_FALSE;
}
const UnicodeString result = TimeZone::getEquivalentID(id, (int32_t)index);
char *str;
int str_len;
intl_convert_utf16_to_utf8(&str, &str_len, result.getBuffer(), result.length(), &status);
INTL_CHECK_STATUS(status, "intltz_get_equivalent_id: "
"could not convert resulting time zone id to UTF-16");
RETVAL_STRINGL(str, str_len);
//????
efree(str);
}
U_CFUNC PHP_FUNCTION(rbbi_get_rules)
{
BREAKITER_METHOD_INIT_VARS;
object = getThis();
if (zend_parse_parameters_none() == FAILURE) {
intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
"rbbi_get_rules: bad arguments", 0);
RETURN_FALSE;
}
BREAKITER_METHOD_FETCH_OBJECT;
char *str;
int str_len;
const UnicodeString rules = fetch_rbbi(bio)->getRules();
if (intl_charFromString(rules, &str, &str_len, BREAKITER_ERROR_CODE_P(bio)) == FAILURE)
{
intl_errors_set(BREAKITER_ERROR_P(bio), BREAKITER_ERROR_CODE(bio),
"rbbi_hash_code: Error converting result to UTF-8 string",
0);
RETURN_FALSE;
}
RETVAL_STRINGL(str, str_len);
//???
efree(str);
}
/**
* Gets last dispatched controller name
*
* @return string
*/
PHP_METHOD(Phalcon_Mvc_Dispatcher, getControllerName){
zval *is_exact;
int i_exact;
phalcon_read_property_this(&is_exact, getThis(), SL("_isExactControllerName"), PH_NOISY TSRMLS_CC);
i_exact = zend_is_true(is_exact);
zval_ptr_dtor(&is_exact);
if (!i_exact) {
RETURN_MEMBER(this_ptr, "_handlerName");
}
phalcon_return_property_quick(return_value, getThis(), SL("_handlerName"), zend_inline_hash_func(SS("_handlerName")) TSRMLS_CC);
if (likely(Z_TYPE_P(return_value) == IS_STRING) && Z_STRLEN_P(return_value) > 1) {
char *c = Z_STRVAL_P(return_value);
int len = Z_STRLEN_P(return_value);
memmove(c, c+1, len-1);
c[len-1] = 0;
c = erealloc(c, len);
if (likely(c != NULL)) {
RETVAL_STRINGL(c, len-1, 0);
}
}
}
static void php_intl_idn_to(INTERNAL_FUNCTION_PARAMETERS,
const char *domain, int32_t domain_len, uint32_t option, int mode)
{
UChar* ustring = NULL;
int ustring_len = 0;
UErrorCode status;
char *converted_utf8;
size_t converted_utf8_len;
UChar converted[MAXPATHLEN];
int32_t converted_ret_len;
/* convert the string to UTF-16. */
status = U_ZERO_ERROR;
intl_convert_utf8_to_utf16(&ustring, &ustring_len, domain, domain_len, &status);
if (U_FAILURE(status)) {
intl_error_set_code(NULL, status);
/* Set error messages. */
intl_error_set_custom_msg( NULL, "Error converting input string to UTF-16", 0 );
if (ustring) {
efree(ustring);
}
RETURN_FALSE;
} else {
UParseError parse_error;
status = U_ZERO_ERROR;
if (mode == INTL_IDN_TO_ASCII) {
converted_ret_len = uidna_IDNToASCII(ustring, ustring_len, converted, MAXPATHLEN, (int32_t)option, &parse_error, &status);
} else {
converted_ret_len = uidna_IDNToUnicode(ustring, ustring_len, converted, MAXPATHLEN, (int32_t)option, &parse_error, &status);
}
efree(ustring);
if (U_FAILURE(status)) {
intl_error_set( NULL, status, "idn_to_ascii: cannot convert to ASCII", 0 );
RETURN_FALSE;
}
status = U_ZERO_ERROR;
intl_convert_utf16_to_utf8(&converted_utf8, &converted_utf8_len, converted, converted_ret_len, &status);
if (U_FAILURE(status)) {
/* Set global error code. */
intl_error_set_code(NULL, status);
/* Set error messages. */
intl_error_set_custom_msg( NULL, "Error converting output string to UTF-8", 0 );
efree(converted_utf8);
RETURN_FALSE;
}
}
/* return the allocated string, not a duplicate */
RETVAL_STRINGL(converted_utf8, converted_utf8_len);
//????
efree(converted_utf8);
}
static ZEND_FUNCTION(lz4_compress)
{
zval *data;
char *output;
int output_len, data_len;
zend_bool high = 0;
char *extra = NULL;
int extra_len = -1;
int offset = 0;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC,
"z|bs", &data, &high,
&extra, &extra_len) == FAILURE) {
RETURN_FALSE;
}
if (Z_TYPE_P(data) != IS_STRING) {
zend_error(E_WARNING,
"lz4_compress : expects parameter to be string.");
RETURN_FALSE;
}
if (extra && extra_len > 0) {
offset = extra_len;
} else {
offset = sizeof(int);
}
data_len = Z_STRLEN_P(data);
output = (char *)emalloc(LZ4_compressBound(data_len) + offset);
if (!output) {
zend_error(E_WARNING, "lz4_compress : memory error");
RETURN_FALSE;
}
if (extra && extra_len > 0) {
memcpy(output, extra, offset);
} else {
/* Set the data length */
memcpy(output, &data_len, offset);
}
if (high) {
output_len = LZ4_compressHC(Z_STRVAL_P(data), output + offset, data_len);
} else {
output_len = LZ4_compress(Z_STRVAL_P(data), output + offset, data_len);
}
if (output_len <= 0) {
RETVAL_FALSE;
} else {
RETVAL_STRINGL(output, output_len + offset, 1);
}
efree(output);
}
static ZEND_FUNCTION(snappy_uncompress)
{
zval *data;
char *output = NULL;
size_t output_len;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC,
"z", &data) == FAILURE) {
RETURN_FALSE;
}
if (Z_TYPE_P(data) != IS_STRING) {
zend_error(E_WARNING,
"snappy_uncompress : expects parameter to be string.");
RETURN_FALSE;
}
if (snappy_uncompressed_length(Z_STRVAL_P(data), Z_STRLEN_P(data),
&output_len) != SNAPPY_OK) {
zend_error(E_WARNING, "snappy_uncompress : output length error");
RETURN_FALSE;
}
output = (char *)emalloc(output_len);
if (!output) {
zend_error(E_WARNING, "snappy_uncompress : memory error");
RETURN_FALSE;
}
if (snappy_uncompress(Z_STRVAL_P(data), Z_STRLEN_P(data),
output, &output_len) == SNAPPY_OK) {
#if ZEND_MODULE_API_NO >= 20141001
RETVAL_STRINGL(output, output_len);
#else
RETVAL_STRINGL(output, output_len, 1);
#endif
} else {
zend_error(E_WARNING, "snappy_uncompress : data error");
RETVAL_FALSE;
}
efree(output);
}
/* {{{ php_converter_default_callback */
static void php_converter_default_callback(zval *return_value, zval *zobj, zend_long reason, zval *error) {
ZVAL_DEREF(error);
zval_dtor(error);
ZVAL_LONG(error, U_ZERO_ERROR);
/* Basic functionality so children can call parent::toUCallback() */
switch (reason) {
case UCNV_UNASSIGNED:
case UCNV_ILLEGAL:
case UCNV_IRREGULAR:
{
php_converter_object *objval = (php_converter_object*)CONV_GET(zobj);
char chars[127];
int8_t chars_len = sizeof(chars);
UErrorCode uerror = U_ZERO_ERROR;
if(!objval->src) {
php_converter_throw_failure(objval, U_INVALID_STATE_ERROR, "Source Converter has not been initialized yet");
chars[0] = 0x1A;
chars[1] = 0;
chars_len = 1;
ZVAL_LONG(error, U_INVALID_STATE_ERROR);
RETVAL_STRINGL(chars, chars_len);
return;
}
/* Yes, this is fairly wasteful at first glance,
* but considering that the alternative is to store
* what's sent into setSubstChars() and the fact
* that this is an extremely unlikely codepath
* I'd rather take the CPU hit here, than waste time
* storing a value I'm unlikely to use.
*/
ucnv_getSubstChars(objval->src, chars, &chars_len, &uerror);
if (U_FAILURE(uerror)) {
THROW_UFAILURE(objval, "ucnv_getSubstChars", uerror);
chars[0] = 0x1A;
chars[1] = 0;
chars_len = 1;
ZVAL_LONG(error, uerror);
}
RETVAL_STRINGL(chars, chars_len);
}
}
}
static ZEND_FUNCTION(lz4_uncompress)
{
zval *data;
int output_len, data_size;
char *output;
long max_size = -1, offset = 0;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC,
"z|ll", &data, &max_size, &offset) == FAILURE) {
RETURN_FALSE;
}
if (Z_TYPE_P(data) != IS_STRING) {
zend_error(E_WARNING,
"lz4_uncompress : expects parameter to be string.");
RETURN_FALSE;
}
if (max_size > 0) {
data_size = max_size;
if (!offset) {
offset = sizeof(int);
}
} else {
/* Get data length */
offset = sizeof(int);
memcpy(&data_size, Z_STRVAL_P(data), offset);
}
if (data_size < 0) {
zend_error(E_WARNING, "lz4_uncompress : allocate size error");
RETURN_FALSE;
}
output = (char *)emalloc(data_size + 1);
if (!output) {
zend_error(E_WARNING, "lz4_uncompress : memory error");
RETURN_FALSE;
}
output_len = LZ4_decompress_safe(Z_STRVAL_P(data) + offset,
output,
Z_STRLEN_P(data) - offset,
data_size);
if (output_len <= 0) {
zend_error(E_WARNING, "lz4_uncompress : data error");
RETVAL_FALSE;
} else {
RETVAL_STRINGL(output, output_len, 1);
}
efree(output);
}
/* {{{ proto string tidy_get_output()
Return a string representing the parsed tidy markup */
static PHP_FUNCTION(tidy_get_output)
{
TidyBuffer output;
TIDY_FETCH_OBJECT;
tidyBufInit(&output);
tidySaveBuffer(obj->ptdoc->doc, &output);
FIX_BUFFER(&output);
RETVAL_STRINGL((char *) output.bp, output.size ? output.size-1 : 0);
tidyBufFree(&output);
}
/* {{{ Qconf::getConf( .. )
*/
static PHP_METHOD(Qconf, getConf)
{
char *path, *idc;
size_t path_len, idc_len;
long get_flags = QCONF_WAIT;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|sl", &path, &path_len, &idc, &idc_len, &get_flags) == FAILURE)
{
RETURN_NULL();
}
char buf[QCONF_CONF_BUF_MAX_LEN];
int buf_len = 0;
int ret = 0;
if (QCONF_NOWAIT == get_flags)
{
ret = qconf_aget_conf(path, buf, sizeof(buf), idc);
}
else
{
ret = qconf_get_conf(path, buf, sizeof(buf), idc);
}
buf_len = strlen(buf);
if (QCONF_OK == ret)
{
#if PHP_VERSION_ID >= 70000
RETVAL_STRINGL(buf, buf_len);
#else
RETVAL_STRINGL(buf, buf_len, 1);
#endif
}
else
{
RETURN_NULL();
}
return;
}
/* {{{ proto string Timestamp::__toString()
Returns [increment:timestamp] */
PHP_METHOD(Timestamp, __toString)
{
php_phongo_timestamp_t *intern;
char *retval;
int retval_len;
intern = (php_phongo_timestamp_t *)zend_object_store_get_object(getThis() TSRMLS_CC);
if (zend_parse_parameters_none() == FAILURE) {
return;
}
retval_len = spprintf(&retval, 0, "[%d:%d]", intern->increment, intern->timestamp);
RETVAL_STRINGL(retval, retval_len, 0);
}
/* {{{ proto string UTCDatetime::__toString()
Returns the string representation of the UTCDatetime */
PHP_METHOD(UTCDatetime, __toString)
{
php_phongo_utcdatetime_t *intern;
char *tmp;
int tmp_len;
intern = (php_phongo_utcdatetime_t *)zend_object_store_get_object(getThis() TSRMLS_CC);
if (zend_parse_parameters_none() == FAILURE) {
return;
}
tmp_len = spprintf(&tmp, 0, "%lld", intern->milliseconds);
RETVAL_STRINGL(tmp, tmp_len, 0);
}
U_CFUNC PHP_FUNCTION(intltz_get_display_name)
{
zend_bool daylight = 0;
zend_long display_type = TimeZone::LONG;
const char *locale_str = NULL;
size_t dummy = 0;
TIMEZONE_METHOD_INIT_VARS;
if (zend_parse_method_parameters(ZEND_NUM_ARGS(), getThis(),
"O|bls!", &object, TimeZone_ce_ptr, &daylight, &display_type,
&locale_str, &dummy) == FAILURE) {
intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
"intltz_get_display_name: bad arguments", 0);
RETURN_FALSE;
}
bool found = false;
for (int i = 0; !found && i < sizeof(display_types)/sizeof(*display_types); i++) {
if (display_types[i] == display_type)
found = true;
}
if (!found) {
intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
"intltz_get_display_name: wrong display type", 0);
RETURN_FALSE;
}
if (!locale_str) {
locale_str = intl_locale_get_default();
}
TIMEZONE_METHOD_FETCH_OBJECT;
UnicodeString result;
to->utimezone->getDisplayName((UBool)daylight, (TimeZone::EDisplayType)display_type,
Locale::createFromName(locale_str), result);
char *str;
int str_len;
intl_convert_utf16_to_utf8(&str, &str_len, result.getBuffer(), result.length(), TIMEZONE_ERROR_CODE_P(to));
INTL_METHOD_CHECK_STATUS(to, "intltz_get_display_name: "
"could not convert resulting time zone id to UTF-16");
RETVAL_STRINGL(str, str_len);
//????
efree(str);
}
static ZEND_FUNCTION(horde_lz4_uncompress)
{
zval *data;
int data_len = 0;
int header_offset = (sizeof(headerid) + sizeof(int));
int output_len;
char *output, *p;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC,
"z", &data) == FAILURE) {
RETURN_FALSE;
}
if (Z_TYPE_P(data) != IS_STRING) {
zend_error(E_WARNING,
"horde_lz4_uncompress: compressed data must be a string.");
RETURN_FALSE;
}
p = Z_STRVAL_P(data);
/* Check for header information. */
if (p[0] == headerid) {
memcpy(&data_len, p + sizeof(headerid), sizeof(int));
}
/* Header information not found. */
if (data_len <= 0) {
RETURN_FALSE;
}
output = (char *)emalloc(data_len + 1);
if (!output) {
RETURN_FALSE;
}
output_len = LZ4_uncompress(p + header_offset, output, data_len);
if (output_len <= 0) {
RETVAL_FALSE;
} else {
RETVAL_STRINGL(output, data_len, 1);
}
efree(output);
}
static ZEND_FUNCTION(horde_lz4_compress)
{
zval *data;
char *output;
int header_offset = (sizeof(headerid) + sizeof(int));
int output_len, data_len;
zend_bool high = 0;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC,
"z|b", &data, &high) == FAILURE) {
RETURN_FALSE;
}
if (Z_TYPE_P(data) != IS_STRING) {
zend_error(E_WARNING,
"horde_lz4_compress: uncompressed data must be a string.");
RETURN_FALSE;
}
data_len = Z_STRLEN_P(data);
output = (char *)emalloc(LZ4_compressBound(data_len) + header_offset);
if (!output) {
zend_error(E_WARNING, "horde_lz4_compress: memory error");
RETURN_FALSE;
}
*output = headerid;
memcpy(output + sizeof(headerid), &data_len, sizeof(int));
if (high) {
output_len = LZ4_compressHC(Z_STRVAL_P(data), output + header_offset, data_len);
} else {
output_len = LZ4_compress(Z_STRVAL_P(data), output + header_offset, data_len);
}
if (output_len <= 0) {
RETVAL_FALSE;
} else {
RETVAL_STRINGL(output, output_len + header_offset, 1);
}
efree(output);
}
/* {{{ proto array GmagickPixel::getColor([boolean as_array = false, normalise_array = false])
Returns the color of the pixel
*/
PHP_METHOD(gmagickpixel, getcolor)
{
php_gmagickpixel_object *internp;
zend_bool as_array = 0, normalise_array = 0;
/* Parse parameters given to function */
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|bb", &as_array, &normalise_array) == FAILURE) {
return;
}
internp = Z_GMAGICKPIXEL_OBJ_P(getThis());
if (!as_array) {
char *buffer, *color_string;
int len;
color_string = PixelGetColorAsString(internp->pixel_wand);
len = spprintf(&buffer, 50, "rgb(%s)", color_string);
GMAGICK_FREE_MEMORY(char *, color_string);
RETVAL_STRINGL(buffer, len);
efree(buffer);
return;
} else {
array_init(return_value);
if (normalise_array == 1) {
add_assoc_double(return_value, "r", PixelGetRed(internp->pixel_wand));
add_assoc_double(return_value, "g", PixelGetGreen(internp->pixel_wand));
add_assoc_double(return_value, "b", PixelGetBlue(internp->pixel_wand));
} else {
double red, green, blue;
red = PixelGetRed(internp->pixel_wand ) * 255;
green = PixelGetGreen(internp->pixel_wand ) * 255;
blue = PixelGetBlue(internp->pixel_wand ) * 255;
add_assoc_long(return_value, "r", (int)(red > 0.0 ? red + 0.5 : red - 0.5));
add_assoc_long(return_value, "g", (int)(green > 0.0 ? green + 0.5 : green - 0.5));
add_assoc_long(return_value, "b", (int)(blue > 0.0 ? blue + 0.5 : blue - 0.5));
}
return;
}
}
U_CFUNC PHP_FUNCTION(intltz_get_canonical_id)
{
char *str_id;
size_t str_id_len;
zval *is_systemid = NULL;
intl_error_reset(NULL);
if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|z",
&str_id, &str_id_len, &is_systemid) == FAILURE) {
intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
"intltz_get_canonical_id: bad arguments", 0);
RETURN_FALSE;
}
UErrorCode status = UErrorCode();
UnicodeString id;
if (intl_stringFromChar(id, str_id, str_id_len, &status) == FAILURE) {
intl_error_set(NULL, status,
"intltz_get_canonical_id: could not convert time zone id to UTF-16", 0);
RETURN_FALSE;
}
UnicodeString result;
UBool isSystemID;
TimeZone::getCanonicalID(id, result, isSystemID, status);
INTL_CHECK_STATUS(status, "intltz_get_canonical_id: error obtaining canonical ID");
char *str;
int str_len;
intl_convert_utf16_to_utf8(&str, &str_len, result.getBuffer(), result.length(), &status);
INTL_CHECK_STATUS(status,
"intltz_get_canonical_id: could not convert time zone id to UTF-16");
RETVAL_STRINGL(str, str_len);
//????
efree(str);
if (is_systemid) { /* by-ref argument passed */
ZVAL_DEREF(is_systemid);
zval_dtor(is_systemid);
ZVAL_BOOL(is_systemid, isSystemID);
}
}
/* {{{ proto bool SessionHandler::read(string id)
Wraps the old read handler */
PHP_METHOD(SessionHandler, read)
{
char *key, *val;
int key_len, val_len;
PS_SANITY_CHECK_IS_OPEN;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &key, &key_len) == FAILURE) {
return;
}
if (PS(default_mod)->s_read(&PS(mod_data), key, &val, &val_len TSRMLS_CC) == FAILURE) {
RETVAL_FALSE;
return;
}
RETVAL_STRINGL(val, val_len, 1);
efree(val);
return;
}
/* {{{ proto string datefmt_get_timezone_id(IntlDateFormatter $mf)
* Get formatter timezone_id.
*/
U_CFUNC PHP_FUNCTION(datefmt_get_timezone_id)
{
char *str;
size_t str_len;
DATE_FORMAT_METHOD_INIT_VARS;
if (zend_parse_method_parameters(ZEND_NUM_ARGS(), getThis(), "O",
&object, IntlDateFormatter_ce_ptr ) == FAILURE) {
intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR, "datefmt_get_timezone_"
"id: unable to parse input params", 0);
RETURN_FALSE;
}
DATE_FORMAT_METHOD_FETCH_OBJECT;
UnicodeString res = UnicodeString();
fetch_datefmt(dfo)->getTimeZone().getID(res);
intl_charFromString(res, &str, &str_len, &INTL_DATA_ERROR_CODE(dfo));
INTL_METHOD_CHECK_STATUS(dfo, "Could not convert time zone id to UTF-8");
RETVAL_STRINGL(str, str_len);
//????
efree(str);
}
/**
* Gets HTTP raw request body
*
* @return string
*/
PHP_METHOD(Phalcon_Http_Request, getRawBody){
zval *raw;
if (SG(request_info).raw_post_data) {
RETURN_STRINGL(SG(request_info).raw_post_data, SG(request_info).raw_post_data_length, 1);
}
phalcon_read_property_this(&raw, getThis(), SL("_rawBody"), PH_NOISY TSRMLS_CC);
if (Z_TYPE_P(raw) == IS_STRING) {
RETURN_ZVAL(raw, 1, 1);
}
else if (sapi_module.read_post) {
int read_bytes;
char *buf = emalloc(8192);
smart_str raw_data = { NULL, 0, 0 };
while ((read_bytes = sapi_module.read_post(buf, 8192 TSRMLS_CC)) > 0) {
smart_str_appendl(&raw_data, buf, read_bytes);
SG(read_post_bytes) += read_bytes;
}
efree(buf);
if (raw_data.c) {
smart_str_0(&raw_data);
RETVAL_STRINGL(raw_data.c, raw_data.len, 0);
}
else {
RETVAL_EMPTY_STRING();
}
phalcon_update_property_this(getThis(), SL("_rawBody"), return_value TSRMLS_CC);
}
else {
RETURN_EMPTY_STRING();
}
}
/* {{{ proto string SolrUtils::escapeQueryChars(string unescaped)
Escapes the lucene string */
PHP_METHOD(SolrUtils, escapeQueryChars)
{
solr_char_t *unescaped = NULL;
solr_string_t sbuilder;
COMPAT_ARG_SIZE_T unescaped_length = 0;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &unescaped, &unescaped_length) == FAILURE) {
RETURN_FALSE;
}
if (!unescaped_length) {
RETURN_NULL();
}
memset(&sbuilder, 0, sizeof(solr_string_t));
solr_escape_query_chars(&sbuilder, unescaped, unescaped_length);
RETVAL_STRINGL(sbuilder.str, sbuilder.len);
solr_string_free(&sbuilder);
}
static void php_tidy_quick_repair(INTERNAL_FUNCTION_PARAMETERS, zend_bool is_file)
{
char *enc = NULL;
size_t enc_len = 0;
zend_bool use_include_path = 0;
TidyDoc doc;
TidyBuffer *errbuf;
zend_string *data, *arg1;
zval *config = NULL;
if (is_file) {
if (zend_parse_parameters(ZEND_NUM_ARGS(), "P|zsb", &arg1, &config, &enc, &enc_len, &use_include_path) == FAILURE) {
RETURN_FALSE;
}
if (!(data = php_tidy_file_to_mem(ZSTR_VAL(arg1), use_include_path))) {
RETURN_FALSE;
}
} else {
if (zend_parse_parameters(ZEND_NUM_ARGS(), "S|zsb", &arg1, &config, &enc, &enc_len, &use_include_path) == FAILURE) {
RETURN_FALSE;
}
data = arg1;
}
if (ZEND_SIZE_T_UINT_OVFL(ZSTR_LEN(data))) {
php_error_docref(NULL, E_WARNING, "Input string is too long");
RETURN_FALSE;
}
doc = tidyCreate();
errbuf = emalloc(sizeof(TidyBuffer));
tidyBufInit(errbuf);
if (tidySetErrorBuffer(doc, errbuf) != 0) {
tidyBufFree(errbuf);
efree(errbuf);
tidyRelease(doc);
php_error_docref(NULL, E_ERROR, "Could not set Tidy error buffer");
}
tidyOptSetBool(doc, TidyForceOutput, yes);
tidyOptSetBool(doc, TidyMark, no);
TIDY_SET_DEFAULT_CONFIG(doc);
if (config) {
TIDY_APPLY_CONFIG_ZVAL(doc, config);
}
if(enc_len) {
if (tidySetCharEncoding(doc, enc) < 0) {
php_error_docref(NULL, E_WARNING, "Could not set encoding '%s'", enc);
RETVAL_FALSE;
}
}
if (data) {
TidyBuffer buf;
tidyBufInit(&buf);
tidyBufAttach(&buf, (byte *) ZSTR_VAL(data), (uint)ZSTR_LEN(data));
if (tidyParseBuffer(doc, &buf) < 0) {
php_error_docref(NULL, E_WARNING, "%s", errbuf->bp);
RETVAL_FALSE;
} else {
if (tidyCleanAndRepair(doc) >= 0) {
TidyBuffer output;
tidyBufInit(&output);
tidySaveBuffer (doc, &output);
FIX_BUFFER(&output);
RETVAL_STRINGL((char *) output.bp, output.size ? output.size-1 : 0);
tidyBufFree(&output);
} else {
RETVAL_FALSE;
}
}
}
if (is_file) {
zend_string_release(data);
}
tidyBufFree(errbuf);
efree(errbuf);
tidyRelease(doc);
}
/* {{{
* common code shared by display_xyz functions to get the value from ICU
}}} */
static void get_icu_disp_value_src_php( char* tag_name, INTERNAL_FUNCTION_PARAMETERS)
{
char* loc_name = NULL;
int loc_name_len = 0;
char* disp_loc_name = NULL;
int disp_loc_name_len = 0;
UChar* disp_name = NULL;
int32_t disp_name_len = 0;
char* mod_loc_name = NULL;
int32_t buflen = 512;
UErrorCode status = U_ZERO_ERROR;
char* utf8value = NULL;
int utf8value_len = 0;
char* msg = NULL;
int grOffset = 0;
intl_error_reset( NULL TSRMLS_CC );
if(zend_parse_parameters( ZEND_NUM_ARGS() TSRMLS_CC, "s|s",
&loc_name, &loc_name_len ,
&disp_loc_name ,&disp_loc_name_len ) == FAILURE)
{
spprintf(&msg , 0, "locale_get_display_%s : unable to parse input params", tag_name );
intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR, msg , 1 TSRMLS_CC );
efree(msg);
RETURN_FALSE;
}
if(loc_name_len == 0) {
loc_name = INTL_G(default_locale);
}
if( tag_name != DISP_NAME ){
/* Handle grandfathered languages */
grOffset = findOffset( LOC_GRANDFATHERED , loc_name );
if( grOffset >= 0 ){
if( strcmp(tag_name , LOC_LANG_TAG)==0 ){
mod_loc_name = getPreferredTag( loc_name );
} else {
/* Since Grandfathered, no value, do nothing, retutn NULL */
RETURN_FALSE;
}
}
} /* end of if != LOC_CANONICAL_TAG */
if( mod_loc_name==NULL ){
mod_loc_name = estrdup( loc_name );
}
/* Get the disp_value for the given locale */
do{
disp_name = erealloc( disp_name , buflen );
disp_name_len = buflen;
/* Check if disp_loc_name passed , if not use default locale */
if( !disp_loc_name){
disp_loc_name = estrdup(INTL_G(default_locale));
}
if( strcmp(tag_name , LOC_LANG_TAG)==0 ){
buflen = uloc_getDisplayLanguage ( mod_loc_name , disp_loc_name , disp_name , disp_name_len , &status);
} else if( strcmp(tag_name , LOC_SCRIPT_TAG)==0 ){
buflen = uloc_getDisplayScript ( mod_loc_name , disp_loc_name , disp_name , disp_name_len , &status);
} else if( strcmp(tag_name , LOC_REGION_TAG)==0 ){
buflen = uloc_getDisplayCountry ( mod_loc_name , disp_loc_name , disp_name , disp_name_len , &status);
} else if( strcmp(tag_name , LOC_VARIANT_TAG)==0 ){
buflen = uloc_getDisplayVariant ( mod_loc_name , disp_loc_name , disp_name , disp_name_len , &status);
} else if( strcmp(tag_name , DISP_NAME)==0 ){
buflen = uloc_getDisplayName ( mod_loc_name , disp_loc_name , disp_name , disp_name_len , &status);
}
if( U_FAILURE( status ) )
{
if( status == U_BUFFER_OVERFLOW_ERROR )
{
status = U_ZERO_ERROR;
continue;
}
spprintf(&msg, 0, "locale_get_display_%s : unable to get locale %s", tag_name , tag_name );
intl_error_set( NULL, status, msg , 1 TSRMLS_CC );
efree(msg);
if( disp_name){
efree( disp_name );
}
if( mod_loc_name){
efree( mod_loc_name );
}
RETURN_FALSE;
}
} while( buflen > disp_name_len );
if( mod_loc_name){
efree( mod_loc_name );
}
/* Convert display locale name from UTF-16 to UTF-8. */
intl_convert_utf16_to_utf8( &utf8value, &utf8value_len, disp_name, buflen, &status );
efree( disp_name );
if( U_FAILURE( status ) )
{
spprintf(&msg, 0, "locale_get_display_%s :error converting display name for %s to UTF-8", tag_name , tag_name );
intl_error_set( NULL, status, msg , 1 TSRMLS_CC );
efree(msg);
RETURN_FALSE;
}
RETVAL_STRINGL( utf8value, utf8value_len , FALSE);
}
/* {{{ php_exec
* If type==0, only last line of output is returned (exec)
* If type==1, all lines will be printed and last lined returned (system)
* If type==2, all lines will be saved to given array (exec with &$array)
* If type==3, output will be printed binary, no lines will be saved or returned (passthru)
*
*/
PHPAPI int php_exec(int type, char *cmd, zval *array, zval *return_value)
{
FILE *fp;
char *buf;
size_t l = 0;
int pclose_return;
char *b, *d=NULL;
php_stream *stream;
size_t buflen, bufl = 0;
#if PHP_SIGCHILD
void (*sig_handler)() = NULL;
#endif
#if PHP_SIGCHILD
sig_handler = signal (SIGCHLD, SIG_DFL);
#endif
#ifdef PHP_WIN32
fp = VCWD_POPEN(cmd, "rb");
#else
fp = VCWD_POPEN(cmd, "r");
#endif
if (!fp) {
php_error_docref(NULL, E_WARNING, "Unable to fork [%s]", cmd);
goto err;
}
stream = php_stream_fopen_from_pipe(fp, "rb");
buf = (char *) emalloc(EXEC_INPUT_BUF);
buflen = EXEC_INPUT_BUF;
if (type != 3) {
b = buf;
while (php_stream_get_line(stream, b, EXEC_INPUT_BUF, &bufl)) {
/* no new line found, let's read some more */
if (b[bufl - 1] != '\n' && !php_stream_eof(stream)) {
if (buflen < (bufl + (b - buf) + EXEC_INPUT_BUF)) {
bufl += b - buf;
buflen = bufl + EXEC_INPUT_BUF;
buf = erealloc(buf, buflen);
b = buf + bufl;
} else {
b += bufl;
}
continue;
} else if (b != buf) {
bufl += b - buf;
}
if (type == 1) {
PHPWRITE(buf, bufl);
if (php_output_get_level() < 1) {
sapi_flush();
}
} else if (type == 2) {
/* strip trailing whitespaces */
l = bufl;
while (l >= 1 && l-- && isspace(((unsigned char *)buf)[l]));
if (l != (bufl - 1)) {
bufl = l + 1;
buf[bufl] = '\0';
}
add_next_index_stringl(array, buf, bufl);
}
b = buf;
}
if (bufl) {
/* strip trailing whitespaces if we have not done so already */
if ((type == 2 && buf != b) || type != 2) {
l = bufl;
while (l >= 1 && l-- && isspace(((unsigned char *)buf)[l]));
if (l != (bufl - 1)) {
bufl = l + 1;
buf[bufl] = '\0';
}
if (type == 2) {
add_next_index_stringl(array, buf, bufl);
}
}
/* Return last line from the shell command */
RETVAL_STRINGL(buf, bufl);
} else { /* should return NULL, but for BC we return "" */
RETVAL_EMPTY_STRING();
}
} else {
while((bufl = php_stream_read(stream, buf, EXEC_INPUT_BUF)) > 0) {
PHPWRITE(buf, bufl);
}
}
pclose_return = php_stream_close(stream);
efree(buf);
done:
#if PHP_SIGCHILD
if (sig_handler) {
signal(SIGCHLD, sig_handler);
}
#endif
if (d) {
efree(d);
}
return pclose_return;
err:
pclose_return = -1;
goto done;
}
U_CFUNC PHP_FUNCTION(datefmt_format_object)
{
zval *object,
*format = NULL;
const char *locale_str = NULL;
size_t locale_len;
bool pattern = false;
UDate date;
TimeZone *timeZone = NULL;
UErrorCode status = U_ZERO_ERROR;
DateFormat *df = NULL;
Calendar *cal = NULL;
DateFormat::EStyle dateStyle = DateFormat::kDefault,
timeStyle = DateFormat::kDefault;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "o|zs!",
&object, &format, &locale_str, &locale_len) == FAILURE) {
RETURN_FALSE;
}
if (!locale_str) {
locale_str = intl_locale_get_default();
}
if (format == NULL || Z_TYPE_P(format) == IS_NULL) {
//nothing
} else if (Z_TYPE_P(format) == IS_ARRAY) {
HashTable *ht = Z_ARRVAL_P(format);
HashPosition pos = {0};
zval *z;
if (zend_hash_num_elements(ht) != 2) {
intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
"datefmt_format_object: bad format; if array, it must have "
"two elements", 0);
RETURN_FALSE;
}
zend_hash_internal_pointer_reset_ex(ht, &pos);
z = zend_hash_get_current_data_ex(ht, &pos);
if (!valid_format(z)) {
intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
"datefmt_format_object: bad format; the date format (first "
"element of the array) is not valid", 0);
RETURN_FALSE;
}
dateStyle = (DateFormat::EStyle)Z_LVAL_P(z);
zend_hash_move_forward_ex(ht, &pos);
z = zend_hash_get_current_data_ex(ht, &pos);
if (!valid_format(z)) {
intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
"datefmt_format_object: bad format; the time format ("
"second element of the array) is not valid", 0);
RETURN_FALSE;
}
timeStyle = (DateFormat::EStyle)Z_LVAL_P(z);
} else if (Z_TYPE_P(format) == IS_LONG) {
if (!valid_format(format)) {
intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
"datefmt_format_object: the date/time format type is invalid",
0);
RETURN_FALSE;
}
dateStyle = timeStyle = (DateFormat::EStyle)Z_LVAL_P(format);
} else {
convert_to_string_ex(format);
if (Z_STRLEN_P(format) == 0) {
intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
"datefmt_format_object: the format is empty", 0);
RETURN_FALSE;
}
pattern = true;
}
//there's no support for relative time in ICU yet
timeStyle = (DateFormat::EStyle)(timeStyle & ~DateFormat::kRelative);
zend_class_entry *instance_ce = Z_OBJCE_P(object);
if (instanceof_function(instance_ce, Calendar_ce_ptr)) {
Calendar *obj_cal = calendar_fetch_native_calendar(object);
if (obj_cal == NULL) {
intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
"datefmt_format_object: bad IntlCalendar instance: "
"not initialized properly", 0);
RETURN_FALSE;
}
timeZone = obj_cal->getTimeZone().clone();
date = obj_cal->getTime(status);
if (U_FAILURE(status)) {
intl_error_set(NULL, status,
"datefmt_format_object: error obtaining instant from "
"IntlCalendar", 0);
RETVAL_FALSE;
goto cleanup;
}
cal = obj_cal->clone();
} else if (instanceof_function(instance_ce, php_date_get_date_ce())) {
if (intl_datetime_decompose(object, &date, &timeZone, NULL,
"datefmt_format_object") == FAILURE) {
RETURN_FALSE;
}
cal = new GregorianCalendar(Locale::createFromName(locale_str), status);
if (U_FAILURE(status)) {
intl_error_set(NULL, status,
"datefmt_format_object: could not create GregorianCalendar",
0);
RETVAL_FALSE;
goto cleanup;
}
} else {
intl_error_set(NULL, status, "datefmt_format_object: the passed object "
"must be an instance of either IntlCalendar or DateTime",
0);
RETURN_FALSE;
}
if (pattern) {
df = new SimpleDateFormat(
UnicodeString(Z_STRVAL_P(format), Z_STRLEN_P(format),
UnicodeString::kInvariant),
Locale::createFromName(locale_str),
status);
if (U_FAILURE(status)) {
intl_error_set(NULL, status,
"datefmt_format_object: could not create SimpleDateFormat",
0);
RETVAL_FALSE;
goto cleanup;
}
} else {
df = DateFormat::createDateTimeInstance(dateStyle, timeStyle,
Locale::createFromName(locale_str));
if (df == NULL) { /* according to ICU sources, this should never happen */
intl_error_set(NULL, status,
"datefmt_format_object: could not create DateFormat",
0);
RETVAL_FALSE;
goto cleanup;
}
}
//must be in this order (or have the cal adopt the tz)
df->adoptCalendar(cal);
cal = NULL;
df->adoptTimeZone(timeZone);
timeZone = NULL;
{
char *ret_str;
int ret_str_len;
UnicodeString result = UnicodeString();
df->format(date, result);
if (intl_charFromString(result, &ret_str, &ret_str_len, &status) == FAILURE) {
intl_error_set(NULL, status,
"datefmt_format_object: error converting result to UTF-8",
0);
RETVAL_FALSE;
goto cleanup;
}
RETVAL_STRINGL(ret_str, ret_str_len);
//???
efree(ret_str);
}
cleanup:
delete df;
delete timeZone;
delete cal;
}
