/**
* Push one or more elements onto the end of an array
*/
int phalcon_array_append(zval **arr, zval *value, int flags TSRMLS_DC) {
if (Z_TYPE_PP(arr) != IS_ARRAY) {
php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Cannot use a scalar value as an array");
return FAILURE;
}
if ((flags & PH_SEPARATE) == PH_SEPARATE) {
if (Z_REFCOUNT_PP(arr) > 1) {
zval *new_zv;
Z_DELREF_PP(arr);
ALLOC_ZVAL(new_zv);
INIT_PZVAL_COPY(new_zv, *arr);
*arr = new_zv;
zval_copy_ctor(new_zv);
}
}
Z_ADDREF_P(value);
return add_next_index_zval(*arr, value);
}
PHP_METHOD(Spotify, getPlaylists)
{
zval *thisptr = getThis(), tempretval;
int i, timeout = 0, num_playlists;
spotify_object *p = (spotify_object*)zend_object_store_get_object(thisptr TSRMLS_CC);
SPOTIFY_METHOD(Spotify, initPlaylistContainer, &tempretval, thisptr);
array_init(return_value);
num_playlists = sp_playlistcontainer_num_playlists(p->playlistcontainer);
for (i=0; i<num_playlists; i++) {
sp_playlist *playlist = sp_playlistcontainer_playlist(p->playlistcontainer, i);
zval *z_playlist;
ALLOC_INIT_ZVAL(z_playlist);
object_init_ex(z_playlist, spotifyplaylist_ce);
SPOTIFY_METHOD2(SpotifyPlaylist, __construct, &tempretval, z_playlist, thisptr, playlist);
add_next_index_zval(return_value, z_playlist);
}
}
/**
* Call single static function on a zval which requires parameters
*/
inline int phalcon_call_static_zval_func_params(zval *return_value, zval *mixed_name, char *method_name, int method_len, zend_uint param_count, zval *params[], int noreturn TSRMLS_DC){
zval *fn;
int status = FAILURE;
if (!noreturn) {
ALLOC_INIT_ZVAL(return_value);
}
ALLOC_INIT_ZVAL(fn);
array_init(fn);
add_next_index_zval(fn, mixed_name);
add_next_index_stringl(fn, method_name, method_len, 1);
status = phalcon_call_user_function(CG(function_table), NULL, fn, return_value, param_count, params TSRMLS_CC);
if (status == FAILURE) {
if(Z_TYPE_P(mixed_name) == IS_STRING) {
php_error_docref(NULL TSRMLS_CC, E_ERROR, "Call to undefined function %s::%s()", Z_STRVAL_P(mixed_name), method_name);
} else {
php_error_docref(NULL TSRMLS_CC, E_ERROR, "Call to undefined function not-callable::%s()", method_name);
}
}
zval_ptr_dtor(&fn);
if (!noreturn) {
zval_ptr_dtor(&return_value);
}
if (EG(exception)) {
status = FAILURE;
}
if (status == FAILURE) {
phalcon_memory_restore_stack(TSRMLS_C);
}
return status;
}
/* {{{ proto array cl_get_devices(void)
*/
static PHP_FUNCTION(cl_get_devices)
{
clmandelbrot_t ctx = { 0 };
cl_uint i = 0;
RETVAL_FALSE;
if (ZEND_NUM_ARGS() != 0) {
WRONG_PARAM_COUNT;
}
if (clm_setup_device(&ctx TSRMLS_CC) == FAILURE) {
return;
}
array_init(return_value);
for (i = 0; i < ctx.deviceCount; i++) {
zval *zinfo = clm_get_device_info(ctx.deviceList[i] TSRMLS_CC);
add_next_index_zval(return_value, zinfo);
}
}
static void
enumerate_providers_fn (const char * const name,
const char * const desc,
const char * const file,
void * ud) /* {{{ */
{
zval *zdesc = (zval *) ud;
zval *tmp_array;
MAKE_STD_ZVAL(tmp_array);
array_init(tmp_array);
add_assoc_string(tmp_array, "name", (char *)name, 1);
add_assoc_string(tmp_array, "desc", (char *)desc, 1);
add_assoc_string(tmp_array, "file", (char *)file, 1);
if (Z_TYPE_P(zdesc)!=IS_ARRAY) {
array_init(zdesc);
}
add_next_index_zval(zdesc, tmp_array);
}
/* {{{ php_parsekit_parse_arginfo */
static void php_parsekit_parse_arginfo(zval *return_value, zend_uint num_args, zend_arg_info *arginfo, long options TSRMLS_DC)
{
zend_uint i;
array_init(return_value);
for(i = 0; i < num_args; i++) {
zval *tmpzval;
MAKE_STD_ZVAL(tmpzval);
array_init(tmpzval);
add_assoc_stringl(tmpzval, "name", arginfo[i].name, arginfo[i].name_len, 1);
if (arginfo[i].class_name_len) {
add_assoc_stringl(tmpzval, "class_name", arginfo[i].class_name, arginfo[i].class_name_len, 1);
} else if (options & PHP_PARSEKIT_ALWAYS_SET) {
add_assoc_null(tmpzval, "class_name");
}
add_assoc_bool(tmpzval, "allow_null", arginfo[i].allow_null);
add_assoc_bool(tmpzval, "pass_by_reference", arginfo[i].pass_by_reference);
add_next_index_zval(return_value, tmpzval);
}
}
/* {{{ proto array Glib::filenameGetCharsets()
Determines the preferred character sets used for filenames.
Returns an array. The first element is a boolean indicating if the filename encoding
is UTF-8. The second element is the filename encoding.
The final element is an array of character sets used when trying to generate a
displayable representation of a filename.
*/
PHP_METHOD(Glib, filenameGetCharsets)
{
const gchar **charsets;
gboolean utf8;
zval *charset_array;
int i;
if (zend_parse_parameters_none() == FAILURE) {
return;
}
array_init(return_value);
MAKE_STD_ZVAL(charset_array);
array_init(charset_array);
utf8 = g_get_filename_charsets(&charsets);
add_next_index_bool(return_value, utf8);
add_next_index_string(return_value, (char *)charsets[0], 1);
for (i = 1; charsets[i]; i++) {
add_next_index_string(charset_array, (char *)charsets[i], 1);
}
add_next_index_zval(return_value, charset_array);
}
/* {{{ php_parsekit_derive_arginfo
ZE1 Func Arg loading is done via opcodes "RECV"ing from the caller */
static void php_parsekit_derive_arginfo(zval *return_value, zend_op_array *op_array, long options TSRMLS_DC)
{
int i;
zend_op *opcodes = op_array->opcodes;
array_init(return_value);
/* Received vars come in pairs:
A ZEND_FETCH_W, and a ZEND_RECV */
for(i = 0; i < op_array->arg_types[0]; i++) {
if (opcodes[i*2].opcode == ZEND_FETCH_W &&
opcodes[i*2].op1.op_type == IS_CONST &&
opcodes[i*2].op1.u.constant.type == IS_STRING &&
(opcodes[(i*2)+1].opcode == ZEND_RECV || opcodes[(i*2)+1].opcode == ZEND_RECV_INIT)) {
zval *tmpzval;
MAKE_STD_ZVAL(tmpzval);
array_init(tmpzval);
add_assoc_stringl(tmpzval, "name", opcodes[i*2].op1.u.constant.value.str.val, opcodes[i*2].op1.u.constant.value.str.len, 1);
add_assoc_bool(tmpzval, "pass_by_reference", op_array->arg_types[i+1]);
if (opcodes[(i*2)+1].opcode == ZEND_RECV_INIT &&
opcodes[(i*2)+1].op2.op_type == IS_CONST) {
zval *def;
MAKE_STD_ZVAL(def);
*def = opcodes[(i*2)+1].op2.u.constant;
zval_copy_ctor(def);
add_assoc_zval(tmpzval, "default", def);
Z_SET_REFCOUNT_P(tmpzval, 1);
}
add_next_index_zval(return_value, tmpzval);
}
}
}
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);
}
}
/* {{{ proto resource clmandelbrot(int width, int height[, float unit])
*/
static PHP_FUNCTION(clmandelbrot)
{
long width = 0;
long height = 0;
double unit = 0.0;
long device = 0;
zend_fcall_info fci;
zend_fcall_info_cache fcc;
zval *zim = NULL, *callable, *args, *zwidth, *zheight;
int err;
gdImagePtr im;
RETVAL_FALSE;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC,
"ll|dl", &width, &height, &unit, &device) == FAILURE) {
return;
}
MAKE_STD_ZVAL(callable);
ZVAL_STRING(callable, "imagecreatetruecolor", 1);
err = zend_fcall_info_init(callable, 0, &fci, &fcc,
NULL, NULL TSRMLS_CC);
if (err != SUCCESS) {
zval_ptr_dtor(&callable);
return;
}
MAKE_STD_ZVAL(args);
MAKE_STD_ZVAL(zwidth);
MAKE_STD_ZVAL(zheight);
ZVAL_LONG(zwidth, width);
ZVAL_LONG(zheight, height);
array_init(args);
add_next_index_zval(args, zwidth);
add_next_index_zval(args, zheight);
zend_fcall_info_call(&fci, &fcc, &zim, args TSRMLS_CC);
zval_ptr_dtor(&callable);
zval_ptr_dtor(&args);
if (!zim) {
return;
}
ZEND_FETCH_RESOURCE_NO_RETURN(im, gdImagePtr, &zim, -1,
"Image", phpi_get_le_gd());
if (im) {
size_t len;
clmandelbrot_t ctx = { 0 };
ctx.deviceId = (cl_uint)device;
ctx.width = gdImageSX(im);
ctx.height = gdImageSY(im);
if (unit > 0.0) {
ctx.unit = (float)unit;
} else {
ctx.unit = 10.0f / (float)(ctx.width + ctx.height);
}
len = ctx.width * ctx.height;
ctx.bitmap = ecalloc(len, sizeof(unsigned char));
if (!ctx.bitmap) {
php_error_docref(NULL TSRMLS_CC, E_WARNING,
"cannot allocate memory");
} else {
if (clm_process(im, &ctx TSRMLS_CC) == SUCCESS) {
RETVAL_ZVAL(zim, 1, 0);
}
}
clm_release(&ctx);
}
zval_ptr_dtor(&zim);
}
/* {{{ proto string q(string arg)
Return Array,of which the 1st value is addr1 and the 2nd value is addr2*/
PHP_METHOD(qqwry,q)
{
char *ip_string = NULL;
int ipstring_len;
zval * _this_zval = NULL;
if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC,getThis(), "Os",&_this_zval,qqwry_class_entry_ptr, &ip_string, &ipstring_len) == FAILURE) {
return;
}
zval *zaddr1,*zaddr2;
char *addr1=(char *)emalloc(QQWRY_ADDR1_LEN);
char *addr2=(char *)emalloc(QQWRY_ADDR2_LEN);
memset(addr1,0,QQWRY_ADDR1_LEN);
memset(addr2,0,QQWRY_ADDR2_LEN);
zval **tmp;
char *qqwry_path;
if (zend_hash_find(Z_OBJPROP_P(_this_zval),"f",sizeof("f"),(void **)&tmp)==FAILURE) {
return;
}
qqwry_path=Z_STRVAL_PP(tmp);
FILE *fp=NULL;
qqwry_fp_list *qfl=QQWRY_G(fp_list);
while (qfl) {
if (!strcmp(qfl->filepath,qqwry_path)) {
fp=qfl->fp;
break;
}
qfl=qfl->next;
}
if (!fp) {
qqwry_fp_list *pre_qfl=NULL;
qfl=QQWRY_G(fp_list);
while (qfl) {
pre_qfl=qfl;
qfl=qfl->next;
}
fp=fopen(qqwry_path,"rb");
if (!fp) {
php_error_docref(NULL TSRMLS_CC, E_WARNING,"%s",strerror(errno));
return;
}
qfl=emalloc(sizeof(qqwry_fp_list));
qfl->filepath = estrndup(qqwry_path, strlen(qqwry_path));
qfl->fp=fp;
qfl->next=NULL;
if (pre_qfl) {
pre_qfl->next=qfl;
} else {
QQWRY_G(fp_list)=qfl;
}
}
qqwry_get_location(addr1,addr2,ip_string,fp);
MAKE_STD_ZVAL(zaddr1);
ZVAL_STRING(zaddr1,addr1,0);
MAKE_STD_ZVAL(zaddr2);
ZVAL_STRING(zaddr2,addr2,0);
array_init(return_value);
add_next_index_zval(return_value,zaddr1);
add_next_index_zval(return_value,zaddr2);
}
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;
}
static void xsl_ext_function_php(xmlXPathParserContextPtr ctxt, int nargs, int type) /* {{{ */
{
xsltTransformContextPtr tctxt;
zval *args;
zval retval;
int result, i;
int error = 0;
zend_fcall_info fci;
zval handler;
xmlXPathObjectPtr obj;
char *str;
xsl_object *intern;
zend_string *callable = NULL;
if (! zend_is_executing()) {
xsltGenericError(xsltGenericErrorContext,
"xsltExtFunctionTest: Function called from outside of PHP\n");
error = 1;
} else {
tctxt = xsltXPathGetTransformContext(ctxt);
if (tctxt == NULL) {
xsltGenericError(xsltGenericErrorContext,
"xsltExtFunctionTest: failed to get the transformation context\n");
error = 1;
} else {
intern = (xsl_object*)tctxt->_private;
if (intern == NULL) {
xsltGenericError(xsltGenericErrorContext,
"xsltExtFunctionTest: failed to get the internal object\n");
error = 1;
}
else if (intern->registerPhpFunctions == 0) {
xsltGenericError(xsltGenericErrorContext,
"xsltExtFunctionTest: PHP Object did not register PHP functions\n");
error = 1;
}
}
}
if (error == 1) {
for (i = nargs - 1; i >= 0; i--) {
obj = valuePop(ctxt);
xmlXPathFreeObject(obj);
}
return;
}
fci.param_count = nargs - 1;
if (fci.param_count > 0) {
args = safe_emalloc(fci.param_count, sizeof(zval), 0);
}
/* Reverse order to pop values off ctxt stack */
for (i = nargs - 2; i >= 0; i--) {
obj = valuePop(ctxt);
switch (obj->type) {
case XPATH_STRING:
ZVAL_STRING(&args[i], (char *)obj->stringval);
break;
case XPATH_BOOLEAN:
ZVAL_BOOL(&args[i], obj->boolval);
break;
case XPATH_NUMBER:
ZVAL_DOUBLE(&args[i], obj->floatval);
break;
case XPATH_NODESET:
if (type == 1) {
str = (char*)xmlXPathCastToString(obj);
ZVAL_STRING(&args[i], str);
xmlFree(str);
} else if (type == 2) {
int j;
dom_object *domintern = (dom_object *)intern->doc;
array_init(&args[i]);
if (obj->nodesetval && obj->nodesetval->nodeNr > 0) {
for (j = 0; j < obj->nodesetval->nodeNr; j++) {
xmlNodePtr node = obj->nodesetval->nodeTab[j];
zval child;
/* not sure, if we need this... it's copied from xpath.c */
if (node->type == XML_NAMESPACE_DECL) {
xmlNsPtr curns;
xmlNodePtr nsparent;
nsparent = node->_private;
curns = xmlNewNs(NULL, node->name, NULL);
if (node->children) {
curns->prefix = xmlStrdup((char *)node->children);
}
if (node->children) {
node = xmlNewDocNode(node->doc, NULL, (char *) node->children, node->name);
} else {
node = xmlNewDocNode(node->doc, NULL, (const xmlChar *) "xmlns", node->name);
}
node->type = XML_NAMESPACE_DECL;
node->parent = nsparent;
node->ns = curns;
} else {
node = xmlDocCopyNodeList(domintern->document->ptr, node);
}
php_dom_create_object(node, &child, domintern);
add_next_index_zval(&args[i], &child);
}
}
}
break;
default:
str = (char *) xmlXPathCastToString(obj);
ZVAL_STRING(&args[i], str);
xmlFree(str);
}
xmlXPathFreeObject(obj);
}
fci.size = sizeof(fci);
fci.function_table = EG(function_table);
if (fci.param_count > 0) {
fci.params = args;
} else {
fci.params = NULL;
}
obj = valuePop(ctxt);
if (obj->stringval == NULL) {
php_error_docref(NULL, E_WARNING, "Handler name must be a string");
xmlXPathFreeObject(obj);
valuePush(ctxt, xmlXPathNewString((const xmlChar *) ""));
if (fci.param_count > 0) {
for (i = 0; i < nargs - 1; i++) {
zval_ptr_dtor(&args[i]);
}
efree(args);
}
return;
}
ZVAL_STRING(&handler, (char *) obj->stringval);
xmlXPathFreeObject(obj);
ZVAL_COPY_VALUE(&fci.function_name, &handler);
fci.symbol_table = NULL;
fci.object = NULL;
fci.retval = &retval;
fci.no_separation = 0;
/*fci.function_handler_cache = &function_ptr;*/
if (!zend_make_callable(&handler, &callable)) {
php_error_docref(NULL, E_WARNING, "Unable to call handler %s()", ZSTR_VAL(callable));
valuePush(ctxt, xmlXPathNewString((const xmlChar *) ""));
} else if ( intern->registerPhpFunctions == 2 && zend_hash_exists(intern->registered_phpfunctions, callable) == 0) {
php_error_docref(NULL, E_WARNING, "Not allowed to call handler '%s()'", ZSTR_VAL(callable));
/* Push an empty string, so that we at least have an xslt result... */
valuePush(ctxt, xmlXPathNewString((const xmlChar *) ""));
} else {
result = zend_call_function(&fci, NULL);
if (result == FAILURE) {
if (Z_TYPE(handler) == IS_STRING) {
php_error_docref(NULL, E_WARNING, "Unable to call handler %s()", Z_STRVAL(handler));
valuePush(ctxt, xmlXPathNewString((const xmlChar *) ""));
}
/* retval is == NULL, when an exception occurred, don't report anything, because PHP itself will handle that */
} else if (Z_ISUNDEF(retval)) {
} else {
if (Z_TYPE(retval) == IS_OBJECT && instanceof_function(Z_OBJCE(retval), dom_node_class_entry)) {
xmlNode *nodep;
dom_object *obj;
if (intern->node_list == NULL) {
ALLOC_HASHTABLE(intern->node_list);
zend_hash_init(intern->node_list, 0, NULL, ZVAL_PTR_DTOR, 0);
}
Z_ADDREF(retval);
zend_hash_next_index_insert(intern->node_list, &retval);
obj = Z_DOMOBJ_P(&retval);
nodep = dom_object_get_node(obj);
valuePush(ctxt, xmlXPathNewNodeSet(nodep));
} else if (Z_TYPE(retval) == IS_TRUE || Z_TYPE(retval) == IS_FALSE) {
valuePush(ctxt, xmlXPathNewBoolean(Z_LVAL(retval)));
} else if (Z_TYPE(retval) == IS_OBJECT) {
php_error_docref(NULL, E_WARNING, "A PHP Object cannot be converted to a XPath-string");
valuePush(ctxt, xmlXPathNewString((const xmlChar *) ""));
} else {
convert_to_string_ex(&retval);
valuePush(ctxt, xmlXPathNewString((xmlChar *) Z_STRVAL(retval)));
}
zval_ptr_dtor(&retval);
}
}
zend_string_release(callable);
zval_ptr_dtor(&handler);
if (fci.param_count > 0) {
for (i = 0; i < nargs - 1; i++) {
zval_ptr_dtor(&args[i]);
}
efree(args);
}
}
static void php_xpath_eval(INTERNAL_FUNCTION_PARAMETERS, int type) /* {{{ */
{
zval *id, retval, *context = NULL;
xmlXPathContextPtr ctxp;
xmlNodePtr nodep = NULL;
xmlXPathObjectPtr xpathobjp;
size_t expr_len, nsnbr = 0, xpath_type;
dom_xpath_object *intern;
dom_object *nodeobj;
char *expr;
xmlDoc *docp = NULL;
xmlNsPtr *ns = NULL;
zend_bool register_node_ns = 1;
if (zend_parse_method_parameters(ZEND_NUM_ARGS(), getThis(), "Os|O!b", &id, dom_xpath_class_entry, &expr, &expr_len, &context, dom_node_class_entry, ®ister_node_ns) == FAILURE) {
return;
}
intern = Z_XPATHOBJ_P(id);
ctxp = (xmlXPathContextPtr) intern->dom.ptr;
if (ctxp == NULL) {
php_error_docref(NULL, E_WARNING, "Invalid XPath Context");
RETURN_FALSE;
}
docp = (xmlDocPtr) ctxp->doc;
if (docp == NULL) {
php_error_docref(NULL, E_WARNING, "Invalid XPath Document Pointer");
RETURN_FALSE;
}
if (context != NULL) {
DOM_GET_OBJ(nodep, context, xmlNodePtr, nodeobj);
}
if (!nodep) {
nodep = xmlDocGetRootElement(docp);
}
if (nodep && docp != nodep->doc) {
php_error_docref(NULL, E_WARNING, "Node From Wrong Document");
RETURN_FALSE;
}
ctxp->node = nodep;
if (register_node_ns) {
/* Register namespaces in the node */
ns = xmlGetNsList(docp, nodep);
if (ns != NULL) {
while (ns[nsnbr] != NULL)
nsnbr++;
}
}
ctxp->namespaces = ns;
ctxp->nsNr = nsnbr;
xpathobjp = xmlXPathEvalExpression((xmlChar *) expr, ctxp);
ctxp->node = NULL;
if (ns != NULL) {
xmlFree(ns);
ctxp->namespaces = NULL;
ctxp->nsNr = 0;
}
if (! xpathobjp) {
RETURN_FALSE;
}
if (type == PHP_DOM_XPATH_QUERY) {
xpath_type = XPATH_NODESET;
} else {
xpath_type = xpathobjp->type;
}
switch (xpath_type) {
case XPATH_NODESET:
{
int i;
xmlNodeSetPtr nodesetp;
array_init(&retval);
if (xpathobjp->type == XPATH_NODESET && NULL != (nodesetp = xpathobjp->nodesetval)) {
for (i = 0; i < nodesetp->nodeNr; i++) {
xmlNodePtr node = nodesetp->nodeTab[i];
zval child;
if (node->type == XML_NAMESPACE_DECL) {
xmlNsPtr curns;
xmlNodePtr nsparent;
nsparent = node->_private;
curns = xmlNewNs(NULL, node->name, NULL);
if (node->children) {
curns->prefix = xmlStrdup((xmlChar *) node->children);
}
if (node->children) {
node = xmlNewDocNode(docp, NULL, (xmlChar *) node->children, node->name);
} else {
node = xmlNewDocNode(docp, NULL, (xmlChar *) "xmlns", node->name);
}
node->type = XML_NAMESPACE_DECL;
node->parent = nsparent;
node->ns = curns;
}
php_dom_create_object(node, &child, &intern->dom);
add_next_index_zval(&retval, &child);
}
}
php_dom_create_interator(return_value, DOM_NODELIST);
nodeobj = Z_DOMOBJ_P(return_value);
dom_xpath_iter(&retval, nodeobj);
break;
}
case XPATH_BOOLEAN:
RETVAL_BOOL(xpathobjp->boolval);
break;
case XPATH_NUMBER:
RETVAL_DOUBLE(xpathobjp->floatval)
break;
case XPATH_STRING:
RETVAL_STRING((char *) xpathobjp->stringval);
break;
default:
RETVAL_NULL();
break;
}
xmlXPathFreeObject(xpathobjp);
}
static void dom_xpath_ext_function_php(xmlXPathParserContextPtr ctxt, int nargs, int type) /* {{{ */
{
zval retval;
int result, i;
int error = 0;
zend_fcall_info fci;
xmlXPathObjectPtr obj;
char *str;
zend_string *callable = NULL;
dom_xpath_object *intern;
if (! zend_is_executing()) {
xmlGenericError(xmlGenericErrorContext,
"xmlExtFunctionTest: Function called from outside of PHP\n");
error = 1;
} else {
intern = (dom_xpath_object *) ctxt->context->userData;
if (intern == NULL) {
xmlGenericError(xmlGenericErrorContext,
"xmlExtFunctionTest: failed to get the internal object\n");
error = 1;
}
else if (intern->registerPhpFunctions == 0) {
xmlGenericError(xmlGenericErrorContext,
"xmlExtFunctionTest: PHP Object did not register PHP functions\n");
error = 1;
}
}
if (error == 1) {
for (i = nargs - 1; i >= 0; i--) {
obj = valuePop(ctxt);
xmlXPathFreeObject(obj);
}
return;
}
fci.param_count = nargs - 1;
if (fci.param_count > 0) {
fci.params = safe_emalloc(fci.param_count, sizeof(zval), 0);
}
/* Reverse order to pop values off ctxt stack */
for (i = nargs - 2; i >= 0; i--) {
obj = valuePop(ctxt);
switch (obj->type) {
case XPATH_STRING:
ZVAL_STRING(&fci.params[i], (char *)obj->stringval);
break;
case XPATH_BOOLEAN:
ZVAL_BOOL(&fci.params[i], obj->boolval);
break;
case XPATH_NUMBER:
ZVAL_DOUBLE(&fci.params[i], obj->floatval);
break;
case XPATH_NODESET:
if (type == 1) {
str = (char *)xmlXPathCastToString(obj);
ZVAL_STRING(&fci.params[i], str);
xmlFree(str);
} else if (type == 2) {
int j;
array_init(&fci.params[i]);
if (obj->nodesetval && obj->nodesetval->nodeNr > 0) {
for (j = 0; j < obj->nodesetval->nodeNr; j++) {
xmlNodePtr node = obj->nodesetval->nodeTab[j];
zval child;
/* not sure, if we need this... it's copied from xpath.c */
if (node->type == XML_NAMESPACE_DECL) {
xmlNsPtr curns;
xmlNodePtr nsparent;
nsparent = node->_private;
curns = xmlNewNs(NULL, node->name, NULL);
if (node->children) {
curns->prefix = xmlStrdup((xmlChar *) node->children);
}
if (node->children) {
node = xmlNewDocNode(node->doc, NULL, (xmlChar *) node->children, node->name);
} else {
node = xmlNewDocNode(node->doc, NULL, (xmlChar *) "xmlns", node->name);
}
node->type = XML_NAMESPACE_DECL;
node->parent = nsparent;
node->ns = curns;
}
php_dom_create_object(node, &child, &intern->dom);
add_next_index_zval(&fci.params[i], &child);
}
}
}
break;
default:
ZVAL_STRING(&fci.params[i], (char *)xmlXPathCastToString(obj));
}
xmlXPathFreeObject(obj);
}
fci.size = sizeof(fci);
fci.function_table = EG(function_table);
obj = valuePop(ctxt);
if (obj->stringval == NULL) {
php_error_docref(NULL, E_WARNING, "Handler name must be a string");
xmlXPathFreeObject(obj);
if (fci.param_count > 0) {
for (i = 0; i < nargs - 1; i++) {
zval_ptr_dtor(&fci.params[i]);
}
efree(fci.params);
}
return;
}
ZVAL_STRING(&fci.function_name, (char *) obj->stringval);
xmlXPathFreeObject(obj);
fci.symbol_table = NULL;
fci.object = NULL;
fci.retval = &retval;
fci.no_separation = 0;
if (!zend_make_callable(&fci.function_name, &callable)) {
php_error_docref(NULL, E_WARNING, "Unable to call handler %s()", callable->val);
} else if (intern->registerPhpFunctions == 2 && zend_hash_exists(intern->registered_phpfunctions, callable) == 0) {
php_error_docref(NULL, E_WARNING, "Not allowed to call handler '%s()'.", callable->val);
/* Push an empty string, so that we at least have an xslt result... */
valuePush(ctxt, xmlXPathNewString((xmlChar *)""));
} else {
result = zend_call_function(&fci, NULL);
if (result == SUCCESS && Z_TYPE(retval) != IS_UNDEF) {
if (Z_TYPE(retval) == IS_OBJECT && instanceof_function(Z_OBJCE(retval), dom_node_class_entry)) {
xmlNode *nodep;
dom_object *obj;
if (intern->node_list == NULL) {
ALLOC_HASHTABLE(intern->node_list);
zend_hash_init(intern->node_list, 0, NULL, ZVAL_PTR_DTOR, 0);
}
GC_REFCOUNT(&retval)++;
zend_hash_next_index_insert(intern->node_list, &retval);
obj = Z_DOMOBJ_P(&retval);
nodep = dom_object_get_node(obj);
valuePush(ctxt, xmlXPathNewNodeSet(nodep));
} else if (Z_TYPE(retval) == IS_FALSE || Z_TYPE(retval) == IS_TRUE) {
valuePush(ctxt, xmlXPathNewBoolean(Z_TYPE(retval) == IS_TRUE));
} else if (Z_TYPE(retval) == IS_OBJECT) {
php_error_docref(NULL, E_WARNING, "A PHP Object cannot be converted to a XPath-string");
valuePush(ctxt, xmlXPathNewString((xmlChar *)""));
} else {
zend_string *str = zval_get_string(&retval);
valuePush(ctxt, xmlXPathNewString((xmlChar *) str->val));
zend_string_release(str);
}
zval_ptr_dtor(&retval);
}
}
zend_string_release(callable);
zval_dtor(&fci.function_name);
if (fci.param_count > 0) {
for (i = 0; i < nargs - 1; i++) {
zval_ptr_dtor(&fci.params[i]);
}
efree(fci.params);
}
}
ZEND_METHOD( alinq_class , GroupBy )
{
zend_fcall_info fci;
zend_fcall_info_cache fci_cache;
zend_class_entry *ce;
ce = Z_OBJCE_P(getThis());
zval * reVal;
zval * resultArray;
MAKE_STD_ZVAL(resultArray);
array_init(resultArray);
zval *retval_ptr = NULL;
zval *returnObj;
zval *dataSource, **tmpns;
char aReturnType;
int aReturnTypeLen;
// aReturnType = 'bool';
//取得数组
dataSource = zend_read_property(ce, getThis(), "dataSource", sizeof("dataSource")-1, 0 TSRMLS_DC);
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "f", &fci, &fci_cache) == FAILURE) {
return;
}
while (zend_hash_get_current_data(Z_ARRVAL_P(dataSource), (void **)&tmpns) == SUCCESS) {
char *key;
uint keylen;
ulong idx;
int type;
zval **ppzval, tmpcopy;
zval **item,*item1;
MAKE_STD_ZVAL(item1);
array_init(item1);
item = &item1;
// php_printf("step-\n");
// if(count>0 && i>=count){ //只循环count次
// break;
// }
type = zend_hash_get_current_key_ex(Z_ARRVAL_P(dataSource), &key, &keylen,&idx, 0, NULL);
//重新copy一个zval，防止破坏原数据
tmpcopy = **tmpns;
zval_copy_ctor(&tmpcopy);
INIT_PZVAL(&tmpcopy);
// convert_to_string(&tmpcopy);
walu_call_anony_function(&retval_ptr, NULL, fci, "sz", key, keylen,&tmpcopy);
if(zend_hash_find(Z_ARRVAL_P(resultArray), Z_STRVAL_P(retval_ptr),sizeof(Z_STRVAL_P(retval_ptr)), (void **)&item) == FAILURE && IS_STRING==Z_TYPE_P(retval_ptr)) {
// php_printf("step0\n");
// zend_error(E_ERROR, "element not found");
// MAKE_STD_ZVAL(item);
// array_init(item);
add_assoc_zval(resultArray, Z_STRVAL_P(retval_ptr), *item);
}
// PHPWRITE(Z_STRVAL_P(retval_ptr),strlen(Z_STRVAL_P(retval_ptr)));
// php_printf("step1\n");
if( IS_ARRAY!=Z_TYPE_PP(item)){
php_printf("not array\n");
continue;
}
// add_assoc_zval(resultArray, retval_ptr, *tmpns);
add_next_index_zval(*item,*tmpns);
// /* Toss out old copy */
zval_dtor(&tmpcopy);
zend_hash_move_forward(Z_ARRVAL_P(dataSource));
}
walu_call_user_function(&returnObj, getThis(), "Instance", "z", resultArray);
RETURN_ZVAL(returnObj,1,1);
return;
}
PHP_METHOD(air_mysql_waiter, step_0) {
AIR_INIT_THIS;
zval *services = zend_read_property(Z_OBJCE_P(self), self, ZEND_STRL("_services"), 0 TSRMLS_CC);
zval *responses = zend_read_property(Z_OBJCE_P(self), self, ZEND_STRL("_responses"), 0 TSRMLS_CC);
zval *context = zend_read_property(Z_OBJCE_P(self), self, ZEND_STRL("_context"), 0 TSRMLS_CC);
zend_class_entry *mysqli_ce = air_get_ce(ZEND_STRL("mysqli") TSRMLS_CC);
zval *async;
MAKE_STD_ZVAL(async);
ZVAL_LONG(async, MYSQLI_ASYNC);
zval *wait_pool, *m2s;
MAKE_STD_ZVAL(wait_pool);
array_init(wait_pool);
MAKE_STD_ZVAL(m2s);
array_init(m2s);
zval *service;
ulong idx;
uint _idx, key_len;
char *key;
zval *mysqli = NULL;
HashTable *ah = Z_ARRVAL_P(services);
for(zend_hash_internal_pointer_reset(ah);
zend_hash_has_more_elements(ah) == SUCCESS;){
zval **___tmp;
if (zend_hash_get_current_data(ah, (void**)&___tmp) == FAILURE) {
continue;
}
if(zend_hash_get_current_key_ex(ah, &key, &key_len, &idx, 0, NULL) != HASH_KEY_IS_STRING) {
key = NULL; key_len = 0;
}
service = *___tmp;
if(Z_TYPE_P(service) == IS_NULL){
zend_hash_index_del(ah, idx);
continue;
}
zval *service_id = zend_read_property(air_async_service_ce, service, ZEND_STRL("_id"), 1 TSRMLS_CC);
zval *mysql = zend_read_property(air_async_service_ce, service, ZEND_STRL("_request"), 1 TSRMLS_CC);
zval *status = zend_read_property(air_mysql_ce, mysql, ZEND_STRL("_status"), 0 TSRMLS_CC);
if(Z_LVAL_P(status)){
//ignore if the mysql's been executed
zend_hash_index_del(ah, idx);
continue;
}
zval *mysql_config = zend_read_property(air_mysql_ce, mysql, ZEND_STRL("_config"), 1 TSRMLS_CC);
zval *mode = zend_read_property(air_mysql_ce, mysql, ZEND_STRL("_mode"), 1 TSRMLS_CC);
if(Z_TYPE_P(mode) == IS_NULL){
air_mysql_auto_mode(mysql TSRMLS_CC);
mode = zend_read_property(air_mysql_ce, mysql, ZEND_STRL("_mode"), 1 TSRMLS_CC);
}
zval **acquire_params[2] = {&mysql_config, &mode};
mysqli = NULL;
air_call_static_method(air_mysql_keeper_ce, "acquire", &mysqli, 2, acquire_params);
if(Z_TYPE_P(mysqli) != IS_NULL){
zval **build_params[1] = {&mysqli};
zval *sql = NULL;
air_call_method(&mysql, air_mysql_ce, NULL, ZEND_STRL("build"), &sql, 1, build_params TSRMLS_CC);
if(sql){
zval **query_params[2] = {&sql, &async};
air_call_method(&mysqli, mysqli_ce, NULL, ZEND_STRL("query"), NULL, 2, query_params TSRMLS_CC);
add_next_index_zval(wait_pool, mysqli);
Z_ADDREF_P(service_id);
add_index_zval(m2s, air_mysqli_get_id(mysqli TSRMLS_CC), service_id);
zval_ptr_dtor(&sql);
}else{
//should not happen
php_error(E_ERROR, "sql not found");
zval_ptr_dtor(&mysqli);
}
}else{
zval_ptr_dtor(&mysqli);
}
zend_hash_move_forward(ah);
}
zval_ptr_dtor(&async);
add_assoc_zval(context, "pool", wait_pool);
add_assoc_zval(context, "m2s", m2s);
add_assoc_long(context, "waited", zend_hash_num_elements(Z_ARRVAL_P(wait_pool)));
add_assoc_long(context, "processed", 0);
add_assoc_long(context, "step", 1);
}
static void php_mongo_enumerate_collections(INTERNAL_FUNCTION_PARAMETERS, int full_collection)
{
zend_bool system_col = 0;
zval *nss, *collection, *cursor, *list, *next;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|b", &system_col) == FAILURE) {
return;
}
// select db.system.namespaces collection
MAKE_STD_ZVAL(nss);
ZVAL_STRING(nss, "system.namespaces", 1);
MAKE_STD_ZVAL(collection);
MONGO_METHOD1(MongoDB, selectCollection, collection, getThis(), nss);
// list to return
MAKE_STD_ZVAL(list);
array_init(list);
// do find
MAKE_STD_ZVAL(cursor);
MONGO_METHOD(MongoCollection, find, cursor, collection);
// populate list
MAKE_STD_ZVAL(next);
MONGO_METHOD(MongoCursor, getNext, next, cursor);
while (!IS_SCALAR_P(next)) {
zval *c, *zname;
zval **collection;
char *name, *first_dot, *system;
// check that the ns is valid and not an index (contains $)
if (zend_hash_find(HASH_P(next), "name", 5, (void**)&collection) == FAILURE ||
strchr(Z_STRVAL_PP(collection), '$')) {
zval_ptr_dtor(&next);
MAKE_STD_ZVAL(next);
ZVAL_NULL(next);
MONGO_METHOD(MongoCursor, getNext, next, cursor);
continue;
}
first_dot = strchr(Z_STRVAL_PP(collection), '.');
system = strstr(Z_STRVAL_PP(collection), ".system.");
// check that this isn't a system ns
if (!system_col && (system && first_dot == system) ||
(name = strchr(Z_STRVAL_PP(collection), '.')) == 0) {
zval_ptr_dtor(&next);
MAKE_STD_ZVAL(next);
ZVAL_NULL(next);
MONGO_METHOD(MongoCursor, getNext, next, cursor);
continue;
}
// take a substring after the first "."
name++;
// "foo." was allowed in earlier versions
if (name == '\0') {
zval_ptr_dtor(&next);
MAKE_STD_ZVAL(next);
ZVAL_NULL(next);
MONGO_METHOD(MongoCursor, getNext, next, cursor);
continue;
}
if (full_collection) {
MAKE_STD_ZVAL(c);
ZVAL_NULL(c);
MAKE_STD_ZVAL(zname);
ZVAL_NULL(zname);
// name must be copied because it is a substring of
// a string that will be garbage collected in a sec
ZVAL_STRING(zname, name, 1);
MONGO_METHOD1(MongoDB, selectCollection, c, getThis(), zname);
add_next_index_zval(list, c);
zval_ptr_dtor(&zname);
} else {
add_next_index_string(list, name, 1);
}
zval_ptr_dtor(&next);
MAKE_STD_ZVAL(next);
MONGO_METHOD(MongoCursor, getNext, next, cursor);
}
zval_ptr_dtor(&next);
zval_ptr_dtor(&nss);
zval_ptr_dtor(&cursor);
zval_ptr_dtor(&collection);
RETURN_ZVAL(list, 0, 1);
}
PHP_METHOD(MongoDB, listCollections) {
// select db.system.namespaces collection
zval *nss, *collection, *cursor, *list, *next;
MAKE_STD_ZVAL(nss);
ZVAL_STRING(nss, "system.namespaces", 1);
MAKE_STD_ZVAL(collection);
MONGO_METHOD1(MongoDB, selectCollection, collection, getThis(), nss);
// list to return
MAKE_STD_ZVAL(list);
array_init(list);
// do find
MAKE_STD_ZVAL(cursor);
MONGO_METHOD(MongoCollection, find, cursor, collection);
// populate list
MAKE_STD_ZVAL(next);
MONGO_METHOD(MongoCursor, getNext, next, cursor);
while (!IS_SCALAR_P(next)) {
zval *c, *zname;
zval **collection;
char *name, *first_dot, *system;
// check that the ns is valid and not an index (contains $)
if (zend_hash_find(HASH_P(next), "name", 5, (void**)&collection) == FAILURE ||
strchr(Z_STRVAL_PP(collection), '$')) {
zval_ptr_dtor(&next);
MAKE_STD_ZVAL(next);
ZVAL_NULL(next);
MONGO_METHOD(MongoCursor, getNext, next, cursor);
continue;
}
first_dot = strchr(Z_STRVAL_PP(collection), '.');
system = strstr(Z_STRVAL_PP(collection), ".system.");
// check that this isn't a system ns
if ((system && first_dot == system) ||
(name = strchr(Z_STRVAL_PP(collection), '.')) == 0) {
zval_ptr_dtor(&next);
MAKE_STD_ZVAL(next);
ZVAL_NULL(next);
MONGO_METHOD(MongoCursor, getNext, next, cursor);
continue;
}
// take a substring after the first "."
name++;
// "foo." was allowed in earlier versions
if (name == '\0') {
zval_ptr_dtor(&next);
MAKE_STD_ZVAL(next);
ZVAL_NULL(next);
MONGO_METHOD(MongoCursor, getNext, next, cursor);
continue;
}
MAKE_STD_ZVAL(c);
ZVAL_NULL(c);
MAKE_STD_ZVAL(zname);
ZVAL_NULL(zname);
// name must be copied because it is a substring of
// a string that will be garbage collected in a sec
ZVAL_STRING(zname, name, 1);
MONGO_METHOD1(MongoDB, selectCollection, c, getThis(), zname);
add_next_index_zval(list, c);
zval_ptr_dtor(&zname);
zval_ptr_dtor(&next);
MAKE_STD_ZVAL(next);
MONGO_METHOD(MongoCursor, getNext, next, cursor);
}
zval_ptr_dtor(&next);
zval_ptr_dtor(&nss);
zval_ptr_dtor(&cursor);
zval_ptr_dtor(&collection);
RETURN_ZVAL(list, 0, 1);
}
int msgpack_convert_array(zval *return_value, zval *tpl, zval **value)
{
TSRMLS_FETCH();
if (Z_TYPE_P(tpl) == IS_ARRAY)
{
char *key;
uint key_len;
int key_type;
ulong key_index;
zval **data, **arydata;
HashPosition pos, valpos;
HashTable *ht, *htval;
int num;
ht = HASH_OF(tpl);
// TODO: maybe need to release memory?
array_init(return_value);
num = zend_hash_num_elements(ht);
if (num <= 0)
{
MSGPACK_WARNING(
"[msgpack] (%s) template array length is 0",
__FUNCTION__);
zval_ptr_dtor(value);
return FAILURE;
}
/* string */
if (ht->nNumOfElements != ht->nNextFreeElement)
{
htval = HASH_OF(*value);
if (!htval)
{
MSGPACK_WARNING(
"[msgpack] (%s) input data is not array",
__FUNCTION__);
zval_ptr_dtor(value);
return FAILURE;
}
zend_hash_internal_pointer_reset_ex(ht, &pos);
zend_hash_internal_pointer_reset_ex(htval, &valpos);
for (;; zend_hash_move_forward_ex(ht, &pos),
zend_hash_move_forward_ex(htval, &valpos))
{
key_type = zend_hash_get_current_key_ex(
ht, &key, &key_len, &key_index, 0, &pos);
if (key_type == HASH_KEY_NON_EXISTANT)
{
break;
}
if (zend_hash_get_current_data_ex(
ht, (void *)&data, &pos) != SUCCESS)
{
continue;
}
if (key_type == HASH_KEY_IS_STRING)
{
int (*convert_function)(zval *, zval *, zval **) = NULL;
zval **dataval, *val;
switch (Z_TYPE_PP(data))
{
case IS_ARRAY:
convert_function = msgpack_convert_array;
break;
case IS_OBJECT:
// case IS_STRING:
convert_function = msgpack_convert_object;
break;
default:
break;
}
if (zend_hash_get_current_data_ex(
htval, (void *)&dataval, &valpos) != SUCCESS)
{
MSGPACK_WARNING(
"[msgpack] (%s) can't get data",
__FUNCTION__);
zval_ptr_dtor(value);
return FAILURE;
}
MSGPACK_CONVERT_COPY_ZVAL(val, dataval);
if (convert_function)
{
zval *rv;
ALLOC_INIT_ZVAL(rv);
if (convert_function(rv, *data, &val) != SUCCESS)
{
zval_ptr_dtor(&val);
return FAILURE;
}
add_assoc_zval_ex(return_value, key, key_len, rv);
}
else
{
add_assoc_zval_ex(return_value, key, key_len, val);
}
}
}
zval_ptr_dtor(value);
return SUCCESS;
}
else
{
/* index */
int (*convert_function)(zval *, zval *, zval **) = NULL;
if (Z_TYPE_PP(value) != IS_ARRAY)
{
MSGPACK_WARNING(
"[msgpack] (%s) unserialized data must be array.",
__FUNCTION__);
zval_ptr_dtor(value);
return FAILURE;
}
zend_hash_internal_pointer_reset_ex(ht, &pos);
key_type = zend_hash_get_current_key_ex(
ht, &key, &key_len, &key_index, 0, &pos);
if (key_type == HASH_KEY_NON_EXISTANT)
{
MSGPACK_WARNING(
"[msgpack] (%s) first element in template array is empty",
__FUNCTION__);
zval_ptr_dtor(value);
return FAILURE;
}
if (zend_hash_get_current_data_ex(
ht, (void *)&data, &pos) != SUCCESS)
{
MSGPACK_WARNING(
"[msgpack] (%s) invalid template: empty array?",
__FUNCTION__);
zval_ptr_dtor(value);
return FAILURE;
}
switch (Z_TYPE_PP(data))
{
case IS_ARRAY:
convert_function = msgpack_convert_array;
break;
case IS_OBJECT:
case IS_STRING:
convert_function = msgpack_convert_object;
break;
default:
break;
}
htval = HASH_OF(*value);
num = zend_hash_num_elements(htval);
if (num <= 0)
{
MSGPACK_WARNING(
"[msgpack] (%s) array length is 0 in unserialized data",
__FUNCTION__);
zval_ptr_dtor(value);
return FAILURE;
}
zend_hash_internal_pointer_reset_ex(htval, &valpos);
for (;; zend_hash_move_forward_ex(htval, &valpos))
{
key_type = zend_hash_get_current_key_ex(
htval, &key, &key_len, &key_index, 0, &valpos);
if (key_type == HASH_KEY_NON_EXISTANT)
{
break;
}
if (zend_hash_get_current_data_ex(
htval, (void *)&arydata, &valpos) != SUCCESS)
{
MSGPACK_WARNING(
"[msgpack] (%s) can't get next data in indexed array",
__FUNCTION__);
continue;
}
switch (key_type)
{
case HASH_KEY_IS_LONG:
{
zval *aryval, *rv;
ALLOC_INIT_ZVAL(rv);
MSGPACK_CONVERT_COPY_ZVAL(aryval, arydata);
if (convert_function)
{
if (convert_function(rv, *data, &aryval) != SUCCESS)
{
zval_ptr_dtor(&aryval);
MSGPACK_WARNING(
"[msgpack] (%s) "
"convert failure in HASH_KEY_IS_LONG "
"in indexed array",
__FUNCTION__);
zval_ptr_dtor(value);
return FAILURE;
}
add_next_index_zval(return_value, rv);
}
else
{
add_next_index_zval(return_value, aryval);
}
break;
}
case HASH_KEY_IS_STRING:
MSGPACK_WARNING(
"[msgpack] (%s) key is string",
__FUNCTION__);
zval_ptr_dtor(value);
return FAILURE;
default:
MSGPACK_WARNING(
"[msgpack] (%s) key is not string nor array",
__FUNCTION__);
zval_ptr_dtor(value);
return FAILURE;
}
}
zval_ptr_dtor(value);
return SUCCESS;
}
}
else
{
// shouldn't reach
MSGPACK_WARNING(
"[msgpack] (%s) template is not array",
__FUNCTION__);
zval_ptr_dtor(value);
return FAILURE;
}
// shouldn't reach
zval_ptr_dtor(value);
return FAILURE;
}
static void php_facedetect(INTERNAL_FUNCTION_PARAMETERS, int return_type)
{
char *file, *casc;
long flen, clen;
zval *array;
CvHaarClassifierCascade* cascade;
IplImage *img, *gray;
CvMemStorage *storage;
CvSeq *faces;
CvRect *rect;
if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss", &file, &flen, &casc, &clen) == FAILURE) {
RETURN_NULL();
}
img = cvLoadImage(file, 1);
if(!img) {
RETURN_FALSE;
}
cascade = (CvHaarClassifierCascade*)cvLoad(casc, 0, 0, 0);
if(!cascade) {
RETURN_FALSE;
}
gray = cvCreateImage(cvSize(img->width, img->height), 8, 1);
cvCvtColor(img, gray, CV_BGR2GRAY);
cvEqualizeHist(gray, gray);
storage = cvCreateMemStorage(0);
faces = cvHaarDetectObjects(gray, cascade, storage, 1.1, 2, CV_HAAR_DO_CANNY_PRUNING, cvSize(0, 0), cvSize(0, 0));
if(return_type) {
array_init(return_value);
if(faces && faces->total > 0) {
int i;
for(i = 0; i < faces->total; i++) {
MAKE_STD_ZVAL(array);
array_init(array);
rect = (CvRect *)cvGetSeqElem(faces, i);
add_assoc_long(array, "x", rect->x);
add_assoc_long(array, "y", rect->y);
add_assoc_long(array, "w", rect->width);
add_assoc_long(array, "h", rect->height);
add_next_index_zval(return_value, array);
}
}
} else {
RETVAL_LONG(faces ? faces->total : 0);
}
cvReleaseMemStorage(&storage);
cvReleaseImage(&gray);
cvReleaseImage(&img);
}
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);
}
/* Iterate over the given protobuf message pointer and transform values into native
php types. writes an associative array into the given zval**. */
void message_php (zval* return_value, const ProtobufCMessage *message)
{
unsigned int i, j;
for (i=0;i<message->descriptor->n_fields;i++) {
const ProtobufCFieldDescriptor *field = message->descriptor->fields + i;
const void* member = get_member(message, field);
size_t* num_fields = get_quantifier(message, field);
const ProtobufCMessage** sub_messages;
const ProtobufCMessage* sub_message;
zval *inner, *inner_repeated;
switch (field->type) {
case PROTOBUF_C_TYPE_INT32:
if (field->label == PROTOBUF_C_LABEL_OPTIONAL && (protobuf_c_boolean)*num_fields) {
int32_php_single(return_value, (char*)field->name, (const int32_t*)member);
} else if (field->label == PROTOBUF_C_LABEL_REQUIRED) {
int32_php_single(return_value, (char*)field->name, (const int32_t*)member);
} else if (field->label == PROTOBUF_C_LABEL_REPEATED && *num_fields) {
int32_php_repeated(return_value, (char*)field->name, (const int32_t**)member, *num_fields);
}
break;
case PROTOBUF_C_TYPE_UINT32:
if (field->label == PROTOBUF_C_LABEL_OPTIONAL && (protobuf_c_boolean)*num_fields) {
uint32_php_single(return_value, (char*)field->name, (const uint32_t*)member);
} else if (field->label == PROTOBUF_C_LABEL_REQUIRED) {
uint32_php_single(return_value, (char*)field->name, (const uint32_t*)member);
} else if (field->label == PROTOBUF_C_LABEL_REPEATED && *num_fields) {
uint32_php_repeated(return_value, (char*)field->name, (const uint32_t**)member, *num_fields);
}
break;
case PROTOBUF_C_TYPE_STRING:
if (field->label == PROTOBUF_C_LABEL_OPTIONAL) {
char** pos = (char**)member;
if (*pos != NULL) {
string_php_single(return_value, (char*)field->name, (char* const*)member);
}
} else if (field->label == PROTOBUF_C_LABEL_REQUIRED) {
string_php_single(return_value, (char*)field->name, (char* const*)member);
} else if (field->label == PROTOBUF_C_LABEL_REPEATED && *num_fields) {
string_php_repeated(return_value, (char*)field->name, (char** const*)member, *num_fields);
}
break;
case PROTOBUF_C_TYPE_BOOL:
bool_php(return_value, field->name, *(const protobuf_c_boolean *)member);
break;
case PROTOBUF_C_TYPE_MESSAGE:
// optional or repeated field with no entries shouldn't make it to PHP
if (field->label == PROTOBUF_C_LABEL_OPTIONAL || field->label == PROTOBUF_C_LABEL_REPEATED) {
if (*((const ProtobufCMessage**)member) == NULL) {
break;
}
}
MAKE_STD_ZVAL(inner);
array_init(inner);
if (field->label == PROTOBUF_C_LABEL_OPTIONAL || field->label == PROTOBUF_C_LABEL_REQUIRED) {
message_php(inner, *((const ProtobufCMessage**)member));
} else if (field->label == PROTOBUF_C_LABEL_REPEATED) {
sub_messages = (const ProtobufCMessage**)*((const ProtobufCMessage**)member);
for (j=0;j<*num_fields;++j) {
MAKE_STD_ZVAL(inner_repeated);
array_init(inner_repeated);
message_php(inner_repeated, sub_messages[j]);
add_next_index_zval(inner, inner_repeated);
}
}
add_assoc_zval(return_value, (char*)field->name, inner);
break;
case PROTOBUF_C_TYPE_DOUBLE:
// double_php(return_value, field->name, *(const uint64_t *)member);
case PROTOBUF_C_TYPE_FLOAT:
// float_php(return_value, field->name, *(const uint32_t *)member);
case PROTOBUF_C_TYPE_SINT32:
// sint32_php(return_value, field->name, *(const int32_t *)member);
case PROTOBUF_C_TYPE_FIXED32:
// fixed32_php(return_value, field->name, *(const uint32_t *)member);
case PROTOBUF_C_TYPE_SFIXED32:
// sfixed32_php(return_value, field->name, *(const uint32_t *)member);
case PROTOBUF_C_TYPE_INT64:
// int64_php(return_value, field->name, *(const uint64_t *)member);
case PROTOBUF_C_TYPE_SINT64:
// sint64_php(return_value, field->name, *(const int64_t *)member);
case PROTOBUF_C_TYPE_UINT64:
// uint64_php(return_value, field->name, *(const uint64_t *)member);
case PROTOBUF_C_TYPE_FIXED64:
// fixed64_php(return_value, field->name, *(const uint64_t *)member);
case PROTOBUF_C_TYPE_SFIXED64:
// sfixed64_php(return_value, field->name, *(const uint64_t *)member);
// XXX unimplemented XXX
case PROTOBUF_C_TYPE_ENUM:
case PROTOBUF_C_TYPE_BYTES:
default:
break;
}
}
}
/**
* Applies a format to a message before sending it to the log
*
* @param string $message
* @param int $type
* @param int $timestamp
* @param array $context
* @return string
*/
PHP_METHOD(Phalcon_Logger_Formatter_Firephp, format) {
zval *message, *type, *type_str = NULL, *timestamp, *context, *interpolated = NULL;
zval *payload, *body, *backtrace = NULL, *meta, *encoded;
zval *show_backtrace, *enable_labels;
int i_show_backtrace, i_enable_labels;
smart_str result = { NULL, 0, 0 };
uint i;
Bucket *p;
phalcon_fetch_params(0, 4, 0, &message, &type, ×tamp, &context);
/*
* We intentionally do not use Phalcon's MM for better performance.
* All variables allocated with ALLOC_INIT_ZVAL() will have
* their reference count set to 1 and therefore they can be nicely
* put into the result array; when that array will be destroyed,
* all inserted variables will be automatically destroyed, too
* and we will just save some time by not using Z_ADDREF_P and Z_DELREF_P
*/
if (Z_TYPE_P(context) == IS_ARRAY) {
PHALCON_CALL_METHODW(&interpolated, this_ptr, "interpolate", message, context);
}
else {
interpolated = message;
Z_ADDREF_P(interpolated);
}
{
zval *params[] = { type };
if (FAILURE == phalcon_call_method(&type_str, this_ptr, "gettypestring", 1, params TSRMLS_CC)) {
zval_ptr_dtor(&interpolated);
return;
}
}
show_backtrace = phalcon_fetch_nproperty_this(getThis(), SL("_showBacktrace"), PH_NOISY TSRMLS_CC);
enable_labels = phalcon_fetch_nproperty_this(getThis(), SL("_enableLabels"), PH_NOISY TSRMLS_CC);
i_show_backtrace = zend_is_true(show_backtrace);
i_enable_labels = zend_is_true(enable_labels);
/*
* Get the backtrace. This differs for different PHP versions.
* 5.3.6+ allows us to skip the function arguments which will save some memory
* For 5.4+ there is an extra argument.
*/
if (i_show_backtrace) {
ALLOC_INIT_ZVAL(backtrace);
#if PHP_VERSION_ID < 50306
zend_fetch_debug_backtrace(backtrace, 1, 0 TSRMLS_CC);
#elif PHP_VERSION_ID < 50400
zend_fetch_debug_backtrace(backtrace, 1, DEBUG_BACKTRACE_IGNORE_ARGS TSRMLS_CC);
#else
zend_fetch_debug_backtrace(backtrace, 1, DEBUG_BACKTRACE_IGNORE_ARGS, 0 TSRMLS_CC);
#endif
if (Z_TYPE_P(backtrace) == IS_ARRAY) {
HashPosition pos;
HashTable *ht = Z_ARRVAL_P(backtrace);
zval **ppzval;
int found = 0;
ulong idx;
char *key;
uint key_len;
/*
* At this point we know that the backtrace is the array.
* Again, we intentionally do not use Phalcon's API because we know
* that we are working with the array / hash table and thus we can
* save some time by omitting Z_TYPE_P(x) == IS_ARRAY checks
*/
for (
zend_hash_internal_pointer_reset_ex(ht, &pos);
zend_hash_has_more_elements_ex(ht, &pos) == SUCCESS;
) {
zend_hash_get_current_data_ex(ht, (void**)&ppzval, &pos);
zend_hash_get_current_key_ex(ht, &key, &key_len, &idx, 0, &pos);
zend_hash_move_forward_ex(ht, &pos);
if (Z_TYPE_PP(ppzval) == IS_ARRAY) {
/*
* Here we need to skip the latest calls into Phalcon's core.
* Calls to Zend internal functions will have "file" index not set.
* We remove these entries from the array.
*/
if (!found && !zend_hash_quick_exists(Z_ARRVAL_PP(ppzval), SS("file"), zend_inline_hash_func(SS("file")))) {
zend_hash_index_del(ht, idx);
}
else {
/*
* Remove args and object indices. They usually give
* too much information; this is not suitable to send
* in the HTTP headers
*/
zend_hash_quick_del(Z_ARRVAL_PP(ppzval), "args", sizeof("args"), zend_inline_hash_func(SS("args")));
zend_hash_quick_del(Z_ARRVAL_PP(ppzval), "object", sizeof("object"), zend_inline_hash_func(SS("object")));
found = 1;
}
}
}
/*
* Now we need to renumber the hash table because we removed several
* heading elements. If we don't do this, json_encode() will convert
* this array to a JavaScript object which is an unwanted side effect
*/
p = ht->pListHead;
i = 0;
while (p != NULL) {
p->nKeyLength = 0;
p->h = i++;
p = p->pListNext;
}
ht->nNextFreeElement = i;
zend_hash_rehash(ht);
}
}
/*
* The result will looks like this:
*
* array(
* array('Type' => 'message type', 'Label' => 'message'),
* array('backtrace' => array(backtrace goes here)
* )
*/
MAKE_STD_ZVAL(payload);
array_init_size(payload, 2);
MAKE_STD_ZVAL(meta);
array_init_size(meta, 4);
add_assoc_zval_ex(meta, SS("Type"), type_str);
if (i_show_backtrace && Z_TYPE_P(backtrace) == IS_ARRAY) {
zval **ppzval;
if (likely(SUCCESS == zend_hash_index_find(Z_ARRVAL_P(backtrace), 0, (void**)&ppzval)) && likely(Z_TYPE_PP(ppzval) == IS_ARRAY)) {
zval **file = NULL, **line = NULL;
zend_hash_quick_find(Z_ARRVAL_PP(ppzval), SS("file"), zend_inline_hash_func(SS("file")), (void**)&file);
zend_hash_quick_find(Z_ARRVAL_PP(ppzval), SS("line"), zend_inline_hash_func(SS("line")), (void**)&line);
if (likely(file != NULL)) {
Z_ADDREF_PP(file);
add_assoc_zval_ex(meta, SS("File"), *file);
}
if (likely(line != NULL)) {
Z_ADDREF_PP(line);
add_assoc_zval_ex(meta, SS("Line"), *line);
}
}
}
if (i_enable_labels) {
add_assoc_zval_ex(meta, SS("Label"), interpolated);
}
if (!i_enable_labels && !i_show_backtrace) {
body = interpolated;
}
else if (i_enable_labels && !i_show_backtrace) {
MAKE_STD_ZVAL(body);
ZVAL_EMPTY_STRING(body);
}
else {
MAKE_STD_ZVAL(body);
array_init_size(body, 2);
if (i_show_backtrace) {
add_assoc_zval_ex(body, SS("backtrace"), backtrace);
}
if (!i_enable_labels) {
add_assoc_zval_ex(body, SS("message"), interpolated);
}
}
add_next_index_zval(payload, meta);
add_next_index_zval(payload, body);
/* Convert everything to JSON */
ALLOC_INIT_ZVAL(encoded);
if (FAILURE == phalcon_json_encode(encoded, payload, 0 TSRMLS_CC)) {
zval_ptr_dtor(&payload);
zval_ptr_dtor(&encoded);
return;
}
/* As promised, kill the payload and all associated elements */
zval_ptr_dtor(&payload);
/*
* We don't want to use Phalcon's concatenation API because it
* requires the memory manager. Therefore we fall back to using smart strings.
* smart_str_alloc4() will allocate all required memory amount (plus some more)
* in one go and this allows us to avoid performance penalties due to
* memory reallocations.
*/
if (Z_TYPE_P(encoded) == IS_STRING && Z_STRVAL_P(encoded) != NULL) {
smart_str_alloc4(&result, (uint)(Z_STRLEN_P(encoded) + 2 + 5), 0, i);
/*
* The format is:
*
* <size>|[meta,body]|
*
* Meta and body are contained in encoded inside the array, as required
* by the protocol specification
* @see http://www.firephp.org/Wiki/Reference/Protocol
*/
smart_str_append_long(&result, Z_STRLEN_P(encoded));
smart_str_appendc(&result, '|');
smart_str_appendl(&result, Z_STRVAL_P(encoded), Z_STRLEN_P(encoded));
smart_str_appendc(&result, '|');
smart_str_0(&result);
}
/* We don't need the JSON message anymore */
zval_ptr_dtor(&encoded);
/* Do not free the smart string because we steal its data for zval */
RETURN_STRINGL(result.c, result.len, 0);
}
int ltd_process_entry( zval *values, char *keyval, int keyval_len, char *filename, int line_number ) {
char *trim_keyval, *key, *trim_key, *val, *trim_val, *col = NULL, *tmp_val;
int trim_keyval_len, key_len, trim_key_len, val_len, trim_val_len, col_pos;
char *brace_open, *brace_close, *tmp_brace, *subarray;
int brace_len, tmp_brace_len, subarray_len;
int ret_val = SUCCESS;
zval *subvalues;
ltd_trim( keyval, keyval_len, &trim_keyval, &trim_keyval_len );
if ( trim_keyval[0] == '{' ) {
trim_val = trim_keyval;
trim_val_len = trim_keyval_len;
} else {
col = memchr( trim_keyval, ':', trim_keyval_len );
if ( col == NULL ) {
trim_val = trim_keyval;
trim_val_len = trim_keyval_len;
} else {
col_pos = (int)( col - trim_keyval );
key_len = col_pos;
key = estrndup( trim_keyval, col_pos );
ltd_trim( key, key_len, &trim_key, &trim_key_len );
tmp_val = trim_keyval + col_pos + 1;
val_len = trim_keyval_len - col_pos - 1;
val = estrndup( tmp_val, val_len );
ltd_trim( val, val_len, &trim_val, &trim_val_len );
}
}
brace_open = memchr( trim_val, '{', trim_val_len );
if ( brace_open != NULL ) {
brace_open++;
brace_len = (int)( brace_open - trim_val );
brace_close = memchr( brace_open, '}', trim_val_len - brace_len );
if ( brace_close == NULL ) {
php_error( E_WARNING, "Unbalanced brace count in '%s' on line %i", filename, line_number );
ret_val = FAILURE;
goto out;
}
tmp_brace_len = (int)( brace_close - brace_open );
if ( memchr( brace_open, '{', tmp_brace_len ) != NULL ) {
if ( ltd_skip_subarrays( brace_open, trim_val_len - brace_len, &tmp_brace, filename, line_number ) == FAILURE ) {
ret_val = FAILURE;
goto out;
}
tmp_brace_len = (int)( tmp_brace - trim_val );
brace_close = memchr( tmp_brace, '}', trim_val_len - tmp_brace_len );
}
subarray_len = (int)( brace_close - brace_open ) - 1;
subarray = estrndup( brace_open, subarray_len );
MAKE_STD_ZVAL( subvalues );
array_init( subvalues );
if( ltd_process_array( subvalues, subarray, subarray_len, filename, line_number ) == FAILURE ) {
efree( subarray );
zval_dtor( subvalues );
ret_val = FAILURE;
goto out;
}
if ( col == NULL ) {
add_next_index_zval( values, subvalues );
} else {
add_assoc_zval_ex( values, trim_key, trim_key_len + 1, subvalues );
}
efree( subarray );
} else {
if ( col == NULL ) {
add_next_index_zval( values, ltd_transform_to_zval( trim_val, trim_val_len ) );
} else {
add_assoc_zval_ex( values, trim_key, trim_key_len + 1, ltd_transform_to_zval( trim_val, trim_val_len ) );
}
}
out:
if ( col != NULL ) {
efree( key );
efree( val );
}
return ret_val;
}
static void dom_xpath_ext_function_php(xmlXPathParserContextPtr ctxt, int nargs, int type) /* {{{ */
{
zval **args = NULL;
zval *retval;
int result, i, ret;
int error = 0;
zend_fcall_info fci;
zval handler;
xmlXPathObjectPtr obj;
char *str;
char *callable = NULL;
dom_xpath_object *intern;
TSRMLS_FETCH();
if (! zend_is_executing(TSRMLS_C)) {
xmlGenericError(xmlGenericErrorContext,
"xmlExtFunctionTest: Function called from outside of PHP\n");
error = 1;
} else {
intern = (dom_xpath_object *) ctxt->context->userData;
if (intern == NULL) {
xmlGenericError(xmlGenericErrorContext,
"xmlExtFunctionTest: failed to get the internal object\n");
error = 1;
}
else if (intern->registerPhpFunctions == 0) {
xmlGenericError(xmlGenericErrorContext,
"xmlExtFunctionTest: PHP Object did not register PHP functions\n");
error = 1;
}
}
if (error == 1) {
for (i = nargs - 1; i >= 0; i--) {
obj = valuePop(ctxt);
xmlXPathFreeObject(obj);
}
return;
}
fci.param_count = nargs - 1;
if (fci.param_count > 0) {
fci.params = safe_emalloc(fci.param_count, sizeof(zval**), 0);
args = safe_emalloc(fci.param_count, sizeof(zval *), 0);
}
/* Reverse order to pop values off ctxt stack */
for (i = nargs - 2; i >= 0; i--) {
obj = valuePop(ctxt);
MAKE_STD_ZVAL(args[i]);
switch (obj->type) {
case XPATH_STRING:
ZVAL_STRING(args[i], (char *)obj->stringval, 1);
break;
case XPATH_BOOLEAN:
ZVAL_BOOL(args[i], obj->boolval);
break;
case XPATH_NUMBER:
ZVAL_DOUBLE(args[i], obj->floatval);
break;
case XPATH_NODESET:
if (type == 1) {
str = (char *)xmlXPathCastToString(obj);
ZVAL_STRING(args[i], str, 1);
xmlFree(str);
} else if (type == 2) {
int j;
array_init(args[i]);
if (obj->nodesetval && obj->nodesetval->nodeNr > 0) {
for (j = 0; j < obj->nodesetval->nodeNr; j++) {
xmlNodePtr node = obj->nodesetval->nodeTab[j];
zval *child;
MAKE_STD_ZVAL(child);
/* not sure, if we need this... it's copied from xpath.c */
if (node->type == XML_NAMESPACE_DECL) {
xmlNsPtr curns;
xmlNodePtr nsparent;
nsparent = node->_private;
curns = xmlNewNs(NULL, node->name, NULL);
if (node->children) {
curns->prefix = xmlStrdup((xmlChar *) node->children);
}
if (node->children) {
node = xmlNewDocNode(node->doc, NULL, (xmlChar *) node->children, node->name);
} else {
node = xmlNewDocNode(node->doc, NULL, (xmlChar *) "xmlns", node->name);
}
node->type = XML_NAMESPACE_DECL;
node->parent = nsparent;
node->ns = curns;
}
child = php_dom_create_object(node, &ret, child, (dom_object *)intern TSRMLS_CC);
add_next_index_zval(args[i], child);
}
}
}
break;
default:
ZVAL_STRING(args[i], (char *)xmlXPathCastToString(obj), 1);
}
xmlXPathFreeObject(obj);
fci.params[i] = &args[i];
}
fci.size = sizeof(fci);
fci.function_table = EG(function_table);
obj = valuePop(ctxt);
if (obj->stringval == NULL) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Handler name must be a string");
xmlXPathFreeObject(obj);
if (fci.param_count > 0) {
for (i = 0; i < nargs - 1; i++) {
zval_ptr_dtor(&args[i]);
}
efree(args);
efree(fci.params);
}
return;
}
INIT_PZVAL(&handler);
ZVAL_STRING(&handler, obj->stringval, 1);
xmlXPathFreeObject(obj);
fci.function_name = &handler;
fci.symbol_table = NULL;
fci.object_ptr = NULL;
fci.retval_ptr_ptr = &retval;
fci.no_separation = 0;
if (!zend_make_callable(&handler, &callable TSRMLS_CC)) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to call handler %s()", callable);
} else if ( intern->registerPhpFunctions == 2 && zend_hash_exists(intern->registered_phpfunctions, callable, strlen(callable) + 1) == 0) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Not allowed to call handler '%s()'.", callable);
/* Push an empty string, so that we at least have an xslt result... */
valuePush(ctxt, xmlXPathNewString((xmlChar *)""));
} else {
result = zend_call_function(&fci, NULL TSRMLS_CC);
if (result == FAILURE) {
if (Z_TYPE(handler) == IS_STRING) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to call handler %s()", Z_STRVAL_P(&handler));
}
/* retval is == NULL, when an exception occurred, don't report anything, because PHP itself will handle that */
} else if (retval == NULL) {
} else {
if (retval->type == IS_OBJECT && instanceof_function( Z_OBJCE_P(retval), dom_node_class_entry TSRMLS_CC)) {
xmlNode *nodep;
dom_object *obj;
if (intern->node_list == NULL) {
ALLOC_HASHTABLE(intern->node_list);
zend_hash_init(intern->node_list, 0, NULL, ZVAL_PTR_DTOR, 0);
}
zval_add_ref(&retval);
zend_hash_next_index_insert(intern->node_list, &retval, sizeof(zval *), NULL);
obj = (dom_object *)zend_object_store_get_object(retval TSRMLS_CC);
nodep = dom_object_get_node(obj);
valuePush(ctxt, xmlXPathNewNodeSet(nodep));
} else if (retval->type == IS_BOOL) {
valuePush(ctxt, xmlXPathNewBoolean(retval->value.lval));
} else if (retval->type == IS_OBJECT) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "A PHP Object cannot be converted to a XPath-string");
valuePush(ctxt, xmlXPathNewString((xmlChar *)""));
} else {
convert_to_string_ex(&retval);
valuePush(ctxt, xmlXPathNewString( Z_STRVAL_P(retval)));
}
zval_ptr_dtor(&retval);
}
}
efree(callable);
zval_dtor(&handler);
if (fci.param_count > 0) {
for (i = 0; i < nargs - 1; i++) {
zval_ptr_dtor(&args[i]);
}
efree(args);
efree(fci.params);
}
}
static void tidy_add_default_properties(PHPTidyObj *obj, tidy_obj_type type)
{
TidyBuffer buf;
TidyAttr tempattr;
TidyNode tempnode;
zval attribute, children, temp;
PHPTidyObj *newobj;
switch(type) {
case is_node:
if (!obj->std.properties) {
rebuild_object_properties(&obj->std);
}
tidyBufInit(&buf);
tidyNodeGetText(obj->ptdoc->doc, obj->node, &buf);
ADD_PROPERTY_STRINGL(obj->std.properties, value, buf.bp, buf.size ? buf.size-1 : 0);
tidyBufFree(&buf);
ADD_PROPERTY_STRING(obj->std.properties, name, tidyNodeGetName(obj->node));
ADD_PROPERTY_LONG(obj->std.properties, type, tidyNodeGetType(obj->node));
ADD_PROPERTY_LONG(obj->std.properties, line, tidyNodeLine(obj->node));
ADD_PROPERTY_LONG(obj->std.properties, column, tidyNodeColumn(obj->node));
ADD_PROPERTY_BOOL(obj->std.properties, proprietary, tidyNodeIsProp(obj->ptdoc->doc, obj->node));
switch(tidyNodeGetType(obj->node)) {
case TidyNode_Root:
case TidyNode_DocType:
case TidyNode_Text:
case TidyNode_Comment:
break;
default:
ADD_PROPERTY_LONG(obj->std.properties, id, tidyNodeGetId(obj->node));
}
tempattr = tidyAttrFirst(obj->node);
if (tempattr) {
char *name, *val;
array_init(&attribute);
do {
name = (char *)tidyAttrName(tempattr);
val = (char *)tidyAttrValue(tempattr);
if (name && val) {
add_assoc_string(&attribute, name, val);
}
} while((tempattr = tidyAttrNext(tempattr)));
} else {
ZVAL_NULL(&attribute);
}
zend_hash_str_update(obj->std.properties, "attribute", sizeof("attribute") - 1, &attribute);
tempnode = tidyGetChild(obj->node);
if (tempnode) {
array_init(&children);
do {
tidy_instanciate(tidy_ce_node, &temp);
newobj = Z_TIDY_P(&temp);
newobj->node = tempnode;
newobj->type = is_node;
newobj->ptdoc = obj->ptdoc;
newobj->ptdoc->ref_count++;
tidy_add_default_properties(newobj, is_node);
add_next_index_zval(&children, &temp);
} while((tempnode = tidyGetNext(tempnode)));
} else {
ZVAL_NULL(&children);
}
zend_hash_str_update(obj->std.properties, "child", sizeof("child") - 1, &children);
break;
case is_doc:
if (!obj->std.properties) {
rebuild_object_properties(&obj->std);
}
ADD_PROPERTY_NULL(obj->std.properties, errorBuffer);
ADD_PROPERTY_NULL(obj->std.properties, value);
break;
}
}
static int php_mimepart_process_header(php_mimepart *part)
{
php_rfc822_tokenized_t *toks;
char *header_key, *header_val, *header_val_stripped;
zval *zheaderval;
zend_string *header_zstring;
if (part->parsedata.headerbuf.len == 0)
return SUCCESS;
smart_string_0(&part->parsedata.headerbuf);
/* parse the header line */
toks = php_mailparse_rfc822_tokenize((const char*)part->parsedata.headerbuf.c, 0);
/* valid headers consist of at least three tokens, with the first being a string and the
* second token being a ':' */
if (toks->ntokens < 2 || toks->tokens[0].token != 0 || toks->tokens[1].token != ':') {
part->parsedata.headerbuf.len = 0;
php_rfc822_tokenize_free(toks);
return FAILURE;
}
/* get a lower-case version of the first token */
header_key = php_rfc822_recombine_tokens(toks, 0, 1, PHP_RFC822_RECOMBINE_IGNORE_COMMENTS|PHP_RFC822_RECOMBINE_STRTOLOWER);
header_val = strchr(part->parsedata.headerbuf.c, ':');
header_val_stripped = php_rfc822_recombine_tokens(toks, 2, toks->ntokens-2, PHP_RFC822_RECOMBINE_IGNORE_COMMENTS|PHP_RFC822_RECOMBINE_STRTOLOWER);
if (header_val) {
header_val++;
while (isspace(*header_val))
header_val++;
/* add the header to the hash.
* join multiple To: or Cc: lines together */
header_zstring = zend_string_init(header_key, strlen(header_key), 0);
if ((strcmp(header_key, "to") == 0 || strcmp(header_key, "cc") == 0) && (zheaderval = zend_hash_find(Z_ARRVAL_P(&part->headerhash), header_zstring)) != NULL) {
int newlen;
char *newstr;
newlen = strlen(header_val) + Z_STRLEN_P(zheaderval) + 3;
newstr = emalloc(newlen);
strcpy(newstr, Z_STRVAL_P(zheaderval));
strcat(newstr, ", ");
strcat(newstr, header_val);
add_assoc_string(&part->headerhash, header_key, newstr);
efree(newstr);
} else {
if((zheaderval = zend_hash_find(Z_ARRVAL_P(&part->headerhash), header_zstring)) != NULL) {
if(Z_TYPE_P(zheaderval) == IS_ARRAY) {
add_next_index_string(zheaderval, header_val);
} else {
/* Create a nested array if there is more than one of the same header */
zval zarr;
array_init(&zarr);
Z_ADDREF_P(zheaderval);
add_next_index_zval(&zarr, zheaderval);
add_next_index_string(&zarr, header_val);
add_assoc_zval(&part->headerhash, header_key, &zarr);
}
} else {
add_assoc_string(&part->headerhash, header_key, header_val);
}
}
zend_string_release(header_zstring);
/* if it is useful, keep a pointer to it in the mime part */
if (strcmp(header_key, "mime-version") == 0)
STR_SET_REPLACE(part->mime_version, header_val_stripped);
if (strcmp(header_key, "content-location") == 0) {
STR_FREE(part->content_location);
part->content_location = php_rfc822_recombine_tokens(toks, 2, toks->ntokens-2, PHP_RFC822_RECOMBINE_IGNORE_COMMENTS);
}
if (strcmp(header_key, "content-base") == 0) {
STR_FREE(part->content_base);
part->content_base = php_rfc822_recombine_tokens(toks, 2, toks->ntokens-2, PHP_RFC822_RECOMBINE_IGNORE_COMMENTS);
}
if (strcmp(header_key, "content-transfer-encoding") == 0)
STR_SET_REPLACE(part->content_transfer_encoding, header_val_stripped);
if (strcmp(header_key, "content-type") == 0) {
char *charset, *boundary;
if (part->content_type) {
php_mimeheader_free(part->content_type);
part->content_type = NULL;
}
part->content_type = php_mimeheader_alloc_from_tok(toks);
boundary = php_mimepart_attribute_get(part->content_type, "boundary");
if (boundary) {
part->boundary = estrdup(boundary);
}
charset = php_mimepart_attribute_get(part->content_type, "charset");
if (charset) {
STR_SET_REPLACE(part->charset, charset);
}
}
if (strcmp(header_key, "content-disposition") == 0) {
part->content_disposition = php_mimeheader_alloc_from_tok(toks);
}
}
STR_FREE(header_key);
STR_FREE(header_val_stripped);
php_rfc822_tokenize_free(toks);
/* zero the buffer size */
part->parsedata.headerbuf.len = 0;
return SUCCESS;
}
PHPAPI int php_sscanf_internal( char *string, char *format,
int argCount, zval *args,
int varStart, zval *return_value)
{
int numVars, nconversions, totalVars = -1;
int i, result;
zend_long value;
int objIndex;
char *end, *baseString;
zval *current;
char op = 0;
int base = 0;
int underflow = 0;
size_t width;
zend_long (*fn)() = NULL;
char *ch, sch;
int flags;
char buf[64]; /* Temporary buffer to hold scanned number
* strings before they are passed to strtoul() */
/* do some sanity checking */
if ((varStart > argCount) || (varStart < 0)){
varStart = SCAN_MAX_ARGS + 1;
}
numVars = argCount - varStart;
if (numVars < 0) {
numVars = 0;
}
#if 0
zend_printf("<br>in sscanf_internal : <br> string is \"%s\", format = \"%s\"<br> NumVars = %d. VarStart = %d<br>-------------------------<br>",
string, format, numVars, varStart);
#endif
/*
* Check for errors in the format string.
*/
if (ValidateFormat(format, numVars, &totalVars) != SCAN_SUCCESS) {
scan_set_error_return( numVars, return_value );
return SCAN_ERROR_INVALID_FORMAT;
}
objIndex = numVars ? varStart : 0;
/*
* If any variables are passed, make sure they are all passed by reference
*/
if (numVars) {
for (i = varStart;i < argCount;i++){
if ( ! Z_ISREF(args[ i ] ) ) {
php_error_docref(NULL, E_WARNING, "Parameter %d must be passed by reference", i);
scan_set_error_return(numVars, return_value);
return SCAN_ERROR_VAR_PASSED_BYVAL;
}
}
}
/*
* Allocate space for the result objects. Only happens when no variables
* are specified
*/
if (!numVars) {
zval tmp;
/* allocate an array for return */
array_init(return_value);
for (i = 0; i < totalVars; i++) {
ZVAL_NULL(&tmp);
if (add_next_index_zval(return_value, &tmp) == FAILURE) {
scan_set_error_return(0, return_value);
return FAILURE;
}
}
varStart = 0; /* Array index starts from 0 */
}
baseString = string;
/*
* Iterate over the format string filling in the result objects until
* we reach the end of input, the end of the format string, or there
* is a mismatch.
*/
nconversions = 0;
/* note ! - we need to limit the loop for objIndex to keep it in bounds */
while (*format != '\0') {
ch = format++;
flags = 0;
/*
* If we see whitespace in the format, skip whitespace in the string.
*/
if ( isspace( (int)*ch ) ) {
sch = *string;
while ( isspace( (int)sch ) ) {
if (*string == '\0') {
goto done;
}
string++;
sch = *string;
}
continue;
}
if (*ch != '%') {
literal:
if (*string == '\0') {
underflow = 1;
goto done;
}
sch = *string;
string++;
if (*ch != sch) {
goto done;
}
continue;
}
ch = format++;
if (*ch == '%') {
goto literal;
}
/*
* Check for assignment suppression ('*') or an XPG3-style
* assignment ('%n$').
*/
if (*ch == '*') {
flags |= SCAN_SUPPRESS;
ch = format++;
} else if ( isdigit(UCHAR(*ch))) {
value = ZEND_STRTOUL(format-1, &end, 10);
if (*end == '$') {
format = end+1;
ch = format++;
objIndex = varStart + value - 1;
}
}
/*
* Parse any width specifier.
*/
if ( isdigit(UCHAR(*ch))) {
width = ZEND_STRTOUL(format-1, &format, 10);
ch = format++;
} else {
width = 0;
}
/*
* Ignore size specifier.
*/
if ((*ch == 'l') || (*ch == 'L') || (*ch == 'h')) {
ch = format++;
}
/*
* Handle the various field types.
*/
switch (*ch) {
case 'n':
if (!(flags & SCAN_SUPPRESS)) {
if (numVars && objIndex >= argCount) {
break;
} else if (numVars) {
current = Z_REFVAL(args[objIndex++]);
zval_ptr_dtor(current);
ZVAL_LONG(current, (zend_long)(string - baseString) );
} else {
add_index_long(return_value, objIndex++, string - baseString);
}
}
nconversions++;
continue;
case 'd':
case 'D':
op = 'i';
base = 10;
fn = (zend_long (*)())ZEND_STRTOL_PTR;
break;
case 'i':
op = 'i';
base = 0;
fn = (zend_long (*)())ZEND_STRTOL_PTR;
break;
case 'o':
op = 'i';
base = 8;
fn = (zend_long (*)())ZEND_STRTOL_PTR;
break;
case 'x':
case 'X':
op = 'i';
base = 16;
fn = (zend_long (*)())ZEND_STRTOL_PTR;
break;
case 'u':
op = 'i';
base = 10;
flags |= SCAN_UNSIGNED;
fn = (zend_long (*)())ZEND_STRTOUL_PTR;
break;
case 'f':
case 'e':
case 'E':
case 'g':
op = 'f';
break;
case 's':
op = 's';
break;
case 'c':
op = 's';
flags |= SCAN_NOSKIP;
/*-cc-*/
if (0 == width) {
width = 1;
}
/*-cc-*/
break;
case '[':
op = '[';
flags |= SCAN_NOSKIP;
break;
} /* switch */
/*
* At this point, we will need additional characters from the
* string to proceed.
*/
if (*string == '\0') {
underflow = 1;
goto done;
}
/*
* Skip any leading whitespace at the beginning of a field unless
* the format suppresses this behavior.
*/
if (!(flags & SCAN_NOSKIP)) {
while (*string != '\0') {
sch = *string;
if (! isspace((int)sch) ) {
break;
}
string++;
}
if (*string == '\0') {
underflow = 1;
goto done;
}
}
/*
* Perform the requested scanning operation.
*/
switch (op) {
case 'c':
case 's':
/*
* Scan a string up to width characters or whitespace.
*/
if (width == 0) {
width = (size_t) ~0;
}
end = string;
while (*end != '\0') {
sch = *end;
if ( isspace( (int)sch ) ) {
break;
}
end++;
if (--width == 0) {
break;
}
}
if (!(flags & SCAN_SUPPRESS)) {
if (numVars && objIndex >= argCount) {
break;
} else if (numVars) {
current = Z_REFVAL(args[objIndex++]);
zval_ptr_dtor(current);
ZVAL_STRINGL(current, string, end-string);
} else {
add_index_stringl(return_value, objIndex++, string, end-string);
}
}
string = end;
break;
case '[': {
CharSet cset;
if (width == 0) {
width = (size_t) ~0;
}
end = string;
format = BuildCharSet(&cset, format);
while (*end != '\0') {
sch = *end;
if (!CharInSet(&cset, (int)sch)) {
break;
}
end++;
if (--width == 0) {
break;
}
}
ReleaseCharSet(&cset);
if (string == end) {
/*
* Nothing matched the range, stop processing
*/
goto done;
}
if (!(flags & SCAN_SUPPRESS)) {
if (numVars && objIndex >= argCount) {
break;
} else if (numVars) {
current = Z_REFVAL(args[objIndex++]);
zval_ptr_dtor(current);
ZVAL_STRINGL(current, string, end-string);
} else {
add_index_stringl(return_value, objIndex++, string, end-string);
}
}
string = end;
break;
}
/*
case 'c':
/ Scan a single character./
sch = *string;
string++;
if (!(flags & SCAN_SUPPRESS)) {
if (numVars) {
char __buf[2];
__buf[0] = sch;
__buf[1] = '\0';;
current = args[objIndex++];
zval_dtor(*current);
ZVAL_STRINGL( *current, __buf, 1);
} else {
add_index_stringl(return_value, objIndex++, &sch, 1);
}
}
break;
*/
case 'i':
/*
* Scan an unsigned or signed integer.
*/
/*-cc-*/
buf[0] = '\0';
/*-cc-*/
if ((width == 0) || (width > sizeof(buf) - 1)) {
width = sizeof(buf) - 1;
}
flags |= SCAN_SIGNOK | SCAN_NODIGITS | SCAN_NOZERO;
for (end = buf; width > 0; width--) {
switch (*string) {
/*
* The 0 digit has special meaning at the beginning of
* a number. If we are unsure of the base, it
* indicates that we are in base 8 or base 16 (if it is
* followed by an 'x').
*/
case '0':
/*-cc-*/
if (base == 16) {
flags |= SCAN_XOK;
}
/*-cc-*/
if (base == 0) {
base = 8;
flags |= SCAN_XOK;
}
if (flags & SCAN_NOZERO) {
flags &= ~(SCAN_SIGNOK | SCAN_NODIGITS | SCAN_NOZERO);
} else {
flags &= ~(SCAN_SIGNOK | SCAN_XOK | SCAN_NODIGITS);
}
goto addToInt;
case '1': case '2': case '3': case '4':
case '5': case '6': case '7':
if (base == 0) {
base = 10;
}
flags &= ~(SCAN_SIGNOK | SCAN_XOK | SCAN_NODIGITS);
goto addToInt;
case '8': case '9':
if (base == 0) {
base = 10;
}
if (base <= 8) {
break;
}
flags &= ~(SCAN_SIGNOK | SCAN_XOK | SCAN_NODIGITS);
goto addToInt;
case 'A': case 'B': case 'C':
case 'D': case 'E': case 'F':
case 'a': case 'b': case 'c':
case 'd': case 'e': case 'f':
if (base <= 10) {
break;
}
flags &= ~(SCAN_SIGNOK | SCAN_XOK | SCAN_NODIGITS);
goto addToInt;
case '+': case '-':
if (flags & SCAN_SIGNOK) {
flags &= ~SCAN_SIGNOK;
goto addToInt;
}
break;
case 'x': case 'X':
if ((flags & SCAN_XOK) && (end == buf+1)) {
base = 16;
flags &= ~SCAN_XOK;
goto addToInt;
}
break;
}
/*
* We got an illegal character so we are done accumulating.
*/
break;
addToInt:
/*
* Add the character to the temporary buffer.
*/
*end++ = *string++;
if (*string == '\0') {
break;
}
}
/*
* Check to see if we need to back up because we only got a
* sign or a trailing x after a 0.
*/
if (flags & SCAN_NODIGITS) {
if (*string == '\0') {
underflow = 1;
}
goto done;
} else if (end[-1] == 'x' || end[-1] == 'X') {
end--;
string--;
}
/*
* Scan the value from the temporary buffer. If we are
* returning a large unsigned value, we have to convert it back
* to a string since PHP only supports signed values.
*/
if (!(flags & SCAN_SUPPRESS)) {
*end = '\0';
value = (zend_long) (*fn)(buf, NULL, base);
if ((flags & SCAN_UNSIGNED) && (value < 0)) {
snprintf(buf, sizeof(buf), ZEND_ULONG_FMT, value); /* INTL: ISO digit */
if (numVars && objIndex >= argCount) {
break;
} else if (numVars) {
/* change passed value type to string */
current = Z_REFVAL(args[objIndex++]);
zval_ptr_dtor(current);
ZVAL_STRING(current, buf);
} else {
add_index_string(return_value, objIndex++, buf);
}
} else {
if (numVars && objIndex >= argCount) {
break;
} else if (numVars) {
current = Z_REFVAL(args[objIndex++]);
zval_ptr_dtor(current);
ZVAL_LONG(current, value);
} else {
add_index_long(return_value, objIndex++, value);
}
}
}
break;
case 'f':
/*
* Scan a floating point number
*/
buf[0] = '\0'; /* call me pedantic */
if ((width == 0) || (width > sizeof(buf) - 1)) {
width = sizeof(buf) - 1;
}
flags |= SCAN_SIGNOK | SCAN_NODIGITS | SCAN_PTOK | SCAN_EXPOK;
for (end = buf; width > 0; width--) {
switch (*string) {
case '0': case '1': case '2': case '3':
case '4': case '5': case '6': case '7':
case '8': case '9':
flags &= ~(SCAN_SIGNOK | SCAN_NODIGITS);
goto addToFloat;
case '+':
case '-':
if (flags & SCAN_SIGNOK) {
flags &= ~SCAN_SIGNOK;
goto addToFloat;
}
break;
case '.':
if (flags & SCAN_PTOK) {
flags &= ~(SCAN_SIGNOK | SCAN_PTOK);
goto addToFloat;
}
break;
case 'e':
case 'E':
/*
* An exponent is not allowed until there has
* been at least one digit.
*/
if ((flags & (SCAN_NODIGITS | SCAN_EXPOK)) == SCAN_EXPOK) {
flags = (flags & ~(SCAN_EXPOK|SCAN_PTOK))
| SCAN_SIGNOK | SCAN_NODIGITS;
goto addToFloat;
}
break;
}
/*
* We got an illegal character so we are done accumulating.
*/
break;
addToFloat:
/*
* Add the character to the temporary buffer.
*/
*end++ = *string++;
if (*string == '\0') {
break;
}
}
/*
* Check to see if we need to back up because we saw a
* trailing 'e' or sign.
*/
if (flags & SCAN_NODIGITS) {
if (flags & SCAN_EXPOK) {
/*
* There were no digits at all so scanning has
* failed and we are done.
*/
if (*string == '\0') {
underflow = 1;
}
goto done;
}
/*
* We got a bad exponent ('e' and maybe a sign).
*/
end--;
string--;
if (*end != 'e' && *end != 'E') {
end--;
string--;
}
}
/*
* Scan the value from the temporary buffer.
*/
if (!(flags & SCAN_SUPPRESS)) {
double dvalue;
*end = '\0';
dvalue = zend_strtod(buf, NULL);
if (numVars && objIndex >= argCount) {
break;
} else if (numVars) {
current = Z_REFVAL(args[objIndex++]);
zval_ptr_dtor(current);
ZVAL_DOUBLE(current, dvalue);
} else {
add_index_double(return_value, objIndex++, dvalue );
}
}
break;
} /* switch (op) */
nconversions++;
} /* while (*format != '\0') */
done:
result = SCAN_SUCCESS;
if (underflow && (0==nconversions)) {
scan_set_error_return( numVars, return_value );
result = SCAN_ERROR_EOF;
} else if (numVars) {
convert_to_long(return_value );
Z_LVAL_P(return_value) = nconversions;
} else if (nconversions < totalVars) {
/* TODO: not all elements converted. we need to prune the list - cc */
}
return result;
}
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);
}
}
