自学教程：C++ x_return_val_if_fail函数代码示例

intxmmsc_ipc_io_in_callback (xmmsc_ipc_t *ipc){	bool disco = false;	x_return_val_if_fail (ipc, false);	x_return_val_if_fail (!ipc->disconnect, false);	while (!disco) {		if (!ipc->read_msg)			ipc->read_msg = xmms_ipc_msg_alloc ();		if (xmms_ipc_msg_read_transport (ipc->read_msg, ipc->transport, &disco)) {			xmms_ipc_msg_t *msg = ipc->read_msg;			/* must unset read_msg here,			   because exec_msg can cause reentrancy */			ipc->read_msg = NULL;			xmmsc_ipc_exec_msg (ipc, msg);		} else {			break;		}	}	if (disco)		xmmsc_ipc_disconnect (ipc);	return !disco;}

xPointer x_bytes_unref_to_data(xBytes *bytes, xSize *size){    xPointer result;    x_return_val_if_fail(bytes != NULL, NULL);    x_return_val_if_fail(size != NULL, NULL);    /*     * Optimal path: if this is was the last reference, then we can return     * the data from this xBytes without copying.     */    result = try_steal_and_unref(bytes, free, size);    if (result == NULL)    {        /*         * Copy: Non malloc (or compatible) allocater, or static memory,         * so we have to copy, and then unref.         */        result = memdup(bytes->data, bytes->size);        *size = bytes->size;        x_bytes_unref(bytes);    }    return result;}

intxmmsc_ipc_io_out_callback (xmmsc_ipc_t *ipc){	bool disco = false;	x_return_val_if_fail (ipc, false);	x_return_val_if_fail (!ipc->disconnect, false);	while (!x_queue_is_empty (ipc->out_msg)) {		xmms_ipc_msg_t *msg = x_queue_peek_head (ipc->out_msg);		if (xmms_ipc_msg_write_transport (msg, ipc->transport, &disco)) {			x_queue_pop_head (ipc->out_msg);			xmms_ipc_msg_destroy (msg);		} else {			break;		}	}	if (disco) {		xmmsc_ipc_disconnect (ipc);	} else {		if (ipc->need_out_callback)			ipc->need_out_callback (xmmsc_ipc_io_out (ipc),			                        ipc->need_out_data);	}	return !disco;}

xBytes* x_bytes_new_from_bytes(xBytes *bytes, xSize offset, xSize length){    /* Note that length may be 0. */    x_return_val_if_fail(bytes != NULL, NULL);    x_return_val_if_fail(offset <= bytes->size, NULL);    x_return_val_if_fail(offset + length <= bytes->size, NULL);    return x_bytes_new_with_free_func((xChar*)bytes->data + offset, length, x_bytes_unref, x_bytes_ref(bytes));}

xBoolean x_bytes_equal(xConstPointer bytes1, xConstPointer bytes2){    const xBytes *b1 = bytes1;    const xBytes *b2 = bytes2;    x_return_val_if_fail(bytes1 != NULL, FALSE);    x_return_val_if_fail(bytes2 != NULL, FALSE);    return b1->size == b2->size && memcmp(b1->data, b2->data, b1->size) == 0;}

xInt32 x_serialport_read(xSerialPort *port, xUInt8 *buffer, xInt32 count){	x_return_val_if_fail(port, -1);	x_return_val_if_fail(buffer, -1);	x_return_val_if_fail(count > 0, -1);	if (!x_serialport_is_open(port))		return -1;	return x_serialport_platform_read(port->platform, buffer, count);}

/** * Try to read message from transport into msg. * * @returns TRUE if message is fully read. */boolxmms_ipc_msg_read_transport (xmms_ipc_msg_t *msg,                             xmms_ipc_transport_t *transport,                             bool *disconnected){	char buf[512];	unsigned int ret, len, rlen;	x_return_val_if_fail (msg, false);	x_return_val_if_fail (transport, false);	while (true) {		len = XMMS_IPC_MSG_HEAD_LEN;		if (msg->xfered >= XMMS_IPC_MSG_HEAD_LEN) {			len += xmms_ipc_msg_get_length (msg);			if (msg->xfered == len) {				return true;			}		}		x_return_val_if_fail (msg->xfered < len, false);		rlen = len - msg->xfered;		if (rlen > sizeof (buf))			rlen = sizeof (buf);		ret = xmms_ipc_transport_read (transport, buf, rlen);		if (ret == SOCKET_ERROR) {			if (xmms_socket_error_recoverable ()) {				return false;			}			if (disconnected) {				*disconnected = true;			}			return false;		} else if (ret == 0) {			if (disconnected) {				*disconnected = true;			}			return false;		} else {			xmmsv_bitbuffer_goto (msg->bb, msg->xfered * 8);			xmmsv_bitbuffer_put_data (msg->bb, (unsigned char *) buf, ret);			msg->xfered += ret;			xmmsv_bitbuffer_goto (msg->bb, XMMS_IPC_MSG_HEAD_LEN * 8);		}	}}

xBoolean x_serialport_set_write_buffer_size(xSerialPort *port, xInt32 value){	x_return_val_if_fail(port, FALSE);	x_return_val_if_fail(value > 0, FALSE);	if (x_serialport_is_open(port))		return FALSE;	port->write_buffer_size = value;	return TRUE;}

xBoolean x_serialport_set_port_name(xSerialPort *port, const xChar *value){	x_return_val_if_fail(port, FALSE);	x_return_val_if_fail(value, FALSE);	if (x_serialport_is_open(port))		return FALSE;	port->port_name = x_string_assign(port->port_name, value);	return TRUE;}

static intxmms_ipc_tcp_write (xmms_ipc_transport_t *ipct, char *buffer, int len){	xmms_socket_t fd;	x_return_val_if_fail (ipct, -1);	x_return_val_if_fail (buffer, -1);	fd = ipct->fd;	return send (fd, buffer, len, 0);}

boolxmmsc_ipc_connect (xmmsc_ipc_t *ipc, char *path){	x_return_val_if_fail (ipc, false);	x_return_val_if_fail (path, false);	ipc->transport = xmms_ipc_client_init (path);	if (!ipc->transport) {		ipc->error = strdup ("Could not init client!");		return false;	}	return true;}

static intxmms_ipc_tcp_read (xmms_ipc_transport_t *ipct, char *buffer, int len){	xmms_socket_t fd;	int ret;	x_return_val_if_fail (ipct, -1);	x_return_val_if_fail (buffer, -1);	fd = ipct->fd;	ret =  recv (fd, buffer, len, 0);	return ret;}

xInt x_bytes_compare(xConstPointer bytes1, xConstPointer bytes2){    const xBytes *b1 = bytes1;    const xBytes *b2 = bytes2;    xInt ret;    x_return_val_if_fail(bytes1 != NULL, 0);    x_return_val_if_fail(bytes2 != NULL, 0);    ret = memcmp(b1->data, b2->data, MIN(b1->size, b2->size));    if (ret == 0 && b1->size != b2->size)        ret = b1->size < b2->size ? -1 : 1;    return ret;}

/** * Remove the value at a given index from the idlist. * @param coll  The collection to update. * @param index The index at which to remove the value. * @return  TRUE on success, false otherwise. */intxmmsv_coll_idlist_remove (xmmsv_t *coll, int index){	x_return_val_if_fail (coll, 0);	return xmmsv_list_remove (coll->value.coll->idlist, index);}

intxmmsc_ipc_io_out (xmmsc_ipc_t *ipc){	x_return_val_if_fail (ipc, false);	return !x_queue_is_empty (ipc->out_msg) && !ipc->disconnect;}

/** * Empties the idlist. * @param coll  The collection to update. * @return  TRUE on success, false otherwise. */intxmmsv_coll_idlist_clear (xmmsv_t *coll){	x_return_val_if_fail (coll, 0);	return xmmsv_list_clear (coll->value.coll->idlist);}

xmmsv_t *xmmsv_coll_operands_get (xmmsv_t *coll){	x_return_val_if_fail (coll, NULL);	return coll->value.coll->operands;}

/** * Sets the value at the given position in the idlist. * @param coll  The collection to update. * @param index The position of the value to set. * @param val   The new value. * @return  TRUE on success, false otherwise. */intxmmsv_coll_idlist_set_index (xmmsv_t *coll, int index, int64_t val){	x_return_val_if_fail (coll, 0);	return xmmsv_list_set_int (coll->value.coll->idlist, index, val);}

boolx_queue_is_empty (x_queue_t *queue){	x_return_val_if_fail (queue, true);	return queue->head == NULL;}

void *x_queue_peek_tail (x_queue_t *queue){	x_return_val_if_fail (queue, NULL);	return queue->tail ? queue->tail->data : NULL;}

/** * Return the type of the collection. * @param coll  The collection to consider. * @return The #xmmsv_coll_type_t of the collection, or -1 if invalid. */xmmsv_coll_type_txmmsv_coll_get_type (xmmsv_t *coll){	x_return_val_if_fail (coll, -1);	return coll->value.coll->type;}

/** * Append a value to the idlist. * @param coll  The collection to update. *
C++ x_strdup函数代码示例
C++ x_malloc函数代码示例