ZEND_METHOD(Closure, __invoke) /* {{{ */
{
zend_function *func = EG(current_execute_data)->function_state.function;
zval ***arguments;
zval *closure_result_ptr = NULL;
arguments = emalloc(sizeof(zval**) * ZEND_NUM_ARGS());
if (zend_get_parameters_array_ex(ZEND_NUM_ARGS(), arguments) == FAILURE) {
efree(arguments);
zend_error(E_RECOVERABLE_ERROR, "Cannot get arguments for calling closure");
RETVAL_FALSE;
} else if (call_user_function_ex(CG(function_table), NULL, this_ptr, &closure_result_ptr, ZEND_NUM_ARGS(), arguments, 1, NULL TSRMLS_CC) == FAILURE) {
RETVAL_FALSE;
} else if (closure_result_ptr) {
if (Z_ISREF_P(closure_result_ptr) && return_value_ptr) {
if (return_value) {
zval_ptr_dtor(&return_value);
}
*return_value_ptr = closure_result_ptr;
} else {
RETVAL_ZVAL(closure_result_ptr, 1, 1);
}
}
efree(arguments);
/* destruct the function also, then - we have allocated it in get_method */
efree(func->internal_function.function_name);
efree(func);
}
/* {{{ proto null Runkit_Sandbox_Parent::echo(mixed var[, mixed var[, ... ]])
Echo through out of the sandbox
Avoid the sandbox's output handler */
PHP_METHOD(Runkit_Sandbox_Parent,echo)
{
php_runkit_sandbox_parent_object *objval;
zval **argv;
int i, argc = ZEND_NUM_ARGS();
if (zend_get_parameters_array_ex(argc, &argv) == FAILURE) {
/* Big problems... */
RETURN_NULL();
}
for(i = 0; i < argc; i++) {
/* Prepare for output */
convert_to_string(argv[i]);
}
PHP_RUNKIT_SANDBOX_PARENT_FETCHBOX_VERIFY_ACCESS(objval, this_ptr);
if (!objval->self->parent_echo) {
php_error_docref(NULL, E_WARNING, "Access to echo data in the parent context is not enabled");
RETURN_FALSE;
}
PHP_RUNKIT_SANDBOX_PARENT_BEGIN(objval)
for(i = 0; i < argc; i++) {
PHPWRITE(Z_STRVAL_P(argv[i]),Z_STRLEN_P(argv[i]));
}
PHP_RUNKIT_SANDBOX_PARENT_END(objval)
RETURN_NULL();
}
/* {{{ _timecop_call_mktime - timecop_(gm)mktime helper */
static void _timecop_call_mktime(INTERNAL_FUNCTION_PARAMETERS, const char *mktime_function_name, const char *date_function_name)
{
zval *params;
uint32_t param_count;
int i;
param_count = MAX(ZEND_NUM_ARGS(), MKTIME_NUM_ARGS);
params = (zval *)safe_emalloc(param_count, sizeof(zval), 0);
if (zend_get_parameters_array_ex(ZEND_NUM_ARGS(), params) == FAILURE) {
efree(params);
zend_throw_error(NULL, "Cannot get arguments for calling");
return;
}
param_count = ZEND_NUM_ARGS();
if (param_count < MKTIME_NUM_ARGS) {
fill_mktime_params(params, date_function_name, param_count);
param_count = MKTIME_NUM_ARGS;
}
if (ZEND_NUM_ARGS() == 0) {
php_error_docref(NULL, E_STRICT, "You should be using the time() function instead");
}
simple_call_function(mktime_function_name, return_value, param_count, params);
for (i = ZEND_NUM_ARGS(); i < MKTIME_NUM_ARGS; i++) {
zval_ptr_dtor(¶ms[i]);
}
efree(params);
}
/* {{{ proto TimecopDateTime::__construct([string time[, DateTimeZone object]])
Creates new TimecopDateTime object
*/
PHP_METHOD(TimecopDateTime, __construct)
{
zval *params;
zval *obj = getThis();
params = (zval *)safe_emalloc(ZEND_NUM_ARGS(), sizeof(zval), 0);
if (zend_get_parameters_array_ex(ZEND_NUM_ARGS(), params) == FAILURE) {
efree(params);
zend_throw_error(NULL, "Cannot get arguments for TimecopDateTime::__construct");
RETURN_FALSE;
}
/* call original DateTime::__construct() */
timecop_call_original_constructor(obj, TIMECOP_G(ce_DateTime), params, ZEND_NUM_ARGS());
if (!EG(exception)) {
zval *time = NULL, *timezone_obj = NULL;
if (ZEND_NUM_ARGS() >= 1) {
time = ¶ms[0];
}
if (ZEND_NUM_ARGS() >= 2) {
timezone_obj = ¶ms[1];
}
fix_datetime_timestamp(obj, time, timezone_obj);
}
efree(params);
}
static int com_call_method(zend_string *method, zend_object *object, INTERNAL_FUNCTION_PARAMETERS)
{
zval *args = NULL;
php_com_dotnet_object *obj = (php_com_dotnet_object*)object;
int nargs;
VARIANT v;
int ret = FAILURE;
if (V_VT(&obj->v) != VT_DISPATCH) {
return FAILURE;
}
nargs = ZEND_NUM_ARGS();
if (nargs) {
args = (zval *)safe_emalloc(sizeof(zval), nargs, 0);
zend_get_parameters_array_ex(nargs, args);
}
VariantInit(&v);
if (SUCCESS == php_com_do_invoke_byref(obj, (zend_internal_function*)EX(func), DISPATCH_METHOD|DISPATCH_PROPERTYGET, &v, nargs, args)) {
php_com_zval_from_variant(return_value, &v, obj->code_page);
ret = SUCCESS;
VariantClear(&v);
}
if (args) {
efree(args);
}
return ret;
}
/* {{{ pip_args_to_tuple(int argc, int start)
Converts PHP arguments into a Python tuple suitable for argument passing */
PyObject * pip_args_to_tuple(int argc, int start TSRMLS_DC)
{
zval ***zargs = NULL;
PyObject *args = NULL;
if (argc < start) {
return NULL;
}
/* Allocate enough memory for all of the arguments. */
if ((zargs = (zval ***) emalloc(sizeof(zval **) * argc)) == NULL) {
return NULL;
}
/* Get the array of PHP parameters. */
if (zend_get_parameters_array_ex(argc, zargs) == SUCCESS) {
int i = 0;
args = PyTuple_New(argc - start);
/* Add each parameter to a new tuple. */
for (i = start; i < argc; i++) {
PyObject *arg = pip_zval_to_pyobject(zargs[i]);
PyTuple_SetItem(args, i - start, arg);
}
}
efree(zargs);
return args;
}
U_CFUNC PHP_FUNCTION(intlcal_roll)
{
zend_long field,
value;
zval args_a[3] = {0},
*args = args_a;
zend_bool bool_variant_val = (zend_bool)-1;
CALENDAR_METHOD_INIT_VARS;
if (ZEND_NUM_ARGS() > (getThis() ? 2 :3) ||
zend_get_parameters_array_ex(ZEND_NUM_ARGS(), args) == FAILURE) {
intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
"intlcal_set: too many arguments", 0 TSRMLS_CC);
RETURN_FALSE;
}
if (!getThis()) {
args++;
}
if (!Z_ISUNDEF(args[1]) && (Z_TYPE(args[1]) == IS_TRUE || Z_TYPE(args[1]) == IS_FALSE)) {
if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(),
"Olb", &object, Calendar_ce_ptr, &field, &bool_variant_val)
== FAILURE) {
intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
"intlcal_roll: bad arguments", 0 TSRMLS_CC);
RETURN_FALSE;
}
bool_variant_val = Z_TYPE(args[1]) == IS_TRUE? 1 : 0;
} else if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(),
"Oll", &object, Calendar_ce_ptr, &field, &value) == FAILURE) {
intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
"intlcal_roll: bad arguments", 0 TSRMLS_CC);
RETURN_FALSE;
}
if (field < 0 || field >= UCAL_FIELD_COUNT) {
intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
"intlcal_roll: invalid field", 0 TSRMLS_CC);
RETURN_FALSE;
}
if (bool_variant_val == (zend_bool)-1 &&
(value < INT32_MIN || value > INT32_MAX)) {
intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
"intlcal_roll: value out of bounds", 0 TSRMLS_CC);
RETURN_FALSE;
}
CALENDAR_METHOD_FETCH_OBJECT;
if (bool_variant_val != (zend_bool)-1) {
co->ucal->roll((UCalendarDateFields)field, (UBool)bool_variant_val,
CALENDAR_ERROR_CODE(co));
} else {
co->ucal->roll((UCalendarDateFields)field, (int32_t)value,
CALENDAR_ERROR_CODE(co));
}
INTL_METHOD_CHECK_STATUS(co, "intlcal_roll: Error calling ICU Calendar::roll");
RETURN_TRUE;
}
static int accel_file_in_cache(INTERNAL_FUNCTION_PARAMETERS)
{
zval **zfilename;
if (ZEND_NUM_ARGS() != 1 ||
zend_get_parameters_array_ex(1, &zfilename) == FAILURE ||
Z_TYPE_PP(zfilename) != IS_STRING ||
Z_STRLEN_PP(zfilename) == 0) {
return 0;
}
return filename_is_in_cache(Z_STRVAL_PP(zfilename), Z_STRLEN_PP(zfilename) TSRMLS_CC);
}
U_CFUNC PHP_FUNCTION(intlcal_clear)
{
zval args_a[2] = {0},
*args = &args_a[0];
zend_long field;
int variant;
CALENDAR_METHOD_INIT_VARS;
if (ZEND_NUM_ARGS() > (getThis() ? 1 : 2) ||
zend_get_parameters_array_ex(ZEND_NUM_ARGS(), args) == FAILURE) {
intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
"intlcal_clear: too many arguments", 0 TSRMLS_CC);
RETURN_FALSE;
}
if (!getThis()) {
args++;
}
if (Z_ISUNDEF(args[0]) || Z_TYPE(args[0]) == IS_NULL) {
zval *dummy; /* we know it's null */
if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC,
getThis(), "O|z", &object, Calendar_ce_ptr, &dummy) == FAILURE) {
intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
"intlcal_clear: bad arguments", 0 TSRMLS_CC);
RETURN_FALSE;
}
variant = 0;
} else if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC,
getThis(), "Ol", &object, Calendar_ce_ptr, &field) == FAILURE) {
intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
"intlcal_clear: bad arguments", 0 TSRMLS_CC);
RETURN_FALSE;
} else if (field < 0 || field >= UCAL_FIELD_COUNT) {
intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
"intlcal_clear: invalid field", 0 TSRMLS_CC);
RETURN_FALSE;
} else {
variant = 1;
}
CALENDAR_METHOD_FETCH_OBJECT;
if (variant == 0) {
co->ucal->clear();
} else {
co->ucal->clear((UCalendarDateFields)field);
}
RETURN_TRUE;
}
/* {{{ proto TimecopOrigDateTime::__construct([string time[, DateTimeZone object]])
Creates new TimecopOrigDateTime object
*/
PHP_METHOD(TimecopOrigDateTime, __construct)
{
zval *params;
zval *obj = getThis();
params = (zval *)safe_emalloc(ZEND_NUM_ARGS(), sizeof(zval), 0);
if (zend_get_parameters_array_ex(ZEND_NUM_ARGS(), params) == FAILURE) {
efree(params);
zend_throw_error(NULL, "Cannot get arguments for TimecopOrigDateTime::__construct");
RETURN_FALSE;
}
/* call original DateTime::__construct() */
timecop_call_original_constructor(obj, TIMECOP_G(ce_DateTime), params, ZEND_NUM_ARGS());
efree(params);
}
ZEND_METHOD(Closure, __invoke) /* {{{ */
{
zend_function *func = EX(func);
zval *arguments;
arguments = emalloc(sizeof(zval) * ZEND_NUM_ARGS());
if (zend_get_parameters_array_ex(ZEND_NUM_ARGS(), arguments) == FAILURE) {
efree(arguments);
zend_error(E_RECOVERABLE_ERROR, "Cannot get arguments for calling closure");
RETVAL_FALSE;
} else if (call_user_function_ex(CG(function_table), NULL, getThis(), return_value, ZEND_NUM_ARGS(), arguments, 1, NULL) == FAILURE) {
RETVAL_FALSE;
}
efree(arguments);
/* destruct the function also, then - we have allocated it in get_method */
zend_string_release(func->internal_function.function_name);
efree(func);
}
zval GetpMatrix(structlpsolvecaller *lpsolvecaller, int element)
{
zval arg;
ZVAL_UNDEF(&arg);
if ((element >= 0) && (element < lpsolvecaller->nrhs)) {
zval *arg_array = NULL;
//arg_array = (zval *) malloc(lpsolvecaller->nrhs * sizeof(arg_array));
arg_array = (zval *)safe_emalloc(sizeof(zval), lpsolvecaller->nrhs, 0);
if (zend_get_parameters_array_ex(lpsolvecaller->nrhs, arg_array) != FAILURE) {
arg = arg_array[element];
//printf("--%d: %d--\n", element, Z_TYPE(arg));
}
if (arg_array) {
efree(arg_array);
}
}
return(arg);
}
static void oop_indirection_func(INTERNAL_FUNCTION_PARAMETERS)
{
indirection_function *ind = (indirection_function *) execute_data->func;
zval *obj = &ind->obj;
zval *params = safe_emalloc(sizeof(zval), ZEND_NUM_ARGS() + 1, 0);
zval result;
zend_class_entry *ce = ind->fn.scope;
zend_fcall_info fci;
zend_fcall_info_cache fcc;
fci.size = sizeof(fci);
fci.param_count = ZEND_NUM_ARGS() + 1;
fci.params = params;
fci.no_separation = 1;
fcc.initialized = 1;
fcc.calling_scope = ce;
fcc.function_handler = ind->fbc;
zend_get_parameters_array_ex(ZEND_NUM_ARGS(), ¶ms[1]);
ZVAL_COPY_VALUE(¶ms[0], obj);
ZVAL_STR(&fci.function_name, ind->fn.function_name);
fci.retval = &result;
fci.object = NULL;
fcc.object = NULL;
fcc.called_scope = ce;
if (zend_call_function(&fci, &fcc TSRMLS_CC) == SUCCESS && !Z_ISUNDEF(result)) {
ZVAL_COPY_VALUE(return_value, &result);
}
zval_ptr_dtor(obj);
execute_data->func = NULL;
zval_ptr_dtor(&fci.function_name);
efree(params);
efree(ind);
}
static void _timecop_call_function(INTERNAL_FUNCTION_PARAMETERS, const char *function_name, int index_to_fill_timestamp)
{
zval *params;
uint32_t param_count;
param_count = MAX(ZEND_NUM_ARGS(), index_to_fill_timestamp+1);
params = (zval *)safe_emalloc(param_count, sizeof(zval), 0);
if (zend_get_parameters_array_ex(ZEND_NUM_ARGS(), params) == FAILURE) {
efree(params);
return;
}
param_count = ZEND_NUM_ARGS();
if (param_count == index_to_fill_timestamp) {
ZVAL_LONG(¶ms[param_count], timecop_current_timestamp());
param_count++;
}
simple_call_function(function_name, return_value, param_count, params);
efree(params);
}
ZEND_METHOD(Vedis, del)
{
int i, argc = ZEND_NUM_ARGS();
zval ***params;
VEDIS_PARAM(DEL, 3);
if (argc <= 0) {
WRONG_PARAM_COUNT;
return;
}
params = (zval ***)emalloc(sizeof(zval *) * argc);
if (!params) {
WRONG_PARAM_COUNT;
return;
}
if (zend_get_parameters_array_ex(argc, params) != SUCCESS) {
WRONG_PARAM_COUNT;
return;
}
VEDIS_SELF(intern);
VEDIS_ARGS_INIT(argc);
for (i = 0; i < argc; i++) {
if (Z_TYPE_PP(params[i]) != IS_STRING) {
convert_to_string(*params[i]);
}
VEDIS_ARGS_STRING(Z_STRVAL_PP(params[i]), Z_STRLEN_PP(params[i]));
}
VEDIS_ARGS_EXEC(RETURN_LONG(0));
VEDIS_RETURN_LONG();
}
static void php_dba_open(INTERNAL_FUNCTION_PARAMETERS, int persistent)
{
pval ***args = (pval ***) NULL;
int ac = ZEND_NUM_ARGS();
dba_mode_t modenr;
dba_info *info;
dba_handler *hptr;
char *key = NULL;
int keylen = 0;
int listid;
int i;
if(ac < 3) {
WRONG_PARAM_COUNT;
}
/* we pass additional args to the respective handler */
args = emalloc(ac * sizeof(pval *));
if(zend_get_parameters_array_ex(ac, args) != SUCCESS) {
FREENOW;
WRONG_PARAM_COUNT;
}
/* we only take string arguments */
for(i = 0; i < ac; i++) {
convert_to_string_ex(args[i]);
keylen += Z_STRLEN_PP(args[i]);
}
if(persistent) {
/* calculate hash */
key = emalloc(keylen);
keylen = 0;
for(i = 0; i < ac; i++) {
memcpy(key+keylen,Z_STRVAL_PP(args[i]),Z_STRLEN_PP(args[i]));
keylen += Z_STRLEN_PP(args[i]);
}
if(zend_hash_find(&ht_keys, key, keylen, (void **) &info) == SUCCESS) {
FREENOW;
RETURN_LONG(zend_list_insert(info, GLOBAL(le_pdb)));
}
}
for(hptr = handler; hptr->name &&
strcasecmp(hptr->name, (*args[2])->value.str.val); hptr++);
if(!hptr->name) {
php_error(E_WARNING, "no such handler: %s", (*args[2])->value.str.val);
FREENOW;
RETURN_FALSE;
}
switch((*args[1])->value.str.val[0]) {
case 'c':
modenr = DBA_CREAT;
break;
case 'w':
modenr = DBA_WRITER;
break;
case 'r':
modenr = DBA_READER;
break;
case 'n':
modenr = DBA_TRUNC;
break;
default:
php_error(E_WARNING,"illegal DBA mode: %s",(*args[1])->value.str.val);
FREENOW;
RETURN_FALSE;
}
info = malloc(sizeof(*info));
memset(info, 0, sizeof(info));
info->path = strdup((*args[0])->value.str.val);
info->mode = modenr;
info->argc = ac - 3;
info->argv = args + 3;
info->hnd = NULL;
if(hptr->open(info) != SUCCESS) {
dba_close(info);
php_error(E_WARNING, "driver initialization failed");
FREENOW;
RETURN_FALSE;
}
info->hnd = hptr;
info->argc = 0;
info->argv = NULL;
listid = zend_list_insert(info, persistent?GLOBAL(le_pdb):GLOBAL(le_db));
if(persistent) {
zend_hash_update(&ht_keys, key, keylen, info, sizeof(*info), NULL);
}
FREENOW;
RETURN_LONG(listid);
}
/** {{{ proto LuaClosure::invoke(mxied $args)
*/
PHP_METHOD(lua_closure, invoke) {
lua_closure_object *objval = php_lua_closure_object_from_zend_object(Z_OBJ_P(getThis()));
int bp, sp;
zval *arguments = NULL;
lua_State *L = NULL;
zval rv;
if (ZEND_NUM_ARGS()) {
arguments = emalloc(sizeof(zval*) * ZEND_NUM_ARGS());
if (zend_get_parameters_array_ex(ZEND_NUM_ARGS(), arguments) == FAILURE) {
efree(arguments);
zend_throw_exception_ex(NULL, 0, "cannot get arguments for calling closure");
return;
}
}
if (Z_TYPE(objval->lua) != IS_OBJECT
|| !instanceof_function(Z_OBJCE(objval->lua), lua_ce)) {
zend_throw_exception_ex(NULL, 0, "corrupted Lua object");
return;
}
L = (Z_LUAVAL(objval->lua))->L;
bp = lua_gettop(L);
lua_rawgeti(L, LUA_REGISTRYINDEX, objval->closure);
if (LUA_TFUNCTION != lua_type(L, lua_gettop(L))) {
lua_pop(L, -1);
zend_throw_exception_ex(NULL, 0, "call to lua closure failed");
return;
}
if (ZEND_NUM_ARGS()) {
int i = 0;
for(;i<ZEND_NUM_ARGS();i++) {
php_lua_send_zval_to_lua(L, &arguments[i]);
}
}
if (lua_pcall(L, ZEND_NUM_ARGS(), LUA_MULTRET, 0) != 0) {
if (arguments) {
efree(arguments);
}
lua_pop(L, lua_gettop(L) - bp);
zend_throw_exception_ex(NULL, 0,
"call to lua function %s failed", lua_tostring(L, -1));
return;
}
sp = lua_gettop(L) - bp;
if (!sp) {
RETURN_NULL();
} else if (sp == 1) {
php_lua_get_zval_from_lua(L, -1, &(objval->lua), return_value);
} else {
zval rv;
int i = 0;
array_init(return_value);
for (i = -sp; i < 0; i++) {
php_lua_get_zval_from_lua(L, i, &(objval->lua), &rv);
add_next_index_zval(return_value, &rv);
}
}
lua_pop(L, sp);
if (arguments) {
efree(arguments);
}
}
U_CFUNC PHP_FUNCTION(intlcal_set)
{
zend_long arg1, arg2, arg3, arg4, arg5, arg6;
zval args_a[7] = {0},
*args = args_a;
int i;
int variant; /* number of args of the set() overload */
CALENDAR_METHOD_INIT_VARS;
/* must come before zpp because zpp would convert the args in the stack to 0 */
if (ZEND_NUM_ARGS() > (getThis() ? 6 : 7) ||
zend_get_parameters_array_ex(ZEND_NUM_ARGS(), args) == FAILURE) {
intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
"intlcal_set: too many arguments", 0 TSRMLS_CC);
RETURN_FALSE;
}
if (!getThis()) {
args++;
}
variant = ZEND_NUM_ARGS() - (getThis() ? 0 : 1);
while (variant > 2 && Z_TYPE(args[variant - 1]) == IS_NULL) {
variant--;
}
if (variant == 4 ||
zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(),
"Oll|llll", &object, Calendar_ce_ptr, &arg1, &arg2, &arg3, &arg4,
&arg5, &arg6) == FAILURE) {
intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
"intlcal_set: bad arguments", 0 TSRMLS_CC);
RETURN_FALSE;
}
for (i = 0; i < variant; i++) {
if (Z_LVAL(args[i]) < INT32_MIN || Z_LVAL(args[i]) > INT32_MAX) {
intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
"intlcal_set: at least one of the arguments has an absolute "
"value that is too large", 0 TSRMLS_CC);
RETURN_FALSE;
}
}
if (variant == 2 && (arg1 < 0 || arg1 >= UCAL_FIELD_COUNT)) {
intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
"intlcal_set: invalid field", 0 TSRMLS_CC);
RETURN_FALSE;
}
CALENDAR_METHOD_FETCH_OBJECT;
if (variant == 2) {
co->ucal->set((UCalendarDateFields)arg1, (int32_t)arg2);
} else if (variant == 3) {
co->ucal->set((int32_t)arg1, (int32_t)arg2, (int32_t)arg3);
} else if (variant == 5) {
co->ucal->set((int32_t)arg1, (int32_t)arg2, (int32_t)arg3, (int32_t)arg4, (int32_t)arg5);
} else if (variant == 6) {
co->ucal->set((int32_t)arg1, (int32_t)arg2, (int32_t)arg3, (int32_t)arg4, (int32_t)arg5, (int32_t)arg6);
}
RETURN_TRUE;
}
static void _php_intlgregcal_constructor_body(INTERNAL_FUNCTION_PARAMETERS)
{
zval *tz_object = NULL;
zval args_a[6] = {0},
*args = &args_a[0];
char *locale = NULL;
int locale_len;
zend_long largs[6];
UErrorCode status = U_ZERO_ERROR;
int variant;
intl_error_reset(NULL TSRMLS_CC);
// parameter number validation / variant determination
if (ZEND_NUM_ARGS() > 6 ||
zend_get_parameters_array_ex(ZEND_NUM_ARGS(), args) == FAILURE) {
intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
"intlgregcal_create_instance: too many arguments", 0 TSRMLS_CC);
Z_OBJ_P(return_value) = NULL;
return;
}
for (variant = ZEND_NUM_ARGS();
variant > 0 && Z_TYPE(args[variant - 1]) == IS_NULL;
variant--) {}
if (variant == 4) {
intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
"intlgregcal_create_instance: no variant with 4 arguments "
"(excluding trailing NULLs)", 0 TSRMLS_CC);
Z_OBJ_P(return_value) = NULL;
return;
}
// argument parsing
if (variant <= 2) {
if (zend_parse_parameters(MIN(ZEND_NUM_ARGS(), 2) TSRMLS_CC,
"|z!s!", &tz_object, &locale, &locale_len) == FAILURE) {
intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
"intlgregcal_create_instance: bad arguments", 0 TSRMLS_CC);
Z_OBJ_P(return_value) = NULL;
return;
}
}
if (variant > 2 && zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC,
"lll|lll", &largs[0], &largs[1], &largs[2], &largs[3], &largs[4],
&largs[5]) == FAILURE) {
intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
"intlgregcal_create_instance: bad arguments", 0 TSRMLS_CC);
Z_OBJ_P(return_value) = NULL;
return;
}
// instantion of ICU object
GregorianCalendar *gcal = NULL;
if (variant <= 2) {
// From timezone and locale (0 to 2 arguments)
TimeZone *tz = timezone_process_timezone_argument(tz_object, NULL,
"intlgregcal_create_instance" TSRMLS_CC);
if (tz == NULL) {
Z_OBJ_P(return_value) = NULL;
return;
}
if (!locale) {
locale = const_cast<char*>(intl_locale_get_default(TSRMLS_C));
}
gcal = new GregorianCalendar(tz, Locale::createFromName(locale),
status);
if (U_FAILURE(status)) {
intl_error_set(NULL, status, "intlgregcal_create_instance: error "
"creating ICU GregorianCalendar from time zone and locale", 0 TSRMLS_CC);
if (gcal) {
delete gcal;
}
delete tz;
Z_OBJ_P(return_value) = NULL;
return;
}
} else {
// From date/time (3, 5 or 6 arguments)
for (int i = 0; i < variant; i++) {
if (largs[i] < INT32_MIN || largs[i] > INT32_MAX) {
intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
"intlgregcal_create_instance: at least one of the arguments"
" has an absolute value that is too large", 0 TSRMLS_CC);
Z_OBJ_P(return_value) = NULL;
return;
}
}
if (variant == 3) {
gcal = new GregorianCalendar((int32_t)largs[0], (int32_t)largs[1],
(int32_t)largs[2], status);
} else if (variant == 5) {
gcal = new GregorianCalendar((int32_t)largs[0], (int32_t)largs[1],
(int32_t)largs[2], (int32_t)largs[3], (int32_t)largs[4], status);
} else if (variant == 6) {
gcal = new GregorianCalendar((int32_t)largs[0], (int32_t)largs[1],
(int32_t)largs[2], (int32_t)largs[3], (int32_t)largs[4], (int32_t)largs[5],
status);
}
if (U_FAILURE(status)) {
intl_error_set(NULL, status, "intlgregcal_create_instance: error "
"creating ICU GregorianCalendar from date", 0 TSRMLS_CC);
if (gcal) {
delete gcal;
}
Z_OBJ_P(return_value) = NULL;
return;
}
timelib_tzinfo *tzinfo = get_timezone_info(TSRMLS_C);
#if U_ICU_VERSION_MAJOR_NUM * 10 + U_ICU_VERSION_MINOR_NUM >= 42
UnicodeString tzstr = UnicodeString::fromUTF8(StringPiece(tzinfo->name));
#else
UnicodeString tzstr = UnicodeString(tzinfo->name,
strlen(tzinfo->name), US_INV);
#endif
if (tzstr.isBogus()) {
intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
"intlgregcal_create_instance: could not create UTF-8 string "
"from PHP's default timezone name (see date_default_timezone_get())",
0 TSRMLS_CC);
delete gcal;
Z_OBJ_P(return_value) = NULL;
return;
}
TimeZone *tz = TimeZone::createTimeZone(tzstr);
gcal->adoptTimeZone(tz);
}
Calendar_object *co = Z_INTL_CALENDAR_P(return_value);
co->ucal = gcal;
}
ONPHP_METHOD(Singleton, getInstance)
{
char *name;
int length, argc = ZEND_NUM_ARGS();
zend_class_entry **cep;
zval *object, *args;
zval **stored;
zval ***params = NULL;
if (argc < 1) {
WRONG_PARAM_COUNT;
}
params = safe_emalloc(sizeof(zval **), argc, 0);
if (zend_get_parameters_array_ex(argc, params) == FAILURE) {
efree(params);
ONPHP_THROW(
BaseException,
"Failed to get calling arguments for object creation"
);
}
// replica of historical Singleton's behaviour
if (argc > 2) {
int i;
ALLOC_INIT_ZVAL(args);
array_init(args);
for (i = 1; i < argc; ++i) {
add_next_index_zval(args, *params[i]);
}
params[1] = &args;
argc = 2;
}
if (Z_TYPE_PP(params[0]) != IS_STRING) {
ONPHP_THROW(WrongArgumentException, "strange class name given");
}
name = estrdup(Z_STRVAL_PP(params[0]));
length = strlen(name);
if (
zend_hash_find(
Z_ARRVAL_P(instances),
name,
length + 1,
(void **) &stored
)
== SUCCESS
) {
efree(params);
efree(name);
object = *stored;
zval_copy_ctor(object);
} else {
// stolen from Reflection's newInstance()
if (zend_lookup_class(name, length, &cep TSRMLS_CC) == SUCCESS) {
zval *retval_ptr;
zend_fcall_info fci;
zend_fcall_info_cache fcc;
zend_class_entry *ce = *cep;
// can use ce->name instead now
efree(name);
if (!instanceof_function(ce, onphp_ce_Singleton TSRMLS_CC)) {
efree(params);
ONPHP_THROW(
WrongArgumentException,
"Class '%s' is something not a Singleton's child",
ce->name
);
}
// we can call protected consturctors,
// since all classes are childs of Singleton
if (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE) {
efree(params);
ONPHP_THROW(
BaseException,
"Can not call private constructor for '%s' creation",
ce->name
);
} else if (ce->constructor->common.fn_flags & ZEND_ACC_PUBLIC) {
efree(params);
ONPHP_THROW(
BaseException,
"Don't want to deal with '%s' class "
"due to public constructor there",
ce->name
);
}
ALLOC_INIT_ZVAL(object);
object_init_ex(object, ce);
fci.size = sizeof(fci);
fci.function_table = EG(function_table);
fci.function_name = NULL;
fci.symbol_table = NULL;
fci.object_pp = &object;
fci.retval_ptr_ptr = &retval_ptr;
fci.param_count = argc - 1;
fci.params = params + 1;
fcc.initialized = 1;
fcc.function_handler = ce->constructor;
fcc.calling_scope = EG(scope);
fcc.object_pp = &object;
if (zend_call_function(&fci, &fcc TSRMLS_CC) == FAILURE) {
zend_throw_exception_ex(
onphp_ce_BaseException,
0 TSRMLS_CC,
"Failed to call '%s' constructor",
ce->name
);
}
efree(params);
if (retval_ptr) {
zval_ptr_dtor(&retval_ptr);
}
if (EG(exception)) {
return;
}
add_assoc_zval_ex(instances, ce->name, length + 1, object);
}
}
RETURN_ZVAL(object, 1, 0);
}
/* {{{ pthreads_call_method */
int pthreads_call_method(PTHREADS_CALL_METHOD_PASSTHRU_D) {
zval ***argv = NULL, zmethod, *zresult;
zend_function *call = NULL;
zend_fcall_info info;
zend_fcall_info_cache cache;
zend_class_entry *scope;
int called = -1, argc = ZEND_NUM_ARGS(), access = ZEND_ACC_PUBLIC, mlength = 0;
char *lcname;
zend_bool unprotect;
if (getThis()) {
PTHREAD thread = PTHREADS_FETCH;
if (thread) {
switch((access=pthreads_modifiers_get(thread->modifiers, method TSRMLS_CC))){
case ZEND_ACC_PRIVATE:
case ZEND_ACC_PROTECTED: {
scope = Z_OBJCE_P(getThis());
/*
* Stop invalid private method calls
*/
if (access == ZEND_ACC_PRIVATE && !PTHREADS_IN_THREAD(thread)) {
zend_error_noreturn(
E_ERROR,
"pthreads detected an attempt to call private method %s::%s from outside the threading context",
scope->name,
method
);
return FAILURE;
}
/*
* Get arguments from stack
*/
if (ZEND_NUM_ARGS())
{
argv = safe_emalloc(sizeof(zval **), argc, 0);
if (argv) {
zend_get_parameters_array_ex(argc, argv);
}
}
mlength = strlen(method);
lcname = calloc(1, mlength+1);
zend_str_tolower_copy(lcname, method, mlength);
if (zend_hash_find(&scope->function_table, lcname, mlength+1, (void**)&call)==SUCCESS) {
if (call) {
/*
* Make protected method call
*/
{
if (access != ZEND_ACC_PROTECTED || pthreads_modifiers_protect(thread->modifiers, method, &unprotect TSRMLS_CC)) {
ZVAL_STRINGL(&zmethod, method, strlen(method), 0);
info.size = sizeof(info);
info.object_ptr = getThis();
info.function_name = &zmethod;
info.retval_ptr_ptr = &zresult;
info.no_separation = 1;
info.symbol_table = NULL;
info.param_count = argc;
info.params = argv;
cache.initialized = 1;
cache.function_handler = call;
cache.calling_scope = EG(called_scope);
cache.called_scope = scope;
cache.object_ptr = getThis();
if ((called=zend_call_function(&info, &cache TSRMLS_CC))!=SUCCESS) {
zend_error_noreturn(
E_ERROR,
"pthreads has experienced an internal error while calling %s method %s::%s and cannot continue",
(access == ZEND_ACC_PROTECTED) ? "protected" : "private",
scope->name,
method
);
} else {
#if PHP_VERSION_ID > 50399
{
zend_op_array *ops = (zend_op_array*) call;
if (ops) {
if (ops->run_time_cache) {
efree(ops->run_time_cache);
ops->run_time_cache = NULL;
}
}
}
#endif
if (!return_value_used) {
zval_ptr_dtor(&zresult);
} else {
ZVAL_ZVAL(return_value, zresult, 1, 1);
}
}
if (access == ZEND_ACC_PROTECTED) {
pthreads_modifiers_unprotect(thread->modifiers, method, unprotect TSRMLS_CC);
}
} else {
zend_error_noreturn(
E_ERROR,
"pthreads has experienced an internal error while calling %s method %s::%s and cannot continue",
(access == ZEND_ACC_PROTECTED) ? "protected" : "private",
scope->name,
method
);
called = FAILURE;
}
}
} else {
zend_error_noreturn(
E_ERROR,
"pthreads has experienced an internal error while finding %s method %s::%s and cannot continue",
(access == ZEND_ACC_PROTECTED) ? "protected" : "private",
scope->name,
method
);
called = FAILURE;
}
}
/*
* Free unstacked arguments
*/
if (argc) {
efree(argv);
}
free(lcname);
return called;
} break;
}
}
}
switch (called) {
case -1:
return zend_handlers->call_method(PTHREADS_CALL_METHOD_PASSTHRU_C);
default: return called;
}
} /* }}} */
/* {{{ php_dba_open
*/
static void php_dba_open(INTERNAL_FUNCTION_PARAMETERS, int persistent)
{
zval *args = NULL;
int ac = ZEND_NUM_ARGS();
dba_mode_t modenr;
dba_info *info, *other;
dba_handler *hptr;
char *key = NULL, *error = NULL;
int keylen = 0;
int i;
int lock_mode, lock_flag, lock_dbf = 0;
char *file_mode;
char mode[4], *pmode, *lock_file_mode = NULL;
int persistent_flag = persistent ? STREAM_OPEN_PERSISTENT : 0;
zend_string *opened_path = NULL;
char *lock_name;
if (ac < 2) {
WRONG_PARAM_COUNT;
}
/* we pass additional args to the respective handler */
args = safe_emalloc(ac, sizeof(zval), 0);
if (zend_get_parameters_array_ex(ac, args) != SUCCESS) {
efree(args);
WRONG_PARAM_COUNT;
}
/* we only take string arguments */
for (i = 0; i < ac; i++) {
if (Z_TYPE(args[i]) != IS_STRING) {
convert_to_string_ex(&args[i]);
} else if (Z_REFCOUNTED(args[i])) {
Z_ADDREF(args[i]);
}
keylen += Z_STRLEN(args[i]);
}
if (persistent) {
zend_resource *le;
/* calculate hash */
key = safe_emalloc(keylen, 1, 1);
key[keylen] = '\0';
keylen = 0;
for(i = 0; i < ac; i++) {
memcpy(key+keylen, Z_STRVAL(args[i]), Z_STRLEN(args[i]));
keylen += Z_STRLEN(args[i]);
}
/* try to find if we already have this link in our persistent list */
if ((le = zend_hash_str_find_ptr(&EG(persistent_list), key, keylen)) != NULL) {
FREENOW;
if (le->type != le_pdb) {
RETURN_FALSE;
}
info = (dba_info *)le->ptr;
GC_REFCOUNT(le)++;
RETURN_RES(le);
return;
}
}
if (ac==2) {
hptr = DBA_G(default_hptr);
if (!hptr) {
php_error_docref2(NULL, Z_STRVAL(args[0]), Z_STRVAL(args[1]), E_WARNING, "No default handler selected");
FREENOW;
RETURN_FALSE;
}
} else {
for (hptr = handler; hptr->name && strcasecmp(hptr->name, Z_STRVAL(args[2])); hptr++);
}
if (!hptr->name) {
php_error_docref2(NULL, Z_STRVAL(args[0]), Z_STRVAL(args[1]), E_WARNING, "No such handler: %s", Z_STRVAL(args[2]));
FREENOW;
RETURN_FALSE;
}
/* Check mode: [rwnc][fl]?t?
* r: Read
* w: Write
* n: Create/Truncate
* c: Create
*
* d: force lock on database file
* l: force lock on lck file
* -: ignore locking
*
* t: test open database, warning if locked
*/
strlcpy(mode, Z_STRVAL(args[1]), sizeof(mode));
pmode = &mode[0];
if (pmode[0] && (pmode[1]=='d' || pmode[1]=='l' || pmode[1]=='-')) { /* force lock on db file or lck file or disable locking */
switch (pmode[1]) {
case 'd':
lock_dbf = 1;
if ((hptr->flags & DBA_LOCK_ALL) == 0) {
lock_flag = (hptr->flags & DBA_LOCK_ALL);
break;
}
/* no break */
case 'l':
lock_flag = DBA_LOCK_ALL;
if ((hptr->flags & DBA_LOCK_ALL) == 0) {
php_error_docref2(NULL, Z_STRVAL(args[0]), Z_STRVAL(args[1]), E_NOTICE, "Handler %s does locking internally", hptr->name);
}
break;
default:
case '-':
if ((hptr->flags & DBA_LOCK_ALL) == 0) {
php_error_docref2(NULL, Z_STRVAL(args[0]), Z_STRVAL(args[1]), E_WARNING, "Locking cannot be disabled for handler %s", hptr->name);
FREENOW;
RETURN_FALSE;
}
lock_flag = 0;
break;
}
} else {
lock_flag = (hptr->flags&DBA_LOCK_ALL);
lock_dbf = 1;
}
switch (*pmode++) {
case 'r':
modenr = DBA_READER;
lock_mode = (lock_flag & DBA_LOCK_READER) ? LOCK_SH : 0;
file_mode = "r";
break;
case 'w':
modenr = DBA_WRITER;
lock_mode = (lock_flag & DBA_LOCK_WRITER) ? LOCK_EX : 0;
file_mode = "r+b";
break;
case 'c':
modenr = DBA_CREAT;
lock_mode = (lock_flag & DBA_LOCK_CREAT) ? LOCK_EX : 0;
if (lock_mode) {
if (lock_dbf) {
/* the create/append check will be done on the lock
* when the lib opens the file it is already created
*/
file_mode = "r+b"; /* read & write, seek 0 */
lock_file_mode = "a+b"; /* append */
} else {
file_mode = "a+b"; /* append */
lock_file_mode = "w+b"; /* create/truncate */
}
} else {
file_mode = "a+b";
}
/* In case of the 'a+b' append mode, the handler is responsible
* to handle any rewind problems (see flatfile handler).
*/
break;
case 'n':
modenr = DBA_TRUNC;
lock_mode = (lock_flag & DBA_LOCK_TRUNC) ? LOCK_EX : 0;
file_mode = "w+b";
break;
default:
php_error_docref2(NULL, Z_STRVAL(args[0]), Z_STRVAL(args[1]), E_WARNING, "Illegal DBA mode");
FREENOW;
RETURN_FALSE;
}
if (!lock_file_mode) {
lock_file_mode = file_mode;
}
if (*pmode=='d' || *pmode=='l' || *pmode=='-') {
pmode++; /* done already - skip here */
}
if (*pmode=='t') {
pmode++;
if (!lock_flag) {
php_error_docref2(NULL, Z_STRVAL(args[0]), Z_STRVAL(args[1]), E_WARNING, "You cannot combine modifiers - (no lock) and t (test lock)");
FREENOW;
RETURN_FALSE;
}
if (!lock_mode) {
if ((hptr->flags & DBA_LOCK_ALL) == 0) {
php_error_docref2(NULL, Z_STRVAL(args[0]), Z_STRVAL(args[1]), E_WARNING, "Handler %s uses its own locking which doesn't support mode modifier t (test lock)", hptr->name);
FREENOW;
RETURN_FALSE;
} else {
php_error_docref2(NULL, Z_STRVAL(args[0]), Z_STRVAL(args[1]), E_WARNING, "Handler %s doesn't uses locking for this mode which makes modifier t (test lock) obsolete", hptr->name);
FREENOW;
RETURN_FALSE;
}
} else {
lock_mode |= LOCK_NB; /* test =: non blocking */
}
}
if (*pmode) {
php_error_docref2(NULL, Z_STRVAL(args[0]), Z_STRVAL(args[1]), E_WARNING, "Illegal DBA mode");
FREENOW;
RETURN_FALSE;
}
info = pemalloc(sizeof(dba_info), persistent);
memset(info, 0, sizeof(dba_info));
info->path = pestrdup(Z_STRVAL(args[0]), persistent);
info->mode = modenr;
info->argc = ac - 3;
info->argv = args + 3;
info->flags = (hptr->flags & ~DBA_LOCK_ALL) | (lock_flag & DBA_LOCK_ALL) | (persistent ? DBA_PERSISTENT : 0);
info->lock.mode = lock_mode;
/* if any open call is a locking call:
* check if we already habe a locking call open that should block this call
* the problem is some systems would allow read during write
*/
if (hptr->flags & DBA_LOCK_ALL) {
if ((other = php_dba_find(info->path)) != NULL) {
if ( ( (lock_mode&LOCK_EX) && (other->lock.mode&(LOCK_EX|LOCK_SH)) )
|| ( (other->lock.mode&LOCK_EX) && (lock_mode&(LOCK_EX|LOCK_SH)) )
) {
error = "Unable to establish lock (database file already open)"; /* force failure exit */
}
}
}
if (!error && lock_mode) {
if (lock_dbf) {
lock_name = Z_STRVAL(args[0]);
} else {
spprintf(&lock_name, 0, "%s.lck", info->path);
if (!strcmp(file_mode, "r")) {
/* when in read only mode try to use existing .lck file first */
/* do not log errors for .lck file while in read ony mode on .lck file */
lock_file_mode = "rb";
info->lock.fp = php_stream_open_wrapper(lock_name, lock_file_mode, STREAM_MUST_SEEK|IGNORE_PATH|persistent_flag, &opened_path);
}
if (!info->lock.fp) {
/* when not in read mode or failed to open .lck file read only. now try again in create(write) mode and log errors */
lock_file_mode = "a+b";
} else {
if (opened_path) {
info->lock.name = pestrndup(opened_path->val, opened_path->len, persistent);
zend_string_release(opened_path);
}
}
}
if (!info->lock.fp) {
info->lock.fp = php_stream_open_wrapper(lock_name, lock_file_mode, STREAM_MUST_SEEK|REPORT_ERRORS|IGNORE_PATH|persistent_flag, &opened_path);
if (info->lock.fp) {
if (lock_dbf) {
/* replace the path info with the real path of the opened file */
pefree(info->path, persistent);
info->path = pestrndup(opened_path->val, opened_path->len, persistent);
}
/* now store the name of the lock */
info->lock.name = pestrndup(opened_path->val, opened_path->len, persistent);
zend_string_release(opened_path);
}
}
if (!lock_dbf) {
efree(lock_name);
}
if (!info->lock.fp) {
dba_close(info);
/* stream operation already wrote an error message */
FREENOW;
RETURN_FALSE;
}
if (!php_stream_supports_lock(info->lock.fp)) {
error = "Stream does not support locking";
}
if (php_stream_lock(info->lock.fp, lock_mode)) {
error = "Unable to establish lock"; /* force failure exit */
}
}
/* centralised open stream for builtin */
if (!error && (hptr->flags&DBA_STREAM_OPEN)==DBA_STREAM_OPEN) {
if (info->lock.fp && lock_dbf) {
info->fp = info->lock.fp; /* use the same stream for locking and database access */
} else {
info->fp = php_stream_open_wrapper(info->path, file_mode, STREAM_MUST_SEEK|REPORT_ERRORS|IGNORE_PATH|persistent_flag, NULL);
}
if (!info->fp) {
dba_close(info);
/* stream operation already wrote an error message */
FREENOW;
RETURN_FALSE;
}
if (hptr->flags & (DBA_NO_APPEND|DBA_CAST_AS_FD)) {
/* Needed because some systems do not allow to write to the original
* file contents with O_APPEND being set.
*/
if (SUCCESS != php_stream_cast(info->fp, PHP_STREAM_AS_FD, (void*)&info->fd, 1)) {
php_error_docref(NULL, E_WARNING, "Could not cast stream");
dba_close(info);
FREENOW;
RETURN_FALSE;
#ifdef F_SETFL
} else if (modenr == DBA_CREAT) {
int flags = fcntl(info->fd, F_SETFL);
fcntl(info->fd, F_SETFL, flags & ~O_APPEND);
#endif
}
}
}
if (error || hptr->open(info, &error) != SUCCESS) {
dba_close(info);
php_error_docref2(NULL, Z_STRVAL(args[0]), Z_STRVAL(args[1]), E_WARNING, "Driver initialization failed for handler: %s%s%s", hptr->name, error?": ":"", error?error:"");
FREENOW;
RETURN_FALSE;
}
info->hnd = hptr;
info->argc = 0;
info->argv = NULL;
if (persistent) {
zend_resource new_le;
new_le.type = le_pdb;
new_le.ptr = info;
if (zend_hash_str_update_mem(&EG(persistent_list), key, keylen, &new_le, sizeof(zend_resource)) == NULL) {
dba_close(info);
php_error_docref2(NULL, Z_STRVAL(args[0]), Z_STRVAL(args[1]), E_WARNING, "Could not register persistent resource");
FREENOW;
RETURN_FALSE;
}
}
RETVAL_RES(zend_register_resource(info, (persistent ? le_pdb : le_db)));
FREENOW;
}
/* {{{ php_mktime
*/
void php_mktime(INTERNAL_FUNCTION_PARAMETERS, int gm)
{
pval **arguments[7];
struct tm *ta, tmbuf;
time_t t, seconds;
int i, gmadjust, arg_count = ZEND_NUM_ARGS();
int is_dst = -1, chgsecs = 0;
long val;
if (arg_count > 7 || zend_get_parameters_array_ex(arg_count, arguments) == FAILURE) {
WRONG_PARAM_COUNT;
}
/* convert supplied arguments to longs */
for (i = 0; i < arg_count; i++) {
convert_to_long_ex(arguments[i]);
}
t = time(NULL);
#ifdef HAVE_TZSET
tzset();
#endif
/*
** Set default time parameters with local time values,
** EVEN when some GMT time parameters are specified!
** This may give strange result, with PHP gmmktime(0, 0, 0),
** which is assumed to return GMT midnight time
** for today (in localtime), so that the result time may be
** AFTER or BEFORE the current time.
** May be we should initialize tn using gmtime(), so that
** default parameters for PHP gmmktime would be the current
** GMT time values...
*/
ta = php_localtime_r(&t, &tmbuf);
/* Let DST be unknown. mktime() should compute the right value
** and behave correctly. Unless the user overrides this.
*/
ta->tm_isdst = -1;
/*
** Now change date values with supplied parameters.
*/
switch(arg_count) {
case 7: /* daylight saving time flag */
#ifdef PHP_WIN32
if (daylight > 0) {
ta->tm_isdst = is_dst = Z_LVAL_PP(arguments[6]);
} else {
ta->tm_isdst = is_dst = 0;
}
#else
ta->tm_isdst = is_dst = Z_LVAL_PP(arguments[6]);
#endif
/* fall-through */
case 6: /* year */
/* special case:
a zero in year, month and day is considered illegal
as it would be interpreted as 30.11.1999 otherwise
*/
if ( ( Z_LVAL_PP(arguments[5])==0)
&&(Z_LVAL_PP(arguments[4])==0)
&&(Z_LVAL_PP(arguments[3])==0)
) {
RETURN_LONG(-1);
}
/*
** Accept parameter in range 0..1000 interpreted as 1900..2900
** (if 100 is given, it means year 2000)
** or in range 1001..9999 interpreted as is (this will store
** negative tm_year for years in range 1001..1899)
** This function is then Y2K ready, and accepts a wide range of
** dates including the whole gregorian calendar.
** But it cannot represent ancestral dates prior to year 1001.
** Additionally, input parameters of 0..70 are mapped to 100..170
*/
if (Z_LVAL_PP(arguments[5]) < 70)
ta->tm_year = Z_LVAL_PP(arguments[5]) + 100;
else
ta->tm_year = Z_LVAL_PP(arguments[5])
- ((Z_LVAL_PP(arguments[5]) > 1000) ? 1900 : 0);
/* fall-through */
case 5: /* day in month (1-based) */
val = (*arguments[4])->value.lval;
if (val < 1) {
chgsecs += (1-val) * 60*60*24;
val = 1;
}
ta->tm_mday = val;
/* fall-through */
case 4: /* month (zero-based) */
val = (*arguments[3])->value.lval - 1;
while (val < 0) {
val += 12; ta->tm_year--;
}
ta->tm_mon = val;
/* fall-through */
case 3: /* second */
val = (*arguments[2])->value.lval;
if (val < 1) {
chgsecs += (1-val); val = 1;
}
ta->tm_sec = val;
/* fall-through */
case 2: /* minute */
val = (*arguments[1])->value.lval;
if (val < 1) {
chgsecs += (1-val) * 60; val = 1;
}
ta->tm_min = val;
/* fall-through */
case 1: /* hour */
val = (*arguments[0])->value.lval;
/*
We avoid midnight and a couple of hours after midnight here to work around
various OS-level bugs in mktime and specifically daylight savings time issues
in many mktime implementation.
See bugs #27533 and #27719 for more info.
*/
if (val < 4) {
chgsecs += (4-val) * 60*60; val = 4;
}
ta->tm_hour = val;
/* fall-through */
case 0:
break;
}
t = mktime(ta);
#ifdef PHP_WIN32
if (t - chgsecs < 0) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Windows does not support negative values for this function");
RETURN_LONG(-1);
}
#endif
seconds = t - chgsecs;
/*
Here we check to see if the chgsecs fuzz factor we applied caused us to
move from dst to non-dst or vice-versa. If so we adjust accordingly to
avoid being off by an hour on the dst changeover date.
*/
if (is_dst == -1) {
struct tm t1, t2;
t1 = *localtime(&t);
t2 = *localtime(&seconds);
if (t1.tm_isdst != t2.tm_isdst) {
seconds += (t1.tm_isdst == 1) ? 3600 : -3600;
ta = localtime(&seconds);
}
/*
If the user didn't specify whether the timestamp passed in was dst or not
then we fill it in based on the dst setting at the evaluated timestamp
at the current TZ
*/
is_dst = ta->tm_isdst;
}
if (gm) {
#if HAVE_TM_GMTOFF
/*
** mktime(ta) very nicely just filled ta->tm_gmtoff with
** the exactly right value for adjustment if we want GMT.
*/
gmadjust = ta->tm_gmtoff;
#else
/*
** If correcting for daylight savings time, we set the adjustment to
** the value of timezone - 3600 seconds.
*/
#ifdef __CYGWIN__
gmadjust = -(is_dst ? _timezone - 3600 : _timezone);
#else
gmadjust = -(is_dst ? timezone - 3600 : timezone);
#endif
#endif
seconds += gmadjust;
}
RETURN_LONG(seconds);
}
/* {{{ proto object ffmpeg_movie(string filename)
Constructor for ffmpeg_movie objects
*/
FFMPEG_PHP_CONSTRUCTOR(ffmpeg_movie, __construct)
{
int persistent = 0, hashkey_length = 0;
char *filename = NULL, *fullpath = NULL, *hashkey = NULL;
zval ***argv;
ff_movie_context *ffmovie_ctx = NULL;
/* retrieve arguments */
argv = (zval ***) safe_emalloc(sizeof(zval **), ZEND_NUM_ARGS(), 0);
if (zend_get_parameters_array_ex(ZEND_NUM_ARGS(), argv) != SUCCESS) {
efree(argv);
php_error_docref(NULL TSRMLS_CC, E_ERROR,
"Error parsing arguments");
}
switch (ZEND_NUM_ARGS()) {
case 2:
convert_to_boolean_ex(argv[1]);
if (! INI_BOOL("ffmpeg.allow_persistent") && Z_LVAL_PP(argv[1])) {
zend_error(E_WARNING,
"Persistent movies have been disabled in php.ini");
break;
}
persistent = Z_LVAL_PP(argv[1]);
/* fallthru */
case 1:
convert_to_string_ex(argv[0]);
filename = Z_STRVAL_PP(argv[0]);
break;
default:
WRONG_PARAM_COUNT;
}
if (persistent) {
list_entry *le;
/* resolve the fully-qualified path name to use as the hash key */
fullpath = expand_filepath(filename, NULL TSRMLS_CC);
hashkey_length = sizeof("ffmpeg-php_")-1 +
strlen(SAFE_STRING(filename));
hashkey = (char *) emalloc(hashkey_length+1);
snprintf(hashkey, hashkey_length, "ffmpeg-php_%s",
SAFE_STRING(filename));
/* do we have an existing persistent movie? */
if (SUCCESS == zend_hash_find(&EG(persistent_list), hashkey,
hashkey_length+1, (void**)&le)) {
int type;
if (Z_TYPE_P(le) != le_ffmpeg_pmovie) {
php_error_docref(NULL TSRMLS_CC, E_ERROR,
"Failed to retrieve persistent resource");
}
ffmovie_ctx = (ff_movie_context*)le->ptr;
/* sanity check to ensure that the resource is still a valid
* regular resource number */
if (zend_list_find(ffmovie_ctx->rsrc_id, &type) == ffmovie_ctx) {
/* add a reference to the persistent movie */
zend_list_addref(ffmovie_ctx->rsrc_id);
} else {
//php_error_docref(NULL TSRMLS_CC, E_ERROR,
//"Not a valid persistent movie resource");
ffmovie_ctx->rsrc_id = ZEND_REGISTER_RESOURCE(NULL,
ffmovie_ctx, le_ffmpeg_pmovie);
}
} else { /* no existing persistant movie, create one */
list_entry new_le;
ffmovie_ctx = _php_alloc_ffmovie_ctx(1);
if (_php_open_movie_file(ffmovie_ctx, filename)) {
zend_error(E_WARNING, "Can't open movie file %s", filename);
efree(argv);
ZVAL_BOOL(getThis(), 0);
RETURN_FALSE;
}
Z_TYPE(new_le) = le_ffmpeg_pmovie;
new_le.ptr = ffmovie_ctx;
if (FAILURE == zend_hash_update(&EG(persistent_list), hashkey,
hashkey_length+1, (void *)&new_le, sizeof(list_entry),
NULL)) {
php_error_docref(NULL TSRMLS_CC, E_WARNING,
"Failed to register persistent resource");
}
ffmovie_ctx->rsrc_id = ZEND_REGISTER_RESOURCE(NULL, ffmovie_ctx,
le_ffmpeg_pmovie);
}
} else {
ffmovie_ctx = _php_alloc_ffmovie_ctx(0);
if (_php_open_movie_file(ffmovie_ctx, Z_STRVAL_PP(argv[0]))) {
zend_error(E_WARNING, "Can't open movie file %s",
Z_STRVAL_PP(argv[0]));
efree(argv);
ZVAL_BOOL(getThis(), 0);
RETURN_FALSE;
}
/* pass NULL for resource result since we're not returning the resource
directly, but adding it to the returned object. */
ffmovie_ctx->rsrc_id = ZEND_REGISTER_RESOURCE(NULL, ffmovie_ctx,
le_ffmpeg_movie);
}
object_init_ex(getThis(), ffmpeg_movie_class_entry_ptr);
add_property_resource(getThis(), "ffmpeg_movie", ffmovie_ctx->rsrc_id);
efree(argv);
if (fullpath) {
efree(fullpath);
}
if (hashkey) {
efree(hashkey);
}
}
