← Back to branch summary

~yolanda.robla/ubuntu/trusty/nodejs/add_distribution

« back to all changes in this revision

Viewing changes to deps/uv/src/win/req.c

  • Committer: Package Import Robot
  • Author(s): Jérémy Lal
  • Date: 2013-08-14 00:16:46 UTC
  • mfrom: (7.1.40 sid)
  • Revision ID: package-import@ubuntu.com-20130814001646-bzlysfh8sd6mukbo
Tags: 0.10.15~dfsg1-4
* Update 2005 patch, adding a handful of tests that can fail on
  slow platforms.
* Add 1004 patch to fix test failures when writing NaN to buffer
  on mipsel.

Show diffs side-by-side

added added

removed removed

Lines of Context:
deps/uv/src/win/req.c
22
22
#include <assert.h>
23
23
 
24
24
#include "uv.h"
25
 
#include "../uv-common.h"
26
25
#include "internal.h"
27
 
 
28
 
 
29
 
void uv_req_init(uv_loop_t* loop, uv_req_t* req) {
30
 
  loop->counters.req_init++;
31
 
  req->type = UV_UNKNOWN_REQ;
32
 
  SET_REQ_SUCCESS(req);
33
 
}
34
 
 
35
 
 
36
 
uv_req_t* uv_overlapped_to_req(OVERLAPPED* overlapped) {
37
 
  return CONTAINING_RECORD(overlapped, uv_req_t, overlapped);
38
 
}
39
 
 
40
 
 
41
 
void uv_insert_pending_req(uv_loop_t* loop, uv_req_t* req) {
42
 
  req->next_req = NULL;
43
 
  if (loop->pending_reqs_tail) {
44
 
    req->next_req = loop->pending_reqs_tail->next_req;
45
 
    loop->pending_reqs_tail->next_req = req;
46
 
    loop->pending_reqs_tail = req;
47
 
  } else {
48
 
    req->next_req = req;
49
 
    loop->pending_reqs_tail = req;
50
 
  }
51
 
}
52
 
 
53
 
 
54
 
#define DELEGATE_STREAM_REQ(loop, req, method, handle_at)                     \
55
 
  do {                                                                        \
56
 
    switch (((uv_handle_t*) (req)->handle_at)->type) {                        \
57
 
      case UV_TCP:                                                            \
58
 
        uv_process_tcp_##method##_req(loop,                                   \
59
 
                                      (uv_tcp_t*) ((req)->handle_at),         \
60
 
                                      req);                                   \
61
 
        break;                                                                \
62
 
                                                                              \
63
 
      case UV_NAMED_PIPE:                                                     \
64
 
        uv_process_pipe_##method##_req(loop,                                  \
65
 
                                       (uv_pipe_t*) ((req)->handle_at),       \
66
 
                                       req);                                  \
67
 
        break;                                                                \
68
 
                                                                              \
69
 
      case UV_TTY:                                                            \
70
 
        uv_process_tty_##method##_req(loop,                                   \
71
 
                                      (uv_tty_t*) ((req)->handle_at),         \
72
 
                                      req);                                   \
73
 
        break;                                                                \
74
 
                                                                              \
75
 
      default:                                                                \
76
 
        assert(0);                                                            \
77
 
    }                                                                         \
78
 
  } while (0)
79
 
 
80
 
 
81
 
void uv_process_reqs(uv_loop_t* loop) {
82
 
  uv_req_t* req;
83
 
  uv_req_t* first;
84
 
  uv_req_t* next;
85
 
 
86
 
  if (loop->pending_reqs_tail == NULL) {
87
 
    return;
88
 
  }
89
 
 
90
 
  first = loop->pending_reqs_tail->next_req;
91
 
  next = first;
92
 
  loop->pending_reqs_tail = NULL;
93
 
 
94
 
  while (next != NULL) {
95
 
    req = next;
96
 
    next = req->next_req != first ? req->next_req : NULL;
97
 
 
98
 
    switch (req->type) {
99
 
      case UV_READ:
100
 
        DELEGATE_STREAM_REQ(loop, req, read, data);
101
 
        break;
102
 
 
103
 
      case UV_WRITE:
104
 
        DELEGATE_STREAM_REQ(loop, (uv_write_t*) req, write, handle);
105
 
        break;
106
 
 
107
 
      case UV_ACCEPT:
108
 
        DELEGATE_STREAM_REQ(loop, req, accept, data);
109
 
        break;
110
 
 
111
 
      case UV_CONNECT:
112
 
        DELEGATE_STREAM_REQ(loop, (uv_connect_t*) req, connect, handle);
113
 
        break;
114
 
 
115
 
      case UV_SHUTDOWN:
116
 
        /* Tcp shutdown requests don't come here. */
117
 
        assert(((uv_shutdown_t*) req)->handle->type == UV_NAMED_PIPE);
118
 
        uv_process_pipe_shutdown_req(
119
 
            loop,
120
 
            (uv_pipe_t*) ((uv_shutdown_t*) req)->handle,
121
 
            (uv_shutdown_t*) req);
122
 
        break;
123
 
 
124
 
      case UV_UDP_RECV:
125
 
        uv_process_udp_recv_req(loop, (uv_udp_t*) req->data, req);
126
 
        break;
127
 
 
128
 
      case UV_UDP_SEND:
129
 
        uv_process_udp_send_req(loop,
130
 
                                ((uv_udp_send_t*) req)->handle,
131
 
                                (uv_udp_send_t*) req);
132
 
        break;
133
 
 
134
 
      case UV_WAKEUP:
135
 
        uv_process_async_wakeup_req(loop, (uv_async_t*) req->data, req);
136
 
        break;
137
 
 
138
 
      case UV_ARES_EVENT_REQ:
139
 
        uv_process_ares_event_req(loop, (uv_ares_action_t*) req->data, req);
140
 
        break;
141
 
 
142
 
      case UV_ARES_CLEANUP_REQ:
143
 
        uv_process_ares_cleanup_req(loop, (uv_ares_task_t*) req->data, req);
144
 
        break;
145
 
 
146
 
      case UV_GETADDRINFO_REQ:
147
 
        uv_process_getaddrinfo_req(loop, (uv_getaddrinfo_t*) req->data, req);
148
 
        break;
149
 
 
150
 
      case UV_PROCESS_EXIT:
151
 
        uv_process_proc_exit(loop, (uv_process_t*) req->data);
152
 
        break;
153
 
 
154
 
      case UV_PROCESS_CLOSE:
155
 
        uv_process_proc_close(loop, (uv_process_t*) req->data);
156
 
        break;
157
 
 
158
 
      case UV_FS:
159
 
        uv_process_fs_req(loop, (uv_fs_t*) req);
160
 
        break;
161
 
 
162
 
      case UV_WORK:
163
 
        uv_process_work_req(loop, (uv_work_t*) req);
164
 
        break;
165
 
 
166
 
      case UV_FS_EVENT_REQ:
167
 
        uv_process_fs_event_req(loop, req, (uv_fs_event_t*) req->data);
168
 
        break;
169
 
 
170
 
      default:
171
 
        assert(0);
172
 
    }
173
 
  }
174
 
}