/** {{{ public ZePageSet::last()
*/
PHP_METHOD(ze_pageset, all) {
zval * self = NULL;
zval * page_count = NULL;
zval * pages = NULL;
int i = 0;
self = getThis();
MAKE_STD_ZVAL(pages);
array_init(pages);
page_count = zend_read_property(ze_pageset_ce, self, ZEND_STRL(ZE_PAGE_COUNT), 0 TSRMLS_CC);
if (Z_LVAL_P(page_count) <= 1) {
add_next_index_long(pages, 1);
}else{
for(i = 0;i < Z_LVAL_P(page_count);i++) {
add_next_index_long(pages, i + 1);
}
}
RETURN_ZVAL(pages, 1, 1);
}
void on_event(zend_php_scanner_event event, int token, int line)
{
zval keyword;
HashTable *tokens_ht;
zval *token_zv;
switch (event) {
case ON_TOKEN:
if (token == END) break;
if (token >= 256) {
array_init(&keyword);
add_next_index_long(&keyword, token);
add_next_index_stringl(&keyword, (char *)LANG_SCNG(yy_text), LANG_SCNG(yy_leng));
add_next_index_long(&keyword, line);
add_next_index_zval(&token_stream, &keyword);
} else {
add_next_index_stringl(&token_stream, (char *)LANG_SCNG(yy_text), LANG_SCNG(yy_leng));
}
break;
case ON_FEEDBACK:
tokens_ht = Z_ARRVAL(token_stream);
token_zv = zend_hash_index_find(tokens_ht, zend_hash_num_elements(tokens_ht) - 1);
if (token_zv && Z_TYPE_P(token_zv) == IS_ARRAY) {
ZVAL_LONG(zend_hash_index_find(Z_ARRVAL_P(token_zv), 0), token);
}
break;
case ON_STOP:
if (LANG_SCNG(yy_cursor) != LANG_SCNG(yy_limit)) {
array_init(&keyword);
add_next_index_long(&keyword, T_INLINE_HTML);
add_next_index_stringl(&keyword,
(char *)LANG_SCNG(yy_cursor), LANG_SCNG(yy_limit) - LANG_SCNG(yy_cursor));
add_next_index_long(&keyword, CG(zend_lineno));
add_next_index_zval(&token_stream, &keyword);
}
break;
}
}
void pdo_sqlsrv_retrieve_context_error( sqlsrv_error const* last_error, zval* pdo_zval )
{
if( last_error ) {
// SQLSTATE is already present in the zval.
add_next_index_long( pdo_zval, last_error->native_code );
add_next_index_string( pdo_zval, reinterpret_cast<char*>( last_error->native_message ), 1 /*dup*/ );
}
else {
add_next_index_null( pdo_zval ); /* native code */
add_next_index_null( pdo_zval ); /* native message */
}
}
PHP_METHOD(WinGdiPath, getPath)
{
wingdi_devicecontext_object *dc_obj;
wingdi_path_object *path_obj;
LPPOINT points;
LPBYTE types;
zval *point_array;
int result, i,
points_total = 0;
WINGDI_ERROR_HANDLING();
if (zend_parse_parameters_none() == FAILURE)
return;
WINGDI_RESTORE_ERRORS();
path_obj = zend_object_store_get_object(getThis() TSRMLS_CC);
dc_obj = zend_object_store_get_object(path_obj->device_context TSRMLS_CC);
// Determine how many points exist in the path
points_total = GetPath(dc_obj->hdc, NULL, NULL, 0);
points = emalloc(sizeof(POINT) * points_total);
types = emalloc(sizeof(BYTE) * points_total);
result = GetPath(dc_obj->hdc, points, types, points_total);
array_init(return_value);
for (i = 0; i < points_total; i++)
{
MAKE_STD_ZVAL(point_array);
add_next_index_long(point_array, points[i].x);
add_next_index_long(point_array, points[i].y);
// Could the char -> long conversion here cause problems?
add_next_index_long(point_array, types[i]);
// Store this array in parent array
add_next_index_zval(return_value, point_array);
}
}
/* Add numeric indexed uint32 value array to given zval by key */
void
uint32_php_repeated (zval* out, char* name, const uint32_t** val, unsigned int num_fields)
{
unsigned int i;
const uint32_t* arr = *val;
zval* repeated;
MAKE_STD_ZVAL(repeated);
array_init(repeated);
for (i=0;i<num_fields;++i) {
add_next_index_long(repeated, (long)arr[i]);
}
add_assoc_zval(out, name, repeated);
}
static int dblib_fetch_error(pdo_dbh_t *dbh, pdo_stmt_t *stmt, zval *info)
{
pdo_dblib_db_handle *H = (pdo_dblib_db_handle *)dbh->driver_data;
pdo_dblib_err *einfo = &H->err;
pdo_dblib_stmt *S = NULL;
char *message;
char *msg;
if (stmt) {
S = (pdo_dblib_stmt*)stmt->driver_data;
einfo = &S->err;
}
if (einfo->dberr == SYBESMSG && einfo->lastmsg) {
msg = einfo->lastmsg;
} else if (einfo->dberr == SYBESMSG && DBLIB_G(err).lastmsg) {
msg = DBLIB_G(err).lastmsg;
DBLIB_G(err).lastmsg = NULL;
} else {
msg = einfo->dberrstr;
}
spprintf(&message, 0, "%s [%d] (severity %d) [%s]",
msg, einfo->dberr, einfo->severity, stmt ? stmt->active_query_string : "");
add_next_index_long(info, einfo->dberr);
add_next_index_string(info, message);
efree(message);
add_next_index_long(info, einfo->oserr);
add_next_index_long(info, einfo->severity);
if (einfo->oserrstr) {
add_next_index_string(info, einfo->oserrstr);
}
return 1;
}
void php_array_add_sum_long(zval *row, zval *data1, zval *data2)
{
long x1, x2;
zval temp;
temp = *data1;
zval_copy_ctor(&temp);
convert_to_long(&temp);
x1 = Z_LVAL(temp);
zval_dtor(&temp);
temp = *data2;
zval_copy_ctor(&temp);
convert_to_long(&temp);
x2 = Z_LVAL(temp);
zval_dtor(&temp);
add_next_index_long(row, x1 + x2);
}
/* {{{ pdo_mysql_fetch_error_func */
static int pdo_mysql_fetch_error_func(pdo_dbh_t *dbh, pdo_stmt_t *stmt, zval *info)
{
pdo_mysql_db_handle *H = (pdo_mysql_db_handle *)dbh->driver_data;
pdo_mysql_error_info *einfo = &H->einfo;
PDO_DBG_ENTER("pdo_mysql_fetch_error_func");
PDO_DBG_INF_FMT("dbh=%p stmt=%p", dbh, stmt);
if (stmt) {
pdo_mysql_stmt *S = (pdo_mysql_stmt*)stmt->driver_data;
einfo = &S->einfo;
} else {
einfo = &H->einfo;
}
if (einfo->errcode) {
add_next_index_long(info, einfo->errcode);
add_next_index_string(info, einfo->errmsg);
}
PDO_DBG_RETURN(1);
}
U_CFUNC PHP_FUNCTION(rbbi_get_rule_status_vec)
{
BREAKITER_METHOD_INIT_VARS;
object = getThis();
if (zend_parse_parameters_none() == FAILURE) {
intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
"rbbi_get_rule_status_vec: bad arguments", 0 TSRMLS_CC);
RETURN_FALSE;
}
BREAKITER_METHOD_FETCH_OBJECT;
int32_t num_rules = fetch_rbbi(bio)->getRuleStatusVec(NULL, 0,
BREAKITER_ERROR_CODE(bio));
if (BREAKITER_ERROR_CODE(bio) == U_BUFFER_OVERFLOW_ERROR) {
BREAKITER_ERROR_CODE(bio) = U_ZERO_ERROR;
} else {
// should not happen
INTL_METHOD_CHECK_STATUS(bio, "rbbi_get_rule_status_vec: failed "
" determining the number of status values");
}
int32_t *rules = new int32_t[num_rules];
num_rules = fetch_rbbi(bio)->getRuleStatusVec(rules, num_rules,
BREAKITER_ERROR_CODE(bio));
if (U_FAILURE(BREAKITER_ERROR_CODE(bio))) {
delete[] rules;
intl_errors_set(BREAKITER_ERROR_P(bio), BREAKITER_ERROR_CODE(bio),
"rbbi_get_rule_status_vec: failed obtaining the status values",
0 TSRMLS_CC);
RETURN_FALSE;
}
array_init_size(return_value, num_rules);
for (int32_t i = 0; i < num_rules; i++) {
add_next_index_long(return_value, rules[i]);
}
delete[] rules;
}
static int pdo_odbc_fetch_error_func(pdo_dbh_t *dbh, pdo_stmt_t *stmt, zval *info)
{
pdo_odbc_db_handle *H = (pdo_odbc_db_handle *)dbh->driver_data;
pdo_odbc_errinfo *einfo = &H->einfo;
pdo_odbc_stmt *S = NULL;
zend_string *message = NULL;
if (stmt) {
S = (pdo_odbc_stmt*)stmt->driver_data;
einfo = &S->einfo;
}
message = strpprintf(0, "%s (%s[%ld] at %s:%d)",
einfo->last_err_msg,
einfo->what, einfo->last_error,
einfo->file, einfo->line);
add_next_index_long(info, einfo->last_error);
add_next_index_str(info, message);
add_next_index_string(info, einfo->last_state);
return 1;
}
static void php_stat(const char *filename, php_stat_len filename_length, int type, pval *return_value)
{
struct stat *stat_sb;
int rmask=S_IROTH,wmask=S_IWOTH,xmask=S_IXOTH; /* access rights defaults to other */
BLS_FETCH();
stat_sb = &BG(sb);
if (!BG(CurrentStatFile) || strcmp(filename, BG(CurrentStatFile))) {
if (!BG(CurrentStatFile) || filename_length > BG(CurrentStatLength)) {
if (BG(CurrentStatFile)) {
efree(BG(CurrentStatFile));
}
BG(CurrentStatLength) = filename_length;
BG(CurrentStatFile) = estrndup(filename, filename_length);
} else {
memcpy(BG(CurrentStatFile), filename, filename_length+1);
}
#if HAVE_SYMLINK
BG(lsb).st_mode = 0; /* mark lstat buf invalid */
#endif
if (VCWD_STAT(BG(CurrentStatFile), &BG(sb)) == -1) {
if (!IS_LINK_OPERATION() && (type != 15 || errno != ENOENT)) { /* fileexists() test must print no error */
php_error(E_NOTICE,"stat failed for %s (errno=%d - %s)", BG(CurrentStatFile), errno, strerror(errno));
}
efree(BG(CurrentStatFile));
BG(CurrentStatFile) = NULL;
if (!IS_LINK_OPERATION()) { /* Don't require success for link operation */
RETURN_FALSE;
}
}
}
#if HAVE_SYMLINK
if (IS_LINK_OPERATION() && !BG(lsb).st_mode) {
/* do lstat if the buffer is empty */
if (VCWD_LSTAT(filename, &BG(lsb)) == -1) {
php_error(E_NOTICE, "lstat failed for %s (errno=%d - %s)", filename, errno, strerror(errno));
RETURN_FALSE;
}
}
#endif
if (type >= 9 && type <= 11) {
if(BG(sb).st_uid==getuid()) {
rmask=S_IRUSR;
wmask=S_IWUSR;
xmask=S_IXUSR;
} else if(BG(sb).st_gid==getgid()) {
rmask=S_IRGRP;
wmask=S_IWGRP;
xmask=S_IXGRP;
} else {
int groups,n,i;
gid_t *gids;
groups = getgroups(0,NULL);
if(groups) {
gids=(gid_t *)emalloc(groups*sizeof(gid_t));
n=getgroups(groups,gids);
for(i=0;i<n;i++){
if(BG(sb).st_gid==gids[i]) {
rmask=S_IRGRP;
wmask=S_IWGRP;
xmask=S_IXGRP;
break;
}
}
efree(gids);
}
}
}
switch (type) {
case 0: /* fileperms */
RETURN_LONG((long)BG(sb).st_mode);
case 1: /* fileinode */
RETURN_LONG((long)BG(sb).st_ino);
case 2: /* filesize */
RETURN_LONG((long)BG(sb).st_size);
case 3: /* fileowner */
RETURN_LONG((long)BG(sb).st_uid);
case 4: /* filegroup */
RETURN_LONG((long)BG(sb).st_gid);
case 5: /* fileatime */
RETURN_LONG((long)BG(sb).st_atime);
case 6: /* filemtime */
RETURN_LONG((long)BG(sb).st_mtime);
case 7: /* filectime */
RETURN_LONG((long)BG(sb).st_ctime);
case 8: /* filetype */
#if HAVE_SYMLINK
if (S_ISLNK(BG(lsb).st_mode)) {
RETURN_STRING("link",1);
}
#endif
switch(BG(sb).st_mode&S_IFMT) {
case S_IFIFO: RETURN_STRING("fifo",1);
case S_IFCHR: RETURN_STRING("char",1);
case S_IFDIR: RETURN_STRING("dir",1);
case S_IFBLK: RETURN_STRING("block",1);
case S_IFREG: RETURN_STRING("file",1);
#if defined(S_IFSOCK) && !defined(ZEND_WIN32)&&!defined(__BEOS__)
case S_IFSOCK: RETURN_STRING("socket",1);
#endif
}
php_error(E_WARNING,"Unknown file type (%d)",BG(sb).st_mode&S_IFMT);
RETURN_STRING("unknown", 1);
case 9: /*is writable*/
if (getuid()==0) {
RETURN_LONG(1); /* root */
}
RETURN_LONG((BG(sb).st_mode & wmask) != 0);
case 10: /*is readable*/
if (getuid()==0) {
RETURN_LONG(1); /* root */
}
RETURN_LONG((BG(sb).st_mode&rmask)!=0);
case 11: /*is executable*/
if (getuid()==0) {
xmask = S_IXROOT; /* root */
}
RETURN_LONG((BG(sb).st_mode&xmask)!=0 && !S_ISDIR(BG(sb).st_mode));
case 12: /*is file*/
RETURN_LONG(S_ISREG(BG(sb).st_mode));
case 13: /*is dir*/
RETURN_LONG(S_ISDIR(BG(sb).st_mode));
case 14: /*is link*/
#if HAVE_SYMLINK
RETURN_LONG(S_ISLNK(BG(lsb).st_mode));
#else
RETURN_FALSE;
#endif
case 15: /*file exists*/
RETURN_TRUE; /* the false case was done earlier */
case 16: /* lstat */
#if HAVE_SYMLINK
stat_sb = &BG(lsb);
#endif
/* FALLTHROUGH */
case 17: /* stat */
if (array_init(return_value) == FAILURE) {
RETURN_FALSE;
}
add_next_index_long(return_value, stat_sb->st_dev);
add_next_index_long(return_value, stat_sb->st_ino);
add_next_index_long(return_value, stat_sb->st_mode);
add_next_index_long(return_value, stat_sb->st_nlink);
add_next_index_long(return_value, stat_sb->st_uid);
add_next_index_long(return_value, stat_sb->st_gid);
#ifdef HAVE_ST_RDEV
add_next_index_long(return_value, stat_sb->st_rdev);
#else
add_next_index_long(return_value, -1);
#endif
add_next_index_long(return_value, stat_sb->st_size);
add_next_index_long(return_value, stat_sb->st_atime);
add_next_index_long(return_value, stat_sb->st_mtime);
add_next_index_long(return_value, stat_sb->st_ctime);
#ifdef HAVE_ST_BLKSIZE
add_next_index_long(return_value, stat_sb->st_blksize);
#else
add_next_index_long(return_value, -1);
#endif
#ifdef HAVE_ST_BLOCKS
add_next_index_long(return_value, stat_sb->st_blocks);
#else
add_next_index_long(return_value, -1);
#endif
/* Support string references as well as numerical*/
add_assoc_long ( return_value , "dev" , stat_sb->st_dev );
add_assoc_long ( return_value , "ino" , stat_sb->st_ino );
add_assoc_long ( return_value , "mode" , stat_sb->st_mode );
add_assoc_long ( return_value , "nlink" , stat_sb->st_nlink );
add_assoc_long ( return_value , "uid" , stat_sb->st_uid );
add_assoc_long ( return_value , "gid" , stat_sb->st_gid );
#ifdef HAVE_ST_RDEV
add_assoc_long ( return_value, "rdev" , stat_sb->st_rdev );
#endif
#ifdef HAVE_ST_BLKSIZE
add_assoc_long ( return_value , "blksize" , stat_sb->st_blksize );
#endif
add_assoc_long ( return_value , "size" , stat_sb->st_size );
add_assoc_long ( return_value , "atime" , stat_sb->st_atime );
add_assoc_long ( return_value , "mtime" , stat_sb->st_mtime );
add_assoc_long ( return_value , "ctime" , stat_sb->st_ctime );
#ifdef HAVE_ST_BLOCKS
add_assoc_long ( return_value , "blocks" , stat_sb->st_blocks );
#endif
return;
}
php_error(E_WARNING, "didn't understand stat call");
RETURN_FALSE;
}
/* {{{ clm_get_device_info() */
static zval *clm_get_device_info(cl_device_id device TSRMLS_DC)
{
const device_info_param_t *param = device_info_list;
cl_int err = CL_SUCCESS;
char buf[1024] = { 0 };
size_t len = 0;
cl_uint max_work_item_dimensions = 0;
zval *zinfo;
err = clGetDeviceInfo(device, CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS,
sizeof(max_work_item_dimensions),
&max_work_item_dimensions, NULL);
if (err != CL_SUCCESS) {
max_work_item_dimensions = 0;
}
MAKE_STD_ZVAL(zinfo);
array_init_size(zinfo, 64);
while (param->key != NULL) {
switch (param->type) {
case PARAM_TYPE_BITFIELD: {
cl_bitfield val = 0;
err = clGetDeviceInfo(device, param->name, sizeof(val), &val, NULL);
if (err == CL_SUCCESS) {
long lval = (long)val;
add_assoc_long(zinfo, param->key, lval);
}
}
break;
case PARAM_TYPE_BOOL: {
cl_bool val = 0;
err = clGetDeviceInfo(device, param->name, sizeof(val), &val, NULL);
if (err == CL_SUCCESS) {
zend_bool bval = (zend_bool)val;
add_assoc_bool(zinfo, param->key, bval);
}
}
break;
case PARAM_TYPE_SIZE: {
size_t val = 0;
err = clGetDeviceInfo(device, param->name, sizeof(val), &val, NULL);
if (err == CL_SUCCESS) {
long lval = (long)val;
add_assoc_long(zinfo, param->key, lval);
}
}
break;
case PARAM_TYPE_UINT: {
cl_uint val = 0;
err = clGetDeviceInfo(device, param->name, sizeof(val), &val, NULL);
if (err == CL_SUCCESS) {
long lval = (long)val;
add_assoc_long(zinfo, param->key, lval);
}
}
break;
case PARAM_TYPE_ULONG: {
cl_ulong val = 0;
err = clGetDeviceInfo(device, param->name, sizeof(val), &val, NULL);
if (err == CL_SUCCESS) {
long lval = (long)val;
add_assoc_long(zinfo, param->key, lval);
}
}
break;
case PARAM_TYPE_STRING: {
err = clGetDeviceInfo(device, param->name, sizeof(buf), buf, &len);
if (err == CL_SUCCESS) {
add_assoc_stringl(zinfo, param->key, buf, len, 1);
}
}
break;
case PARAM_TYPE_PLATFORM: {
cl_platform_id platform;
err = clGetDeviceInfo(device, param->name, sizeof(platform), &platform, NULL);
if (err == CL_SUCCESS) {
zval *pinfo = clm_get_platform_info(platform TSRMLS_CC);
add_assoc_zval(zinfo, param->key, pinfo);
}
}
break;
case PARAM_TYPE_MAX_WORK_ITEM_SIZES: {
size_t siz = sizeof(size_t) * max_work_item_dimensions;
size_t *sizes = ecalloc(max_work_item_dimensions, sizeof(size_t));
if (!sizes) {
break;
}
err = clGetDeviceInfo(device, CL_DEVICE_MAX_WORK_ITEM_SIZES, siz, sizes, NULL);
if (err == CL_SUCCESS) {
cl_uint i;
zval *zsizes;
MAKE_STD_ZVAL(zsizes);
array_init_size(zsizes, max_work_item_dimensions);
for (i = 0; i < max_work_item_dimensions; i++) {
long lval = (long)sizes[i];
add_next_index_long(zsizes, lval);
}
add_assoc_zval(zinfo, param->key, zsizes);
}
efree(sizes);
}
break;
}
if (err != CL_SUCCESS) {
add_assoc_null(zinfo, param->key);
}
param++;
}
return zinfo;
}
static zend_bool tokenize(zval *return_value, zend_string *source)
{
zval source_zval;
zend_lex_state original_lex_state;
zval token;
zval keyword;
int token_type;
int token_line = 1;
int need_tokens = -1; /* for __halt_compiler lexing. -1 = disabled */
ZVAL_STR_COPY(&source_zval, source);
zend_save_lexical_state(&original_lex_state);
if (zend_prepare_string_for_scanning(&source_zval, "") == FAILURE) {
zend_restore_lexical_state(&original_lex_state);
return 0;
}
LANG_SCNG(yy_state) = yycINITIAL;
array_init(return_value);
ZVAL_UNDEF(&token);
while ((token_type = lex_scan(&token))) {
if (token_type == T_CLOSE_TAG && zendtext[zendleng - 1] != '>') {
CG(zend_lineno)++;
}
if (token_type >= 256) {
array_init(&keyword);
add_next_index_long(&keyword, token_type);
if (token_type == T_END_HEREDOC) {
if (CG(increment_lineno)) {
token_line = ++CG(zend_lineno);
CG(increment_lineno) = 0;
}
}
add_next_index_stringl(&keyword, (char *)zendtext, zendleng);
add_next_index_long(&keyword, token_line);
add_next_index_zval(return_value, &keyword);
} else {
add_next_index_stringl(return_value, (char *)zendtext, zendleng);
}
if (Z_TYPE(token) != IS_UNDEF) {
zval_dtor(&token);
ZVAL_UNDEF(&token);
}
/* after T_HALT_COMPILER collect the next three non-dropped tokens */
if (need_tokens != -1) {
if (token_type != T_WHITESPACE && token_type != T_OPEN_TAG
&& token_type != T_COMMENT && token_type != T_DOC_COMMENT
&& --need_tokens == 0
) {
/* fetch the rest into a T_INLINE_HTML */
if (zendcursor != zendlimit) {
array_init(&keyword);
add_next_index_long(&keyword, T_INLINE_HTML);
add_next_index_stringl(&keyword, (char *)zendcursor, zendlimit - zendcursor);
add_next_index_long(&keyword, token_line);
add_next_index_zval(return_value, &keyword);
}
break;
}
} else if (token_type == T_HALT_COMPILER) {
need_tokens = 3;
}
token_line = CG(zend_lineno);
}
zval_dtor(&source_zval);
zend_restore_lexical_state(&original_lex_state);
return 1;
}
/* {{{ proto mixed R::__call(string function_name, array arguments)
*/
static PHP_METHOD(R, __call)
{
char *func;
int func_len, error_occurred = 0, num_args;
zval *args;
SEXP e, fun, val, arg, next;
HashPosition pos;
zval **element;
SEXPTYPE type;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sa", &func, &func_len, &args) == FAILURE) {
return;
}
fun = Rf_install(func);
if (!fun) {
RETURN_FALSE;
}
num_args = zend_hash_num_elements(Z_ARRVAL_P(args));
PROTECT(fun);
PROTECT(e = allocVector(LANGSXP, num_args + 1));
SETCAR(e, fun);
next = CDR(e);
for(zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(args), &pos);
zend_hash_get_current_data_ex(Z_ARRVAL_P(args), (void **)&element, &pos) == SUCCESS;
zend_hash_move_forward_ex(Z_ARRVAL_P(args), &pos)
) {
arg = php_zval_to_r(element);
SETCAR(next, arg);
next = CDR(next);
}
val = R_tryEval(e, R_GlobalEnv, &error_occurred);
if (error_occurred) {
UNPROTECT(2);
RETURN_FALSE;
}
/* okay, the call succeeded */
PROTECT(val);
if (val == NULL_USER_OBJECT || GET_LENGTH(val) == 0) {
/* ignore the return value */
} else if (php_is_r_primitive(val, &type)) {
int i;
array_init(return_value);
for (i = 0; i < GET_LENGTH(val); i++) {
switch (type) {
case STRSXP:
add_next_index_string(return_value, CHAR(STRING_ELT(val, 0)), 1);
break;
case LGLSXP:
add_next_index_bool(return_value, LOGICAL_DATA(val)[0] ? 1 : 0);
break;
case INTSXP:
add_next_index_long(return_value, INTEGER_DATA(val)[0]);
break;
case REALSXP:
add_next_index_double(return_value, NUMERIC_DATA(val)[0]);
break;
default:
add_next_index_null(return_value);
break;
}
}
UNPROTECT(3);
return;
}
UNPROTECT(3);
RETURN_TRUE;
}
static int add_long(zval* list, char* id, int num) {
if(id) return add_assoc_long(list, id, num);
else return add_next_index_long(list, num);
}
static void tokenize(zval *return_value)
{
zval token;
zval keyword;
int token_type;
zend_bool destroy;
int token_line = 1;
int need_tokens = -1; // for __halt_compiler lexing. -1 = disabled
array_init(return_value);
ZVAL_NULL(&token);
while ((token_type = lex_scan(&token))) {
destroy = 1;
switch (token_type) {
case T_CLOSE_TAG:
if (zendtext[zendleng - 1] != '>') {
CG(zend_lineno)++;
}
case T_OPEN_TAG:
case T_OPEN_TAG_WITH_ECHO:
case T_WHITESPACE:
case T_COMMENT:
case T_DOC_COMMENT:
destroy = 0;
break;
}
if (token_type >= 256) {
array_init(&keyword);
add_next_index_long(&keyword, token_type);
if (token_type == T_END_HEREDOC) {
if (CG(increment_lineno)) {
token_line = ++CG(zend_lineno);
CG(increment_lineno) = 0;
}
}
add_next_index_stringl(&keyword, (char *)zendtext, zendleng);
add_next_index_long(&keyword, token_line);
add_next_index_zval(return_value, &keyword);
} else {
add_next_index_stringl(return_value, (char *)zendtext, zendleng);
}
if (destroy && Z_TYPE(token) != IS_NULL) {
zval_dtor(&token);
}
ZVAL_NULL(&token);
// after T_HALT_COMPILER collect the next three non-dropped tokens
if (need_tokens != -1) {
if (token_type != T_WHITESPACE && token_type != T_OPEN_TAG
&& token_type != T_COMMENT && token_type != T_DOC_COMMENT
&& --need_tokens == 0
) {
// fetch the rest into a T_INLINE_HTML
if (zendcursor != zendlimit) {
array_init(&keyword);
add_next_index_long(&keyword, T_INLINE_HTML);
add_next_index_stringl(&keyword, (char *)zendcursor, zendlimit - zendcursor);
add_next_index_long(&keyword, token_line);
add_next_index_zval(return_value, &keyword);
}
break;
}
} else if (token_type == T_HALT_COMPILER) {
need_tokens = 3;
}
token_line = CG(zend_lineno);
}
}
/** {{{ public CheetahPageCore::siblings()
*/
PHP_METHOD(cheetah_page_core, siblings) {
zval * self = NULL;
zval * page_count = NULL;
zval * current = NULL;
zval * pages = NULL;
int i = 0;
int count = 0;
int jumper = 0;
int startPage = 0;
int endPage = 0;
zend_bool isContinue = 0;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l"
, &count
) == FAILURE) {
WRONG_PARAM_COUNT;
}
self = getThis();
CHEETAH_NEW_ARRAY(pages);
page_count = CHEETAH_READ_PROPERTY(self, CHEETAH_PAGE_COUNT);
current = CHEETAH_READ_PROPERTY(self, CHEETAH_CURRENT);
if (Z_LVAL_P(page_count) > 0 && count > 0) {
/**
* 去除当前页
*/
count--;
startPage = Z_LVAL_P(current) - ((((count % 2) > 0) ? count - 1 : count) / 2);
endPage = count + startPage;
jumper = 0;
/**
* 可缩小的滑块
*/
do {
jumper++;
isContinue = 0;
/**
* 向后走 1 位
*/
if (startPage < 1) {
startPage++;
if (endPage < Z_LVAL_P(page_count)) {
endPage++;
}
isContinue = 1;
}
/**
* 向前走 1 位
*/
if (endPage > Z_LVAL_P(page_count)) {
endPage--;
if (startPage > 1) {
startPage--;
}
isContinue = 1;
}
/**
* 防循环锁
* 该方法已经严格测试。
* 请勿为此举感到担心，纯属极端癖好。
*/
if (jumper > 500) {
isContinue = 0;
}
} while (isContinue);
for (i = startPage; i <= endPage; i++) {
add_next_index_long(pages, i);
}
} else {
add_next_index_long(pages, 1);
}
RETURN_ZVAL(pages, 1, 1);
}
/* {{{ php_parsekit_parse_op_array */
static void php_parsekit_parse_op_array(zval *return_value, zend_op_array *ops, long options TSRMLS_DC)
{
zend_op *op;
zval *tmpzval;
int i = 0;
/* TODO: Reorder / Organize */
array_init(return_value);
add_assoc_long(return_value, "type", (long)(ops->type));
add_assoc_string(return_value, "type_name", php_parsekit_define_name(ops->type, php_parsekit_function_types, PHP_PARSEKIT_FUNCTYPE_UNKNOWN), 1);
if (ops->function_name) {
add_assoc_string(return_value, "function_name", ops->function_name, 1);
} else if (options & PHP_PARSEKIT_ALWAYS_SET) {
add_assoc_null(return_value, "function_name");
}
#ifdef ZEND_ENGINE_2
/* ZE2 op_array members */
if (ops->scope && ops->scope->name) {
add_assoc_stringl(return_value, "scope", ops->scope->name, ops->scope->name_length, 1);
} else if (options & PHP_PARSEKIT_ALWAYS_SET) {
add_assoc_null(return_value, "scope");
}
add_assoc_long(return_value, "fn_flags", ops->fn_flags);
if (ops->function_name && ops->prototype) {
MAKE_STD_ZVAL(tmpzval);
array_init(tmpzval);
add_assoc_long(tmpzval, "type", ops->prototype->type);
add_assoc_string(return_value, "type_name", php_parsekit_define_name(ops->prototype->type, php_parsekit_function_types, PHP_PARSEKIT_FUNCTYPE_UNKNOWN), 1);
if (ops->prototype->common.function_name) {
add_assoc_string(tmpzval, "function_name", ops->prototype->common.function_name, 1);
} else if (options & PHP_PARSEKIT_ALWAYS_SET) {
add_assoc_null(tmpzval, "function_name");
}
if (ops->prototype->common.scope && ops->prototype->common.scope->name) {
add_assoc_stringl(tmpzval, "scope", ops->prototype->common.scope->name, ops->prototype->common.scope->name_length, 1);
} else if (options & PHP_PARSEKIT_ALWAYS_SET) {
add_assoc_null(tmpzval, "scope");
}
add_assoc_zval(return_value, "prototype", tmpzval);
} else if (options & PHP_PARSEKIT_ALWAYS_SET) {
add_assoc_null(return_value, "prototype");
}
add_assoc_long(return_value, "num_args", ops->num_args);
add_assoc_long(return_value, "required_num_args", ops->required_num_args);
add_assoc_bool(return_value, "pass_rest_by_reference", ops->pass_rest_by_reference);
if (ops->num_args && ops->arg_info) {
MAKE_STD_ZVAL(tmpzval);
php_parsekit_parse_arginfo(tmpzval, ops->num_args, ops->arg_info, options TSRMLS_CC);
add_assoc_zval(return_value, "arg_info", tmpzval);
} else if (options & PHP_PARSEKIT_ALWAYS_SET) {
add_assoc_null(return_value, "arg_info");
}
if (ops->last_try_catch > 0) {
MAKE_STD_ZVAL(tmpzval);
array_init(tmpzval);
for(i = 0; i < ops->last_try_catch; i++) {
zval *tmp_zval;
MAKE_STD_ZVAL(tmp_zval);
array_init(tmp_zval);
add_assoc_long(tmp_zval, "try_op", ops->try_catch_array[i].try_op);
add_assoc_long(tmp_zval, "catch_op", ops->try_catch_array[i].catch_op);
add_index_zval(tmpzval, i, tmp_zval);
}
add_assoc_zval(return_value, "try_catch_array", tmpzval);
} else if (options & PHP_PARSEKIT_ALWAYS_SET) {
add_assoc_null(return_value, "try_catch_array");
}
#ifndef ZEND_ACC_CLOSURE
/* PHP<5.3 */
add_assoc_bool(return_value, "uses_this", ops->uses_this);
#endif
add_assoc_long(return_value, "line_start", ops->line_start);
add_assoc_long(return_value, "line_end", ops->line_end);
if (ops->doc_comment && ops->doc_comment_len) {
add_assoc_stringl(return_value, "doc_comment", ops->doc_comment, ops->doc_comment_len, 1);
} else if (options & PHP_PARSEKIT_ALWAYS_SET) {
add_assoc_null(return_value, "doc_comment");
}
#else
/* ZE1 op_array members */
if (ops->arg_types) {
zend_uchar *arg_types = ops->arg_types;
int numargs = *(ops->arg_types);
MAKE_STD_ZVAL(tmpzval);
array_init(tmpzval);
add_assoc_long(tmpzval, "arg_count", numargs);
for(i = 0; i < numargs; i++) {
add_next_index_long(tmpzval, arg_types[i+1]);
}
add_assoc_zval(return_value, "arg_types", tmpzval);
/* Emulated arg_info */
MAKE_STD_ZVAL(tmpzval);
php_parsekit_derive_arginfo(tmpzval, ops, options TSRMLS_CC);
add_assoc_zval(return_value, "arg_info", tmpzval);
} else {
MAKE_STD_ZVAL(tmpzval);
array_init(tmpzval);
add_assoc_long(tmpzval, "arg_count", 0);
add_assoc_zval(return_value, "arg_types", tmpzval);
add_assoc_null(return_value, "arg_info");
}
add_assoc_bool(return_value, "uses_global", ops->uses_globals);
#endif
/* ZE1 and ZE2 */
add_assoc_bool(return_value, "return_reference", ops->return_reference);
add_assoc_long(return_value, "refcount", *(ops->refcount));
add_assoc_long(return_value, "last", ops->last);
add_assoc_long(return_value, "size", ops->size);
add_assoc_long(return_value, "T", ops->T);
add_assoc_long(return_value, "last_brk_cont", ops->last_brk_cont);
add_assoc_long(return_value, "current_brk_cont", ops->current_brk_cont);
add_assoc_long(return_value, "backpatch_count", ops->backpatch_count);
add_assoc_bool(return_value, "done_pass_two", ops->done_pass_two);
if (ops->last_brk_cont > 0) {
MAKE_STD_ZVAL(tmpzval);
array_init(tmpzval);
for(i = 0; i < ops->last_brk_cont; i++) {
zval *tmp_zval;
MAKE_STD_ZVAL(tmp_zval);
array_init(tmp_zval);
add_assoc_long(tmp_zval, "cont", ops->brk_cont_array[i].cont);
add_assoc_long(tmp_zval, "brk", ops->brk_cont_array[i].brk);
add_assoc_long(tmp_zval, "parent", ops->brk_cont_array[i].parent);
add_index_zval(tmpzval, i, tmp_zval);
}
add_assoc_zval(return_value, "brk_cont_array", tmpzval);
} else if (options & PHP_PARSEKIT_ALWAYS_SET) {
add_assoc_null(return_value, "brk_cont_array");
}
if (ops->static_variables) {
zval *tmp_zval;
MAKE_STD_ZVAL(tmpzval);
array_init(tmpzval);
zend_hash_copy(HASH_OF(tmpzval), ops->static_variables, (copy_ctor_func_t) zval_add_ref, (void *) &tmp_zval, sizeof(zval *));
add_assoc_zval(return_value, "static_variables", tmpzval);
} else if (options & PHP_PARSEKIT_ALWAYS_SET) {
add_assoc_null(return_value, "static_variables");
}
if (ops->start_op) {
char sop[(sizeof(void *) * 2) + 1];
snprintf(sop, sizeof(sop), "%X", (unsigned int)ops->start_op);
add_assoc_string(return_value, "start_op", sop, 1);
} else if (options & PHP_PARSEKIT_ALWAYS_SET) {
add_assoc_null(return_value, "start_op");
}
if (ops->filename) {
add_assoc_string(return_value, "filename", ops->filename, 1);
} else {
add_assoc_null(return_value, "filename");
}
/* Leave this last, it simplifies readability */
MAKE_STD_ZVAL(tmpzval);
array_init(tmpzval);
for(op = ops->opcodes, i = 0; op && i < ops->size; op++, i++) {
zval *zop;
MAKE_STD_ZVAL(zop);
php_parsekit_parse_op(zop, ops, op, options TSRMLS_CC);
add_next_index_zval(tmpzval, zop);
}
add_assoc_zval(return_value, "opcodes", tmpzval);
}
/* {{{ _php_mb_regex_ereg_search_exec */
static void
_php_mb_regex_ereg_search_exec(INTERNAL_FUNCTION_PARAMETERS, int mode)
{
char *arg_pattern = NULL, *arg_options = NULL;
size_t arg_pattern_len, arg_options_len;
int err;
size_t n, i, pos, len, beg, end;
OnigOptionType option;
OnigUChar *str;
OnigSyntaxType *syntax;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "|ss", &arg_pattern, &arg_pattern_len, &arg_options, &arg_options_len) == FAILURE) {
return;
}
option = MBREX(regex_default_options);
if (arg_options) {
option = 0;
_php_mb_regex_init_options(arg_options, arg_options_len, &option, &syntax, NULL);
}
if (arg_pattern) {
/* create regex pattern buffer */
if ((MBREX(search_re) = php_mbregex_compile_pattern(arg_pattern, arg_pattern_len, option, MBREX(current_mbctype), MBREX(regex_default_syntax))) == NULL) {
RETURN_FALSE;
}
}
pos = MBREX(search_pos);
str = NULL;
len = 0;
if (!Z_ISUNDEF(MBREX(search_str)) && Z_TYPE(MBREX(search_str)) == IS_STRING){
str = (OnigUChar *)Z_STRVAL(MBREX(search_str));
len = Z_STRLEN(MBREX(search_str));
}
if (MBREX(search_re) == NULL) {
php_error_docref(NULL, E_WARNING, "No regex given");
RETURN_FALSE;
}
if (str == NULL) {
php_error_docref(NULL, E_WARNING, "No string given");
RETURN_FALSE;
}
if (MBREX(search_regs)) {
onig_region_free(MBREX(search_regs), 1);
}
MBREX(search_regs) = onig_region_new();
err = onig_search(MBREX(search_re), str, str + len, str + pos, str + len, MBREX(search_regs), 0);
if (err == ONIG_MISMATCH) {
MBREX(search_pos) = len;
RETVAL_FALSE;
} else if (err <= -2) {
OnigUChar err_str[ONIG_MAX_ERROR_MESSAGE_LEN];
onig_error_code_to_str(err_str, err);
php_error_docref(NULL, E_WARNING, "mbregex search failure in mbregex_search(): %s", err_str);
RETVAL_FALSE;
} else {
switch (mode) {
case 1:
array_init(return_value);
beg = MBREX(search_regs)->beg[0];
end = MBREX(search_regs)->end[0];
add_next_index_long(return_value, beg);
add_next_index_long(return_value, end - beg);
break;
case 2:
array_init(return_value);
n = MBREX(search_regs)->num_regs;
for (i = 0; i < n; i++) {
beg = MBREX(search_regs)->beg[i];
end = MBREX(search_regs)->end[i];
if (beg >= 0 && beg <= end && end <= len) {
add_index_stringl(return_value, i, (char *)&str[beg], end - beg);
} else {
add_index_bool(return_value, i, 0);
}
}
break;
default:
RETVAL_TRUE;
break;
}
end = MBREX(search_regs)->end[0];
if (pos <= end) {
MBREX(search_pos) = end;
} else {
MBREX(search_pos) = pos + 1;
}
}
if (err < 0) {
onig_region_free(MBREX(search_regs), 1);
MBREX(search_regs) = (OnigRegion *)NULL;
}
}
static inline int phpdbg_call_register(phpdbg_param_t *stack) /* {{{ */
{
phpdbg_param_t *name = NULL;
if (stack->type == STACK_PARAM) {
char *lc_name;
name = stack->next;
if (!name || name->type != STR_PARAM) {
return FAILURE;
}
lc_name = zend_str_tolower_dup(name->str, name->len);
if (zend_hash_str_exists(&PHPDBG_G(registered), lc_name, name->len)) {
zval fretval;
zend_fcall_info fci;
memset(&fci, 0, sizeof(zend_fcall_info));
ZVAL_STRINGL(&fci.function_name, lc_name, name->len);
fci.size = sizeof(zend_fcall_info);
fci.function_table = &PHPDBG_G(registered);
fci.symbol_table = zend_rebuild_symbol_table();
fci.object = NULL;
fci.retval = &fretval;
fci.no_separation = 1;
if (name->next) {
zval params;
phpdbg_param_t *next = name->next;
array_init(¶ms);
while (next) {
char *buffered = NULL;
switch (next->type) {
case OP_PARAM:
case COND_PARAM:
case STR_PARAM:
add_next_index_stringl(¶ms, next->str, next->len);
break;
case NUMERIC_PARAM:
add_next_index_long(¶ms, next->num);
break;
case METHOD_PARAM:
spprintf(&buffered, 0, "%s::%s", next->method.class, next->method.name);
add_next_index_string(¶ms, buffered);
break;
case NUMERIC_METHOD_PARAM:
spprintf(&buffered, 0, "%s::%s#%ld", next->method.class, next->method.name, next->num);
add_next_index_string(¶ms, buffered);
break;
case NUMERIC_FUNCTION_PARAM:
spprintf(&buffered, 0, "%s#%ld", next->str, next->num);
add_next_index_string(¶ms, buffered);
break;
case FILE_PARAM:
spprintf(&buffered, 0, "%s:%ld", next->file.name, next->file.line);
add_next_index_string(¶ms, buffered);
break;
case NUMERIC_FILE_PARAM:
spprintf(&buffered, 0, "%s:#%ld", next->file.name, next->file.line);
add_next_index_string(¶ms, buffered);
break;
default: {
/* not yet */
}
}
next = next->next;
}
zend_fcall_info_args(&fci, ¶ms);
} else {
static zend_always_inline php_hrtime_t _timer_current(void)
{/*{{{*/
#if PHP_HRTIME_PLATFORM_WINDOWS
LARGE_INTEGER lt = {0};
QueryPerformanceCounter(<);
return (php_hrtime_t)((php_hrtime_t)lt.QuadPart * _timer_scale);
#elif PHP_HRTIME_PLATFORM_APPLE
return (php_hrtime_t)mach_absolute_time() * _timerlib_info.numer / _timerlib_info.denom;
#elif PHP_HRTIME_PLATFORM_POSIX
struct timespec ts = { .tv_sec = 0, .tv_nsec = 0 };
if (0 == clock_gettime(CLOCK_MONOTONIC, &ts)) {
return ((php_hrtime_t) ts.tv_sec * (php_hrtime_t)NANO_IN_SEC) + ts.tv_nsec;
}
return 0;
#elif PHP_HRTIME_PLATFORM_HPUX
return (php_hrtime_t) gethrtime();
#elif PHP_HRTIME_PLATFORM_AIX
timebasestruct_t t;
read_wall_time(&t, TIMEBASE_SZ);
time_base_to_time(&t, TIMEBASE_SZ);
return (php_hrtime_t) t.tb_high * (php_hrtime_t)NANO_IN_SEC + t.tb_low;
#else
return 0;
#endif
}/*}}}*/
#if ZEND_ENABLE_ZVAL_LONG64
#define PHP_RETURN_HRTIME(t) RETURN_LONG((zend_long)t)
#else
#ifdef _WIN32
# define HRTIME_U64A(i, s, len) _ui64toa_s(i, s, len, 10)
#else
# define HRTIME_U64A(i, s, len) \
do { \
int st = snprintf(s, len, "%llu", i); \
s[st] = '\0'; \
} while (0)
#endif
#define PHP_RETURN_HRTIME(t) do { \
char _a[ZEND_LTOA_BUF_LEN]; \
double _d; \
HRTIME_U64A(t, _a, ZEND_LTOA_BUF_LEN); \
_d = zend_strtod(_a, NULL); \
RETURN_DOUBLE(_d); \
} while (0)
#endif
/* {{{ proto mixed hrtime([bool get_as_number = false])
Returns an array of integers in form [seconds, nanoseconds] counted
from an arbitrary point in time. If an optional boolean argument is
passed, returns an integer on 64-bit platforms or float on 32-bit
containing the current high-resolution time in nanoseconds. The
delivered timestamp is monotonic and can not be adjusted. */
PHP_FUNCTION(hrtime)
{
#if HRTIME_AVAILABLE
zend_bool get_as_num = 0;
php_hrtime_t t = _timer_current();
ZEND_PARSE_PARAMETERS_START(0, 1)
Z_PARAM_OPTIONAL
Z_PARAM_BOOL(get_as_num)
ZEND_PARSE_PARAMETERS_END();
if (UNEXPECTED(get_as_num)) {
PHP_RETURN_HRTIME(t);
} else {
array_init_size(return_value, 2);
zend_hash_real_init_packed(Z_ARRVAL_P(return_value));
add_next_index_long(return_value, (zend_long)(t / (php_hrtime_t)NANO_IN_SEC));
add_next_index_long(return_value, (zend_long)(t % (php_hrtime_t)NANO_IN_SEC));
}
#else
RETURN_FALSE
#endif
}
/* }}} */
PHPAPI php_hrtime_t php_hrtime_current(void)
{/*{{{*/
return _timer_current();
}/*}}}*/
