void php_mongo_db_construct(zval *z_client, zval *zlink, char *name, int name_len TSRMLS_DC) { mongo_db *db; mongoclient *link; if (!php_mongo_db_is_valid_dbname(name, name_len TSRMLS_CC)) { return; } db = (mongo_db*)zend_object_store_get_object(z_client TSRMLS_CC); db->link = zlink; zval_add_ref(&db->link); link = (mongoclient*)zend_object_store_get_object(zlink TSRMLS_CC); if (!(link->servers)) { zend_throw_exception(mongo_ce_Exception, "The MongoDB object has not been correctly initialized by its constructor", 0 TSRMLS_CC); return; } if (link->servers->options.default_w != -1) { zend_update_property_long(mongo_ce_DB, z_client, "w", strlen("w"), link->servers->options.default_w TSRMLS_CC); } else if (link->servers->options.default_wstring != NULL) { zend_update_property_string(mongo_ce_DB, z_client, "w", strlen("w"), link->servers->options.default_wstring TSRMLS_CC); } if (link->servers->options.default_wtimeout != -1) { zend_update_property_long(mongo_ce_DB, z_client, "wtimeout", strlen("wtimeout"), link->servers->options.default_wtimeout TSRMLS_CC); } mongo_read_preference_copy(&link->servers->read_pref, &db->read_pref); MAKE_STD_ZVAL(db->name); ZVAL_STRING(db->name, name, 1); }
/* {{{ proto AMQPDecimal::__construct(int $e, int $n) */ static PHP_METHOD(amqp_decimal_class, __construct) { PHP5to7_param_long_type_t exponent, significand; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ll", &exponent, &significand) == FAILURE) { return; } if (exponent < AMQP_DECIMAL_EXPONENT_MIN) { zend_throw_exception_ex(amqp_value_exception_class_entry, 0 TSRMLS_CC, "Decimal exponent value must be unsigned."); return; } if (exponent > AMQP_DECIMAL_EXPONENT_MAX) { zend_throw_exception_ex(amqp_value_exception_class_entry, 0 TSRMLS_CC, "Decimal exponent value must be less than %u.", AMQP_DECIMAL_EXPONENT_MAX); return; } if (significand < AMQP_DECIMAL_SIGNIFICAND_MIN) { zend_throw_exception_ex(amqp_value_exception_class_entry, 0 TSRMLS_CC, "Decimal significand value must be unsigned."); return; } if (significand > AMQP_DECIMAL_SIGNIFICAND_MAX) { zend_throw_exception_ex(amqp_value_exception_class_entry, 0 TSRMLS_CC, "Decimal significand value must be less than %u.", AMQP_DECIMAL_SIGNIFICAND_MAX); return; } zend_update_property_long(this_ce, getThis(), ZEND_STRL("exponent"), exponent TSRMLS_CC); zend_update_property_long(this_ce, getThis(), ZEND_STRL("significand"), significand TSRMLS_CC); }
static zend_object *zend_default_exception_new_ex(zend_class_entry *class_type, int skip_top_traces) /* {{{ */ { zval obj; zend_object *object; zval trace; zend_class_entry *base_ce; zend_string *filename; Z_OBJ(obj) = object = zend_objects_new(class_type); Z_OBJ_HT(obj) = &default_exception_handlers; object_properties_init(object, class_type); if (EG(current_execute_data)) { zend_fetch_debug_backtrace(&trace, skip_top_traces, 0, 0); } else { array_init(&trace); } Z_SET_REFCOUNT(trace, 0); base_ce = i_get_exception_base(&obj); if (EXPECTED(class_type != zend_ce_parse_error || !(filename = zend_get_compiled_filename()))) { zend_update_property_string(base_ce, &obj, "file", sizeof("file")-1, zend_get_executed_filename()); zend_update_property_long(base_ce, &obj, "line", sizeof("line")-1, zend_get_executed_lineno()); } else { zend_update_property_str(base_ce, &obj, "file", sizeof("file")-1, filename); zend_update_property_long(base_ce, &obj, "line", sizeof("line")-1, zend_get_compiled_lineno()); } zend_update_property(base_ce, &obj, "trace", sizeof("trace")-1, &trace); return object; }
static PHP_METHOD(swoole_process, useQueue) { long msgkey = 0; long mode = 2; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|ll", &msgkey, &mode) == FAILURE) { RETURN_FALSE; } swWorker *process = swoole_get_object(getThis()); if (msgkey <= 0) { #if PHP_MAJOR_VERSION >= 7 msgkey = ftok(zend_get_executed_filename(), 0); #else msgkey = ftok(zend_get_executed_filename(TSRMLS_C), 0); #endif } swMsgQueue *queue = emalloc(sizeof(swMsgQueue)); if (swMsgQueue_create(queue, 1, msgkey, 0) < 0) { RETURN_FALSE; } queue->remove = 0; process->queue = queue; process->ipc_mode = mode; zend_update_property_long(swoole_process_class_entry_ptr, getThis(), ZEND_STRL("msgQueueId"), queue->msg_id TSRMLS_CC); zend_update_property_long(swoole_process_class_entry_ptr, getThis(), ZEND_STRL("msgQueueKey"), msgkey TSRMLS_CC); RETURN_TRUE; }
int swoole_websocket_onMessage(swEventData *req) { #if PHP_MAJOR_VERSION < 7 TSRMLS_FETCH_FROM_CTX(sw_thread_ctx ? sw_thread_ctx : NULL); #endif int fd = req->info.fd; zval *zdata; SW_MAKE_STD_ZVAL(zdata); zdata = php_swoole_get_recv_data(zdata, req TSRMLS_CC); char *buf = Z_STRVAL_P(zdata); long finish = buf[0] ? 1 : 0; long opcode = buf[1] ? 1 : 0; zval *zframe; SW_MAKE_STD_ZVAL(zframe); object_init_ex(zframe, swoole_websocket_frame_class_entry_ptr); zend_update_property_long(swoole_websocket_frame_class_entry_ptr, zframe, ZEND_STRL("fd"), fd TSRMLS_CC); zend_update_property_long(swoole_websocket_frame_class_entry_ptr, zframe, ZEND_STRL("finish"), finish TSRMLS_CC); zend_update_property_long(swoole_websocket_frame_class_entry_ptr, zframe, ZEND_STRL("opcode"), opcode TSRMLS_CC); zend_update_property_stringl(swoole_websocket_frame_class_entry_ptr, zframe, ZEND_STRL("data"), buf + 2, (Z_STRLEN_P(zdata) - 2) TSRMLS_CC); swServer *serv = SwooleG.serv; zval *zserv = (zval *) serv->ptr2; zval **args[2]; args[0] = &zserv; args[1] = &zframe; zval *retval = NULL; if (sw_call_user_function_ex(EG(function_table), NULL, websocket_callbacks[WEBSOCKET_CALLBACK_onMessage], &retval, 2, args, 0, NULL TSRMLS_CC) == FAILURE) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "onMessage handler error"); } if (EG(exception)) { zend_exception_error(EG(exception), E_ERROR TSRMLS_CC); } if (retval) { sw_zval_ptr_dtor(&retval); } sw_zval_ptr_dtor(&zdata); sw_zval_ptr_dtor(&zframe); return SW_OK; }
int swoole_websocket_onMessage(swEventData *req) { #if PHP_MAJOR_VERSION < 7 TSRMLS_FETCH_FROM_CTX(sw_thread_ctx ? sw_thread_ctx : NULL); #endif int fd = req->info.fd; zval *zdata; SW_MAKE_STD_ZVAL(zdata); char frame_header[2]; php_swoole_get_recv_data(zdata, req, frame_header, 2); long finish = frame_header[0] ? 1 : 0; long opcode = frame_header[1]; zval *zframe; SW_MAKE_STD_ZVAL(zframe); object_init_ex(zframe, swoole_websocket_frame_class_entry_ptr); zend_update_property_long(swoole_websocket_frame_class_entry_ptr, zframe, ZEND_STRL("fd"), fd TSRMLS_CC); zend_update_property_bool(swoole_websocket_frame_class_entry_ptr, zframe, ZEND_STRL("finish"), finish TSRMLS_CC); zend_update_property_long(swoole_websocket_frame_class_entry_ptr, zframe, ZEND_STRL("opcode"), opcode TSRMLS_CC); zend_update_property(swoole_websocket_frame_class_entry_ptr, zframe, ZEND_STRL("data"), zdata TSRMLS_CC); swServer *serv = SwooleG.serv; zval *zserv = (zval *) serv->ptr2; zval **args[2]; args[0] = &zserv; args[1] = &zframe; zval *retval = NULL; zval *zcallback = php_swoole_server_get_callback(serv, req->info.from_fd, SW_SERVER_CB_onMessage); if (sw_call_user_function_ex(EG(function_table), NULL, zcallback, &retval, 2, args, 0, NULL TSRMLS_CC) == FAILURE) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "onMessage handler error"); } if (EG(exception)) { zend_exception_error(EG(exception), E_ERROR TSRMLS_CC); } if (retval) { sw_zval_ptr_dtor(&retval); } sw_zval_ptr_dtor(&zdata); sw_zval_ptr_dtor(&zframe); return SW_OK; }
PHP_METHOD(MongoCollection, __construct) { zval *parent, *name, *zns, *w, *wtimeout; mongo_collection *c; mongo_db *db; char *ns, *name_str; int name_len; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Os", &parent, mongo_ce_DB, &name_str, &name_len) == FAILURE) { zval *object = getThis(); ZVAL_NULL(object); return; } // check for empty collection name if (name_len == 0) { #if ZEND_MODULE_API_NO >= 20060613 zend_throw_exception_ex(zend_exception_get_default(TSRMLS_C), 0 TSRMLS_CC, "MongoDB::__construct(): invalid name %s", name_str); #else zend_throw_exception_ex(zend_exception_get_default(), 0 TSRMLS_CC, "MongoDB::__construct(): invalid name %s", name_str); #endif /* ZEND_MODULE_API_NO >= 20060613 */ return; } c = (mongo_collection*)zend_object_store_get_object(getThis() TSRMLS_CC); PHP_MONGO_GET_DB(parent); c->link = db->link; zval_add_ref(&db->link); c->parent = parent; zval_add_ref(&parent); MAKE_STD_ZVAL(name); ZVAL_STRINGL(name, name_str, name_len, 1); c->name = name; spprintf(&ns, 0, "%s.%s", Z_STRVAL_P(db->name), Z_STRVAL_P(name)); MAKE_STD_ZVAL(zns); ZVAL_STRING(zns, ns, 0); c->ns = zns; mongo_read_preference_copy(&db->read_pref, &c->read_pref); w = zend_read_property(mongo_ce_DB, parent, "w", strlen("w"), NOISY TSRMLS_CC); zend_update_property_long(mongo_ce_Collection, getThis(), "w", strlen("w"), Z_LVAL_P(w) TSRMLS_CC); wtimeout = zend_read_property(mongo_ce_DB, parent, "wtimeout", strlen("wtimeout"), NOISY TSRMLS_CC); zend_update_property_long(mongo_ce_Collection, getThis(), "wtimeout", strlen("wtimeout"), Z_LVAL_P(wtimeout) TSRMLS_CC); }
/**{{{ proto Mylogs::logInit */ PHP_METHOD(Mylogs, logInit) { long level, maxNum, maxSize; char *logPath, *fileName; int logPath_len, fileName_len; zval *instance = _getInstance(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lllss", &level, &maxNum, &maxSize, &logPath, &logPath_len, &fileName, &fileName_len) == FAILURE) return; zend_update_property_long(mylogs_ce, instance, ZEND_STRL(MYLOGS_LEVEL), level TSRMLS_CC); zend_update_property_long(mylogs_ce, instance, ZEND_STRL(MYLOGS_MAXFILE_NUM), maxNum TSRMLS_CC); zend_update_property_long(mylogs_ce, instance, ZEND_STRL(MYLOGS_MAXFILE_SIZE), maxSize TSRMLS_CC); zend_update_property_string(mylogs_ce, instance, ZEND_STRL(MYLOGS_PATH), logPath TSRMLS_CC); zend_update_property_string(mylogs_ce, instance, ZEND_STRL(MYLOGS_FILE_NAME), fileName TSRMLS_CC); RETURN_TRUE; }
void php_mongo_mongodate_populate(zval *mongodate_object, long sec, long usec TSRMLS_DC) { mongo_date *date; int64_t internal_date = 0; internal_date += usec / 1000; internal_date += (sec * 1000); usec = (usec / 1000) * 1000; zend_update_property_long(mongo_ce_Date, mongodate_object, "usec", strlen("usec"), usec TSRMLS_CC); zend_update_property_long(mongo_ce_Date, mongodate_object, "sec", strlen("sec"), sec TSRMLS_CC); date = (mongo_date*) zend_object_store_get_object(mongodate_object TSRMLS_CC); date->datetime = internal_date; }
/* {{{ proto Exception|Error::__construct(string message, int code [, Throwable previous]) Exception constructor */ ZEND_METHOD(exception, __construct) { zend_string *message = NULL; zend_long code = 0; zval *object, *previous = NULL; zend_class_entry *base_ce; int argc = ZEND_NUM_ARGS(); object = getThis(); base_ce = i_get_exception_base(object); if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, argc, "|SlO!", &message, &code, &previous, zend_ce_throwable) == FAILURE) { zend_class_entry *ce; if (execute_data->called_scope) { ce = execute_data->called_scope; } else { ce = base_ce; } zend_throw_error(NULL, "Wrong parameters for %s([string $message [, long $code [, Throwable $previous = NULL]]])", ZSTR_VAL(ce->name)); return; } if (message) { zend_update_property_str(base_ce, object, "message", sizeof("message")-1, message); } if (code) { zend_update_property_long(base_ce, object, "code", sizeof("code")-1, code); } if (previous) { zend_update_property(base_ce, object, "previous", sizeof("previous")-1, previous); } }
PHP_METHOD(Money, __construct) { long amount; zval *currency, *currency_obj; if (zend_parse_parameters(ZEND_NUM_ARGS(), "lz", &amount, ¤cy) == FAILURE) { return; } switch(Z_TYPE_P(currency)) { case IS_OBJECT: if (!instanceof_function(currency_ce, Z_OBJCE_P(currency))) { zend_throw_exception(spl_ce_InvalidArgumentException, "Invalid currency object", 0); return; } break; case IS_STRING: ALLOC_INIT_ZVAL(currency_obj); object_init_ex(currency_obj, currency_ce); zend_update_property_stringl(currency_ce, currency_obj, CURRENCY_PROP_CURRENCYCODE_WS, Z_STRVAL_P(currency), Z_STRLEN_P(currency)); currency = currency_obj; Z_DELREF_P(currency); break; default: zend_throw_exception(spl_ce_InvalidArgumentException, "Invalid currency value", 0); return; } zend_update_property_long(Z_OBJCE_P(getThis()), getThis(), MONEY_PROP_AMOUNT_WS, amount); zend_update_property(Z_OBJCE_P(getThis()), getThis(), MONEY_PROP_CURRENCY_WS, currency); }
static PHP_METHOD(swoole_buffer, clear) { swString *buffer = swoole_get_object(getThis()); buffer->length = 0; buffer->offset = 0; zend_update_property_long(swoole_buffer_class_entry_ptr, getThis(), ZEND_STRL("length"), 0 TSRMLS_CC); }
static PHP_METHOD(MsgqueForPhp_MqDumpS, __destruct) { SETUP_dump; MqDumpDelete(&dump); zend_update_property_long(NS(MqDumpS), getThis(), ID(__ctx), 0L TSRMLS_CC); }
static PHP_METHOD(swoole_buffer, __construct) { long size = SW_STRING_BUFFER_DEFAULT; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &size) == FAILURE) { RETURN_FALSE; } if (size < 1) { php_error_docref(NULL TSRMLS_CC, E_ERROR, "buffer size cannot be less than 0"); RETURN_FALSE; } else if (size > SW_STRING_BUFFER_MAXLEN) { php_error_docref(NULL TSRMLS_CC, E_ERROR, "buffer size must not exceed %d", SW_STRING_BUFFER_MAXLEN); RETURN_FALSE; } swString *buffer = swString_new(size); if (buffer == NULL) { php_error_docref(NULL TSRMLS_CC, E_ERROR, "malloc(%ld) failed.", size); RETURN_FALSE; } swoole_set_object(getThis(), buffer); zend_update_property_long(swoole_buffer_class_entry_ptr, getThis(), ZEND_STRL("capacity"), size TSRMLS_CC); }
/** * Throws a zval object as exception */ void zephir_throw_exception_debug(zval *object, const char *file, zend_uint line) { zend_class_entry *default_exception_ce; int ZEPHIR_LAST_CALL_STATUS = 0; zval curline; zval object_copy; ZVAL_UNDEF(&curline); ZEPHIR_MM_GROW(); if (Z_TYPE_P(object) != IS_OBJECT) { ZVAL_COPY_VALUE(&object_copy, object); object_init_ex(object, zend_exception_get_default()); ZEPHIR_CALL_METHOD(NULL, object, "__construct", NULL, 0, &object_copy); zval_ptr_dtor(&object_copy); } Z_ADDREF_P(object); if (line > 0) { ZEPHIR_CALL_METHOD(&curline, object, "getline", NULL, 0); zephir_check_call_status(); if (ZEPHIR_IS_LONG(&curline, 0)) { default_exception_ce = zend_exception_get_default(); zend_update_property_string(default_exception_ce, object, SL("file"), file); zend_update_property_long(default_exception_ce, object, SL("line"), line); } } if (ZEPHIR_LAST_CALL_STATUS != FAILURE) { zend_throw_exception_object(object); } ZEPHIR_MM_RESTORE(); }
static PHP_METHOD(swoole_process, __construct) { zend_bool redirect_stdin_and_stdout = 0; long create_pipe = 1; zval *callback; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|bl", &callback, &redirect_stdin_and_stdout, &create_pipe) == FAILURE) { RETURN_FALSE; } char *func_name = NULL; if (!sw_zend_is_callable(callback, 0, &func_name TSRMLS_CC)) { php_error_docref(NULL TSRMLS_CC, E_ERROR, "function '%s' is not callable", func_name); efree(func_name); RETURN_FALSE; } efree(func_name); swWorker *process = emalloc(sizeof(swWorker)); bzero(process, sizeof(swWorker)); process->id = php_swoole_worker_round_id++; if (php_swoole_worker_round_id == 0) { php_swoole_worker_round_id = 1; } if (redirect_stdin_and_stdout) { process->redirect_stdin = 1; process->redirect_stdout = 1; process->redirect_stderr = 1; create_pipe = 1; } if (create_pipe > 0) { swPipe *_pipe = emalloc(sizeof(swWorker)); int socket_type = create_pipe == 1 ? SOCK_STREAM : SOCK_DGRAM; if (swPipeUnsock_create(_pipe, 1, socket_type) < 0) { RETURN_FALSE; } process->pipe_object = _pipe; process->pipe_master = _pipe->getFd(_pipe, SW_PIPE_MASTER); process->pipe_worker = _pipe->getFd(_pipe, SW_PIPE_WORKER); process->pipe = process->pipe_master; zend_update_property_long(swoole_process_class_entry_ptr, getThis(), ZEND_STRL("pipe"), process->pipe_master TSRMLS_CC); } swoole_set_object(getThis(), process); zend_update_property(swoole_process_class_entry_ptr, getThis(), ZEND_STRL("callback"), callback TSRMLS_CC); }
/* Timestamp is 4 bytes of seconds since epoch and 4 bytes of increment. */ PHP_METHOD(MongoTimestamp, __construct) { long sec = 0, inc = 0; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|ll", &sec, &inc) == FAILURE) { return; } if (ZEND_NUM_ARGS() == 0) { sec = time(0); } if (ZEND_NUM_ARGS() <= 1 && !inc) { inc = MonGlo(ts_inc)++; } zend_update_property_long(mongo_ce_Timestamp, getThis(), "sec", strlen("sec"), sec TSRMLS_CC); zend_update_property_long(mongo_ce_Timestamp, getThis(), "inc", strlen("inc"), inc TSRMLS_CC); }
PHP_METHOD(pdo_connect_pool_PDOStatement, next) { zval *pos; zend_class_entry *ce; ce = Z_OBJCE_P(getThis()); pos = cp_zend_read_property(ce, getThis(), "pos", sizeof ("pos") - 1, 0 TSRMLS_DC); zend_update_property_long(ce, getThis(), "pos", sizeof ("pos") - 1, ++Z_LVAL_P(pos) TSRMLS_CC); }
/* {{{ MongoDB::__construct */ PHP_METHOD(MongoDB, __construct) { zval *zlink; char *name; int name_len; mongo_db *db; mongoclient *link; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Os", &zlink, mongo_ce_MongoClient, &name, &name_len) == FAILURE) { zval *object = getThis(); ZVAL_NULL(object); return; } if (0 == name_len || 0 != strchr(name, ' ') || 0 != strchr(name, '.') || 0 != strchr(name, '\\') || 0 != strchr(name, '/') || 0 != strchr(name, '$')) { #if ZEND_MODULE_API_NO >= 20060613 zend_throw_exception_ex(zend_exception_get_default(TSRMLS_C), 0 TSRMLS_CC, "MongoDB::__construct(): invalid name %s", name); #else zend_throw_exception_ex(zend_exception_get_default(), 0 TSRMLS_CC, "MongoDB::__construct(): invalid name %s", name); #endif /* ZEND_MODULE_API_NO >= 20060613 */ return; } db = (mongo_db*)zend_object_store_get_object(getThis() TSRMLS_CC); db->link = zlink; zval_add_ref(&db->link); PHP_MONGO_GET_LINK(zlink); if (link->servers->options.default_w != -1) { zend_update_property_long(mongo_ce_DB, getThis(), "w", strlen("w"), link->servers->options.default_w TSRMLS_CC); } else if (link->servers->options.default_wstring != NULL) { zend_update_property_string(mongo_ce_DB, getThis(), "w", strlen("w"), link->servers->options.default_wstring TSRMLS_CC); } if (link->servers->options.default_wtimeout != -1) { zend_update_property_long(mongo_ce_DB, getThis(), "wtimeout", strlen("wtimeout"), link->servers->options.default_wtimeout TSRMLS_CC); } mongo_read_preference_copy(&link->servers->read_pref, &db->read_pref); MAKE_STD_ZVAL(db->name); ZVAL_STRING(db->name, name, 1); }
/* {{{ proto ErrorException::__construct(string message, int code, int severity [, string filename [, int lineno [, Throwable previous]]]) ErrorException constructor */ ZEND_METHOD(error_exception, __construct) { char *message = NULL, *filename = NULL; zend_long code = 0, severity = E_ERROR, lineno; zval *object, *previous = NULL; int argc = ZEND_NUM_ARGS(); size_t message_len, filename_len; if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, argc, "|sllslO!", &message, &message_len, &code, &severity, &filename, &filename_len, &lineno, &previous, zend_ce_throwable) == FAILURE) { zend_class_entry *ce; if (execute_data->called_scope) { ce = execute_data->called_scope; } else { ce = zend_ce_error_exception; } zend_throw_error(NULL, "Wrong parameters for %s([string $message [, long $code, [ long $severity, [ string $filename, [ long $lineno [, Throwable $previous = NULL]]]]]])", ZSTR_VAL(ce->name)); return; } object = getThis(); if (message) { zend_update_property_string(zend_ce_exception, object, "message", sizeof("message")-1, message); } if (code) { zend_update_property_long(zend_ce_exception, object, "code", sizeof("code")-1, code); } if (previous) { zend_update_property(zend_ce_exception, object, "previous", sizeof("previous")-1, previous); } zend_update_property_long(zend_ce_error_exception, object, "severity", sizeof("severity")-1, severity); if (argc >= 4) { zend_update_property_string(zend_ce_exception, object, "file", sizeof("file")-1, filename); if (argc < 5) { lineno = 0; /* invalidate lineno */ } zend_update_property_long(zend_ce_exception, object, "line", sizeof("line")-1, lineno); } }
/* {{{ proto void Riak\BucketProperties->__construct(int $nVal, bool $allowMult) Creates a new RiakBucketProperties */ PHP_METHOD(RiakBucketProperties, __construct) { long nVal; zend_bool allowMult; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lb", &nVal, &allowMult) == FAILURE) { return; } zend_update_property_long(riak_bucket_properties_ce, getThis(), "nVal", sizeof("nVal")-1, nVal TSRMLS_CC); zend_update_property_bool(riak_bucket_properties_ce, getThis(), "allowMult", sizeof("allowMult")-1, allowMult TSRMLS_CC); }
void NS(MqBufferS_New) (zval *return_value, MQ_BUF buf TSRMLS_DC) { // convert to an object instance if (object_init_ex(return_value, NS(MqBufferS)) == FAILURE) { RaiseError("unable to create an 'MqBufferS' instance."); return; } // link 'buf' with the object instance zend_update_property_long(NS(MqBufferS), return_value, ID(__buf), (long) buf TSRMLS_CC); return; }
static int coro_exit_handler(zend_execute_data *execute_data) { zval ex; zend_object *obj; zend_long flags = 0; if (sw_get_current_cid() != -1) { flags |= SW_EXIT_IN_COROUTINE; } if (SwooleG.serv && SwooleG.serv->gs->start) { flags |= SW_EXIT_IN_SERVER; } if (flags) { const zend_op *opline = EX(opline); zval _exit_status; zval *exit_status = NULL; if (opline->op1_type != IS_UNUSED) { if (opline->op1_type == IS_CONST) { // see: https://github.com/php/php-src/commit/e70618aff6f447a298605d07648f2ce9e5a284f5 #ifdef EX_CONSTANT exit_status = EX_CONSTANT(opline->op1); #else exit_status = RT_CONSTANT(opline, opline->op1); #endif } else { exit_status = EX_VAR(opline->op1.var); } if (Z_ISREF_P(exit_status)) { exit_status = Z_REFVAL_P(exit_status); } } else { exit_status = &_exit_status; ZVAL_NULL(exit_status); } obj = zend_throw_error_exception(swoole_exit_exception_class_entry_ptr, "swoole exit.", 0, E_ERROR TSRMLS_CC); ZVAL_OBJ(&ex, obj); zend_update_property_long(swoole_exit_exception_class_entry_ptr, &ex, ZEND_STRL("flags"), flags); Z_TRY_ADDREF_P(exit_status); zend_update_property(swoole_exit_exception_class_entry_ptr, &ex, ZEND_STRL("status"), exit_status); } return ZEND_USER_OPCODE_DISPATCH; }
/* {{{ MongoBinData::__construct() */ PHP_METHOD(MongoBinData, __construct) { char *bin; long bin_len, type = PHP_MONGO_BIN_GENERIC; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|l", &bin, &bin_len, &type) == FAILURE) { return; } zend_update_property_stringl(mongo_ce_BinData, getThis(), "bin", strlen("bin"), bin, bin_len TSRMLS_CC); zend_update_property_long(mongo_ce_BinData, getThis(), "type", strlen("type"), type TSRMLS_CC); }
static PHP_METHOD(Hello, updateProperties) { zval *obj; obj = getThis(); zend_update_property_string(hello_ce, obj, "name", sizeof("name") -1, "name-update" TSRMLS_CC);//更新属性值, $this->name = name zend_update_property_long(hello_ce, obj, "age", sizeof("age") -1, 10 TSRMLS_CC); //this->age = age zend_update_property_string(hello_ce, obj, "last_name", sizeof("last_name") -1, "leon-update" TSRMLS_CC);//this->last_name = "leon" zend_update_property_null(hello_ce, obj, "first_name", sizeof("first_name") - 1 TSRMLS_CC); //this->first_name = null; zend_update_property_bool(hello_ce, obj, "sex", sizeof("sex") -1, 0 TSRMLS_CC); //this->sex = true zend_update_property_double(hello_ce, obj, "score", sizeof("score") -1, 15.50 TSRMLS_CC); //this->score = 12.50 }
static PHP_METHOD(swoole_http2_client_coro, __construct) { char *host; zend_size_t host_len; long port = 80; zend_bool ssl = SW_FALSE; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|lb", &host, &host_len, &port, &ssl) == FAILURE) { return; } if (host_len <= 0) { zend_throw_exception(swoole_exception_class_entry_ptr, "host is empty.", SW_ERROR_INVALID_PARAMS TSRMLS_CC); RETURN_FALSE; } http2_client_property *hcc; hcc = (http2_client_property*) emalloc(sizeof(http2_client_property)); bzero(hcc, sizeof(http2_client_property)); swoole_set_property(getThis(), HTTP2_CLIENT_CORO_PROPERTY, hcc); php_context *context = emalloc(sizeof(php_context)); swoole_set_property(getThis(), HTTP2_CLIENT_CORO_CONTEXT, context); context->onTimeout = NULL; #if PHP_MAJOR_VERSION < 7 context->coro_params = getThis(); #else context->coro_params = *getThis(); #endif hcc->streams = swHashMap_new(8, http2_client_stream_free); hcc->stream_id = 1; long type = SW_FLAG_ASYNC | SW_SOCK_TCP; if (ssl) { #ifdef SW_USE_OPENSSL type |= SW_SOCK_SSL; hcc->ssl = 1; #else swoole_php_fatal_error(E_ERROR, "require openssl library."); #endif } zend_update_property_long(swoole_http2_client_coro_class_entry_ptr, getThis(), ZEND_STRL("type"), type TSRMLS_CC); hcc->host = estrndup(host, host_len); hcc->host_len = host_len; hcc->port = port; }
zend_object * pion_exception_new(zend_class_entry * exception_ce, const char * message, long code) { zval ex; // A(ex); object_init_ex(&ex, exception_ce); // zend_objects_new(); if (message) { zend_update_property_string(exception_ce, &ex, "message", sizeof("message")-1, message); } if (code) { zend_update_property_long(exception_ce, &ex, "code", sizeof("code")-1, code); } return Z_OBJ(ex); }
static PHP_METHOD(swoole_buffer, append) { swString str; bzero(&str, sizeof(str)); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &str.str, &str.length) == FAILURE) { RETURN_FALSE; } if (str.length < 1) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "string empty."); RETURN_FALSE; } swString *buffer = swoole_get_object(getThis()); if ((str.length + buffer->size) > SW_STRING_BUFFER_MAXLEN) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "buffer size must not exceed %d", SW_STRING_BUFFER_MAXLEN); RETURN_FALSE; } size_t size_old = buffer->size; if (swString_append(buffer, &str) == SW_OK) { if (buffer->size > size_old) { zend_update_property_long(swoole_buffer_class_entry_ptr, getThis(), ZEND_STRL("capacity"), buffer->size TSRMLS_CC); } zend_update_property_long(swoole_buffer_class_entry_ptr, getThis(), ZEND_STRL("length"), buffer->length TSRMLS_CC); RETURN_LONG(buffer->length); } else { RETURN_FALSE; } }
/* {{{ bool MongoDB::setWriteConcern(mixed w [, int wtimeout]) * Set the MongoDB write concern, which will be inherited by constructed * MongoCollection objects. */ PHP_METHOD(MongoDB, setWriteConcern) { zval *write_concern; long wtimeout; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|l", &write_concern, &wtimeout) == FAILURE) { return; } if (Z_TYPE_P(write_concern) == IS_LONG) { zend_update_property_long(mongo_ce_DB, getThis(), "w", strlen("w"), Z_LVAL_P(write_concern) TSRMLS_CC); } else if (Z_TYPE_P(write_concern) == IS_STRING) { zend_update_property_stringl(mongo_ce_DB, getThis(), "w", strlen("w"), Z_STRVAL_P(write_concern), Z_STRLEN_P(write_concern) TSRMLS_CC); } else { php_error_docref(NULL TSRMLS_CC, E_WARNING, "expects parameter 1 to be an string or integer, %s given", zend_get_type_by_const(Z_TYPE_P(write_concern))); RETURN_FALSE; } if (ZEND_NUM_ARGS() > 1) { zend_update_property_long(mongo_ce_DB, getThis(), "wtimeout", strlen("wtimeout"), wtimeout TSRMLS_CC); } RETURN_TRUE; }
static PHP_METHOD(swoole_buffer, expand) { long size = -1; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &size) == FAILURE) { RETURN_FALSE; } swString *buffer = swoole_get_object(getThis()); if (size <= buffer->size) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "new size must more than %ld", buffer->size); RETURN_FALSE; } zend_update_property_long(swoole_buffer_class_entry_ptr, getThis(), ZEND_STRL("capacity"), size TSRMLS_CC); SW_CHECK_RETURN(swString_extend(buffer, size)); }