コード例 #1
0
ファイル: attribute.c プロジェクト: vaualbus/reactos
static HRESULT WINAPI domattr_insertBefore(
    IXMLDOMAttribute *iface,
    IXMLDOMNode* newNode, VARIANT refChild,
    IXMLDOMNode** old_node)
{
    domattr *This = impl_from_IXMLDOMAttribute( iface );
    DOMNodeType type;
    HRESULT hr;

    FIXME("(%p)->(%p %s %p) needs test\n", This, newNode, debugstr_variant(&refChild), old_node);

    if (!newNode) return E_INVALIDARG;

    hr = IXMLDOMNode_get_nodeType(newNode, &type);
    if (hr != S_OK) return hr;

    TRACE("new node type %d\n", type);
    switch (type)
    {
        case NODE_ATTRIBUTE:
        case NODE_CDATA_SECTION:
        case NODE_COMMENT:
        case NODE_ELEMENT:
        case NODE_PROCESSING_INSTRUCTION:
            if (old_node) *old_node = NULL;
            return E_FAIL;
        default:
            return node_insert_before(&This->node, newNode, &refChild, old_node);
    }
}
コード例 #2
0
ファイル: network.c プロジェクト: vszurma/brickd
void network_client_expects_response(Client *client, Packet *request) {
	PendingRequest *pending_request;
	char packet_signature[PACKET_MAX_SIGNATURE_LENGTH];

	if (client->pending_request_count >= CLIENT_MAX_PENDING_REQUESTS) {
		log_warn("Pending requests list for client ("CLIENT_SIGNATURE_FORMAT") is full, dropping %d pending request(s)",
		         client_expand_signature(client),
		         client->pending_request_count - CLIENT_MAX_PENDING_REQUESTS + 1);

		while (client->pending_request_count >= CLIENT_MAX_PENDING_REQUESTS) {
			pending_request = containerof(client->pending_request_sentinel.next, PendingRequest, client_node);

			pending_request_remove_and_free(pending_request);
		}
	}

	pending_request = calloc(1, sizeof(PendingRequest));

	if (pending_request == NULL) {
		log_error("Could not allocate pending request: %s (%d)",
		          get_errno_name(ENOMEM), ENOMEM);

		return;
	}

	node_reset(&pending_request->global_node);
	node_insert_before(&_pending_request_sentinel, &pending_request->global_node);

	node_reset(&pending_request->client_node);
	node_insert_before(&client->pending_request_sentinel, &pending_request->client_node);

	++client->pending_request_count;

	pending_request->client = client;
	pending_request->zombie = NULL;

	memcpy(&pending_request->header, &request->header, sizeof(PacketHeader));

#ifdef BRICKD_WITH_PROFILING
	pending_request->arrival_time = microseconds();
#endif

	log_packet_debug("Added pending request (%s) for client ("CLIENT_SIGNATURE_FORMAT")",
	                 packet_get_request_signature(packet_signature, request),
	                 client_expand_signature(client));
}
コード例 #3
0
ファイル: text.c プロジェクト: dylanahsmith/wine
static HRESULT WINAPI domtext_insertBefore(
    IXMLDOMText *iface,
    IXMLDOMNode* newNode, VARIANT refChild,
    IXMLDOMNode** outOldNode)
{
    domtext *This = impl_from_IXMLDOMText( iface );

    FIXME("(%p)->(%p %s %p) needs test\n", This, newNode, debugstr_variant(&refChild), outOldNode);

    return node_insert_before(&This->node, newNode, &refChild, outOldNode);
}
コード例 #4
0
ファイル: pi.c プロジェクト: mikekap/wine
static HRESULT WINAPI dom_pi_insertBefore(
    IXMLDOMProcessingInstruction *iface,
    IXMLDOMNode* newNode, VARIANT refChild,
    IXMLDOMNode** outOldNode)
{
    dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );

    FIXME("(%p)->(%p x%d %p) needs test\n", This, newNode, V_VT(&refChild), outOldNode);

    return node_insert_before(&This->node, newNode, &refChild, outOldNode);
}
コード例 #5
0
static HRESULT WINAPI entityref_insertBefore(
    IXMLDOMEntityReference *iface,
    IXMLDOMNode* newNode, VARIANT refChild,
    IXMLDOMNode** outOldNode)
{
    entityref *This = impl_from_IXMLDOMEntityReference( iface );

    FIXME("(%p)->(%p %s %p) needs test\n", This, newNode, debugstr_variant(&refChild), outOldNode);

    return node_insert_before(&This->node, newNode, &refChild, outOldNode);
}
コード例 #6
0
ファイル: node.c プロジェクト: RareHare/reactos
static HRESULT WINAPI unknode_insertBefore(
    IXMLDOMNode *iface,
    IXMLDOMNode* newNode, VARIANT refChild,
    IXMLDOMNode** outOldNode)
{
    unknode *This = unknode_from_IXMLDOMNode( iface );

    FIXME("(%p)->(%p x%d %p)\n", This, newNode, V_VT(&refChild), outOldNode);

    return node_insert_before(&This->node, newNode, &refChild, outOldNode);
}
コード例 #7
0
ファイル: comment.c プロジェクト: mikekap/wine
static HRESULT WINAPI domcomment_insertBefore(
    IXMLDOMComment *iface,
    IXMLDOMNode* newNode, VARIANT refChild,
    IXMLDOMNode** outOldNode)
{
    domcomment *This = impl_from_IXMLDOMComment( iface );

    FIXME("(%p)->(%p x%d %p) needs test\n", This, newNode, V_VT(&refChild), outOldNode);

    return node_insert_before(&This->node, newNode, &refChild, outOldNode);
}
コード例 #8
0
ファイル: docfrag.c プロジェクト: Sunmonds/wine
static HRESULT WINAPI domfrag_insertBefore(
    IXMLDOMDocumentFragment *iface,
    IXMLDOMNode* newNode, VARIANT refChild,
    IXMLDOMNode** outOldNode)
{
    domfrag *This = impl_from_IXMLDOMDocumentFragment( iface );

    TRACE("(%p)->(%p %s %p)\n", This, newNode, debugstr_variant(&refChild), outOldNode);

    /* TODO: test */
    return node_insert_before(&This->node, newNode, &refChild, outOldNode);
}
コード例 #9
0
int main()
{
    struct node* head = head_init();
    int i;

    for(i=0; i<5; i++)
    {
        node_add(head, i);
    }

    printf_list(head);
    node_del(head, 3);
    printf_list(head);
    node_insert_after(head,2,6);
    printf_list(head);
    node_insert_before(&head,0,5);
    printf_list(head);
    node_insert_before(&head,6,8);
    printf_list(head);
    node_reverse(&head);
    printf_list(head);
    node_reverse_by_test(&head);
    printf_list(head);
    
    struct node* p = search_mid_node(head);
    printf("mid=%d\n", p->data);
   /* delete head emlement */
    Remove_head(&head);
    printf_list(head);

    
    for(i=7; i<10; i++)
    {
        node_add(head, i);
    }	
    printf_list(head);
    p = search_mid_node(head);
    printf("mid=%d\n", p->data);
    return 0;
}
コード例 #10
0
ファイル: libusb_android.c プロジェクト: Tinkerforge/brickd
int libusb_submit_transfer(struct libusb_transfer *transfer) {
	usbi_transfer *itransfer = (usbi_transfer *)transfer;
	libusb_device_handle *dev_handle = transfer->dev_handle;
	libusb_context *ctx = dev_handle->dev->ctx;
	usbfs_urb *urb = &itransfer->urb;
	int rc;

	if (transfer->type != LIBUSB_TRANSFER_TYPE_BULK ||
		transfer->timeout != 0 || transfer->callback == NULL) {
		return LIBUSB_ERROR_INVALID_PARAM;
	}

	if (itransfer->submitted) {
		return LIBUSB_ERROR_BUSY;
	}

	libusb_ref_device(dev_handle->dev);

	itransfer->submitted = true;

	urb->status = INT32_MIN;
	urb->endpoint = transfer->endpoint;
	urb->buffer = transfer->buffer;
	urb->buffer_length = transfer->length;

	rc = ioctl(dev_handle->pollfd.fd, IOCTL_USBFS_SUBMITURB, urb);

	if (rc < 0) {
		if (errno == ENODEV) {
			rc = LIBUSB_ERROR_NO_DEVICE;
		} else {
			rc = LIBUSB_ERROR_IO;
		}

		itransfer->submitted = false;

		libusb_unref_device(dev_handle->dev);

		usbi_log_error(ctx, "Could not submit %s transfer %p (length: %d): %s (%d)",
		               (LIBUSB_ENDPOINT_IN & transfer->endpoint) != 0 ? "read" : "write",
		               transfer, transfer->length, get_errno_name(errno), errno);

		return rc;
	}

	node_insert_before(&dev_handle->itransfer_sentinel, &itransfer->node);

	return LIBUSB_SUCCESS;
}
コード例 #11
0
ファイル: libusb_android.c プロジェクト: Tinkerforge/brickd
int libusb_open(libusb_device *dev, libusb_device_handle **dev_handle_ptr) {
	libusb_context *ctx = dev->ctx;
	libusb_device_handle *dev_handle;
	jmethodID open_device_mid;
	int fd;

	dev_handle = calloc(1, sizeof(libusb_device_handle));

	if (dev_handle == NULL) {
		usbi_log_error(ctx, "Could not allocate device handle");

		return LIBUSB_ERROR_NO_MEM;
	}

	open_device_mid = (*android_env)->GetMethodID(android_env, (*android_env)->GetObjectClass(android_env, android_service), "openDevice",
	                                              "(Landroid/hardware/usb/UsbDevice;)I"); // FIXME: check result
	fd = (*android_env)->CallIntMethod(android_env, android_service, open_device_mid, dev->device); // FIXME: check result

	if (fd < 0) {
		free(dev_handle);

		return LIBUSB_ERROR_NO_DEVICE;
	}

	dev_handle->dev = libusb_ref_device(dev);
	dev_handle->pollfd.fd = fd;
	dev_handle->pollfd.events = POLLOUT;
	dev_handle->disconnected = false;

	node_reset(&dev_handle->itransfer_sentinel);

	node_insert_before(&ctx->dev_handle_sentinel, &dev_handle->node);
	++ctx->dev_handle_count;

	*dev_handle_ptr = dev_handle;

	usbi_log_debug(ctx, "Opened device %p (context: %p, name: %s, fd: %d)",
	               dev, ctx, dev->name, dev_handle->pollfd.fd);

	if (ctx->pollfd_added_callback != NULL) {
		ctx->pollfd_added_callback(dev_handle->pollfd.fd, dev_handle->pollfd.events, ctx->pollfd_user_data);
	}

	return LIBUSB_SUCCESS;
}
コード例 #12
0
ファイル: libusb_android.c プロジェクト: Tinkerforge/brickd
static int usbi_get_device_list(libusb_context *ctx, Node *sentinel) {
	int rc;
	jmethodID get_device_list_mid;
	jobjectArray device_infos;
	int device_infos_length;
	int i;
	jobject device_info;
	int vendor_id;
	int product_id;
	libusb_device *dev;
	int length = 0;

	get_device_list_mid = (*android_env)->GetMethodID(android_env, (*android_env)->GetObjectClass(android_env, android_service), "getDeviceList",
	                                                  "()[Lcom/tinkerforge/brickd/USBDeviceInfo;"); // FIXME: check result
	device_infos = (jobjectArray)(*android_env)->CallObjectMethod(android_env, android_service, get_device_list_mid);
	device_infos_length = (*android_env)->GetArrayLength(android_env, device_infos);

	for (i = 0; i < device_infos_length; ++i) {
		device_info = (*android_env)->GetObjectArrayElement(android_env, device_infos, i);

		usbi_get_int_field(device_info, "vendorID", &vendor_id); // FIXME: check result
		usbi_get_int_field(device_info, "productID", &product_id); // FIXME: check result

		if (vendor_id == 0x16D0 && (product_id == 0x063D || product_id == 0x09E5)) {
			rc = usbi_create_device(ctx, device_info, &dev);

			if (rc < 0) {
				return rc;
			}

			node_insert_before(sentinel, &dev->node);
			++length;
		}
	}

	return length;
}
コード例 #13
0
void
list_insert_back (linked_list_t list, node_t node)
{
    node_insert_before (list->data, node);
    list->count++;
}
コード例 #14
0
ファイル: btree.c プロジェクト: cj19881112/btree
static void	
node_insert_after(struct bnode_s *node, int pos, struct bnode_s *nnode)
{
	node_insert_before(node, pos+1, nnode);
}