U_CFUNC PHP_FUNCTION(intlcal_is_set) { zend_long field; CALENDAR_METHOD_INIT_VARS; if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Ol", &object, Calendar_ce_ptr, &field) == FAILURE) { intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR, "intlcal_is_set: bad arguments", 0 TSRMLS_CC); RETURN_FALSE; } if (field < 0 || field >= UCAL_FIELD_COUNT) { intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR, "intlcal_is_set: invalid field", 0 TSRMLS_CC); RETURN_FALSE; } CALENDAR_METHOD_FETCH_OBJECT; RETURN_BOOL((int)co->ucal->isSet((UCalendarDateFields)field)); }
/* {{{ proto bool Runkit_Sandbox_Parent::print(mixed var) Echo through the sandbox Avoid the sandbox's output_handler */ PHP_METHOD(Runkit_Sandbox_Parent,print) { php_runkit_sandbox_parent_object *objval; char *str; int len; if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", &str, &len) == FAILURE) { RETURN_FALSE; } PHP_RUNKIT_SANDBOX_PARENT_FETCHBOX_VERIFY_ACCESS(objval, this_ptr); if (!objval->self->parent_echo) { php_error_docref(NULL, E_WARNING, "Access to echo data in the parent context is not enabled"); RETURN_FALSE; } PHP_RUNKIT_SANDBOX_PARENT_BEGIN(objval) PHPWRITE(str,len); PHP_RUNKIT_SANDBOX_PARENT_END(objval) RETURN_BOOL(len > 1 || (len == 1 && str[0] != '0')); }
PHP_METHOD(Test_Mcall, optionalParameterBoolean) { zval *start_param = NULL; zend_bool start; zephir_fetch_params(0, 0, 1, &start_param); if (!start_param) { start = 1; } else { if (Z_TYPE_P(start_param) != IS_BOOL) { zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'start' must be a bool") TSRMLS_CC); RETURN_NULL(); } start = Z_BVAL_P(start_param); } RETURN_BOOL(start); }
PHP_METHOD(Test_Mcall, optionalParameterBooleanNull) { zval *value_param = NULL; zend_bool value; zephir_fetch_params(0, 0, 1, &value_param); if (!value_param) { value = 0; } else { if (Z_TYPE_P(value_param) != IS_BOOL) { zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'value' must be a bool") TSRMLS_CC); RETURN_NULL(); } value = Z_BVAL_P(value_param); } RETURN_BOOL(value); }
U_CFUNC PHP_FUNCTION(intlgregcal_is_leap_year) { zend_long year; CALENDAR_METHOD_INIT_VARS; if (zend_parse_method_parameters(ZEND_NUM_ARGS(), getThis(), "Ol", &object, GregorianCalendar_ce_ptr, &year) == FAILURE) { intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR, "intlgregcal_is_leap_year: bad arguments", 0); RETURN_FALSE; } if (year < INT32_MIN || year > INT32_MAX) { intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR, "intlgregcal_is_leap_year: year out of bounds", 0); RETURN_FALSE; } CALENDAR_METHOD_FETCH_OBJECT; RETURN_BOOL((int)fetch_greg(co)->isLeapYear((int32_t)year)); }
PHP_METHOD(WinGdiPath, frameRectangle) { wingdi_devicecontext_object *dc_obj; wingdi_brush_object *br_obj; wingdi_path_object *path_obj; zval *coords_zval, *br_zval, **tmp; RECT rect_coords; WINGDI_ERROR_HANDLING(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &br_zval, &coords_zval) == 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); if (Z_TYPE_P(br_zval) == IS_OBJECT) br_obj = zend_object_store_get_object(br_zval TSRMLS_CC); else { php_error_docref(NULL TSRMLS_CC, E_ERROR, "expected an object for parameter 2, got %s", zend_zval_type_name(br_zval)); return; } // Is this the best way to do this? zend_hash_index_find(Z_ARRVAL_P(coords_zval), 0, (void **)&tmp); rect_coords.top = Z_LVAL_PP(tmp); zend_hash_index_find(Z_ARRVAL_P(coords_zval), 1, (void **)&tmp); rect_coords.left = Z_LVAL_PP(tmp); zend_hash_index_find(Z_ARRVAL_P(coords_zval), 2, (void **)&tmp); rect_coords.bottom = Z_LVAL_PP(tmp); zend_hash_index_find(Z_ARRVAL_P(coords_zval), 3, (void **)&tmp); rect_coords.right = Z_LVAL_PP(tmp); RETURN_BOOL(FrameRect(dc_obj->hdc, &rect_coords, br_obj->brush_handle)); }
/** * Gets an attribute a message using the array syntax * *<code> * print_r($messages[0]); *</code> * * @param int index * @return Phalcon\Validation\Message */ PHP_METHOD(Phalcon_Validation_Message_Group, offsetGet) { zval *index_param = NULL, *message, *_0; int index; zephir_fetch_params(0, 1, 0, &index_param); if (unlikely(Z_TYPE_P(index_param) != IS_LONG)) { zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'index' must be a long/integer") TSRMLS_CC); RETURN_NULL(); } index = Z_LVAL_P(index_param); _0 = zephir_fetch_nproperty_this(this_ptr, SL("_messages"), PH_NOISY_CC); if (zephir_array_isset_long_fetch(&message, _0, index, 1 TSRMLS_CC)) { RETURN_CTORW(message); } RETURN_BOOL(0); }
/* {{{ proto boolean XMLReader::next([string localname]) Moves the position of the current instance to the next node in the stream. */ PHP_METHOD(xmlreader, next) { zval *id; int retval; size_t name_len=0; xmlreader_object *intern; char *name = NULL; if (zend_parse_parameters(ZEND_NUM_ARGS(), "|s", &name, &name_len) == FAILURE) { return; } id = getThis(); intern = Z_XMLREADER_P(id); if (intern != NULL && intern->ptr != NULL) { #if LIBXML_VERSION <= 20617 /* Bug in libxml prevents a next in certain cases when positioned on end of element */ if (xmlTextReaderNodeType(intern->ptr) == XML_READER_TYPE_END_ELEMENT) { retval = xmlTextReaderRead(intern->ptr); } else #endif retval = xmlTextReaderNext(intern->ptr); while (name != NULL && retval == 1) { if (xmlStrEqual(xmlTextReaderConstLocalName(intern->ptr), (xmlChar *)name)) { RETURN_TRUE; } retval = xmlTextReaderNext(intern->ptr); } if (retval == -1) { RETURN_FALSE; } else { RETURN_BOOL(retval); } } php_error_docref(NULL, E_WARNING, "Load Data before trying to read"); RETURN_FALSE; }
PHP_METHOD(Label, equal) { php_jit_label_t *plabels[2]; php_jit_function_t *pfuncs[2]; zval *zlabel; if (php_jit_parameters("O", &zlabel, jit_label_ce) != SUCCESS) { php_jit_exception("unexpected parameters, expected (Label label)"); return; } plabels[0] = PHP_JIT_FETCH_LABEL(getThis()); plabels[1] = PHP_JIT_FETCH_LABEL(zlabel); pfuncs[0] = PHP_JIT_FETCH_FUNCTION(&plabels[0]->zfunc); pfuncs[1] = PHP_JIT_FETCH_FUNCTION(&plabels[1]->zfunc); if (pfuncs[0]->func != pfuncs[1]->func) { RETURN_FALSE; } RETURN_BOOL(jit_function_labels_equal(pfuncs[0]->func, plabels[0]->label, plabels[1]->label)); }
static PHP_METHOD(midgard_workspace_manager, purge_content) { char *type; int type_length; zval *z_workspace; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sO", &type, &type_length, &z_workspace, php_midgard_workspace_class) == FAILURE) { return; } MidgardWorkspaceManager *self = MIDGARD_WORKSPACE_MANAGER(__php_gobject_ptr(getThis())); MidgardWorkspace *workspace = MIDGARD_WORKSPACE(__php_gobject_ptr(z_workspace)); GError *error = NULL; zend_bool result = midgard_workspace_manager_purge_content(self, type, workspace, &error); if (error) { zend_throw_exception_ex(NULL, 0 TSRMLS_CC, "Failed to purge %s content from workspace. %s", type, error->message); g_error_free(error); } RETURN_BOOL(result); }
static PHP_METHOD(midgard_workspace_manager, create_workspace) { char *path; int path_length; zval *z_workspace; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Os", &z_workspace, php_midgard_workspace_storage_class, &path, &path_length) == FAILURE) { return; } MidgardWorkspaceManager *self = MIDGARD_WORKSPACE_MANAGER(__php_gobject_ptr(getThis())); MidgardWorkspaceStorage *workspace = MIDGARD_WORKSPACE_STORAGE(__php_gobject_ptr(z_workspace)); GError *error = NULL; zend_bool result = midgard_workspace_manager_create_workspace(self, workspace, path, &error); if (error) { zend_throw_exception_ex(NULL, 0 TSRMLS_CC, "Failed to create workspace. %s", error->message); g_error_free(error); } RETURN_BOOL(result); }
static PHP_METHOD(midgard_connection, set_loglevel) { RETVAL_NULL(); MidgardConnection *mgd =__midgard_connection_get_ptr(getThis()); CHECK_MGD(mgd); char *level; int level_length; zval *callback; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|z", &level, &level_length, &callback) == FAILURE) return; /* no support for callback atm */ gboolean rv = midgard_connection_set_loglevel(mgd, (gchar *)level, php_midgard_log_errors); global_loghandler = midgard_connection_get_loghandler(mgd); if (MGDG(midgard_memory_debug)) { php_printf("---> global_loghandler = %d\n", global_loghandler); } RETURN_BOOL(rv); }
U_CFUNC PHP_FUNCTION(intltz_has_same_rules) { zval *other_object; TimeZone_object *other_to; TIMEZONE_METHOD_INIT_VARS; if (zend_parse_method_parameters(ZEND_NUM_ARGS(), getThis(), "OO", &object, TimeZone_ce_ptr, &other_object, TimeZone_ce_ptr) == FAILURE) { intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR, "intltz_has_same_rules: bad arguments", 0); RETURN_FALSE; } TIMEZONE_METHOD_FETCH_OBJECT; other_to = Z_INTL_TIMEZONE_P(other_object); if (other_to->utimezone == NULL) { intl_errors_set(&to->err, U_ILLEGAL_ARGUMENT_ERROR, "intltz_has_same_rules: The second IntlTimeZone is unconstructed", 0); RETURN_FALSE; } RETURN_BOOL(to->utimezone->hasSameRules(*other_to->utimezone)); }
/* {{{ proto bool SimpleXMLIterator::hasChildren() Check whether element has children (elements) */ PHP_METHOD(ce_SimpleXMLIterator, hasChildren) { php_sxe_object *sxe = Z_SXEOBJ_P(getThis()); php_sxe_object *child; xmlNodePtr node; if (zend_parse_parameters_none() == FAILURE) { return; } if (Z_ISUNDEF(sxe->iter.data) || sxe->iter.type == SXE_ITER_ATTRLIST) { RETURN_FALSE; } child = Z_SXEOBJ_P(&sxe->iter.data); GET_NODE(child, node); if (node) { node = node->children; } while (node && node->type != XML_ELEMENT_NODE) { node = node->next; } RETURN_BOOL(node ? 1 : 0); }
/* {{{ proto boolean XMLReader::getParserProperty(int property) Indicates whether given property (one of the parser option constants) is set or not on parser */ PHP_METHOD(xmlreader, getParserProperty) { zval *id; zend_long property; int retval = -1; xmlreader_object *intern; if (zend_parse_parameters(ZEND_NUM_ARGS(), "l", &property) == FAILURE) { return; } id = getThis(); intern = Z_XMLREADER_P(id); if (intern && intern->ptr) { retval = xmlTextReaderGetParserProp(intern->ptr,property); } if (retval == -1) { php_error_docref(NULL, E_WARNING, "Invalid parser property"); RETURN_FALSE; } RETURN_BOOL(retval); }
/** * {@inheritdoc} */ PHP_METHOD(Phalcon_Session_Adapter_Memcache, gc) { RETURN_BOOL(1); }
/* {{{ php_stat */ static void phar_fancy_stat(zend_stat_t *stat_sb, int type, zval *return_value) { zval stat_dev, stat_ino, stat_mode, stat_nlink, stat_uid, stat_gid, stat_rdev, stat_size, stat_atime, stat_mtime, stat_ctime, stat_blksize, stat_blocks; int rmask=S_IROTH, wmask=S_IWOTH, xmask=S_IXOTH; /* access rights defaults to other */ char *stat_sb_names[13] = { "dev", "ino", "mode", "nlink", "uid", "gid", "rdev", "size", "atime", "mtime", "ctime", "blksize", "blocks" }; #ifndef NETWARE if (type >= FS_IS_W && type <= FS_IS_X) { if(stat_sb->st_uid==getuid()) { rmask=S_IRUSR; wmask=S_IWUSR; xmask=S_IXUSR; } else if(stat_sb->st_gid==getgid()) { rmask=S_IRGRP; wmask=S_IWGRP; xmask=S_IXGRP; } else { int groups, n, i; gid_t *gids; groups = getgroups(0, NULL); if(groups > 0) { gids=(gid_t *)safe_emalloc(groups, sizeof(gid_t), 0); n=getgroups(groups, gids); for(i=0;i<n;++i){ if(stat_sb->st_gid==gids[i]) { rmask=S_IRGRP; wmask=S_IWGRP; xmask=S_IXGRP; break; } } efree(gids); } } } #endif switch (type) { case FS_PERMS: RETURN_LONG((zend_long)stat_sb->st_mode); case FS_INODE: RETURN_LONG((zend_long)stat_sb->st_ino); case FS_SIZE: RETURN_LONG((zend_long)stat_sb->st_size); case FS_OWNER: RETURN_LONG((zend_long)stat_sb->st_uid); case FS_GROUP: RETURN_LONG((zend_long)stat_sb->st_gid); case FS_ATIME: #ifdef NETWARE RETURN_LONG((zend_long)stat_sb->st_atime.tv_sec); #else RETURN_LONG((zend_long)stat_sb->st_atime); #endif case FS_MTIME: #ifdef NETWARE RETURN_LONG((zend_long)stat_sb->st_mtime.tv_sec); #else RETURN_LONG((zend_long)stat_sb->st_mtime); #endif case FS_CTIME: #ifdef NETWARE RETURN_LONG((zend_long)stat_sb->st_ctime.tv_sec); #else RETURN_LONG((zend_long)stat_sb->st_ctime); #endif case FS_TYPE: if (S_ISLNK(stat_sb->st_mode)) { RETURN_STRING("link"); } switch(stat_sb->st_mode & S_IFMT) { case S_IFDIR: RETURN_STRING("dir"); case S_IFREG: RETURN_STRING("file"); } php_error_docref(NULL, E_NOTICE, "Unknown file type (%u)", stat_sb->st_mode & S_IFMT); RETURN_STRING("unknown"); case FS_IS_W: RETURN_BOOL((stat_sb->st_mode & wmask) != 0); case FS_IS_R: RETURN_BOOL((stat_sb->st_mode&rmask)!=0); case FS_IS_X: RETURN_BOOL((stat_sb->st_mode&xmask)!=0 && !S_ISDIR(stat_sb->st_mode)); case FS_IS_FILE: RETURN_BOOL(S_ISREG(stat_sb->st_mode)); case FS_IS_DIR: RETURN_BOOL(S_ISDIR(stat_sb->st_mode)); case FS_IS_LINK: RETURN_BOOL(S_ISLNK(stat_sb->st_mode)); case FS_EXISTS: RETURN_TRUE; /* the false case was done earlier */ case FS_LSTAT: /* FALLTHROUGH */ case FS_STAT: array_init(return_value); ZVAL_LONG(&stat_dev, stat_sb->st_dev); ZVAL_LONG(&stat_ino, stat_sb->st_ino); ZVAL_LONG(&stat_mode, stat_sb->st_mode); ZVAL_LONG(&stat_nlink, stat_sb->st_nlink); ZVAL_LONG(&stat_uid, stat_sb->st_uid); ZVAL_LONG(&stat_gid, stat_sb->st_gid); #ifdef HAVE_ST_RDEV ZVAL_LONG(&stat_rdev, stat_sb->st_rdev); #else ZVAL_LONG(&stat_rdev, -1); #endif ZVAL_LONG(&stat_size, stat_sb->st_size); #ifdef NETWARE ZVAL_LONG(&stat_atime, (stat_sb->st_atime).tv_sec); ZVAL_LONG(&stat_mtime, (stat_sb->st_mtime).tv_sec); ZVAL_LONG(&stat_ctime, (stat_sb->st_ctime).tv_sec); #else ZVAL_LONG(&stat_atime, stat_sb->st_atime); ZVAL_LONG(&stat_mtime, stat_sb->st_mtime); ZVAL_LONG(&stat_ctime, stat_sb->st_ctime); #endif #ifdef HAVE_ST_BLKSIZE ZVAL_LONG(&stat_blksize, stat_sb->st_blksize); #else ZVAL_LONG(&stat_blksize,-1); #endif #ifdef HAVE_ST_BLOCKS ZVAL_LONG(&stat_blocks, stat_sb->st_blocks); #else ZVAL_LONG(&stat_blocks,-1); #endif /* Store numeric indexes in proper order */ zend_hash_next_index_insert(HASH_OF(return_value), &stat_dev); zend_hash_next_index_insert(HASH_OF(return_value), &stat_ino); zend_hash_next_index_insert(HASH_OF(return_value), &stat_mode); zend_hash_next_index_insert(HASH_OF(return_value), &stat_nlink); zend_hash_next_index_insert(HASH_OF(return_value), &stat_uid); zend_hash_next_index_insert(HASH_OF(return_value), &stat_gid); zend_hash_next_index_insert(HASH_OF(return_value), &stat_rdev); zend_hash_next_index_insert(HASH_OF(return_value), &stat_size); zend_hash_next_index_insert(HASH_OF(return_value), &stat_atime); zend_hash_next_index_insert(HASH_OF(return_value), &stat_mtime); zend_hash_next_index_insert(HASH_OF(return_value), &stat_ctime); zend_hash_next_index_insert(HASH_OF(return_value), &stat_blksize); zend_hash_next_index_insert(HASH_OF(return_value), &stat_blocks); /* Store string indexes referencing the same zval*/ zend_hash_str_update(HASH_OF(return_value), stat_sb_names[0], strlen(stat_sb_names[0]), &stat_dev); zend_hash_str_update(HASH_OF(return_value), stat_sb_names[1], strlen(stat_sb_names[1]), &stat_ino); zend_hash_str_update(HASH_OF(return_value), stat_sb_names[2], strlen(stat_sb_names[2]), &stat_mode); zend_hash_str_update(HASH_OF(return_value), stat_sb_names[3], strlen(stat_sb_names[3]), &stat_nlink); zend_hash_str_update(HASH_OF(return_value), stat_sb_names[4], strlen(stat_sb_names[4]), &stat_uid); zend_hash_str_update(HASH_OF(return_value), stat_sb_names[5], strlen(stat_sb_names[5]), &stat_gid); zend_hash_str_update(HASH_OF(return_value), stat_sb_names[6], strlen(stat_sb_names[6]), &stat_rdev); zend_hash_str_update(HASH_OF(return_value), stat_sb_names[7], strlen(stat_sb_names[7]), &stat_size); zend_hash_str_update(HASH_OF(return_value), stat_sb_names[8], strlen(stat_sb_names[8]), &stat_atime); zend_hash_str_update(HASH_OF(return_value), stat_sb_names[9], strlen(stat_sb_names[9]), &stat_mtime); zend_hash_str_update(HASH_OF(return_value), stat_sb_names[10], strlen(stat_sb_names[10]), &stat_ctime); zend_hash_str_update(HASH_OF(return_value), stat_sb_names[11], strlen(stat_sb_names[11]), &stat_blksize); zend_hash_str_update(HASH_OF(return_value), stat_sb_names[12], strlen(stat_sb_names[12]), &stat_blocks); return; } php_error_docref(NULL, E_WARNING, "Didn't understand stat call"); RETURN_FALSE; }
/** * Returns true if the event watcher is pending (ie. it has outstanding events but * the callback has not been called yet). * * @return boolean * @return null If object has not been initialized */ PHP_METHOD(Event, isPending) { event_object *obj = (event_object *)zend_object_store_get_object(getThis() TSRMLS_CC); RETURN_BOOL(event_is_pending(obj)); }
/** * Returns true if the event is active, ie. associated with an event loop. * * @return boolean * @return null If object has not been initialized */ PHP_METHOD(Event, isActive) { event_object *obj = (event_object *)zend_object_store_get_object(getThis() TSRMLS_CC); RETURN_BOOL(event_is_active(obj)); }
/** {{{ proto bool Win\Gdi\Window::endPaint( paint_data ); Marks the end of painting in the specified window. */ PHP_METHOD( WinGdiWindow, endPaint ) { wingdi_devicecontext_object * dc_object; wingdi_window_object * window_object = zend_object_store_get_object( getThis() TSRMLS_CC ); HashTable * paint_data; PAINTSTRUCT paint_struct; WINGDI_ERROR_HANDLING(); if ( zend_parse_parameters( ZEND_NUM_ARGS() TSRMLS_CC, "h", &paint_data ) == FAILURE ) return; WINGDI_RESTORE_ERRORS(); // Error checking // Not sure about the error messages if ( ! zend_hash_exists( paint_data, "hdc", strlen( "hdc" ) + 1 ) ) { php_error( E_ERROR, "no 'hdc' element found in array" ); return; } else if ( ! zend_hash_exists( paint_data, "erase", strlen( "erase" ) + 1 ) ) { php_error( E_ERROR, "no 'erase' element found in array" ); return; } else if ( ! zend_hash_exists( paint_data, "paint", strlen( "paint" ) + 1 ) ) { php_error( E_ERROR, "no 'paint' element found in array" ); return; } else { zval ** hdc_element, ** erase_element, ** paint_element, ** left = NULL, ** top = NULL, ** right = NULL, ** bottom = NULL; HashTable * paint_rect; zend_hash_find( paint_data, "hdc", strlen( "hdc" ) + 1, ( void ** ) &hdc_element ); dc_object = ( wingdi_devicecontext_object * ) zend_objects_get_address( * hdc_element TSRMLS_CC ); paint_struct.hdc = dc_object->hdc; zend_hash_find( paint_data, "erase", strlen( "erase" ) + 1, ( void ** ) &erase_element ); paint_struct.fErase = Z_BVAL_PP( erase_element ); zend_hash_find( paint_data, "paint", strlen( "paint" ) + 1, ( void ** ) &paint_element ); if ( Z_TYPE_PP( paint_element ) != IS_ARRAY || zend_hash_num_elements( Z_ARRVAL_PP( paint_element ) ) < 4 ) { php_error( E_ERROR, "expected an array of for elements for 'paint' element of array" ); return; } paint_rect = Z_ARRVAL_PP( paint_element ); // TODO: error checking zend_hash_index_find( paint_rect, 0, ( void ** ) &left ); zend_hash_index_find( paint_rect, 1, ( void ** ) &top ); zend_hash_index_find( paint_rect, 2, ( void ** ) &right ); zend_hash_index_find( paint_rect, 3, ( void ** ) &bottom ); paint_struct.rcPaint.left = Z_LVAL_PP( left ); paint_struct.rcPaint.top = Z_LVAL_PP( top ); paint_struct.rcPaint.right = Z_LVAL_PP( right ); paint_struct.rcPaint.bottom = Z_LVAL_PP( bottom ); RETURN_BOOL( EndPaint( window_object->window_handle, &paint_struct ) ); } }
static PHP_METHOD(Operand, isConstant) { php_inspector_operand_t *operand = php_inspector_operand_this(); RETURN_BOOL(operand->type & IS_CONST); }
PHP_METHOD(Mongo, getSlaveOkay) { mongoclient *link; PHP_MONGO_GET_LINK(getThis()); RETURN_BOOL(link->servers->read_pref.type != MONGO_RP_PRIMARY); }
static PHP_METHOD(Operand, isUnused) { php_inspector_operand_t *operand = php_inspector_operand_this(); RETURN_BOOL(operand->type & IS_UNUSED); }
PHP_METHOD(Struct, isPointer) { RETURN_BOOL(0); }
PHP_METHOD(Struct, getIndirection) { RETURN_BOOL(0); }
PHP_METHOD(Money, lessThan) { CHECK_MONEY_PARAMS RETURN_BOOL(money_handler_compare_objects(getThis(), other_money) == -1); }
PHP_METHOD(Money, equals) { CHECK_MONEY_PARAMS RETURN_BOOL(money_handler_compare_objects(getThis(), other_money) == 0); }
/* {{{ proto boolean tidy_is_xml() Indicates if the document is a generic (non HTML/XHTML) XML document. */ static PHP_FUNCTION(tidy_is_xml) { TIDY_FETCH_OBJECT; RETURN_BOOL(tidyDetectedGenericXml(obj->ptdoc->doc)); }
PHP_METHOD(MongoDB, getSlaveOkay) { mongo_db *db; PHP_MONGO_GET_DB(getThis()); RETURN_BOOL(db->slave_okay); }
static PHP_METHOD(Operand, isVariable) { php_inspector_operand_t *operand = php_inspector_operand_this(); RETURN_BOOL(operand->type & IS_VAR); }