Пример #1
0
    }
    PHP_MAPSCRIPT_RESTORE_ERRORS(TRUE);

    php_rect = (php_rect_object *) zend_object_store_get_object(zobj TSRMLS_CC);

    retval = rectObj_fit(php_rect->rect, width, height);

    RETURN_DOUBLE(retval);
}
/* }}} */

zend_function_entry rect_functions[] = {
    PHP_ME(rectObj, __construct, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR)
    PHP_ME(rectObj, __get, rect___get_args, ZEND_ACC_PUBLIC)
    PHP_ME(rectObj, __set, rect___set_args, ZEND_ACC_PUBLIC)
    PHP_MALIAS(rectObj, set, __set, NULL, ZEND_ACC_PUBLIC)
    PHP_ME(rectObj, draw, rect_draw_args, ZEND_ACC_PUBLIC)
    PHP_ME(rectObj, project, rect_project_args, ZEND_ACC_PUBLIC)
    PHP_ME(rectObj, setExtent, rect_setExtent_args, ZEND_ACC_PUBLIC)
    PHP_ME(rectObj, fit, rect_fit_args, ZEND_ACC_PUBLIC)
    {NULL, NULL, NULL}
};


void mapscript_create_rect(rectObj *rect, parent_object parent, zval *return_value TSRMLS_DC)
{
    php_rect_object * php_rect;
    object_init_ex(return_value, mapscript_ce_rect); 
    php_rect = (php_rect_object *)zend_object_store_get_object(return_value TSRMLS_CC);
    php_rect->rect = rect;
Пример #2
0
  php_scalebar = (php_scalebar_object *) zend_object_store_get_object(zobj TSRMLS_CC);

  MAPSCRIPT_DELREF(php_scalebar->color);
  MAPSCRIPT_DELREF(php_scalebar->backgroundcolor);
  MAPSCRIPT_DELREF(php_scalebar->outlinecolor);
  MAPSCRIPT_DELREF(php_scalebar->imagecolor);
  MAPSCRIPT_DELREF(php_scalebar->label);
}
/* }}} */

zend_function_entry scalebar_functions[] = {
  PHP_ME(scalebarObj, __construct, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR)
  PHP_ME(scalebarObj, __get, scalebar___get_args, ZEND_ACC_PUBLIC)
  PHP_ME(scalebarObj, __set, scalebar___set_args, ZEND_ACC_PUBLIC)
  PHP_MALIAS(scalebarObj, set, __set, NULL, ZEND_ACC_PUBLIC)
  PHP_ME(scalebarObj, updateFromString, scalebar_updateFromString_args, ZEND_ACC_PUBLIC)
  PHP_ME(scalebarObj, setImageColor, scalebar_setImageColor_args, ZEND_ACC_PUBLIC)
  PHP_ME(scalebarObj, free, NULL, ZEND_ACC_PUBLIC) {
    NULL, NULL, NULL
  }
};

void mapscript_create_scalebar(scalebarObj *scalebar, parent_object parent, zval *return_value TSRMLS_DC)
{
  php_scalebar_object * php_scalebar;
  object_init_ex(return_value, mapscript_ce_scalebar);
  php_scalebar = (php_scalebar_object *)zend_object_store_get_object(return_value TSRMLS_CC);
  php_scalebar->scalebar = scalebar;

  php_scalebar->parent = parent;
Пример #3
0
		SOP_ME(__construct,			arginfo_oauth_provider__construct,		ZEND_ACC_PUBLIC|ZEND_ACC_CTOR)
		SOP_ME(consumerHandler,	arginfo_oauth_provider_handler,		ZEND_ACC_PUBLIC)
		SOP_ME(tokenHandler,	arginfo_oauth_provider_handler,		ZEND_ACC_PUBLIC)
		SOP_ME(timestampNonceHandler,	arginfo_oauth_provider_handler,		ZEND_ACC_PUBLIC)
		SOP_ME(callconsumerHandler,	arginfo_oauth_provider_noparams,		ZEND_ACC_PUBLIC)
		SOP_ME(calltokenHandler,	arginfo_oauth_provider_noparams,		ZEND_ACC_PUBLIC)
		SOP_ME(callTimestampNonceHandler,	arginfo_oauth_provider_noparams,		ZEND_ACC_PUBLIC)
		SOP_ME(checkOAuthRequest,	arginfo_oauth_provider_check,		ZEND_ACC_PUBLIC)
		SOP_ME(isRequestTokenEndpoint,	arginfo_oauth_provider_req_token,		ZEND_ACC_PUBLIC)
		SOP_ME(setRequestTokenPath,	arginfo_oauth_provider_set_path,	ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
		SOP_ME(addRequiredParameter,	arginfo_oauth_provider_set_req_param,		ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
		SOP_ME(reportProblem,	arginfo_oauth_provider_reportproblem,		ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
		SOP_ME(setParam, 		arginfo_oauth_provider_set_param,		ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
		SOP_ME(removeRequiredParameter,	arginfo_oauth_provider_set_req_param,		ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
		SOP_ME(generateToken,		arginfo_oauth_provider_generate_token,		ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_FINAL)
		PHP_MALIAS(oauthprovider,	is2LeggedEndpoint, isRequestTokenEndpoint, arginfo_oauth_provider_req_token, ZEND_ACC_PUBLIC)
		{NULL, NULL, NULL}
};

extern int oauth_provider_register_class() /* {{{ */
{
	zend_class_entry osce;

	INIT_CLASS_ENTRY(osce, "OAuthProvider", oauth_provider_methods);
	osce.create_object = oauth_provider_new;
	oauthprovider = zend_register_internal_class(&osce);

	memcpy(&oauth_provider_obj_hndlrs, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
	oauth_provider_obj_hndlrs.offset = XtOffsetOf(php_oauth_provider, zo);
	oauth_provider_obj_hndlrs.free_obj = oauth_provider_free_storage;
Пример #4
0
  value =  labelObj_getTextString(php_label->label);

  if (value == NULL)
    MAPSCRIPT_RETURN_STRING("", 1);

  MAPSCRIPT_RETVAL_STRING(value, 1);
  free(value);
}
/* }}} */

zend_function_entry label_functions[] = {
  PHP_ME(labelObj, __construct, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR)
  PHP_ME(labelObj, __get, label___get_args, ZEND_ACC_PUBLIC)
  PHP_ME(labelObj, __set, label___set_args, ZEND_ACC_PUBLIC)
  PHP_MALIAS(labelObj, set, __set, NULL, ZEND_ACC_PUBLIC)
  PHP_ME(labelObj, updateFromString, label_updateFromString_args, ZEND_ACC_PUBLIC)
  PHP_ME(labelObj, convertToString, NULL, ZEND_ACC_PUBLIC)
  PHP_ME(labelObj, setBinding, label_setBinding_args, ZEND_ACC_PUBLIC)
  PHP_ME(labelObj, getBinding, label_getBinding_args, ZEND_ACC_PUBLIC)
  PHP_ME(labelObj, removeBinding, label_removeBinding_args, ZEND_ACC_PUBLIC)
  PHP_ME(labelObj, getStyle, label_getStyle_args, ZEND_ACC_PUBLIC)
  PHP_ME(labelObj, insertStyle, label_insertStyle_args, ZEND_ACC_PUBLIC)
  PHP_ME(labelObj, removeStyle, label_removeStyle_args, ZEND_ACC_PUBLIC)
  PHP_ME(labelObj, moveStyleUp, label_moveStyleUp_args, ZEND_ACC_PUBLIC)
  PHP_ME(labelObj, moveStyleDown, label_moveStyleDown_args, ZEND_ACC_PUBLIC)
  PHP_ME(labelObj, deleteStyle, label_deleteStyle_args, ZEND_ACC_PUBLIC)
  PHP_ME(labelObj, setExpression, label_setExpression_args, ZEND_ACC_PUBLIC)
  PHP_ME(labelObj, getExpressionString, NULL, ZEND_ACC_PUBLIC)
  PHP_ME(labelObj, setText, label_setText_args, ZEND_ACC_PUBLIC)
  PHP_ME(labelObj, getTextString, NULL, ZEND_ACC_PUBLIC)  
Пример #5
0
static zend_class_entry swoole_coroutine_util_ce;
static zend_class_entry *swoole_coroutine_util_class_entry_ptr;

static zend_class_entry swoole_coroutine_iterator_ce;
static zend_class_entry *swoole_coroutine_iterator_class_entry_ptr;

static zend_class_entry swoole_exit_exception_ce;
static zend_class_entry *swoole_exit_exception_class_entry_ptr;

static const zend_function_entry swoole_coroutine_util_methods[] =
{
    ZEND_FENTRY(create, ZEND_FN(swoole_coroutine_create), arginfo_swoole_coroutine_create, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC)
    ZEND_FENTRY(exec, ZEND_FN(swoole_coroutine_exec), arginfo_swoole_coroutine_exec, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC)
    PHP_ME(swoole_coroutine_util, set, arginfo_swoole_coroutine_set, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC)
    PHP_ME(swoole_coroutine_util, yield, arginfo_swoole_coroutine_void, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC)
    PHP_MALIAS(swoole_coroutine_util, suspend, yield, arginfo_swoole_coroutine_void, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC)
    PHP_ME(swoole_coroutine_util, resume, arginfo_swoole_coroutine_resume, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC)
    PHP_ME(swoole_coroutine_util, stats, arginfo_swoole_coroutine_void, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC)
    PHP_ME(swoole_coroutine_util, getuid, arginfo_swoole_coroutine_void, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC)
    PHP_ME(swoole_coroutine_util, sleep, arginfo_swoole_coroutine_sleep, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC)
    PHP_ME(swoole_coroutine_util, fread, arginfo_swoole_coroutine_fread, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC)
    PHP_ME(swoole_coroutine_util, fgets, arginfo_swoole_coroutine_fgets, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC)
    PHP_ME(swoole_coroutine_util, fwrite, arginfo_swoole_coroutine_fwrite, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC)
    PHP_ME(swoole_coroutine_util, readFile, arginfo_swoole_coroutine_readFile, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC)
    PHP_ME(swoole_coroutine_util, writeFile, arginfo_swoole_coroutine_writeFile, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC)
    PHP_ME(swoole_coroutine_util, gethostbyname, arginfo_swoole_coroutine_gethostbyname, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC)
    PHP_ME(swoole_coroutine_util, getaddrinfo, arginfo_swoole_coroutine_getaddrinfo, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC)
    PHP_ME(swoole_coroutine_util, getBackTrace, arginfo_swoole_coroutine_getBackTrace, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC)
    PHP_ME(swoole_coroutine_util, listCoroutines, arginfo_swoole_coroutine_void, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC)
    PHP_FE_END
};
Пример #6
0
/* }}} */

/** {{{ $page
 */
ZEND_BEGIN_ARG_INFO(pageset_isCurrent_args, 0)
    ZEND_ARG_INFO(0, page)
ZEND_END_ARG_INFO()
/* }}} */

/** {{{
 */
zend_function_entry cheetah_page_core_methods[] = {
    PHP_ME(cheetah_page_core, __construct     , pageset_construct_args  , ZEND_ACC_PUBLIC  | ZEND_ACC_CTOR)
    PHP_ME(cheetah_page_core, setRecordCount  , pageset_setRecordCount_args    , ZEND_ACC_PUBLIC)
    PHP_ME(cheetah_page_core, getCurrent      , NULL    , ZEND_ACC_PUBLIC)
    PHP_MALIAS(cheetah_page_core, current     , getCurrent    , NULL              , ZEND_ACC_PUBLIC)
    PHP_ME(cheetah_page_core, getPageCount    , NULL       , ZEND_ACC_PUBLIC)
    PHP_ME(cheetah_page_core, getPageSize     , NULL       , ZEND_ACC_PUBLIC)
    PHP_ME(cheetah_page_core, getRecordCount  , NULL       , ZEND_ACC_PUBLIC)
    PHP_ME(cheetah_page_core, getStartRow     , NULL       , ZEND_ACC_PUBLIC)
    PHP_ME(cheetah_page_core, getOffset       , NULL       , ZEND_ACC_PUBLIC)
    PHP_ME(cheetah_page_core, getEndRow       , NULL       , ZEND_ACC_PUBLIC)
    PHP_ME(cheetah_page_core, hasPrev         , NULL       , ZEND_ACC_PUBLIC)
    PHP_ME(cheetah_page_core, hasNext         , NULL       , ZEND_ACC_PUBLIC)
    PHP_ME(cheetah_page_core, isLast          , NULL       , ZEND_ACC_PUBLIC)
    PHP_ME(cheetah_page_core, isFirst         , NULL       , ZEND_ACC_PUBLIC)
    PHP_ME(cheetah_page_core, hasList         , NULL       , ZEND_ACC_PUBLIC)
    PHP_ME(cheetah_page_core, first           , NULL       , ZEND_ACC_PUBLIC)
    PHP_ME(cheetah_page_core, prev            , NULL       , ZEND_ACC_PUBLIC)
    PHP_ME(cheetah_page_core, next            , NULL       , ZEND_ACC_PUBLIC)
    PHP_ME(cheetah_page_core, last            , NULL       , ZEND_ACC_PUBLIC)
Пример #7
0
	PHP_ME(swoole_process, useQueue, NULL, ZEND_ACC_PUBLIC)
	PHP_ME(swoole_process, start, NULL, ZEND_ACC_PUBLIC)
	PHP_ME(swoole_process, write, NULL, ZEND_ACC_PUBLIC)
	PHP_ME(swoole_process, read, NULL, ZEND_ACC_PUBLIC)
	PHP_ME(swoole_process, push, NULL, ZEND_ACC_PUBLIC)
	PHP_ME(swoole_process, pop, NULL, ZEND_ACC_PUBLIC)
	PHP_ME(swoole_process, exit, NULL, ZEND_ACC_PUBLIC)
	PHP_ME(swoole_process, exec, NULL, ZEND_ACC_PUBLIC)
	PHP_FE_END
};

const zend_function_entry swoole_buffer_methods[] =
{
    PHP_ME(swoole_buffer, __construct, NULL, ZEND_ACC_PUBLIC | ZEND_ACC_CTOR)
    PHP_ME(swoole_buffer, substr, NULL, ZEND_ACC_PUBLIC)
    PHP_MALIAS(swoole_buffer, read, substr, NULL, ZEND_ACC_PUBLIC)
    PHP_ME(swoole_buffer, write, NULL, ZEND_ACC_PUBLIC)
    PHP_ME(swoole_buffer, append, NULL, ZEND_ACC_PUBLIC)
    PHP_ME(swoole_buffer, expand, NULL, ZEND_ACC_PUBLIC)
    PHP_ME(swoole_buffer, clear, NULL, ZEND_ACC_PUBLIC)
    PHP_FE_END
};

const zend_function_entry swoole_lock_methods[] =
{
	PHP_ME(swoole_lock, __construct, NULL, ZEND_ACC_PUBLIC | ZEND_ACC_CTOR)
	PHP_ME(swoole_lock, lock, NULL, ZEND_ACC_PUBLIC)
	PHP_ME(swoole_lock, trylock, NULL, ZEND_ACC_PUBLIC)
	PHP_ME(swoole_lock, lock_read, NULL, ZEND_ACC_PUBLIC)
	PHP_ME(swoole_lock, trylock_read, NULL, ZEND_ACC_PUBLIC)
	PHP_ME(swoole_lock, unlock, NULL, ZEND_ACC_PUBLIC)
Пример #8
0
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_annotations_annotation_hasargument, 0, 0, 1)
	ZEND_ARG_INFO(0, position)
ZEND_END_ARG_INFO()

static const zend_function_entry phalcon_annotations_annotation_method_entry[] = {
	PHP_ME(Phalcon_Annotations_Annotation, __construct, arginfo_phalcon_annotations_annotation___construct, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR)
	PHP_ME(Phalcon_Annotations_Annotation, getName, NULL, ZEND_ACC_PUBLIC)
	PHP_ME(Phalcon_Annotations_Annotation, getExpression, arginfo_phalcon_annotations_annotation_getexpression, ZEND_ACC_PUBLIC)
	PHP_ME(Phalcon_Annotations_Annotation, getExprArguments, NULL, ZEND_ACC_PUBLIC)
	PHP_ME(Phalcon_Annotations_Annotation, getArguments, NULL, ZEND_ACC_PUBLIC)
	PHP_ME(Phalcon_Annotations_Annotation, numberArguments, NULL, ZEND_ACC_PUBLIC)
	PHP_ME(Phalcon_Annotations_Annotation, getArgument, arginfo_phalcon_annotations_annotation_getargument, ZEND_ACC_PUBLIC)
	PHP_ME(Phalcon_Annotations_Annotation, hasArgument, arginfo_phalcon_annotations_annotation_hasargument, ZEND_ACC_PUBLIC)
	PHP_MALIAS(Phalcon_Annotations_Annotation, getNamedArgument, getArgument, arginfo_phalcon_annotations_annotation_getargument, ZEND_ACC_PUBLIC)
	PHP_MALIAS(Phalcon_Annotations_Annotation, getNamedParameter, getArgument, arginfo_phalcon_annotations_annotation_getargument, ZEND_ACC_PUBLIC | ZEND_ACC_DEPRECATED)
	PHP_MALIAS(Phalcon_Annotations_Annotation, hasNamedArgument, hasArgument, arginfo_phalcon_annotations_annotation_hasargument, ZEND_ACC_PUBLIC)
	PHP_FE_END
};

/**
 * Phalcon\Annotations\Annotation initializer
 */
PHALCON_INIT_CLASS(Phalcon_Annotations_Annotation){

	PHALCON_REGISTER_CLASS(Phalcon\\Annotations, Annotation, annotations_annotation, phalcon_annotations_annotation_method_entry, 0);

	zend_declare_property_null(phalcon_annotations_annotation_ce, SL("_name"), ZEND_ACC_PROTECTED TSRMLS_CC);
	zend_declare_property_null(phalcon_annotations_annotation_ce, SL("_arguments"), ZEND_ACC_PROTECTED TSRMLS_CC);
	zend_declare_property_null(phalcon_annotations_annotation_ce, SL("_exprArguments"), ZEND_ACC_PROTECTED TSRMLS_CC);
Пример #9
0
PHP_METHOD(Phalcon_Translate_Adapter, offsetExists);
PHP_METHOD(Phalcon_Translate_Adapter, offsetUnset);
PHP_METHOD(Phalcon_Translate_Adapter, offsetGet);

ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_translate_adapter_t, 0, 0, 1)
	ZEND_ARG_INFO(0, translateKey)
	ZEND_ARG_INFO(0, placeholders)
ZEND_END_ARG_INFO()

static const zend_function_entry phalcon_translate_adapter_method_entry[] = {
	PHP_ME(Phalcon_Translate_Adapter, t, arginfo_phalcon_translate_adapter_t, ZEND_ACC_PUBLIC)
	PHP_ME(Phalcon_Translate_Adapter, offsetSet, arginfo_arrayaccess_offsetset, ZEND_ACC_PUBLIC)
	PHP_ME(Phalcon_Translate_Adapter, offsetExists, arginfo_arrayaccess_offsetexists, ZEND_ACC_PUBLIC)
	PHP_ME(Phalcon_Translate_Adapter, offsetUnset, arginfo_arrayaccess_offsetunset, ZEND_ACC_PUBLIC)
	PHP_ME(Phalcon_Translate_Adapter, offsetGet, arginfo_arrayaccess_offsetget, ZEND_ACC_PUBLIC)
	PHP_MALIAS(Phalcon_Translate_Adapter, _, t, arginfo_phalcon_translate_adapter_t, ZEND_ACC_PUBLIC)
	PHP_FE_END
};

/**
 * Phalcon\Translate\Adapter initializer
 */
PHALCON_INIT_CLASS(Phalcon_Translate_Adapter){

	PHALCON_REGISTER_CLASS(Phalcon\\Translate, Adapter, translate_adapter, phalcon_translate_adapter_method_entry, ZEND_ACC_EXPLICIT_ABSTRACT_CLASS);

	zend_class_implements(phalcon_translate_adapter_ce, 2, zend_ce_arrayaccess, phalcon_translate_adapterinterface_ce);

	return SUCCESS;
}
Пример #10
0
    image = symbolObj_getImage(php_symbol->symbol, php_outputformat->outputformat);
    if (image == NULL)
    {
        mapscript_throw_exception("Unable to get the symbol image" TSRMLS_CC);
        return;
    }

    mapscript_create_image(image, return_value TSRMLS_CC);
}
/* }}} */

zend_function_entry symbol_functions[] = {
    PHP_ME(symbolObj, __construct, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR)
    PHP_ME(symbolObj, __get, symbol___get_args, ZEND_ACC_PUBLIC)
    PHP_ME(symbolObj, __set, symbol___set_args, ZEND_ACC_PUBLIC)
    PHP_MALIAS(symbolObj, set, __set, NULL, ZEND_ACC_PUBLIC)
    PHP_ME(symbolObj, setPoints, symbol_setPoints_args, ZEND_ACC_PUBLIC)
    PHP_ME(symbolObj, getPointsArray, NULL, ZEND_ACC_PUBLIC)
    PHP_ME(symbolObj, setImage, symbol_setImage_args, ZEND_ACC_PUBLIC)
    PHP_ME(symbolObj, getImage, symbol_getImage_args, ZEND_ACC_PUBLIC)        
    PHP_ME(symbolObj, setImagePath, symbol_setImagePath_args, ZEND_ACC_PUBLIC)
    {NULL, NULL, NULL}
};

void mapscript_create_symbol(symbolObj *symbol, parent_object parent, zval *return_value TSRMLS_DC)
{
    php_symbol_object * php_symbol;
    object_init_ex(return_value, mapscript_ce_symbol); 
    php_symbol = (php_symbol_object *)zend_object_store_get_object(return_value TSRMLS_CC);
    php_symbol->symbol = symbol;
Пример #11
0
ZEND_BEGIN_ARG_INFO_EX(arginfo_appnet_server_task_cb, 0, 0, 3 )
ZEND_ARG_INFO(0, data )
ZEND_ARG_INFO(0, taskid )
ZEND_ARG_INFO(0, to )
ZEND_END_ARG_INFO()

/* {{{ appnet_functions[]
 *
 * Every user visible function must have an entry in appnet_functions[].
 */
const zend_function_entry appnet_functions[] = {
	PHP_FE(confirm_appnet_compiled,	NULL)		/* For testing, remove later. */
	PHP_ME(appnetServer,    __construct,   arginfo_appnet_server_construct ,   ZEND_ACC_PUBLIC | ZEND_ACC_CTOR)
	PHP_ME(appnetServer,    on,            arginfo_appnet_server_on , ZEND_ACC_PUBLIC )
	PHP_MALIAS( appnetServer,    setEventCallback,     on ,       arginfo_appnet_server_on , ZEND_ACC_PUBLIC )
	PHP_MALIAS( appnetServer,    addEventListener,     on ,       arginfo_appnet_server_on , ZEND_ACC_PUBLIC )
	PHP_ME(appnetServer,    run,           NULL ,                 ZEND_ACC_PUBLIC )
	PHP_ME(appnetServer,    send,          arginfo_appnet_server_send , ZEND_ACC_PUBLIC )
	PHP_ME(appnetServer,    close,         arginfo_appnet_server_close , ZEND_ACC_PUBLIC )
	PHP_ME(appnetServer,    getHeader,     NULL ,                 ZEND_ACC_PUBLIC )
	PHP_ME(appnetServer,    setHeader,     arginfo_appnet_set_header, ZEND_ACC_PUBLIC )
	PHP_ME(appnetServer,    timerAdd,      arginfo_appnet_server_timer_add , ZEND_ACC_PUBLIC )
	PHP_ME(appnetServer,    timerRemove,   arginfo_appnet_server_timer_remove , ZEND_ACC_PUBLIC )
	PHP_ME(appnetServer ,   setOption,     arginfo_appnet_server_set_option , ZEND_ACC_PUBLIC )
	PHP_ME(appnetServer,    getInfo,     NULL ,                 ZEND_ACC_PUBLIC )
	PHP_ME(appnetServer,    addAsynTask,      arginfo_appnet_server_add_task , ZEND_ACC_PUBLIC )
	PHP_ME(appnetServer,    taskCallback,     arginfo_appnet_server_task_cb , ZEND_ACC_PUBLIC )
	{NULL, NULL, NULL}
};
/* }}} */
Пример #12
0
ZEND_END_ARG_INFO()

static const zend_function_entry phalcon_mvc_model_criteria_method_entry[] = {
	PHP_ME(Phalcon_Mvc_Model_Criteria, setDI, arginfo_phalcon_di_injectionawareinterface_setdi, ZEND_ACC_PUBLIC)
	PHP_ME(Phalcon_Mvc_Model_Criteria, getDI, arginfo_phalcon_di_injectionawareinterface_getdi, ZEND_ACC_PUBLIC)
	PHP_ME(Phalcon_Mvc_Model_Criteria, setModelName, arginfo_phalcon_mvc_model_criteriainterface_setmodelname, ZEND_ACC_PUBLIC)
	PHP_ME(Phalcon_Mvc_Model_Criteria, getModelName, NULL, ZEND_ACC_PUBLIC)
	PHP_ME(Phalcon_Mvc_Model_Criteria, bind, arginfo_phalcon_mvc_model_criteriainterface_bind, ZEND_ACC_PUBLIC)
	PHP_ME(Phalcon_Mvc_Model_Criteria, bindTypes, arginfo_phalcon_mvc_model_criteriainterface_bindtypes, ZEND_ACC_PUBLIC)
	PHP_ME(Phalcon_Mvc_Model_Criteria, columns, arginfo_phalcon_mvc_model_criteriainterface_columns, ZEND_ACC_PUBLIC)
	PHP_ME(Phalcon_Mvc_Model_Criteria, join, arginfo_phalcon_mvc_model_criteriainterface_join, ZEND_ACC_PUBLIC)
	PHP_ME(Phalcon_Mvc_Model_Criteria, innerJoin, arginfo_phalcon_mvc_model_criteria_innerjoin, ZEND_ACC_PUBLIC)
	PHP_ME(Phalcon_Mvc_Model_Criteria, leftJoin, arginfo_phalcon_mvc_model_criteria_leftjoin, ZEND_ACC_PUBLIC)
	PHP_ME(Phalcon_Mvc_Model_Criteria, rightJoin, arginfo_phalcon_mvc_model_criteria_rightjoin, ZEND_ACC_PUBLIC)
	PHP_ME(Phalcon_Mvc_Model_Criteria, where, arginfo_phalcon_mvc_model_criteriainterface_where, ZEND_ACC_PUBLIC)
	PHP_MALIAS(Phalcon_Mvc_Model_Criteria, addWhere, andWhere, arginfo_phalcon_mvc_model_criteriainterface_andwhere, ZEND_ACC_PUBLIC | ZEND_ACC_DEPRECATED)
	PHP_ME(Phalcon_Mvc_Model_Criteria, andWhere, arginfo_phalcon_mvc_model_criteriainterface_andwhere, ZEND_ACC_PUBLIC)
	PHP_ME(Phalcon_Mvc_Model_Criteria, orWhere, arginfo_phalcon_mvc_model_criteriainterface_orwhere, ZEND_ACC_PUBLIC)
	PHP_ME(Phalcon_Mvc_Model_Criteria, betweenWhere, arginfo_phalcon_mvc_model_criteriainterface_betweenwhere, ZEND_ACC_PUBLIC)
	PHP_ME(Phalcon_Mvc_Model_Criteria, notBetweenWhere, arginfo_phalcon_mvc_model_criteriainterface_notbetweenwhere, ZEND_ACC_PUBLIC)
	PHP_ME(Phalcon_Mvc_Model_Criteria, inWhere, arginfo_phalcon_mvc_model_criteriainterface_inwhere, ZEND_ACC_PUBLIC)
	PHP_ME(Phalcon_Mvc_Model_Criteria, notInWhere, arginfo_phalcon_mvc_model_criteriainterface_notinwhere, ZEND_ACC_PUBLIC)
	PHP_ME(Phalcon_Mvc_Model_Criteria, conditions, arginfo_phalcon_mvc_model_criteriainterface_conditions, ZEND_ACC_PUBLIC)
	PHP_MALIAS(Phalcon_Mvc_Model_Criteria, order, orderBy, arginfo_phalcon_mvc_model_criteriainterface_orderby, ZEND_ACC_PUBLIC | ZEND_ACC_DEPRECATED)
	PHP_ME(Phalcon_Mvc_Model_Criteria, orderBy, arginfo_phalcon_mvc_model_criteriainterface_orderby, ZEND_ACC_PUBLIC)
	PHP_ME(Phalcon_Mvc_Model_Criteria, limit, arginfo_phalcon_mvc_model_criteriainterface_limit, ZEND_ACC_PUBLIC)
	PHP_ME(Phalcon_Mvc_Model_Criteria, forUpdate, arginfo_phalcon_mvc_model_criteriainterface_forupdate, ZEND_ACC_PUBLIC)
	PHP_ME(Phalcon_Mvc_Model_Criteria, sharedLock, arginfo_phalcon_mvc_model_criteriainterface_sharedlock, ZEND_ACC_PUBLIC)
	PHP_ME(Phalcon_Mvc_Model_Criteria, getWhere, NULL, ZEND_ACC_PUBLIC)
	PHP_ME(Phalcon_Mvc_Model_Criteria, getColumns, NULL, ZEND_ACC_PUBLIC)
	PHP_ME(Phalcon_Mvc_Model_Criteria, getConditions, NULL, ZEND_ACC_PUBLIC)
Пример #13
0
	PHP_ME(Phalcon_Mvc_View_Simple, getViewsDir, NULL, ZEND_ACC_PUBLIC)
	PHP_ME(Phalcon_Mvc_View_Simple, registerEngines, arginfo_phalcon_mvc_view_simple_registerengines, ZEND_ACC_PUBLIC)
	PHP_ME(Phalcon_Mvc_View_Simple, getRegisteredEngines, NULL, ZEND_ACC_PUBLIC)
	PHP_ME(Phalcon_Mvc_View_Simple, _loadTemplateEngines, NULL, ZEND_ACC_PROTECTED)
	PHP_ME(Phalcon_Mvc_View_Simple, _internalRender, NULL, ZEND_ACC_PROTECTED)
	PHP_ME(Phalcon_Mvc_View_Simple, render, arginfo_phalcon_mvc_view_simple_render, ZEND_ACC_PUBLIC)
	PHP_ME(Phalcon_Mvc_View_Simple, partial, arginfo_phalcon_mvc_view_simple_partial, ZEND_ACC_PUBLIC)
	PHP_ME(Phalcon_Mvc_View_Simple, setCacheOptions, arginfo_phalcon_mvc_view_simple_setcacheoptions, ZEND_ACC_PUBLIC)
	PHP_ME(Phalcon_Mvc_View_Simple, getCacheOptions, NULL, ZEND_ACC_PUBLIC)
	PHP_ME(Phalcon_Mvc_View_Simple, _createCache, NULL, ZEND_ACC_PROTECTED)
	PHP_ME(Phalcon_Mvc_View_Simple, getCache, NULL, ZEND_ACC_PUBLIC)
	PHP_ME(Phalcon_Mvc_View_Simple, cache, arginfo_phalcon_mvc_view_simple_cache, ZEND_ACC_PUBLIC)
	PHP_ME(Phalcon_Mvc_View_Simple, setParamToView, arginfo_phalcon_mvc_view_simple_setparamtoview, ZEND_ACC_PUBLIC)
	PHP_ME(Phalcon_Mvc_View_Simple, setVars, arginfo_phalcon_mvc_view_simple_setvars, ZEND_ACC_PUBLIC)
	PHP_ME(Phalcon_Mvc_View_Simple, setVar, arginfo_phalcon_mvc_view_simple_setvar, ZEND_ACC_PUBLIC)
	PHP_MALIAS(Phalcon_Mvc_View_Simple, getVar, __get, arginfo_phalcon_mvc_view_simple___get, ZEND_ACC_PUBLIC)
	PHP_ME(Phalcon_Mvc_View_Simple, getParamsToView, NULL, ZEND_ACC_PUBLIC)
	PHP_ME(Phalcon_Mvc_View_Simple, setContent, arginfo_phalcon_mvc_view_simple_setcontent, ZEND_ACC_PUBLIC)
	PHP_ME(Phalcon_Mvc_View_Simple, getContent, NULL, ZEND_ACC_PUBLIC)
	PHP_ME(Phalcon_Mvc_View_Simple, getActiveRenderPath, NULL, ZEND_ACC_PUBLIC)
	PHP_ME(Phalcon_Mvc_View_Simple, __set, arginfo_phalcon_mvc_view_simple___set, ZEND_ACC_PUBLIC)
	PHP_ME(Phalcon_Mvc_View_Simple, __get, arginfo_phalcon_mvc_view_simple___get, ZEND_ACC_PUBLIC)
	PHP_FE_END
};

/**
 * Phalcon\Mvc\View\Simple initializer
 */
PHALCON_INIT_CLASS(Phalcon_Mvc_View_Simple){

	PHALCON_REGISTER_CLASS_EX(Phalcon\\Mvc\\View, Simple, mvc_view_simple, phalcon_di_injectable_ce, phalcon_mvc_view_simple_method_entry, 0);
Пример #14
0
	PHP_ME(ze_recorder, query           , recorder_query_args      , ZEND_ACC_PUBLIC)
	PHP_ME(ze_recorder, getStmt         , NULL                     , ZEND_ACC_PUBLIC)
	PHP_ME(ze_recorder, bind            , recorder_bind_args       , ZEND_ACC_PUBLIC)
	PHP_ME(ze_recorder, fetch           , recorder_fetch_args      , ZEND_ACC_PUBLIC)
	PHP_ME(ze_recorder, getInt          , NULL                     , ZEND_ACC_PUBLIC)
	PHP_ME(ze_recorder, fetchAll        , recorder_fetchAll_args   , ZEND_ACC_PUBLIC)
	PHP_ME(ze_recorder, execute         , NULL                     , ZEND_ACC_PUBLIC)
	PHP_ME(ze_recorder, exec            , NULL                     , ZEND_ACC_PUBLIC)
	PHP_ME(ze_recorder, lastId          , recorder_lastId_args     , ZEND_ACC_PUBLIC)
	PHP_ME(ze_recorder, affected        , NULL                     , ZEND_ACC_PUBLIC)
	PHP_ME(ze_recorder, begin           , NULL                     , ZEND_ACC_PUBLIC)
	PHP_ME(ze_recorder, rollback        , NULL                     , ZEND_ACC_PUBLIC)
	PHP_ME(ze_recorder, commit          , NULL                     , ZEND_ACC_PUBLIC)
	PHP_ME(ze_recorder, close           , NULL                     , ZEND_ACC_PUBLIC)
	PHP_ME(ze_recorder, debugDump       , NULL                     , ZEND_ACC_PUBLIC)
	PHP_MALIAS(ze_recorder, __destruct  , close      , NULL        , ZEND_ACC_PUBLIC | ZEND_ACC_DTOR)
	{NULL, NULL, NULL}
};
/* }}} */

/** {{{ PHP_MINIT_FUNCTION
 */
PHP_MINIT_FUNCTION(ze_recorder) {
	zend_class_entry ce;
	INIT_CLASS_ENTRY(ce, "ZeRecorder", ze_recorder_methods);
	ze_recorder_ce = zend_register_internal_class_ex(&ce, NULL, NULL TSRMLS_CC);

	zend_declare_property_null(ze_recorder_ce, ZEND_STRL(ZE_PDO_DBH) , ZEND_ACC_PRIVATE TSRMLS_CC);
	zend_declare_property_null(ze_recorder_ce, ZEND_STRL(ZE_STMT) , ZEND_ACC_PRIVATE TSRMLS_CC);
	zend_declare_property_null(ze_recorder_ce, ZEND_STRL(ZE_KEYS) , ZEND_ACC_PRIVATE TSRMLS_CC);
Пример #15
0
static const zend_function_entry phalcon_events_manager_method_entry[] = {
	PHP_ME(Phalcon_Events_Manager, attach, arginfo_phalcon_events_managerinterface_attach, ZEND_ACC_PUBLIC)
	PHP_ME(Phalcon_Events_Manager, enablePriorities, arginfo_phalcon_events_manager_enablepriorities, ZEND_ACC_PUBLIC)
	PHP_ME(Phalcon_Events_Manager, arePrioritiesEnabled, NULL, ZEND_ACC_PUBLIC)
	PHP_ME(Phalcon_Events_Manager, collectResponses, arginfo_phalcon_events_manager_collectresponses, ZEND_ACC_PUBLIC)
	PHP_ME(Phalcon_Events_Manager, isCollecting, NULL, ZEND_ACC_PUBLIC)
	PHP_ME(Phalcon_Events_Manager, getResponses, NULL, ZEND_ACC_PUBLIC)
	PHP_ME(Phalcon_Events_Manager, detach, arginfo_phalcon_events_managerinterface_detach, ZEND_ACC_PUBLIC)
	PHP_ME(Phalcon_Events_Manager, detachAll, arginfo_phalcon_events_managerinterface_detachall, ZEND_ACC_PUBLIC)
	PHP_ME(Phalcon_Events_Manager, fireQueue, arginfo_phalcon_events_manager_firequeue, ZEND_ACC_PUBLIC)
	PHP_ME(Phalcon_Events_Manager, fire, arginfo_phalcon_events_managerinterface_fire, ZEND_ACC_PUBLIC)
	PHP_ME(Phalcon_Events_Manager, hasListeners, arginfo_phalcon_events_manager_haslisteners, ZEND_ACC_PUBLIC)
	PHP_ME(Phalcon_Events_Manager, getListeners, arginfo_phalcon_events_managerinterface_getlisteners, ZEND_ACC_PUBLIC)
	PHP_ME(Phalcon_Events_Manager, getEvents, NULL, ZEND_ACC_PUBLIC)
	PHP_MALIAS(Phalcon_Events_Manager, dettachAll, detachAll, arginfo_phalcon_events_managerinterface_detachall, ZEND_ACC_PUBLIC | ZEND_ACC_DEPRECATED)
	PHP_MALIAS(Phalcon_Events_Manager, clearListeners, detachAll, arginfo_phalcon_events_managerinterface_detachall, ZEND_ACC_PUBLIC | ZEND_ACC_DEPRECATED)
	PHP_FE_END
};


/**
 * Phalcon\Events\Manager initializer
 */
PHALCON_INIT_CLASS(Phalcon_Events_Manager){

	PHALCON_REGISTER_CLASS(Phalcon\\Events, Manager, events_manager, phalcon_events_manager_method_entry, 0);

	zend_declare_property_null(phalcon_events_manager_ce, SL("_events"), ZEND_ACC_PROTECTED);
	zend_declare_property_bool(phalcon_events_manager_ce, SL("_collect"), 0, ZEND_ACC_PROTECTED);
	zend_declare_property_bool(phalcon_events_manager_ce, SL("_enablePriorities"), 0, ZEND_ACC_PROTECTED);
Пример #16
0
zend_function_entry yaf_config_simple_methods[] = {
	PHP_ME(yaf_config_simple, __construct, yaf_config_simple_construct_arginfo, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR)
	/* PHP_ME(yaf_config_simple, __destruct,	NULL, ZEND_ACC_PUBLIC|ZEND_ACC_DTOR) */
	PHP_ME(yaf_config_simple, __isset, yaf_config_simple_isset_arginfo, ZEND_ACC_PUBLIC)
	PHP_ME(yaf_config_simple, get, yaf_config_simple_get_arginfo, ZEND_ACC_PUBLIC)
	PHP_ME(yaf_config_simple, set, yaf_config_simple_set_arginfo, ZEND_ACC_PUBLIC)
	PHP_ME(yaf_config_simple, count, yaf_config_simple_void_arginfo, ZEND_ACC_PUBLIC)
	PHP_ME(yaf_config_simple, offsetUnset,	yaf_config_simple_unset_arginfo, ZEND_ACC_PUBLIC)
	PHP_ME(yaf_config_simple, rewind, yaf_config_simple_void_arginfo, ZEND_ACC_PUBLIC)
	PHP_ME(yaf_config_simple, current, yaf_config_simple_void_arginfo, ZEND_ACC_PUBLIC)
	PHP_ME(yaf_config_simple, next,	yaf_config_simple_void_arginfo, ZEND_ACC_PUBLIC)
	PHP_ME(yaf_config_simple, valid, yaf_config_simple_void_arginfo, ZEND_ACC_PUBLIC)
	PHP_ME(yaf_config_simple, key, yaf_config_simple_void_arginfo, ZEND_ACC_PUBLIC)
	PHP_ME(yaf_config_simple, readonly,	yaf_config_simple_void_arginfo, ZEND_ACC_PUBLIC)
	PHP_ME(yaf_config_simple, toArray, yaf_config_simple_void_arginfo, ZEND_ACC_PUBLIC)
	PHP_MALIAS(yaf_config_simple, __set, set, yaf_config_simple_set_arginfo, ZEND_ACC_PUBLIC)
	PHP_MALIAS(yaf_config_simple, __get, get, yaf_config_simple_get_arginfo, ZEND_ACC_PUBLIC)
	PHP_MALIAS(yaf_config_simple, offsetGet, get, yaf_config_simple_rget_arginfo, ZEND_ACC_PUBLIC)
	PHP_MALIAS(yaf_config_simple, offsetExists, __isset, yaf_config_simple_isset_arginfo, ZEND_ACC_PUBLIC)
	PHP_MALIAS(yaf_config_simple, offsetSet, set, yaf_config_simple_set_arginfo, ZEND_ACC_PUBLIC)
	{NULL, NULL, NULL}
};
/* }}} */

/** {{{ YAF_STARTUP_FUNCTION
*/
YAF_STARTUP_FUNCTION(config_simple) {
	zend_class_entry ce;

	YAF_INIT_CLASS_ENTRY(ce, "Yaf_Config_Simple", "Yaf\\Config\\Simple", yaf_config_simple_methods);
	yaf_config_simple_ce = zend_register_internal_class_ex(&ce, yaf_config_ce);
Пример #17
0
    PHP_FE(swoole_async_dns_lookup, arginfo_swoole_async_dns_lookup)
    /*------other-----*/
    PHP_FE(swoole_client_select, arginfo_swoole_client_select)
    PHP_FALIAS(swoole_select, swoole_client_select, arginfo_swoole_client_select)
    PHP_FE(swoole_set_process_name, arginfo_swoole_set_process_name)
    PHP_FE(swoole_get_local_ip, arginfo_swoole_void)
    PHP_FE(swoole_strerror, arginfo_swoole_strerror)
    PHP_FE(swoole_errno, arginfo_swoole_void)
    PHP_FE(swoole_load_module, NULL)
    PHP_FE_END /* Must be the last line in swoole_functions[] */
};

static zend_function_entry swoole_server_methods[] = {
    PHP_ME(swoole_server, __construct, arginfo_swoole_server__construct, ZEND_ACC_PUBLIC | ZEND_ACC_CTOR)
    PHP_ME(swoole_server, listen, arginfo_swoole_server_listen, ZEND_ACC_PUBLIC)
    PHP_MALIAS(swoole_server, addlistener, listen, arginfo_swoole_server_listen, ZEND_ACC_PUBLIC)
    PHP_ME(swoole_server, on, arginfo_swoole_server_on, ZEND_ACC_PUBLIC)
    PHP_ME(swoole_server, set, arginfo_swoole_server_set_oo, ZEND_ACC_PUBLIC)
    PHP_ME(swoole_server, start, arginfo_swoole_void, ZEND_ACC_PUBLIC)
    PHP_ME(swoole_server, send, arginfo_swoole_server_send_oo, ZEND_ACC_PUBLIC)
    PHP_ME(swoole_server, sendto, arginfo_swoole_server_sendto_oo, ZEND_ACC_PUBLIC)
    PHP_ME(swoole_server, sendwait, arginfo_swoole_server_sendwait, ZEND_ACC_PUBLIC)
    PHP_ME(swoole_server, exist, arginfo_swoole_server_exist, ZEND_ACC_PUBLIC)
    PHP_ME(swoole_server, protect, arginfo_swoole_server_protect, ZEND_ACC_PUBLIC)
    PHP_ME(swoole_server, sendfile, arginfo_swoole_server_sendfile_oo, ZEND_ACC_PUBLIC)
    PHP_ME(swoole_server, close, arginfo_swoole_server_close_oo, ZEND_ACC_PUBLIC)
    PHP_ME(swoole_server, confirm, arginfo_swoole_server_confirm, ZEND_ACC_PUBLIC)
    PHP_ME(swoole_server, pause, arginfo_swoole_server_pause, ZEND_ACC_PUBLIC)
    PHP_ME(swoole_server, resume, arginfo_swoole_server_resume, ZEND_ACC_PUBLIC)
    PHP_ME(swoole_server, task, arginfo_swoole_server_task_oo, ZEND_ACC_PUBLIC)
    PHP_ME(swoole_server, taskwait, arginfo_swoole_server_taskwait_oo, ZEND_ACC_PUBLIC)
Пример #18
0
    {
        php_write(iptr, size TSRMLS_CC);
        status = MS_SUCCESS;
        /* status = size;  why should we return the size ?? */
        msFree(iptr);
    }

    RETURN_LONG(status);
}
/* }}} */

zend_function_entry image_functions[] = {
    PHP_ME(imageObj, __construct, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR)
    PHP_ME(imageObj, __get, image___get_args, ZEND_ACC_PUBLIC)
    PHP_ME(imageObj, __set, image___set_args, ZEND_ACC_PUBLIC)
    PHP_MALIAS(imageObj, set, __set, NULL, ZEND_ACC_PUBLIC)
    PHP_ME(imageObj, saveWebImage, NULL, ZEND_ACC_PUBLIC)
    PHP_ME(imageObj, pasteImage, image_pasteImage_args, ZEND_ACC_PUBLIC)
    PHP_ME(imageObj, saveImage, image_saveImage_args, ZEND_ACC_PUBLIC)
    {NULL, NULL, NULL}
};


void mapscript_create_image(imageObj *image, zval *return_value TSRMLS_DC)
{
    php_image_object * php_image;
    object_init_ex(return_value, mapscript_ce_image);
    php_image = (php_image_object *)zend_object_store_get_object(return_value TSRMLS_CC);
    php_image->image = image;
}
Пример #19
0
    PHP_MAPSCRIPT_RESTORE_ERRORS(TRUE);
    
    php_labelcachemember = (php_labelcachemember_object *) zend_object_store_get_object(zobj TSRMLS_CC);

    MAPSCRIPT_DELREF(php_labelcachemember->point);
    MAPSCRIPT_DELREF(php_labelcachemember->label);
    MAPSCRIPT_DELREF(php_labelcachemember->styles);
    MAPSCRIPT_DELREF(php_labelcachemember->poly);
}
/* }}} */

zend_function_entry labelcachemember_functions[] = {
    PHP_ME(labelCacheMemberObj, __construct, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR)
    PHP_ME(labelCacheMemberObj, __get, labelcachemember___get_args, ZEND_ACC_PUBLIC)
    PHP_ME(labelCacheMemberObj, __set, labelcachemember___set_args, ZEND_ACC_PUBLIC)
    PHP_MALIAS(labelCacheMemberObj, setProperty, __set, NULL, ZEND_ACC_PUBLIC)
    PHP_ME(labelCacheMemberObj, free, NULL, ZEND_ACC_PUBLIC)
    {NULL, NULL, NULL}
};


void mapscript_create_labelcachemember(labelCacheMemberObj *labelcachemember, 
                                        parent_object parent, zval *return_value TSRMLS_DC)
{
    php_labelcachemember_object * php_labelcachemember;
    object_init_ex(return_value, mapscript_ce_labelcachemember); 
    php_labelcachemember = (php_labelcachemember_object *)zend_object_store_get_object(return_value TSRMLS_CC);
    php_labelcachemember->labelcachemember = labelcachemember;

    php_labelcachemember->parent = parent;
Пример #20
0
  }

  RETURN_LONG(status);
}
/* }}} */

zend_function_entry point_functions[] = {
  PHP_ME(pointObj, __construct, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR)
  PHP_ME(pointObj, __get, point___get_args, ZEND_ACC_PUBLIC)
  PHP_ME(pointObj, __set, point___set_args, ZEND_ACC_PUBLIC)
  PHP_ME(pointObj, setXY, point_setXY_args, ZEND_ACC_PUBLIC)
  PHP_ME(pointObj, setXYZ, point_setXYZ_args, ZEND_ACC_PUBLIC)
  PHP_ME(pointObj, project, point_project_args, ZEND_ACC_PUBLIC)
  PHP_ME(pointObj, distanceToPoint, point_distanceToPoint_args, ZEND_ACC_PUBLIC)
  PHP_ME(pointObj, distanceToLine, point_distanceToLine_args, ZEND_ACC_PUBLIC)
  PHP_MALIAS(pointObj, distanceToSegment, distanceToLine, point_distanceToLine_args, ZEND_ACC_PUBLIC)
  PHP_ME(pointObj, distanceToShape, point_distanceToShape_args, ZEND_ACC_PUBLIC)
  PHP_ME(pointObj, draw, point_draw_args, ZEND_ACC_PUBLIC) {
    NULL, NULL, NULL
  }
};


void mapscript_create_point(pointObj *point, parent_object parent, zval *return_value TSRMLS_DC)
{
  php_point_object * php_point;
  object_init_ex(return_value, mapscript_ce_point);
  php_point = (php_point_object *)zend_object_store_get_object(return_value TSRMLS_CC);
  php_point->point = point;

  if (parent.val)
Пример #21
0
static const zend_function_entry phalcon_session_adapter_method_entry[] = {
	PHP_ME(Phalcon_Session_Adapter, __construct, arginfo_phalcon_session_adapter___construct, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR)
	PHP_ME(Phalcon_Session_Adapter, __destruct, arginfo___destruct, ZEND_ACC_PUBLIC | ZEND_ACC_DTOR)
	PHP_ME(Phalcon_Session_Adapter, start, arginfo_phalcon_session_adapterinterface_start, ZEND_ACC_PUBLIC)
	PHP_ME(Phalcon_Session_Adapter, setOptions, arginfo_phalcon_session_adapterinterface_setoptions, ZEND_ACC_PUBLIC)
	PHP_ME(Phalcon_Session_Adapter, getOptions, arginfo_phalcon_session_adapterinterface_getoptions, ZEND_ACC_PUBLIC)
	PHP_ME(Phalcon_Session_Adapter, get, arginfo_phalcon_session_adapterinterface_get, ZEND_ACC_PUBLIC)
	PHP_ME(Phalcon_Session_Adapter, set, arginfo_phalcon_session_adapterinterface_set, ZEND_ACC_PUBLIC)
	PHP_ME(Phalcon_Session_Adapter, sets, arginfo_phalcon_session_adapterinterface_sets, ZEND_ACC_PUBLIC)
	PHP_ME(Phalcon_Session_Adapter, has, arginfo_phalcon_session_adapterinterface_has, ZEND_ACC_PUBLIC)
	PHP_ME(Phalcon_Session_Adapter, remove, arginfo_phalcon_session_adapterinterface_remove, ZEND_ACC_PUBLIC)
	PHP_ME(Phalcon_Session_Adapter, getId, arginfo_phalcon_session_adapterinterface_getid, ZEND_ACC_PUBLIC)
	PHP_ME(Phalcon_Session_Adapter, isStarted, arginfo_phalcon_session_adapterinterface_isstarted, ZEND_ACC_PUBLIC)
	PHP_ME(Phalcon_Session_Adapter, destroy, arginfo_phalcon_session_adapterinterface_destroy, ZEND_ACC_PUBLIC)
	PHP_ME(Phalcon_Session_Adapter, __get, arginfo___get, ZEND_ACC_PUBLIC)
	PHP_MALIAS(Phalcon_Session_Adapter, __set, set, arginfo___set, ZEND_ACC_PUBLIC)
	PHP_MALIAS(Phalcon_Session_Adapter, __isset, has, arginfo___isset, ZEND_ACC_PUBLIC)
	PHP_MALIAS(Phalcon_Session_Adapter, __unset, remove, arginfo___unset, ZEND_ACC_PUBLIC)
	PHP_MALIAS(Phalcon_Session_Adapter, offsetGet, __get, arginfo_arrayaccess_offsetget, ZEND_ACC_PUBLIC)
	PHP_MALIAS(Phalcon_Session_Adapter, offsetSet, set, arginfo_arrayaccess_offsetset, ZEND_ACC_PUBLIC)
	PHP_MALIAS(Phalcon_Session_Adapter, offsetExists, has, arginfo_arrayaccess_offsetexists, ZEND_ACC_PUBLIC)
	PHP_MALIAS(Phalcon_Session_Adapter, offsetUnset, remove, arginfo_arrayaccess_offsetunset, ZEND_ACC_PUBLIC)
	PHP_ME(Phalcon_Session_Adapter, count, arginfo_countable_count, ZEND_ACC_PUBLIC)
	PHP_ME(Phalcon_Session_Adapter, getIterator, arginfo_iteratoraggregate_getiterator, ZEND_ACC_PUBLIC)
	PHP_ME(Phalcon_Session_Adapter, setId, arginfo_phalcon_session_adapter_setid, ZEND_ACC_PUBLIC)
	PHP_FE_END
};

static zval** phalcon_session_adapter_get_property_ptr_ptr_internal(zval *object, zval *member, int type TSRMLS_DC)
{
	zval *unique_id, *_SESSION, key = zval_used_for_init, *pkey = &key;
Пример #22
0
	}

	lua_pop(L, sp);

	if (arguments) {
		efree(arguments);
	}
}
/* }}} */

/* {{{ lua_class_methods[]
 */
zend_function_entry lua_closure_methods[] = {
	PHP_ME(lua_closure, __construct,		NULL,  					ZEND_ACC_PRIVATE|ZEND_ACC_CTOR)
	PHP_ME(lua_closure, invoke,				arginfo_lua_invoke,  	ZEND_ACC_PUBLIC)
	PHP_MALIAS(lua_closure, __invoke, invoke, arginfo_lua_invoke,	ZEND_ACC_PUBLIC)
	PHP_FE_END
};
/* }}} */

static void php_lua_closure_free_obj(zend_object *zobj) /* {{{ */
{
	lua_closure_object *objval = php_lua_closure_object_from_zend_object(zobj);

	if ((Z_TYPE(objval->lua) == IS_OBJECT) &&
		instanceof_function(Z_OBJCE(objval->lua), lua_ce)) {
		luaL_unref((Z_LUAVAL(objval->lua))->L, LUA_REGISTRYINDEX, objval->closure);
	}
	zval_dtor(&(objval->lua));
	zend_object_std_dtor(zobj);
} /* }}} */
Пример #23
0
ZEND_BEGIN_ARG_INFO_EX(edge_controller_check_login, 0, 0, 3)
    ZEND_ARG_INFO(0, chktype)
    ZEND_ARG_INFO(1, uin)
    ZEND_ARG_INFO(0, key)
ZEND_END_ARG_INFO()


zend_function_entry edge_controller_methods[] = {
    PHP_ME(Edge_Controller, __construct, NULL, ZEND_ACC_PUBLIC)
    PHP_ME(Edge_Controller, get, edge_controller_get_arginfo, ZEND_ACC_PUBLIC)
    PHP_ME(Edge_Controller, model, NULL, ZEND_ACC_PUBLIC)
    PHP_ME(Edge_Controller, post, NULL, ZEND_ACC_PUBLIC)
    PHP_ME(Edge_Controller, result, NULL, ZEND_ACC_PUBLIC)
    PHP_ME(Edge_Controller, check_login, edge_controller_check_login, ZEND_ACC_PUBLIC)
    PHP_MALIAS(Edge_Controller, __get, get, edge_controller_get_arginfo, ZEND_ACC_PUBLIC)
    {NULL, NULL, NULL}
};


PHP_METHOD(Edge_Controller, __construct)
{
    /*
    zval *config;
    zval *config_data;
    zval **ppval;
    config = zend_read_static_property(edge_core_ce, ZEND_STRL("config"), 1 TSRMLS_DC);
    config_data = zend_read_property(edge_config_ce, config, ZEND_STRL("_data"), 1 TSRMLS_DC);
    
    if(zend_hash_find(Z_ARRVAL_P(config_data), "_models_home", strlen("_models_home")+1, (void **)&ppval) == FAILURE)
    {
Пример #24
0
zend_function_entry jz_data_methods[] = {
	PHP_ME(jz_data, __construct, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR)
	PHP_ME(jz_data, __destruct, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_DTOR)
	PHP_ME(jz_data, __isset, jz_data_isset_arginfo, ZEND_ACC_PUBLIC)
	PHP_ME(jz_data, get, jz_data_get_arginfo, ZEND_ACC_PUBLIC)
	PHP_ME(jz_data, set, jz_data_set_arginfo, ZEND_ACC_PUBLIC)
	PHP_ME(jz_data, count, jz_data_void_arginfo, ZEND_ACC_PUBLIC)
	PHP_ME(jz_data, offsetUnset, jz_data_unset_arginfo, ZEND_ACC_PUBLIC)
	PHP_ME(jz_data, rewind, jz_data_void_arginfo, ZEND_ACC_PUBLIC)
	PHP_ME(jz_data, current, jz_data_void_arginfo, ZEND_ACC_PUBLIC)
	PHP_ME(jz_data, next,	jz_data_void_arginfo, ZEND_ACC_PUBLIC)
	PHP_ME(jz_data, valid, jz_data_void_arginfo, ZEND_ACC_PUBLIC)
	PHP_ME(jz_data, key, jz_data_void_arginfo, ZEND_ACC_PUBLIC)
	PHP_ME(jz_data, readonly,	jz_data_void_arginfo, ZEND_ACC_PUBLIC)
	PHP_ME(jz_data, to_array, jz_data_void_arginfo, ZEND_ACC_PUBLIC)
	PHP_MALIAS(jz_data, __set, set, jz_data_set_arginfo, ZEND_ACC_PUBLIC)
	PHP_MALIAS(jz_data, __get, get, jz_data_get_arginfo, ZEND_ACC_PUBLIC)
	PHP_MALIAS(jz_data, offsetGet, get, jz_data_rget_arginfo, ZEND_ACC_PUBLIC)
	PHP_MALIAS(jz_data, offsetExists, __isset, jz_data_isset_arginfo, ZEND_ACC_PUBLIC)
	PHP_MALIAS(jz_data, offsetSet, set, jz_data_set_arginfo, ZEND_ACC_PUBLIC)
	{NULL, NULL, NULL}
};

JZ_STARTUP_FUNCTION(data)
{
	zend_class_entry ce;

	INIT_CLASS_ENTRY(ce, "JZ_Data", jz_data_methods);
	jz_data_class_entry = zend_register_internal_class(&ce TSRMLS_CC);

#ifdef HAVE_SPL
Пример #25
0
  php_line->line->point[index].y = php_point->point->y;

  RETURN_LONG(MS_SUCCESS);
}
/* }}} */

zend_function_entry line_functions[] = {
  PHP_ME(lineObj, __construct, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR)
  PHP_ME(lineObj, __get, line___get_args, ZEND_ACC_PUBLIC)
  PHP_ME(lineObj, __set, line___set_args, ZEND_ACC_PUBLIC)
  PHP_ME(lineObj, add, line_add_args, ZEND_ACC_PUBLIC)
  PHP_ME(lineObj, addXY, line_addXY_args, ZEND_ACC_PUBLIC)
  PHP_ME(lineObj, addXYZ, line_addXYZ_args, ZEND_ACC_PUBLIC)
  PHP_ME(lineObj, project, line_project_args, ZEND_ACC_PUBLIC)
  PHP_ME(lineObj, point, line_point_args, ZEND_ACC_PUBLIC)
  PHP_MALIAS(lineObj, get, point, line_point_args, ZEND_ACC_PUBLIC)
  PHP_ME(lineObj, set, line_set_args, ZEND_ACC_PUBLIC) {
    NULL, NULL, NULL
  }
};


void mapscript_create_line(lineObj *line, parent_object parent, zval *return_value TSRMLS_DC)
{
  php_line_object * php_line;
  object_init_ex(return_value, mapscript_ce_line);
  php_line = (php_line_object *)zend_object_store_get_object(return_value TSRMLS_CC);
  php_line->line = line;

  if (parent.val)
    php_line->is_ref = 1;
Пример #26
0
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_phalcon_debug_dump_variable, 0, 0, 1)
	ZEND_ARG_INFO(0, variable)
	ZEND_ARG_INFO(0, name)
ZEND_END_ARG_INFO()

static const zend_function_entry phalcon_debug_dump_method_entry[] = {
	PHP_ME(Phalcon_Debug_Dump, __construct, arginfo_phalcon_debug_dump___construct, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR)
	PHP_ME(Phalcon_Debug_Dump, all, NULL, ZEND_ACC_PUBLIC)
	PHP_ME(Phalcon_Debug_Dump, getStyle, arginfo_phalcon_debug_dump_getstyle, ZEND_ACC_PUBLIC)
	PHP_ME(Phalcon_Debug_Dump, setStyles, arginfo_phalcon_debug_dump_setstyles, ZEND_ACC_PUBLIC)
	PHP_ME(Phalcon_Debug_Dump, output, arginfo_phalcon_debug_dump_output, ZEND_ACC_PUBLIC)
	PHP_ME(Phalcon_Debug_Dump, variable, arginfo_phalcon_debug_dump_variable, ZEND_ACC_PUBLIC)
	PHP_ME(Phalcon_Debug_Dump, variables, NULL, ZEND_ACC_PUBLIC)
	PHP_MALIAS(Phalcon_Debug_Dump, one, variable, arginfo_phalcon_debug_dump_variable, ZEND_ACC_PUBLIC)
	PHP_MALIAS(Phalcon_Debug_Dump, var, variable, arginfo_phalcon_debug_dump_variable, ZEND_ACC_PUBLIC)
	PHP_MALIAS(Phalcon_Debug_Dump, vars, variables, NULL, ZEND_ACC_PUBLIC)
	PHP_FE_END
};

/**
 * Phalcon\Debug\Dump initializer
 */
PHALCON_INIT_CLASS(Phalcon_Debug_Dump){

	PHALCON_REGISTER_CLASS(Phalcon\\Debug, Dump, debug_dump, phalcon_debug_dump_method_entry, 0);

	zend_declare_property_bool(phalcon_debug_dump_ce, SL("_detailed"), 0, ZEND_ACC_PROTECTED TSRMLS_CC);
	zend_declare_property_null(phalcon_debug_dump_ce, SL("_styles"), ZEND_ACC_PROTECTED TSRMLS_CC);
	zend_declare_property_null(phalcon_debug_dump_ce, SL("_objects"), ZEND_ACC_PROTECTED TSRMLS_CC);
Пример #27
0
    if (cp_zend_hash_index_find(Z_ARRVAL_P(rs), Z_LVAL_P(pos), (void**) &row) == SUCCESS) {
        RETURN_BOOL(1);
    } else {
        RETURN_BOOL(0);
    }

}
const zend_function_entry redis_connect_pool_methods[] = {
    PHP_ME(redis_connect_pool, __construct, NULL, ZEND_ACC_PUBLIC | ZEND_ACC_CTOR)
    PHP_ME(redis_connect_pool, __destruct, NULL, ZEND_ACC_PUBLIC | ZEND_ACC_CTOR)
    PHP_ME(redis_connect_pool, __call, __call_args, ZEND_ACC_PUBLIC)
    PHP_ME(redis_connect_pool, release, NULL, ZEND_ACC_PUBLIC)
    PHP_ME(redis_connect_pool, select, NULL, ZEND_ACC_PUBLIC)
    PHP_ME(redis_connect_pool, connect, NULL, ZEND_ACC_PUBLIC)
    PHP_MALIAS(redis_connect_pool, pconnect, connect, NULL, ZEND_ACC_PUBLIC) /* pconnect 别名指向connect */
    PHP_FE_END
};


int le_cp_server;
int le_cli_connect_pool;

zend_class_entry pdo_connect_pool_ce;
zend_class_entry *pdo_connect_pool_class_entry_ptr;

zend_class_entry redis_connect_pool_ce;
zend_class_entry *redis_connect_pool_class_entry_ptr;

zend_class_entry pdo_connect_pool_PDOStatement_ce;
zend_class_entry *pdo_connect_pool_PDOStatement_class_entry_ptr;
Пример #28
0
	PHP_ME(Phalcon_DI, getRaw, arginfo_phalcon_di_getraw, ZEND_ACC_PUBLIC)
	PHP_ME(Phalcon_DI, getService, arginfo_phalcon_diinterface_getservice, ZEND_ACC_PUBLIC)
	PHP_ME(Phalcon_DI, setService, arginfo_phalcon_diinterface_setservice, ZEND_ACC_PUBLIC)
	PHP_ME(Phalcon_DI, get, arginfo_phalcon_diinterface_get, ZEND_ACC_PUBLIC)
	PHP_ME(Phalcon_DI, getShared, arginfo_phalcon_diinterface_getshared, ZEND_ACC_PUBLIC)
	PHP_ME(Phalcon_DI, has, arginfo_phalcon_diinterface_has, ZEND_ACC_PUBLIC)
	PHP_ME(Phalcon_DI, wasFreshInstance, NULL, ZEND_ACC_PUBLIC)
	PHP_ME(Phalcon_DI, getServices, NULL, ZEND_ACC_PUBLIC)
	PHP_ME(Phalcon_DI, setDefault, arginfo_phalcon_diinterface_setdefault, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
	PHP_ME(Phalcon_DI, getDefault, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
	PHP_ME(Phalcon_DI, reset, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)

	/* Convenience methods */
	PHP_ME(Phalcon_DI, attempt, arginfo_phalcon_di_attempt, ZEND_ACC_PUBLIC)
	PHP_ME(Phalcon_DI, setShared, arginfo_phalcon_di_setshared, ZEND_ACC_PUBLIC)
	PHP_MALIAS(Phalcon_DI, setRaw, setService, arginfo_phalcon_diinterface_setservice, ZEND_ACC_PUBLIC | ZEND_ACC_DEPRECATED)

	/* Syntactic sugar */
	PHP_MALIAS(Phalcon_DI, offsetExists, has, arginfo_arrayaccess_offsetexists, ZEND_ACC_PUBLIC)
	PHP_MALIAS(Phalcon_DI, offsetSet, setShared, arginfo_arrayaccess_offsetset, ZEND_ACC_PUBLIC)
	PHP_MALIAS(Phalcon_DI, offsetGet, getShared, arginfo_arrayaccess_offsetget, ZEND_ACC_PUBLIC)
	PHP_MALIAS(Phalcon_DI, offsetUnset, remove, arginfo_arrayaccess_offsetunset, ZEND_ACC_PUBLIC)
	PHP_ME(Phalcon_DI, __call, arginfo_phalcon_di___call, ZEND_ACC_PUBLIC)

	/* Misc */
	PHP_ME(Phalcon_DI, __clone, NULL, ZEND_ACC_PUBLIC)

	PHP_MALIAS(Phalcon_DI, __set, set, arginfo___set, ZEND_ACC_PUBLIC)
	PHP_MALIAS(Phalcon_DI, __get, get, arginfo___get, ZEND_ACC_PUBLIC)
	PHP_FE_END
};
Пример #29
0
    }
    PHP_MAPSCRIPT_RESTORE_ERRORS(TRUE);

    php_referencemap = (php_referencemap_object *) zend_object_store_get_object(zobj TSRMLS_CC);

    MAPSCRIPT_DELREF(php_referencemap->extent);
    MAPSCRIPT_DELREF(php_referencemap->color);
    MAPSCRIPT_DELREF(php_referencemap->outlinecolor);
}
/* }}} */

zend_function_entry referencemap_functions[] = {
    PHP_ME(referenceMapObj, __construct, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR)
    PHP_ME(referenceMapObj, __get, referenceMap___get_args, ZEND_ACC_PUBLIC)
    PHP_ME(referenceMapObj, __set, referenceMap___set_args, ZEND_ACC_PUBLIC)
    PHP_MALIAS(referenceMapObj, set, __set, NULL, ZEND_ACC_PUBLIC)
    PHP_ME(referenceMapObj, updateFromString, referenceMap_updateFromString_args, ZEND_ACC_PUBLIC)
    PHP_ME(referenceMapObj, convertToString, NULL, ZEND_ACC_PUBLIC)
    PHP_ME(referenceMapObj, free, NULL, ZEND_ACC_PUBLIC) {
        NULL, NULL, NULL
    }
};

void mapscript_create_referencemap(referenceMapObj *referencemap, parent_object parent, zval *return_value TSRMLS_DC)
{
    php_referencemap_object * php_referencemap;
    object_init_ex(return_value, mapscript_ce_referencemap);
    php_referencemap = (php_referencemap_object *)zend_object_store_get_object(return_value TSRMLS_CC);
    php_referencemap->referencemap = referencemap;

    php_referencemap->parent = parent;
Пример #30
0
	ZEND_ARG_PASS_INFO(0)
	ZEND_ARG_PASS_INFO(0)
ZEND_END_ARG_INFO()

static zend_function_entry php_runkit_sandbox_parent_functions[] = {
	PHP_ME(Runkit_Sandbox_Parent,		__call,						arginfo_runkit_sandbox_parent__call,ZEND_ACC_PUBLIC)
	/* Language Constructs */
	PHP_ME(Runkit_Sandbox_Parent,		eval,						NULL,								ZEND_ACC_PUBLIC)
	PHP_ME(Runkit_Sandbox_Parent,		include,					NULL,								ZEND_ACC_PUBLIC)
	PHP_ME(Runkit_Sandbox_Parent,		include_once,				NULL,								ZEND_ACC_PUBLIC)
	PHP_ME(Runkit_Sandbox_Parent,		require,					NULL,								ZEND_ACC_PUBLIC)
	PHP_ME(Runkit_Sandbox_Parent,		require_once,				NULL,								ZEND_ACC_PUBLIC)
	PHP_ME(Runkit_Sandbox_Parent,		echo,						NULL,								ZEND_ACC_PUBLIC)
	PHP_ME(Runkit_Sandbox_Parent,		print,						NULL,								ZEND_ACC_PUBLIC)
	PHP_ME(Runkit_Sandbox_Parent,		die,						NULL,								ZEND_ACC_PUBLIC)
	PHP_MALIAS(Runkit_Sandbox_Parent,	exit,	die,				NULL,								ZEND_ACC_PUBLIC)
	{ NULL, NULL, NULL }
};

static void php_runkit_sandbox_parent_dtor(php_runkit_sandbox_parent_object *objval)
{
	zend_hash_destroy(objval->obj.properties);
	FREE_HASHTABLE(objval->obj.properties);

	efree(objval);
}

static zend_object_value php_runkit_sandbox_parent_ctor(zend_class_entry *ce)
{
	php_runkit_sandbox_parent_object *objval;
	zend_object_value retval;