/**
* Construct an instance of the Channel class. If the $args array contains a
* "credentials" key mapping to a ChannelCredentials object, a secure channel
* will be created with those credentials.
* @param string $target The hostname to associate with this channel
* @param array $args The arguments to pass to the Channel (optional)
*/
PHP_METHOD(Channel, __construct) {
wrapped_grpc_channel *channel = Z_WRAPPED_GRPC_CHANNEL_P(getThis());
zend_string *target;
zval *args_array = NULL;
grpc_channel_args args;
HashTable *array_hash;
zval *creds_obj = NULL;
wrapped_grpc_channel_credentials *creds = NULL;
/* "Sa" == 1 string, 1 array */
#ifndef FAST_ZPP
if (zend_parse_parameters(ZEND_NUM_ARGS(), "Sa", &target, &args_array)
== FAILURE) {
zend_throw_exception(spl_ce_InvalidArgumentException,
"Channel expects a string and an array", 1);
return;
}
#else
ZEND_PARSE_PARAMETERS_START(2, 2)
Z_PARAM_STR(target)
Z_PARAM_ARRAY(args_array)
ZEND_PARSE_PARAMETERS_END();
#endif
array_hash = HASH_OF(args_array);
if ((creds_obj = zend_hash_str_find(array_hash, "credentials",
sizeof("credentials") - 1)) != NULL) {
if (Z_TYPE_P(creds_obj) == IS_NULL) {
creds = NULL;
zend_hash_str_del(array_hash, "credentials", sizeof("credentials") - 1);
} else if (Z_OBJ_P(creds_obj)->ce != grpc_ce_channel_credentials) {
zend_throw_exception(spl_ce_InvalidArgumentException,
"credentials must be a ChannelCredentials object",
1);
return;
} else {
creds = Z_WRAPPED_GRPC_CHANNEL_CREDS_P(creds_obj);
zend_hash_str_del(array_hash, "credentials", sizeof("credentials") - 1);
}
}
php_grpc_read_args_array(args_array, &args);
if (creds == NULL) {
channel->wrapped = grpc_insecure_channel_create(ZSTR_VAL(target),
&args, NULL);
} else {
channel->wrapped =
grpc_secure_channel_create(creds->wrapped, ZSTR_VAL(target),
&args, NULL);
}
efree(args.args);
}
/* {{{ bool SQLite::sqliteCreateFunction(string name, mixed callback [, int argcount])
Registers a UDF with the sqlite db handle */
static PHP_METHOD(SQLite, sqliteCreateFunction)
{
struct pdo_sqlite_func *func;
zval *callback;
char *func_name;
size_t func_name_len;
zend_long argc = -1;
zend_string *cbname = NULL;
pdo_dbh_t *dbh;
pdo_sqlite_db_handle *H;
int ret;
ZEND_PARSE_PARAMETERS_START(2, 3)
Z_PARAM_STRING(func_name, func_name_len)
Z_PARAM_ZVAL_DEREF(callback)
Z_PARAM_OPTIONAL
Z_PARAM_LONG(argc)
ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
dbh = Z_PDO_DBH_P(getThis());
PDO_CONSTRUCT_CHECK;
if (!zend_is_callable(callback, 0, &cbname)) {
php_error_docref(NULL, E_WARNING, "function '%s' is not callable", ZSTR_VAL(cbname));
zend_string_release(cbname);
RETURN_FALSE;
}
zend_string_release(cbname);
H = (pdo_sqlite_db_handle *)dbh->driver_data;
func = (struct pdo_sqlite_func*)ecalloc(1, sizeof(*func));
ret = sqlite3_create_function(H->db, func_name, argc, SQLITE_UTF8,
func, php_sqlite3_func_callback, NULL, NULL);
if (ret == SQLITE_OK) {
func->funcname = estrdup(func_name);
ZVAL_COPY(&func->func, callback);
func->argc = argc;
func->next = H->funcs;
H->funcs = func;
RETURN_TRUE;
}
efree(func);
RETURN_FALSE;
}
/* {{{ php_stream_bucket_attach */
static void php_stream_bucket_attach(int append, INTERNAL_FUNCTION_PARAMETERS)
{
zval *zbrigade, *zobject;
zval *pzbucket, *pzdata;
php_stream_bucket_brigade *brigade;
php_stream_bucket *bucket;
ZEND_PARSE_PARAMETERS_START(2, 2)
Z_PARAM_RESOURCE(zbrigade)
Z_PARAM_OBJECT(zobject)
ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
if (NULL == (pzbucket = zend_hash_str_find(Z_OBJPROP_P(zobject), "bucket", sizeof("bucket")-1))) {
php_error_docref(NULL, E_WARNING, "Object has no bucket property");
RETURN_FALSE;
}
if ((brigade = (php_stream_bucket_brigade*)zend_fetch_resource(
Z_RES_P(zbrigade), PHP_STREAM_BRIGADE_RES_NAME, le_bucket_brigade)) == NULL) {
RETURN_FALSE;
}
if ((bucket = (php_stream_bucket *)zend_fetch_resource_ex(pzbucket, PHP_STREAM_BUCKET_RES_NAME, le_bucket)) == NULL) {
RETURN_FALSE;
}
if (NULL != (pzdata = zend_hash_str_find(Z_OBJPROP_P(zobject), "data", sizeof("data")-1)) && Z_TYPE_P(pzdata) == IS_STRING) {
if (!bucket->own_buf) {
bucket = php_stream_bucket_make_writeable(bucket);
}
if (bucket->buflen != Z_STRLEN_P(pzdata)) {
bucket->buf = perealloc(bucket->buf, Z_STRLEN_P(pzdata), bucket->is_persistent);
bucket->buflen = Z_STRLEN_P(pzdata);
}
memcpy(bucket->buf, Z_STRVAL_P(pzdata), bucket->buflen);
}
if (append) {
php_stream_bucket_append(brigade, bucket);
} else {
php_stream_bucket_prepend(brigade, bucket);
}
/* This is a hack necessary to accommodate situations where bucket is appended to the stream
* multiple times. See bug35916.phpt for reference.
*/
if (bucket->refcount == 1) {
bucket->refcount++;
}
}
static PHP_METHOD(swoole_coroutine_util, readFile)
{
coro_check(TSRMLS_C);
char *filename = NULL;
size_t l_filename = 0;
#ifdef FAST_ZPP
ZEND_PARSE_PARAMETERS_START(1, 2)
Z_PARAM_STRING(filename, l_filename)
ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
#else
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &filename, &l_filename) == FAILURE)
{
return;
}
#endif
swAio_event ev;
bzero(&ev, sizeof(swAio_event));
php_context *context = emalloc(sizeof(php_context));
ev.type = SW_AIO_READ_FILE;
ev.object = context;
ev.handler = swAio_handler_read_file;
ev.callback = aio_onReadFileCompleted;
ev.req = estrndup(filename, l_filename);
if (!SwooleAIO.init)
{
php_swoole_check_reactor();
swAio_init();
}
swTrace("readFile(%s)", filename);
int ret = swAio_dispatch(&ev);
if (ret < 0)
{
efree(context);
RETURN_FALSE;
}
context->state = SW_CORO_CONTEXT_RUNNING;
coro_save(context);
coro_yield();
}
/** public function ION\HTTP\Message::withProtocolVersion(string $version) : self */
CLASS_METHOD(ION_HTTP_Message, withProtocolVersion) {
ion_http_message * message = ION_THIS_OBJECT(ion_http_message);
zend_string * version = NULL;
ZEND_PARSE_PARAMETERS_START(1, 1)
Z_PARAM_STR(version)
ZEND_PARSE_PARAMETERS_END_EX(PION_ZPP_THROW);
if(message->version) {
zend_string_release(message->version);
}
message->version = zend_string_copy(version);
RETURN_THIS();
}
// extern void TF_SetDevice(TF_OperationDescription* desc, const char* device);
static PHP_METHOD(TensorFlow_OperationDescription, setDevice)
{
zend_string *device;
ZEND_PARSE_PARAMETERS_START(1, 1)
Z_PARAM_STR(device)
ZEND_PARSE_PARAMETERS_END();
// php_printf("device : %s\n", device->val);
t_tf_operation_description_object* intern = TF_OPERATION_DESCRIPTION_P_ZV(getThis());
t_tf_operation_description* node = intern->ptr;
TF_SetDevice(node->src, device->val);
}
/** public function ION\HTTP\Message::hasHeader(string $name) : bool */
CLASS_METHOD(ION_HTTP_Message, hasHeader) {
ion_http_message * message = ION_THIS_OBJECT(ion_http_message);
zend_string * name = NULL;
ZEND_PARSE_PARAMETERS_START(1, 1)
Z_PARAM_STR(name)
ZEND_PARSE_PARAMETERS_END_EX(PION_ZPP_THROW);
name = zend_string_tolower(name);
if(zend_hash_exists(message->headers, name)) {
RETVAL_TRUE;
} else {
RETVAL_FALSE;
}
zend_string_release(name);
}
/** public function ION\HTTP\Message::getHeader(string $name) : array */
CLASS_METHOD(ION_HTTP_Message, getHeader) {
ion_http_message * message = ION_THIS_OBJECT(ion_http_message);
zend_string * name = NULL;
zval * header = NULL;
ZEND_PARSE_PARAMETERS_START(1, 1)
Z_PARAM_STR(name)
ZEND_PARSE_PARAMETERS_END_EX(PION_ZPP_THROW);
name = zend_string_tolower(name);
header = zend_hash_find(message->headers, name);
zend_string_release(name);
if(header) {
RETURN_ZVAL(header, 1, 0)
} else {
// extern void TF_SetAttrBool(TF_OperationDescription* desc, const char* attr_name,
// unsigned char value);
static PHP_METHOD(TensorFlow_OperationDescription, setAttrBool)
{
zend_string *name;
zend_bool value;
ZEND_PARSE_PARAMETERS_START(2, 2)
Z_PARAM_STR(name)
Z_PARAM_BOOL(value)
ZEND_PARSE_PARAMETERS_END();
// this
t_tf_operation_description_object* intern = TF_OPERATION_DESCRIPTION_P_ZV(getThis());
t_tf_operation_description* node = intern->ptr;
TF_SetAttrBool(node->src, name->val, value);
}
PHP_METHOD(swoole_atomic_long, set)
{
sw_atomic_long_t *atomic = swoole_get_object(getThis());
zend_long set_value;
#ifdef FAST_ZPP
ZEND_PARSE_PARAMETERS_START(1, 1)
Z_PARAM_LONG(set_value)
ZEND_PARSE_PARAMETERS_END();
#else
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &set_value) == FAILURE)
{
RETURN_FALSE;
}
#endif
*atomic = (sw_atomic_long_t) set_value;
}
/** public function ION\Process\IPC::send(string $data) : self */
CLASS_METHOD(ION_Process_IPC, send) {
ion_process_ipc * ipc = ION_THIS_OBJECT(ion_process_ipc);
zend_string * data = NULL;
size_t frame_size;
char * frame;
ZEND_PARSE_PARAMETERS_START(1, 1)
Z_PARAM_STR(data)
ZEND_PARSE_PARAMETERS_END_EX(PION_ZPP_THROW);
frame_size = websocket_calc_frame_size(ION_IPC_FIN | ION_IPC_DATA, ZSTR_LEN(data));
frame = emalloc(frame_size);
websocket_build_frame(frame, ION_IPC_FIN | ION_IPC_DATA, NULL, ZSTR_VAL(data), ZSTR_LEN(data));
bufferevent_write(ipc->buffer, frame, frame_size);
efree(frame);
RETURN_THIS();
}
/* {{{ bool SQLite::sqliteCreateCollation(string name, mixed callback)
Registers a collation with the sqlite db handle */
static PHP_METHOD(SQLite, sqliteCreateCollation)
{
struct pdo_sqlite_collation *collation;
zval *callback;
char *collation_name;
size_t collation_name_len;
zend_string *cbname = NULL;
pdo_dbh_t *dbh;
pdo_sqlite_db_handle *H;
int ret;
ZEND_PARSE_PARAMETERS_START(2, 2)
Z_PARAM_STRING(collation_name, collation_name_len)
Z_PARAM_ZVAL_DEREF(callback)
ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
dbh = Z_PDO_DBH_P(getThis());
PDO_CONSTRUCT_CHECK;
if (!zend_is_callable(callback, 0, &cbname)) {
php_error_docref(NULL, E_WARNING, "function '%s' is not callable", ZSTR_VAL(cbname));
zend_string_release(cbname);
RETURN_FALSE;
}
zend_string_release(cbname);
H = (pdo_sqlite_db_handle *)dbh->driver_data;
collation = (struct pdo_sqlite_collation*)ecalloc(1, sizeof(*collation));
ret = sqlite3_create_collation(H->db, collation_name, SQLITE_UTF8, collation, php_sqlite3_collation_callback);
if (ret == SQLITE_OK) {
collation->name = estrdup(collation_name);
ZVAL_COPY(&collation->callback, callback);
collation->next = H->collations;
H->collations = collation;
RETURN_TRUE;
}
efree(collation);
RETURN_FALSE;
}
/**
* Constructs a new instance of the Call class.
* @param Channel $channel The channel to associate the call with. Must not be
* closed.
* @param string $method The method to call
* @param Timeval $absolute_deadline The deadline for completing the call
*/
PHP_METHOD(Call, __construct) {
wrapped_grpc_call *call = Z_WRAPPED_GRPC_CALL_P(getThis());
zval *channel_obj;
//char *method;
//size_t method_len;
zend_string *method;
zval *deadline_obj;
//char *host_override = NULL;
//size_t host_override_len = 0;
zend_string *host_override;
/* "OSO|S" == 1 Object, 1 string, 1 Object, 1 optional string */
#ifndef FAST_ZPP
if (zend_parse_parameters(ZEND_NUM_ARGS(), "OSO|S", &channel_obj,
grpc_ce_channel, &method, &deadline_obj,
grpc_ce_timeval, &host_override) == FAILURE) {
zend_throw_exception(
spl_ce_InvalidArgumentException,
"Call expects a Channel, a String, a Timeval and an optional String",
1);
return;
}
#else
ZEND_PARSE_PARAMETERS_START(3, 4)
Z_PARAM_OBJECT_OF_CLASS(channel_obj, grpc_ce_channel)
Z_PARAM_STR(method)
Z_PARAM_OBJECT_OF_CLASS(deadline_obj, grpc_ce_timeval)
Z_PARAM_OPTIONAL
Z_PARAM_STR(host_override)
ZEND_PARSE_PARAMETERS_END();
#endif
wrapped_grpc_channel *channel = Z_WRAPPED_GRPC_CHANNEL_P(channel_obj);
if (channel->wrapped == NULL) {
zend_throw_exception(spl_ce_InvalidArgumentException,
"Call cannot be constructed from a closed Channel",
1);
return;
}
add_property_zval(getThis(), "channel", channel_obj);
wrapped_grpc_timeval *deadline = Z_WRAPPED_GRPC_TIMEVAL_P(deadline_obj);
call->wrapped = grpc_channel_create_call(
channel->wrapped, NULL, GRPC_PROPAGATE_DEFAULTS, completion_queue,
ZSTR_VAL(method), ZSTR_VAL(host_override), deadline->wrapped, NULL);
}
/* {{{ proto mixed json_decode(string json [, bool assoc [, long depth]])
Decodes the JSON representation into a PHP value */
static PHP_FUNCTION(json_decode)
{
char *str;
size_t str_len;
zend_bool assoc = 0; /* return JS objects as PHP objects by default */
zend_bool assoc_null = 1;
zend_long depth = PHP_JSON_PARSER_DEFAULT_DEPTH;
zend_long options = 0;
ZEND_PARSE_PARAMETERS_START(1, 4)
Z_PARAM_STRING(str, str_len)
Z_PARAM_OPTIONAL
Z_PARAM_BOOL_EX(assoc, assoc_null, 1, 0)
Z_PARAM_LONG(depth)
Z_PARAM_LONG(options)
ZEND_PARSE_PARAMETERS_END();
JSON_G(error_code) = PHP_JSON_ERROR_NONE;
if (!str_len) {
JSON_G(error_code) = PHP_JSON_ERROR_SYNTAX;
RETURN_NULL();
}
if (depth <= 0) {
php_error_docref(NULL, E_WARNING, "Depth must be greater than zero");
RETURN_NULL();
}
if (depth > INT_MAX) {
php_error_docref(NULL, E_WARNING, "Depth must be lower than %d", INT_MAX);
RETURN_NULL();
}
/* For BC reasons, the bool $assoc overrides the long $options bit for PHP_JSON_OBJECT_AS_ARRAY */
if (!assoc_null) {
if (assoc) {
options |= PHP_JSON_OBJECT_AS_ARRAY;
} else {
options &= ~PHP_JSON_OBJECT_AS_ARRAY;
}
}
php_json_decode_ex(return_value, str, str_len, options, depth);
}
PHP_METHOD(swoole_atomic, sub)
{
zend_long sub_value = 1;
sw_atomic_t *atomic = swoole_get_object(getThis());
#ifdef FAST_ZPP
ZEND_PARSE_PARAMETERS_START(0, 1)
Z_PARAM_OPTIONAL
Z_PARAM_LONG(sub_value)
ZEND_PARSE_PARAMETERS_END();
#else
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &sub_value) == FAILURE)
{
RETURN_FALSE;
}
#endif
RETURN_LONG(sw_atomic_sub_fetch(atomic, (uint32_t ) sub_value));
}
/** public function ION\Sequence::__invoke(mixed ...$data) : void */
CLASS_METHOD(ION_Sequence, __invoke) {
zval * data = NULL;
int count = 0;
ZEND_PARSE_PARAMETERS_START(0, 255)
Z_PARAM_VARIADIC('*', data, count);
ZEND_PARSE_PARAMETERS_END_EX(PION_ZPP_THROW);
if(!count) {
zval nil;
ZVAL_NULL(&nil);
ion_promisor_sequence_invoke(Z_OBJ_P(getThis()), &nil);
} else if(count == 1) {
ion_promisor_sequence_invoke(Z_OBJ_P(getThis()), data);
} else {
ion_promisor_sequence_invoke_args(Z_OBJ_P(getThis()), data, count);
}
}
static PHP_METHOD(swoole_coroutine_util, call_user_func_array)
{
zval *params;
zend_fcall_info fci;
zend_fcall_info_cache fci_cache;
ZEND_PARSE_PARAMETERS_START(2, 2)
Z_PARAM_FUNC(fci, fci_cache)
Z_PARAM_ARRAY_EX(params, 0, 1)
ZEND_PARSE_PARAMETERS_END();
zend_fcall_info_args(&fci, params);
fci.retval = (execute_data->prev_execute_data->opline->result_type != IS_UNUSED) ? return_value : NULL;
swoole_corountine_call_function(&fci, &fci_cache, 1);
zend_fcall_info_args_clear(&fci, 1);
}
/** public static function ION\EventAbstract::_occurred(mixed $obj) */
CLASS_METHOD(ION_EventAbstract, _occurred) {
ion_php_event * php_event = ION_THIS_OBJECT(ion_php_event);
zval * context = NULL;
if (!php_event->event) {
if (php_event->promise) {
ion_promisor_throw(php_event->promise, ion_ce_ION_RuntimeException, ERR_ION_EVENT_NOT_READY, 0);
} else {
// @todo trigger notice
}
return;
}
ZEND_PARSE_PARAMETERS_START(1, 1)
Z_PARAM_ZVAL(context)
ZEND_PARSE_PARAMETERS_END_EX(PION_ZPP_THROW);
ion_promisor_done(php_event->promise, context);
}
/** public function ION\Sequence::__construct(callable $starter = null, callable $release = null) */
CLASS_METHOD(ION_Sequence, __construct) {
ion_promisor * sequence = get_this_instance(ion_promisor);
zval * starter = NULL;
zval * release = NULL;
ZEND_PARSE_PARAMETERS_START(0, 2)
Z_PARAM_OPTIONAL
Z_PARAM_ZVAL_DEREF_EX(starter, 1, 0)
Z_PARAM_ZVAL_DEREF_EX(release, 1, 0)
ZEND_PARSE_PARAMETERS_END_EX(PION_ZPP_THROW);
if(starter) {
ion_promisor_set_initial_callback(ION_OBJ(sequence), starter);
}
if(release) {
ion_promisor_set_php_cb(&sequence->canceler, pion_cb_create_from_zval(release));
sequence->flags |= ION_PROMISOR_AUTOCLEAN;
}
}
static void php_exec_ex(INTERNAL_FUNCTION_PARAMETERS, int mode) /* {{{ */
{
char *cmd;
size_t cmd_len;
zval *ret_code=NULL, *ret_array=NULL;
int ret;
ZEND_PARSE_PARAMETERS_START(1, (mode ? 2 : 3))
Z_PARAM_STRING(cmd, cmd_len)
Z_PARAM_OPTIONAL
if (!mode) {
Z_PARAM_ZVAL(ret_array)
}
Z_PARAM_ZVAL(ret_code)
ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
if (!cmd_len) {
php_error_docref(NULL, E_WARNING, "Cannot execute a blank command");
RETURN_FALSE;
}
if (strlen(cmd) != cmd_len) {
php_error_docref(NULL, E_WARNING, "NULL byte detected. Possible attack");
RETURN_FALSE;
}
if (!ret_array) {
ret = php_exec(mode, cmd, NULL, return_value);
} else {
if (Z_TYPE_P(Z_REFVAL_P(ret_array)) == IS_ARRAY) {
ZVAL_DEREF(ret_array);
SEPARATE_ARRAY(ret_array);
} else {
ret_array = zend_try_array_init(ret_array);
if (!ret_array) {
return;
}
}
ret = php_exec(2, cmd, ret_array, return_value);
}
if (ret_code) {
ZEND_TRY_ASSIGN_LONG(ret_code, ret);
}
}
PHP_METHOD(swoole_atomic_long, cmpset)
{
zend_long cmp_value, set_value;
sw_atomic_long_t *atomic = swoole_get_object(getThis());
#ifdef FAST_ZPP
ZEND_PARSE_PARAMETERS_START(2, 2)
Z_PARAM_LONG(cmp_value)
Z_PARAM_LONG(set_value)
ZEND_PARSE_PARAMETERS_END();
#else
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ll", &cmp_value, &set_value) == FAILURE)
{
RETURN_FALSE;
}
#endif
RETURN_BOOL(sw_atomic_cmp_set(atomic, (sw_atomic_long_t) cmp_value, (sw_atomic_long_t) set_value));
}
static inline void php_is_type(INTERNAL_FUNCTION_PARAMETERS, int type)
{
zval *arg;
ZEND_PARSE_PARAMETERS_START(1, 1)
Z_PARAM_ZVAL(arg)
ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
if (Z_TYPE_P(arg) == type) {
if (type == IS_RESOURCE) {
const char *type_name = zend_rsrc_list_get_rsrc_type(Z_RES_P(arg));
if (!type_name) {
RETURN_FALSE;
}
}
RETURN_TRUE;
} else {
RETURN_FALSE;
}
}
/**
* Constructs a new instance of the Timeval class
* @param long $usec The number of microseconds in the interval
*/
PHP_METHOD(Timeval, __construct) {
wrapped_grpc_timeval *timeval = Z_WRAPPED_GRPC_TIMEVAL_P(getThis());
zend_long microseconds;
/* "l" == 1 long */
#ifndef FAST_ZPP
if (zend_parse_parameters(ZEND_NUM_ARGS(), "l", µseconds) == FAILURE) {
zend_throw_exception(spl_ce_InvalidArgumentException,
"Timeval expects a long", 1);
return;
}
#else
ZEND_PARSE_PARAMETERS_START(1, 1)
Z_PARAM_LONG(microseconds)
ZEND_PARSE_PARAMETERS_END();
#endif
gpr_timespec time = gpr_time_from_micros(microseconds, GPR_TIMESPAN);
memcpy(&timeval->wrapped, &time, sizeof(gpr_timespec));
}
// extern void TF_SetAttrType(TF_OperationDescription* desc, const char* attr_name,
// TF_DataType value);
static PHP_METHOD(TensorFlow_OperationDescription, setAttrType)
{
zend_string *name;
zend_long dtype;
ZEND_PARSE_PARAMETERS_START(2, 2)
Z_PARAM_STR(name)
Z_PARAM_LONG(dtype)
ZEND_PARSE_PARAMETERS_END();
if (!valid_dtype(dtype)) {
zend_throw_exception(spl_ce_InvalidArgumentException, "dtype must be from 1 to 20", 0);
return;
}
// this
t_tf_operation_description_object* intern = TF_OPERATION_DESCRIPTION_P_ZV(getThis());
t_tf_operation_description* node = intern->ptr;
TF_SetAttrType(node->src, name->val, dtype);
}
static void curlfile_ctor(INTERNAL_FUNCTION_PARAMETERS)
{
zend_string *fname, *mime = NULL, *postname = NULL;
zval *cf = return_value;
ZEND_PARSE_PARAMETERS_START(1,3)
Z_PARAM_PATH_STR(fname)
Z_PARAM_OPTIONAL
Z_PARAM_STR(mime)
Z_PARAM_STR(postname)
ZEND_PARSE_PARAMETERS_END();
zend_update_property_string(curl_CURLFile_class, cf, "name", sizeof("name")-1, ZSTR_VAL(fname));
if (mime) {
zend_update_property_string(curl_CURLFile_class, cf, "mime", sizeof("mime")-1, ZSTR_VAL(mime));
}
if (postname) {
zend_update_property_string(curl_CURLFile_class, cf, "postname", sizeof("postname")-1, ZSTR_VAL(postname));
}
}
/** public function ION\Process\IPC::create(mixed $ctx1 = null, mixed $ctx2 = null) : ION\IPC[] */
CLASS_METHOD(ION_Process_IPC, create) {
zval one;
zval two;
zval * ctx1 = NULL;
zval * ctx2 = NULL;
ZEND_PARSE_PARAMETERS_START(0, 2)
Z_PARAM_OPTIONAL
Z_PARAM_ZVAL(ctx1)
Z_PARAM_ZVAL(ctx2)
ZEND_PARSE_PARAMETERS_END_EX(PION_ZPP_THROW);
if(ion_ipc_create(&one, &two, ctx1, ctx2, ION_IPC_CTX_RELEASE) == FAILURE) {
zend_throw_exception(ion_ce_ION_RuntimeException, ERR_ION_PROCESS_IPC_FAIL, 0);
return;
}
zval_add_ref(ctx1);
zval_add_ref(ctx2);
array_init(return_value);
add_next_index_zval(return_value, &one);
add_next_index_zval(return_value, &two);
}
/**
* Get the connectivity state of the channel
* @param bool (optional) try to connect on the channel
* @return long The grpc connectivity state
*/
PHP_METHOD(Channel, getConnectivityState) {
wrapped_grpc_channel *channel = Z_WRAPPED_GRPC_CHANNEL_P(getThis());
zend_bool try_to_connect = 0;
/* "|b" == 1 optional bool */
#ifndef FAST_ZPP
if (zend_parse_parameters(ZEND_NUM_ARGS(), "|b",
&try_to_connect) == FAILURE) {
zend_throw_exception(spl_ce_InvalidArgumentException,
"getConnectivityState expects a bool", 1);
return;
}
#else
ZEND_PARSE_PARAMETERS_START(0, 1)
Z_PARAM_OPTIONAL
Z_PARAM_BOOL(try_to_connect)
ZEND_PARSE_PARAMETERS_END();
#endif
RETURN_LONG(grpc_channel_check_connectivity_state(channel->wrapped,
(int)try_to_connect));
}
/* {{{ proto string json_encode(mixed data [, int options[, int depth]])
Returns the JSON representation of a value */
static PHP_FUNCTION(json_encode)
{
zval *parameter;
php_json_encoder encoder;
smart_str buf = {0};
zend_long options = 0;
zend_long depth = PHP_JSON_PARSER_DEFAULT_DEPTH;
ZEND_PARSE_PARAMETERS_START(1, 3)
Z_PARAM_ZVAL(parameter)
Z_PARAM_OPTIONAL
Z_PARAM_LONG(options)
Z_PARAM_LONG(depth)
ZEND_PARSE_PARAMETERS_END();
php_json_encode_init(&encoder);
encoder.max_depth = (int)depth;
php_json_encode_zval(&buf, parameter, (int)options, &encoder);
if (!(options & PHP_JSON_THROW_ON_ERROR) || (options & PHP_JSON_PARTIAL_OUTPUT_ON_ERROR)) {
JSON_G(error_code) = encoder.error_code;
if (encoder.error_code != PHP_JSON_ERROR_NONE && !(options & PHP_JSON_PARTIAL_OUTPUT_ON_ERROR)) {
smart_str_free(&buf);
RETURN_FALSE;
}
} else {
if (encoder.error_code != PHP_JSON_ERROR_NONE) {
smart_str_free(&buf);
zend_throw_exception(php_json_exception_ce, php_json_get_error_msg(encoder.error_code), encoder.error_code);
RETURN_FALSE;
}
}
smart_str_0(&buf); /* copy? */
if (buf.s) {
RETURN_NEW_STR(buf.s);
}
RETURN_EMPTY_STRING();
}
/**
* Adds another Timeval to this one and returns the sum. Calculations saturate
* at infinities.
* @param Timeval $other The other Timeval object to add
* @return Timeval A new Timeval object containing the sum
*/
PHP_METHOD(Timeval, add) {
zval *other_obj;
/* "O" == 1 Object */
#ifndef FAST_ZPP
if (zend_parse_parameters(ZEND_NUM_ARGS(), "O", &other_obj, grpc_ce_timeval)
== FAILURE) {
zend_throw_exception(spl_ce_InvalidArgumentException,
"add expects a Timeval", 1);
return;
}
#else
ZEND_PARSE_PARAMETERS_START(1, 1)
Z_PARAM_OBJECT_OF_CLASS(other_obj, grpc_ce_timeval)
ZEND_PARSE_PARAMETERS_END();
#endif
wrapped_grpc_timeval *self = Z_WRAPPED_GRPC_TIMEVAL_P(getThis());
wrapped_grpc_timeval *other = Z_WRAPPED_GRPC_TIMEVAL_P(other_obj);
grpc_php_wrap_timeval(gpr_time_add(self->wrapped, other->wrapped), return_value);
RETURN_DESTROY_ZVAL(return_value);
}
static inline void php_is_type(INTERNAL_FUNCTION_PARAMETERS, int type)
{
zval *arg;
#ifndef FAST_ZPP
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &arg) == FAILURE) {
RETURN_FALSE;
}
ZVAL_DEREF(arg);
#else
ZEND_PARSE_PARAMETERS_START(1, 1)
Z_PARAM_ZVAL_DEREF(arg)
ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
#endif
if (Z_TYPE_P(arg) == type) {
if (type == IS_OBJECT) {
zend_class_entry *ce;
if (Z_OBJ_HT_P(arg)->get_class_entry == NULL) {
/* if there's no get_class_entry it's not a PHP object, so it can't be INCOMPLETE_CLASS */
RETURN_TRUE;
}
ce = Z_OBJCE_P(arg);
if (ce->name->len == sizeof(INCOMPLETE_CLASS) - 1
&& !strncmp(ce->name->val, INCOMPLETE_CLASS, ce->name->len)) {
RETURN_FALSE;
}
} else if (type == IS_RESOURCE) {
const char *type_name = zend_rsrc_list_get_rsrc_type(Z_RES_P(arg) TSRMLS_CC);
if (!type_name) {
RETURN_FALSE;
}
}
RETURN_TRUE;
} else {
RETURN_FALSE;
}
}
