4 * Copyright (C) 1999 Alexandre Julliard
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
21 #ifndef __WINE_SERVER_REQUEST_H
22 #define __WINE_SERVER_REQUEST_H
27 #include "wine/server_protocol.h"
29 /* max request length */
30 #define MAX_REQUEST_LENGTH 8192
32 /* request handler definition */
33 #define DECL_HANDLER(name) \
34 void req_##name( const struct name##_request *req, struct name##_reply *reply )
36 /* request functions */
39 extern void fatal_protocol_error( struct thread
*thread
,
40 const char *err
, ... ) __attribute__((format (printf
,2,3)));
41 extern void fatal_protocol_perror( struct thread
*thread
,
42 const char *err
, ... ) __attribute__((format (printf
,2,3)));
43 extern void fatal_error( const char *err
, ... ) __attribute__((noreturn
,format(printf
,1,2)));
44 extern void fatal_perror( const char *err
, ... ) __attribute__((noreturn
,format(printf
,1,2)));
46 extern void fatal_protocol_error( struct thread
*thread
, const char *err
, ... );
47 extern void fatal_protocol_perror( struct thread
*thread
, const char *err
, ... );
48 extern void fatal_error( const char *err
, ... );
49 extern void fatal_perror( const char *err
, ... );
52 extern const char *get_config_dir(void);
53 extern void *set_reply_data_size( data_size_t size
);
54 extern int receive_fd( struct process
*process
);
55 extern int send_client_fd( struct process
*process
, int fd
, obj_handle_t handle
);
56 extern void read_request( struct thread
*thread
);
57 extern void write_reply( struct thread
*thread
);
58 extern unsigned int get_tick_count(void);
59 extern void open_master_socket(void);
60 extern void close_master_socket( timeout_t timeout
);
61 extern void shutdown_master_socket(void);
62 extern int wait_for_lock(void);
63 extern int kill_lock_owner( int sig
);
64 extern int server_dir_fd
, config_dir_fd
;
66 extern void trace_request(void);
67 extern void trace_reply( enum request req
, const union generic_reply
*reply
);
69 /* get the request vararg data */
70 static inline const void *get_req_data(void)
72 return current
->req_data
;
75 /* get the request vararg size */
76 static inline data_size_t
get_req_data_size(void)
78 return current
->req
.request_header
.request_size
;
81 /* get the request vararg as unicode string */
82 static inline void get_req_unicode_str( struct unicode_str
*str
)
84 str
->str
= get_req_data();
85 str
->len
= (get_req_data_size() / sizeof(WCHAR
)) * sizeof(WCHAR
);
88 /* get the reply maximum vararg size */
89 static inline data_size_t
get_reply_max_size(void)
91 return current
->req
.request_header
.reply_size
;
94 /* allocate and fill the reply data */
95 static inline void *set_reply_data( const void *data
, data_size_t size
)
97 void *ret
= set_reply_data_size( size
);
98 if (ret
) memcpy( ret
, data
, size
);
102 /* set the reply data pointer directly (will be freed by request code) */
103 static inline void set_reply_data_ptr( void *data
, data_size_t size
)
105 assert( size
<= get_reply_max_size() );
106 current
->reply_size
= size
;
107 current
->reply_data
= data
;
111 /* Everything below this line is generated automatically by tools/make_requests */
112 /* ### make_requests begin ### */
114 DECL_HANDLER(new_process
);
115 DECL_HANDLER(get_new_process_info
);
116 DECL_HANDLER(new_thread
);
117 DECL_HANDLER(get_startup_info
);
118 DECL_HANDLER(init_process_done
);
119 DECL_HANDLER(init_thread
);
120 DECL_HANDLER(terminate_process
);
121 DECL_HANDLER(terminate_thread
);
122 DECL_HANDLER(get_process_info
);
123 DECL_HANDLER(set_process_info
);
124 DECL_HANDLER(get_thread_info
);
125 DECL_HANDLER(set_thread_info
);
126 DECL_HANDLER(get_dll_info
);
127 DECL_HANDLER(suspend_thread
);
128 DECL_HANDLER(resume_thread
);
129 DECL_HANDLER(load_dll
);
130 DECL_HANDLER(unload_dll
);
131 DECL_HANDLER(queue_apc
);
132 DECL_HANDLER(get_apc_result
);
133 DECL_HANDLER(close_handle
);
134 DECL_HANDLER(set_handle_info
);
135 DECL_HANDLER(dup_handle
);
136 DECL_HANDLER(open_process
);
137 DECL_HANDLER(open_thread
);
138 DECL_HANDLER(select
);
139 DECL_HANDLER(create_event
);
140 DECL_HANDLER(event_op
);
141 DECL_HANDLER(open_event
);
142 DECL_HANDLER(create_mutex
);
143 DECL_HANDLER(release_mutex
);
144 DECL_HANDLER(open_mutex
);
145 DECL_HANDLER(create_semaphore
);
146 DECL_HANDLER(release_semaphore
);
147 DECL_HANDLER(open_semaphore
);
148 DECL_HANDLER(create_file
);
149 DECL_HANDLER(open_file_object
);
150 DECL_HANDLER(alloc_file_handle
);
151 DECL_HANDLER(get_handle_unix_name
);
152 DECL_HANDLER(get_handle_fd
);
153 DECL_HANDLER(flush_file
);
154 DECL_HANDLER(lock_file
);
155 DECL_HANDLER(unlock_file
);
156 DECL_HANDLER(create_socket
);
157 DECL_HANDLER(accept_socket
);
158 DECL_HANDLER(accept_into_socket
);
159 DECL_HANDLER(set_socket_event
);
160 DECL_HANDLER(get_socket_event
);
161 DECL_HANDLER(enable_socket_event
);
162 DECL_HANDLER(set_socket_deferred
);
163 DECL_HANDLER(alloc_console
);
164 DECL_HANDLER(free_console
);
165 DECL_HANDLER(get_console_renderer_events
);
166 DECL_HANDLER(open_console
);
167 DECL_HANDLER(get_console_wait_event
);
168 DECL_HANDLER(get_console_mode
);
169 DECL_HANDLER(set_console_mode
);
170 DECL_HANDLER(set_console_input_info
);
171 DECL_HANDLER(get_console_input_info
);
172 DECL_HANDLER(append_console_input_history
);
173 DECL_HANDLER(get_console_input_history
);
174 DECL_HANDLER(create_console_output
);
175 DECL_HANDLER(set_console_output_info
);
176 DECL_HANDLER(get_console_output_info
);
177 DECL_HANDLER(write_console_input
);
178 DECL_HANDLER(read_console_input
);
179 DECL_HANDLER(write_console_output
);
180 DECL_HANDLER(fill_console_output
);
181 DECL_HANDLER(read_console_output
);
182 DECL_HANDLER(move_console_output
);
183 DECL_HANDLER(send_console_signal
);
184 DECL_HANDLER(read_directory_changes
);
185 DECL_HANDLER(read_change
);
186 DECL_HANDLER(create_mapping
);
187 DECL_HANDLER(open_mapping
);
188 DECL_HANDLER(get_mapping_info
);
189 DECL_HANDLER(get_mapping_committed_range
);
190 DECL_HANDLER(add_mapping_committed_range
);
191 DECL_HANDLER(create_snapshot
);
192 DECL_HANDLER(next_process
);
193 DECL_HANDLER(next_thread
);
194 DECL_HANDLER(wait_debug_event
);
195 DECL_HANDLER(queue_exception_event
);
196 DECL_HANDLER(get_exception_status
);
197 DECL_HANDLER(output_debug_string
);
198 DECL_HANDLER(continue_debug_event
);
199 DECL_HANDLER(debug_process
);
200 DECL_HANDLER(debug_break
);
201 DECL_HANDLER(set_debugger_kill_on_exit
);
202 DECL_HANDLER(read_process_memory
);
203 DECL_HANDLER(write_process_memory
);
204 DECL_HANDLER(create_key
);
205 DECL_HANDLER(open_key
);
206 DECL_HANDLER(delete_key
);
207 DECL_HANDLER(flush_key
);
208 DECL_HANDLER(enum_key
);
209 DECL_HANDLER(set_key_value
);
210 DECL_HANDLER(get_key_value
);
211 DECL_HANDLER(enum_key_value
);
212 DECL_HANDLER(delete_key_value
);
213 DECL_HANDLER(load_registry
);
214 DECL_HANDLER(unload_registry
);
215 DECL_HANDLER(save_registry
);
216 DECL_HANDLER(set_registry_notification
);
217 DECL_HANDLER(create_timer
);
218 DECL_HANDLER(open_timer
);
219 DECL_HANDLER(set_timer
);
220 DECL_HANDLER(cancel_timer
);
221 DECL_HANDLER(get_timer_info
);
222 DECL_HANDLER(get_thread_context
);
223 DECL_HANDLER(set_thread_context
);
224 DECL_HANDLER(get_selector_entry
);
225 DECL_HANDLER(add_atom
);
226 DECL_HANDLER(delete_atom
);
227 DECL_HANDLER(find_atom
);
228 DECL_HANDLER(get_atom_information
);
229 DECL_HANDLER(set_atom_information
);
230 DECL_HANDLER(empty_atom_table
);
231 DECL_HANDLER(init_atom_table
);
232 DECL_HANDLER(get_msg_queue
);
233 DECL_HANDLER(set_queue_fd
);
234 DECL_HANDLER(set_queue_mask
);
235 DECL_HANDLER(get_queue_status
);
236 DECL_HANDLER(get_process_idle_event
);
237 DECL_HANDLER(send_message
);
238 DECL_HANDLER(post_quit_message
);
239 DECL_HANDLER(send_hardware_message
);
240 DECL_HANDLER(get_message
);
241 DECL_HANDLER(reply_message
);
242 DECL_HANDLER(accept_hardware_message
);
243 DECL_HANDLER(get_message_reply
);
244 DECL_HANDLER(set_win_timer
);
245 DECL_HANDLER(kill_win_timer
);
246 DECL_HANDLER(is_window_hung
);
247 DECL_HANDLER(get_serial_info
);
248 DECL_HANDLER(set_serial_info
);
249 DECL_HANDLER(register_async
);
250 DECL_HANDLER(cancel_async
);
252 DECL_HANDLER(get_ioctl_result
);
253 DECL_HANDLER(create_named_pipe
);
254 DECL_HANDLER(get_named_pipe_info
);
255 DECL_HANDLER(create_window
);
256 DECL_HANDLER(destroy_window
);
257 DECL_HANDLER(get_desktop_window
);
258 DECL_HANDLER(set_window_owner
);
259 DECL_HANDLER(get_window_info
);
260 DECL_HANDLER(set_window_info
);
261 DECL_HANDLER(set_parent
);
262 DECL_HANDLER(get_window_parents
);
263 DECL_HANDLER(get_window_children
);
264 DECL_HANDLER(get_window_children_from_point
);
265 DECL_HANDLER(get_window_tree
);
266 DECL_HANDLER(set_window_pos
);
267 DECL_HANDLER(get_window_rectangles
);
268 DECL_HANDLER(get_window_text
);
269 DECL_HANDLER(set_window_text
);
270 DECL_HANDLER(get_windows_offset
);
271 DECL_HANDLER(get_visible_region
);
272 DECL_HANDLER(get_window_region
);
273 DECL_HANDLER(set_window_region
);
274 DECL_HANDLER(get_update_region
);
275 DECL_HANDLER(update_window_zorder
);
276 DECL_HANDLER(redraw_window
);
277 DECL_HANDLER(set_window_property
);
278 DECL_HANDLER(remove_window_property
);
279 DECL_HANDLER(get_window_property
);
280 DECL_HANDLER(get_window_properties
);
281 DECL_HANDLER(create_winstation
);
282 DECL_HANDLER(open_winstation
);
283 DECL_HANDLER(close_winstation
);
284 DECL_HANDLER(get_process_winstation
);
285 DECL_HANDLER(set_process_winstation
);
286 DECL_HANDLER(enum_winstation
);
287 DECL_HANDLER(create_desktop
);
288 DECL_HANDLER(open_desktop
);
289 DECL_HANDLER(close_desktop
);
290 DECL_HANDLER(get_thread_desktop
);
291 DECL_HANDLER(set_thread_desktop
);
292 DECL_HANDLER(enum_desktop
);
293 DECL_HANDLER(set_user_object_info
);
294 DECL_HANDLER(attach_thread_input
);
295 DECL_HANDLER(get_thread_input
);
296 DECL_HANDLER(get_last_input_time
);
297 DECL_HANDLER(get_key_state
);
298 DECL_HANDLER(set_key_state
);
299 DECL_HANDLER(set_foreground_window
);
300 DECL_HANDLER(set_focus_window
);
301 DECL_HANDLER(set_active_window
);
302 DECL_HANDLER(set_capture_window
);
303 DECL_HANDLER(set_caret_window
);
304 DECL_HANDLER(set_caret_info
);
305 DECL_HANDLER(set_hook
);
306 DECL_HANDLER(remove_hook
);
307 DECL_HANDLER(start_hook_chain
);
308 DECL_HANDLER(finish_hook_chain
);
309 DECL_HANDLER(get_hook_info
);
310 DECL_HANDLER(create_class
);
311 DECL_HANDLER(destroy_class
);
312 DECL_HANDLER(set_class_info
);
313 DECL_HANDLER(set_clipboard_info
);
314 DECL_HANDLER(open_token
);
315 DECL_HANDLER(set_global_windows
);
316 DECL_HANDLER(adjust_token_privileges
);
317 DECL_HANDLER(get_token_privileges
);
318 DECL_HANDLER(check_token_privileges
);
319 DECL_HANDLER(duplicate_token
);
320 DECL_HANDLER(access_check
);
321 DECL_HANDLER(get_token_sid
);
322 DECL_HANDLER(get_token_groups
);
323 DECL_HANDLER(get_token_default_dacl
);
324 DECL_HANDLER(set_token_default_dacl
);
325 DECL_HANDLER(set_security_object
);
326 DECL_HANDLER(get_security_object
);
327 DECL_HANDLER(create_mailslot
);
328 DECL_HANDLER(set_mailslot_info
);
329 DECL_HANDLER(create_directory
);
330 DECL_HANDLER(open_directory
);
331 DECL_HANDLER(get_directory_entry
);
332 DECL_HANDLER(create_symlink
);
333 DECL_HANDLER(open_symlink
);
334 DECL_HANDLER(query_symlink
);
335 DECL_HANDLER(get_object_info
);
336 DECL_HANDLER(unlink_object
);
337 DECL_HANDLER(get_token_impersonation_level
);
338 DECL_HANDLER(allocate_locally_unique_id
);
339 DECL_HANDLER(create_device_manager
);
340 DECL_HANDLER(create_device
);
341 DECL_HANDLER(delete_device
);
342 DECL_HANDLER(get_next_device_request
);
343 DECL_HANDLER(make_process_system
);
344 DECL_HANDLER(get_token_statistics
);
345 DECL_HANDLER(create_completion
);
346 DECL_HANDLER(open_completion
);
347 DECL_HANDLER(add_completion
);
348 DECL_HANDLER(remove_completion
);
349 DECL_HANDLER(query_completion
);
350 DECL_HANDLER(set_completion_info
);
351 DECL_HANDLER(add_fd_completion
);
352 DECL_HANDLER(get_window_layered_info
);
353 DECL_HANDLER(set_window_layered_info
);
354 DECL_HANDLER(alloc_user_handle
);
355 DECL_HANDLER(free_user_handle
);
356 DECL_HANDLER(set_cursor
);
358 #ifdef WANT_REQUEST_HANDLERS
360 typedef void (*req_handler
)( const void *req
, void *reply
);
361 static const req_handler req_handlers
[REQ_NB_REQUESTS
] =
363 (req_handler
)req_new_process
,
364 (req_handler
)req_get_new_process_info
,
365 (req_handler
)req_new_thread
,
366 (req_handler
)req_get_startup_info
,
367 (req_handler
)req_init_process_done
,
368 (req_handler
)req_init_thread
,
369 (req_handler
)req_terminate_process
,
370 (req_handler
)req_terminate_thread
,
371 (req_handler
)req_get_process_info
,
372 (req_handler
)req_set_process_info
,
373 (req_handler
)req_get_thread_info
,
374 (req_handler
)req_set_thread_info
,
375 (req_handler
)req_get_dll_info
,
376 (req_handler
)req_suspend_thread
,
377 (req_handler
)req_resume_thread
,
378 (req_handler
)req_load_dll
,
379 (req_handler
)req_unload_dll
,
380 (req_handler
)req_queue_apc
,
381 (req_handler
)req_get_apc_result
,
382 (req_handler
)req_close_handle
,
383 (req_handler
)req_set_handle_info
,
384 (req_handler
)req_dup_handle
,
385 (req_handler
)req_open_process
,
386 (req_handler
)req_open_thread
,
387 (req_handler
)req_select
,
388 (req_handler
)req_create_event
,
389 (req_handler
)req_event_op
,
390 (req_handler
)req_open_event
,
391 (req_handler
)req_create_mutex
,
392 (req_handler
)req_release_mutex
,
393 (req_handler
)req_open_mutex
,
394 (req_handler
)req_create_semaphore
,
395 (req_handler
)req_release_semaphore
,
396 (req_handler
)req_open_semaphore
,
397 (req_handler
)req_create_file
,
398 (req_handler
)req_open_file_object
,
399 (req_handler
)req_alloc_file_handle
,
400 (req_handler
)req_get_handle_unix_name
,
401 (req_handler
)req_get_handle_fd
,
402 (req_handler
)req_flush_file
,
403 (req_handler
)req_lock_file
,
404 (req_handler
)req_unlock_file
,
405 (req_handler
)req_create_socket
,
406 (req_handler
)req_accept_socket
,
407 (req_handler
)req_accept_into_socket
,
408 (req_handler
)req_set_socket_event
,
409 (req_handler
)req_get_socket_event
,
410 (req_handler
)req_enable_socket_event
,
411 (req_handler
)req_set_socket_deferred
,
412 (req_handler
)req_alloc_console
,
413 (req_handler
)req_free_console
,
414 (req_handler
)req_get_console_renderer_events
,
415 (req_handler
)req_open_console
,
416 (req_handler
)req_get_console_wait_event
,
417 (req_handler
)req_get_console_mode
,
418 (req_handler
)req_set_console_mode
,
419 (req_handler
)req_set_console_input_info
,
420 (req_handler
)req_get_console_input_info
,
421 (req_handler
)req_append_console_input_history
,
422 (req_handler
)req_get_console_input_history
,
423 (req_handler
)req_create_console_output
,
424 (req_handler
)req_set_console_output_info
,
425 (req_handler
)req_get_console_output_info
,
426 (req_handler
)req_write_console_input
,
427 (req_handler
)req_read_console_input
,
428 (req_handler
)req_write_console_output
,
429 (req_handler
)req_fill_console_output
,
430 (req_handler
)req_read_console_output
,
431 (req_handler
)req_move_console_output
,
432 (req_handler
)req_send_console_signal
,
433 (req_handler
)req_read_directory_changes
,
434 (req_handler
)req_read_change
,
435 (req_handler
)req_create_mapping
,
436 (req_handler
)req_open_mapping
,
437 (req_handler
)req_get_mapping_info
,
438 (req_handler
)req_get_mapping_committed_range
,
439 (req_handler
)req_add_mapping_committed_range
,
440 (req_handler
)req_create_snapshot
,
441 (req_handler
)req_next_process
,
442 (req_handler
)req_next_thread
,
443 (req_handler
)req_wait_debug_event
,
444 (req_handler
)req_queue_exception_event
,
445 (req_handler
)req_get_exception_status
,
446 (req_handler
)req_output_debug_string
,
447 (req_handler
)req_continue_debug_event
,
448 (req_handler
)req_debug_process
,
449 (req_handler
)req_debug_break
,
450 (req_handler
)req_set_debugger_kill_on_exit
,
451 (req_handler
)req_read_process_memory
,
452 (req_handler
)req_write_process_memory
,
453 (req_handler
)req_create_key
,
454 (req_handler
)req_open_key
,
455 (req_handler
)req_delete_key
,
456 (req_handler
)req_flush_key
,
457 (req_handler
)req_enum_key
,
458 (req_handler
)req_set_key_value
,
459 (req_handler
)req_get_key_value
,
460 (req_handler
)req_enum_key_value
,
461 (req_handler
)req_delete_key_value
,
462 (req_handler
)req_load_registry
,
463 (req_handler
)req_unload_registry
,
464 (req_handler
)req_save_registry
,
465 (req_handler
)req_set_registry_notification
,
466 (req_handler
)req_create_timer
,
467 (req_handler
)req_open_timer
,
468 (req_handler
)req_set_timer
,
469 (req_handler
)req_cancel_timer
,
470 (req_handler
)req_get_timer_info
,
471 (req_handler
)req_get_thread_context
,
472 (req_handler
)req_set_thread_context
,
473 (req_handler
)req_get_selector_entry
,
474 (req_handler
)req_add_atom
,
475 (req_handler
)req_delete_atom
,
476 (req_handler
)req_find_atom
,
477 (req_handler
)req_get_atom_information
,
478 (req_handler
)req_set_atom_information
,
479 (req_handler
)req_empty_atom_table
,
480 (req_handler
)req_init_atom_table
,
481 (req_handler
)req_get_msg_queue
,
482 (req_handler
)req_set_queue_fd
,
483 (req_handler
)req_set_queue_mask
,
484 (req_handler
)req_get_queue_status
,
485 (req_handler
)req_get_process_idle_event
,
486 (req_handler
)req_send_message
,
487 (req_handler
)req_post_quit_message
,
488 (req_handler
)req_send_hardware_message
,
489 (req_handler
)req_get_message
,
490 (req_handler
)req_reply_message
,
491 (req_handler
)req_accept_hardware_message
,
492 (req_handler
)req_get_message_reply
,
493 (req_handler
)req_set_win_timer
,
494 (req_handler
)req_kill_win_timer
,
495 (req_handler
)req_is_window_hung
,
496 (req_handler
)req_get_serial_info
,
497 (req_handler
)req_set_serial_info
,
498 (req_handler
)req_register_async
,
499 (req_handler
)req_cancel_async
,
500 (req_handler
)req_ioctl
,
501 (req_handler
)req_get_ioctl_result
,
502 (req_handler
)req_create_named_pipe
,
503 (req_handler
)req_get_named_pipe_info
,
504 (req_handler
)req_create_window
,
505 (req_handler
)req_destroy_window
,
506 (req_handler
)req_get_desktop_window
,
507 (req_handler
)req_set_window_owner
,
508 (req_handler
)req_get_window_info
,
509 (req_handler
)req_set_window_info
,
510 (req_handler
)req_set_parent
,
511 (req_handler
)req_get_window_parents
,
512 (req_handler
)req_get_window_children
,
513 (req_handler
)req_get_window_children_from_point
,
514 (req_handler
)req_get_window_tree
,
515 (req_handler
)req_set_window_pos
,
516 (req_handler
)req_get_window_rectangles
,
517 (req_handler
)req_get_window_text
,
518 (req_handler
)req_set_window_text
,
519 (req_handler
)req_get_windows_offset
,
520 (req_handler
)req_get_visible_region
,
521 (req_handler
)req_get_window_region
,
522 (req_handler
)req_set_window_region
,
523 (req_handler
)req_get_update_region
,
524 (req_handler
)req_update_window_zorder
,
525 (req_handler
)req_redraw_window
,
526 (req_handler
)req_set_window_property
,
527 (req_handler
)req_remove_window_property
,
528 (req_handler
)req_get_window_property
,
529 (req_handler
)req_get_window_properties
,
530 (req_handler
)req_create_winstation
,
531 (req_handler
)req_open_winstation
,
532 (req_handler
)req_close_winstation
,
533 (req_handler
)req_get_process_winstation
,
534 (req_handler
)req_set_process_winstation
,
535 (req_handler
)req_enum_winstation
,
536 (req_handler
)req_create_desktop
,
537 (req_handler
)req_open_desktop
,
538 (req_handler
)req_close_desktop
,
539 (req_handler
)req_get_thread_desktop
,
540 (req_handler
)req_set_thread_desktop
,
541 (req_handler
)req_enum_desktop
,
542 (req_handler
)req_set_user_object_info
,
543 (req_handler
)req_attach_thread_input
,
544 (req_handler
)req_get_thread_input
,
545 (req_handler
)req_get_last_input_time
,
546 (req_handler
)req_get_key_state
,
547 (req_handler
)req_set_key_state
,
548 (req_handler
)req_set_foreground_window
,
549 (req_handler
)req_set_focus_window
,
550 (req_handler
)req_set_active_window
,
551 (req_handler
)req_set_capture_window
,
552 (req_handler
)req_set_caret_window
,
553 (req_handler
)req_set_caret_info
,
554 (req_handler
)req_set_hook
,
555 (req_handler
)req_remove_hook
,
556 (req_handler
)req_start_hook_chain
,
557 (req_handler
)req_finish_hook_chain
,
558 (req_handler
)req_get_hook_info
,
559 (req_handler
)req_create_class
,
560 (req_handler
)req_destroy_class
,
561 (req_handler
)req_set_class_info
,
562 (req_handler
)req_set_clipboard_info
,
563 (req_handler
)req_open_token
,
564 (req_handler
)req_set_global_windows
,
565 (req_handler
)req_adjust_token_privileges
,
566 (req_handler
)req_get_token_privileges
,
567 (req_handler
)req_check_token_privileges
,
568 (req_handler
)req_duplicate_token
,
569 (req_handler
)req_access_check
,
570 (req_handler
)req_get_token_sid
,
571 (req_handler
)req_get_token_groups
,
572 (req_handler
)req_get_token_default_dacl
,
573 (req_handler
)req_set_token_default_dacl
,
574 (req_handler
)req_set_security_object
,
575 (req_handler
)req_get_security_object
,
576 (req_handler
)req_create_mailslot
,
577 (req_handler
)req_set_mailslot_info
,
578 (req_handler
)req_create_directory
,
579 (req_handler
)req_open_directory
,
580 (req_handler
)req_get_directory_entry
,
581 (req_handler
)req_create_symlink
,
582 (req_handler
)req_open_symlink
,
583 (req_handler
)req_query_symlink
,
584 (req_handler
)req_get_object_info
,
585 (req_handler
)req_unlink_object
,
586 (req_handler
)req_get_token_impersonation_level
,
587 (req_handler
)req_allocate_locally_unique_id
,
588 (req_handler
)req_create_device_manager
,
589 (req_handler
)req_create_device
,
590 (req_handler
)req_delete_device
,
591 (req_handler
)req_get_next_device_request
,
592 (req_handler
)req_make_process_system
,
593 (req_handler
)req_get_token_statistics
,
594 (req_handler
)req_create_completion
,
595 (req_handler
)req_open_completion
,
596 (req_handler
)req_add_completion
,
597 (req_handler
)req_remove_completion
,
598 (req_handler
)req_query_completion
,
599 (req_handler
)req_set_completion_info
,
600 (req_handler
)req_add_fd_completion
,
601 (req_handler
)req_get_window_layered_info
,
602 (req_handler
)req_set_window_layered_info
,
603 (req_handler
)req_alloc_user_handle
,
604 (req_handler
)req_free_user_handle
,
605 (req_handler
)req_set_cursor
,
608 C_ASSERT( sizeof(affinity_t
) == 8 );
609 C_ASSERT( sizeof(apc_call_t
) == 40 );
610 C_ASSERT( sizeof(apc_param_t
) == 8 );
611 C_ASSERT( sizeof(apc_result_t
) == 40 );
612 C_ASSERT( sizeof(async_data_t
) == 40 );
613 C_ASSERT( sizeof(atom_t
) == 4 );
614 C_ASSERT( sizeof(char) == 1 );
615 C_ASSERT( sizeof(char_info_t
) == 4 );
616 C_ASSERT( sizeof(client_ptr_t
) == 8 );
617 C_ASSERT( sizeof(cpu_type_t
) == 4 );
618 C_ASSERT( sizeof(data_size_t
) == 4 );
619 C_ASSERT( sizeof(file_pos_t
) == 8 );
620 C_ASSERT( sizeof(int) == 4 );
621 C_ASSERT( sizeof(ioctl_code_t
) == 4 );
622 C_ASSERT( sizeof(lparam_t
) == 8 );
623 C_ASSERT( sizeof(luid_t
) == 8 );
624 C_ASSERT( sizeof(mem_size_t
) == 8 );
625 C_ASSERT( sizeof(mod_handle_t
) == 8 );
626 C_ASSERT( sizeof(obj_handle_t
) == 4 );
627 C_ASSERT( sizeof(process_id_t
) == 4 );
628 C_ASSERT( sizeof(rectangle_t
) == 16 );
629 C_ASSERT( sizeof(short int) == 2 );
630 C_ASSERT( sizeof(thread_id_t
) == 4 );
631 C_ASSERT( sizeof(timeout_t
) == 8 );
632 C_ASSERT( sizeof(unsigned char) == 1 );
633 C_ASSERT( sizeof(unsigned int) == 4 );
634 C_ASSERT( sizeof(unsigned short) == 2 );
635 C_ASSERT( sizeof(user_handle_t
) == 4 );
636 C_ASSERT( FIELD_OFFSET(struct new_process_request
, inherit_all
) == 12 );
637 C_ASSERT( FIELD_OFFSET(struct new_process_request
, create_flags
) == 16 );
638 C_ASSERT( FIELD_OFFSET(struct new_process_request
, socket_fd
) == 20 );
639 C_ASSERT( FIELD_OFFSET(struct new_process_request
, exe_file
) == 24 );
640 C_ASSERT( FIELD_OFFSET(struct new_process_request
, process_access
) == 28 );
641 C_ASSERT( FIELD_OFFSET(struct new_process_request
, process_attr
) == 32 );
642 C_ASSERT( FIELD_OFFSET(struct new_process_request
, thread_access
) == 36 );
643 C_ASSERT( FIELD_OFFSET(struct new_process_request
, thread_attr
) == 40 );
644 C_ASSERT( FIELD_OFFSET(struct new_process_request
, info_size
) == 44 );
645 C_ASSERT( sizeof(struct new_process_request
) == 48 );
646 C_ASSERT( FIELD_OFFSET(struct new_process_reply
, info
) == 8 );
647 C_ASSERT( FIELD_OFFSET(struct new_process_reply
, pid
) == 12 );
648 C_ASSERT( FIELD_OFFSET(struct new_process_reply
, phandle
) == 16 );
649 C_ASSERT( FIELD_OFFSET(struct new_process_reply
, tid
) == 20 );
650 C_ASSERT( FIELD_OFFSET(struct new_process_reply
, thandle
) == 24 );
651 C_ASSERT( sizeof(struct new_process_reply
) == 32 );
652 C_ASSERT( FIELD_OFFSET(struct get_new_process_info_request
, info
) == 12 );
653 C_ASSERT( sizeof(struct get_new_process_info_request
) == 16 );
654 C_ASSERT( FIELD_OFFSET(struct get_new_process_info_reply
, success
) == 8 );
655 C_ASSERT( FIELD_OFFSET(struct get_new_process_info_reply
, exit_code
) == 12 );
656 C_ASSERT( sizeof(struct get_new_process_info_reply
) == 16 );
657 C_ASSERT( FIELD_OFFSET(struct new_thread_request
, access
) == 12 );
658 C_ASSERT( FIELD_OFFSET(struct new_thread_request
, attributes
) == 16 );
659 C_ASSERT( FIELD_OFFSET(struct new_thread_request
, suspend
) == 20 );
660 C_ASSERT( FIELD_OFFSET(struct new_thread_request
, request_fd
) == 24 );
661 C_ASSERT( sizeof(struct new_thread_request
) == 32 );
662 C_ASSERT( FIELD_OFFSET(struct new_thread_reply
, tid
) == 8 );
663 C_ASSERT( FIELD_OFFSET(struct new_thread_reply
, handle
) == 12 );
664 C_ASSERT( sizeof(struct new_thread_reply
) == 16 );
665 C_ASSERT( sizeof(struct get_startup_info_request
) == 16 );
666 C_ASSERT( FIELD_OFFSET(struct get_startup_info_reply
, exe_file
) == 8 );
667 C_ASSERT( FIELD_OFFSET(struct get_startup_info_reply
, info_size
) == 12 );
668 C_ASSERT( sizeof(struct get_startup_info_reply
) == 16 );
669 C_ASSERT( FIELD_OFFSET(struct init_process_done_request
, gui
) == 12 );
670 C_ASSERT( FIELD_OFFSET(struct init_process_done_request
, module
) == 16 );
671 C_ASSERT( FIELD_OFFSET(struct init_process_done_request
, ldt_copy
) == 24 );
672 C_ASSERT( FIELD_OFFSET(struct init_process_done_request
, entry
) == 32 );
673 C_ASSERT( sizeof(struct init_process_done_request
) == 40 );
674 C_ASSERT( FIELD_OFFSET(struct init_thread_request
, unix_pid
) == 12 );
675 C_ASSERT( FIELD_OFFSET(struct init_thread_request
, unix_tid
) == 16 );
676 C_ASSERT( FIELD_OFFSET(struct init_thread_request
, debug_level
) == 20 );
677 C_ASSERT( FIELD_OFFSET(struct init_thread_request
, teb
) == 24 );
678 C_ASSERT( FIELD_OFFSET(struct init_thread_request
, entry
) == 32 );
679 C_ASSERT( FIELD_OFFSET(struct init_thread_request
, reply_fd
) == 40 );
680 C_ASSERT( FIELD_OFFSET(struct init_thread_request
, wait_fd
) == 44 );
681 C_ASSERT( FIELD_OFFSET(struct init_thread_request
, cpu
) == 48 );
682 C_ASSERT( sizeof(struct init_thread_request
) == 56 );
683 C_ASSERT( FIELD_OFFSET(struct init_thread_reply
, pid
) == 8 );
684 C_ASSERT( FIELD_OFFSET(struct init_thread_reply
, tid
) == 12 );
685 C_ASSERT( FIELD_OFFSET(struct init_thread_reply
, server_start
) == 16 );
686 C_ASSERT( FIELD_OFFSET(struct init_thread_reply
, info_size
) == 24 );
687 C_ASSERT( FIELD_OFFSET(struct init_thread_reply
, version
) == 28 );
688 C_ASSERT( FIELD_OFFSET(struct init_thread_reply
, all_cpus
) == 32 );
689 C_ASSERT( sizeof(struct init_thread_reply
) == 40 );
690 C_ASSERT( FIELD_OFFSET(struct terminate_process_request
, handle
) == 12 );
691 C_ASSERT( FIELD_OFFSET(struct terminate_process_request
, exit_code
) == 16 );
692 C_ASSERT( sizeof(struct terminate_process_request
) == 24 );
693 C_ASSERT( FIELD_OFFSET(struct terminate_process_reply
, self
) == 8 );
694 C_ASSERT( sizeof(struct terminate_process_reply
) == 16 );
695 C_ASSERT( FIELD_OFFSET(struct terminate_thread_request
, handle
) == 12 );
696 C_ASSERT( FIELD_OFFSET(struct terminate_thread_request
, exit_code
) == 16 );
697 C_ASSERT( sizeof(struct terminate_thread_request
) == 24 );
698 C_ASSERT( FIELD_OFFSET(struct terminate_thread_reply
, self
) == 8 );
699 C_ASSERT( FIELD_OFFSET(struct terminate_thread_reply
, last
) == 12 );
700 C_ASSERT( sizeof(struct terminate_thread_reply
) == 16 );
701 C_ASSERT( FIELD_OFFSET(struct get_process_info_request
, handle
) == 12 );
702 C_ASSERT( sizeof(struct get_process_info_request
) == 16 );
703 C_ASSERT( FIELD_OFFSET(struct get_process_info_reply
, pid
) == 8 );
704 C_ASSERT( FIELD_OFFSET(struct get_process_info_reply
, ppid
) == 12 );
705 C_ASSERT( FIELD_OFFSET(struct get_process_info_reply
, affinity
) == 16 );
706 C_ASSERT( FIELD_OFFSET(struct get_process_info_reply
, peb
) == 24 );
707 C_ASSERT( FIELD_OFFSET(struct get_process_info_reply
, start_time
) == 32 );
708 C_ASSERT( FIELD_OFFSET(struct get_process_info_reply
, end_time
) == 40 );
709 C_ASSERT( FIELD_OFFSET(struct get_process_info_reply
, exit_code
) == 48 );
710 C_ASSERT( FIELD_OFFSET(struct get_process_info_reply
, priority
) == 52 );
711 C_ASSERT( FIELD_OFFSET(struct get_process_info_reply
, cpu
) == 56 );
712 C_ASSERT( FIELD_OFFSET(struct get_process_info_reply
, debugger_present
) == 60 );
713 C_ASSERT( sizeof(struct get_process_info_reply
) == 64 );
714 C_ASSERT( FIELD_OFFSET(struct set_process_info_request
, handle
) == 12 );
715 C_ASSERT( FIELD_OFFSET(struct set_process_info_request
, mask
) == 16 );
716 C_ASSERT( FIELD_OFFSET(struct set_process_info_request
, priority
) == 20 );
717 C_ASSERT( FIELD_OFFSET(struct set_process_info_request
, affinity
) == 24 );
718 C_ASSERT( sizeof(struct set_process_info_request
) == 32 );
719 C_ASSERT( FIELD_OFFSET(struct get_thread_info_request
, handle
) == 12 );
720 C_ASSERT( FIELD_OFFSET(struct get_thread_info_request
, tid_in
) == 16 );
721 C_ASSERT( sizeof(struct get_thread_info_request
) == 24 );
722 C_ASSERT( FIELD_OFFSET(struct get_thread_info_reply
, pid
) == 8 );
723 C_ASSERT( FIELD_OFFSET(struct get_thread_info_reply
, tid
) == 12 );
724 C_ASSERT( FIELD_OFFSET(struct get_thread_info_reply
, teb
) == 16 );
725 C_ASSERT( FIELD_OFFSET(struct get_thread_info_reply
, affinity
) == 24 );
726 C_ASSERT( FIELD_OFFSET(struct get_thread_info_reply
, creation_time
) == 32 );
727 C_ASSERT( FIELD_OFFSET(struct get_thread_info_reply
, exit_time
) == 40 );
728 C_ASSERT( FIELD_OFFSET(struct get_thread_info_reply
, exit_code
) == 48 );
729 C_ASSERT( FIELD_OFFSET(struct get_thread_info_reply
, priority
) == 52 );
730 C_ASSERT( FIELD_OFFSET(struct get_thread_info_reply
, last
) == 56 );
731 C_ASSERT( sizeof(struct get_thread_info_reply
) == 64 );
732 C_ASSERT( FIELD_OFFSET(struct set_thread_info_request
, handle
) == 12 );
733 C_ASSERT( FIELD_OFFSET(struct set_thread_info_request
, mask
) == 16 );
734 C_ASSERT( FIELD_OFFSET(struct set_thread_info_request
, priority
) == 20 );
735 C_ASSERT( FIELD_OFFSET(struct set_thread_info_request
, affinity
) == 24 );
736 C_ASSERT( FIELD_OFFSET(struct set_thread_info_request
, token
) == 32 );
737 C_ASSERT( sizeof(struct set_thread_info_request
) == 40 );
738 C_ASSERT( FIELD_OFFSET(struct get_dll_info_request
, handle
) == 12 );
739 C_ASSERT( FIELD_OFFSET(struct get_dll_info_request
, base_address
) == 16 );
740 C_ASSERT( sizeof(struct get_dll_info_request
) == 24 );
741 C_ASSERT( FIELD_OFFSET(struct get_dll_info_reply
, entry_point
) == 8 );
742 C_ASSERT( FIELD_OFFSET(struct get_dll_info_reply
, size
) == 16 );
743 C_ASSERT( FIELD_OFFSET(struct get_dll_info_reply
, filename_len
) == 20 );
744 C_ASSERT( sizeof(struct get_dll_info_reply
) == 24 );
745 C_ASSERT( FIELD_OFFSET(struct suspend_thread_request
, handle
) == 12 );
746 C_ASSERT( sizeof(struct suspend_thread_request
) == 16 );
747 C_ASSERT( FIELD_OFFSET(struct suspend_thread_reply
, count
) == 8 );
748 C_ASSERT( sizeof(struct suspend_thread_reply
) == 16 );
749 C_ASSERT( FIELD_OFFSET(struct resume_thread_request
, handle
) == 12 );
750 C_ASSERT( sizeof(struct resume_thread_request
) == 16 );
751 C_ASSERT( FIELD_OFFSET(struct resume_thread_reply
, count
) == 8 );
752 C_ASSERT( sizeof(struct resume_thread_reply
) == 16 );
753 C_ASSERT( FIELD_OFFSET(struct load_dll_request
, handle
) == 12 );
754 C_ASSERT( FIELD_OFFSET(struct load_dll_request
, base
) == 16 );
755 C_ASSERT( FIELD_OFFSET(struct load_dll_request
, name
) == 24 );
756 C_ASSERT( FIELD_OFFSET(struct load_dll_request
, size
) == 32 );
757 C_ASSERT( FIELD_OFFSET(struct load_dll_request
, dbg_offset
) == 36 );
758 C_ASSERT( FIELD_OFFSET(struct load_dll_request
, dbg_size
) == 40 );
759 C_ASSERT( sizeof(struct load_dll_request
) == 48 );
760 C_ASSERT( FIELD_OFFSET(struct unload_dll_request
, base
) == 16 );
761 C_ASSERT( sizeof(struct unload_dll_request
) == 24 );
762 C_ASSERT( FIELD_OFFSET(struct queue_apc_request
, handle
) == 12 );
763 C_ASSERT( FIELD_OFFSET(struct queue_apc_request
, call
) == 16 );
764 C_ASSERT( sizeof(struct queue_apc_request
) == 56 );
765 C_ASSERT( FIELD_OFFSET(struct queue_apc_reply
, handle
) == 8 );
766 C_ASSERT( FIELD_OFFSET(struct queue_apc_reply
, self
) == 12 );
767 C_ASSERT( sizeof(struct queue_apc_reply
) == 16 );
768 C_ASSERT( FIELD_OFFSET(struct get_apc_result_request
, handle
) == 12 );
769 C_ASSERT( sizeof(struct get_apc_result_request
) == 16 );
770 C_ASSERT( FIELD_OFFSET(struct get_apc_result_reply
, result
) == 8 );
771 C_ASSERT( sizeof(struct get_apc_result_reply
) == 48 );
772 C_ASSERT( FIELD_OFFSET(struct close_handle_request
, handle
) == 12 );
773 C_ASSERT( sizeof(struct close_handle_request
) == 16 );
774 C_ASSERT( FIELD_OFFSET(struct set_handle_info_request
, handle
) == 12 );
775 C_ASSERT( FIELD_OFFSET(struct set_handle_info_request
, flags
) == 16 );
776 C_ASSERT( FIELD_OFFSET(struct set_handle_info_request
, mask
) == 20 );
777 C_ASSERT( sizeof(struct set_handle_info_request
) == 24 );
778 C_ASSERT( FIELD_OFFSET(struct set_handle_info_reply
, old_flags
) == 8 );
779 C_ASSERT( sizeof(struct set_handle_info_reply
) == 16 );
780 C_ASSERT( FIELD_OFFSET(struct dup_handle_request
, src_process
) == 12 );
781 C_ASSERT( FIELD_OFFSET(struct dup_handle_request
, src_handle
) == 16 );
782 C_ASSERT( FIELD_OFFSET(struct dup_handle_request
, dst_process
) == 20 );
783 C_ASSERT( FIELD_OFFSET(struct dup_handle_request
, access
) == 24 );
784 C_ASSERT( FIELD_OFFSET(struct dup_handle_request
, attributes
) == 28 );
785 C_ASSERT( FIELD_OFFSET(struct dup_handle_request
, options
) == 32 );
786 C_ASSERT( sizeof(struct dup_handle_request
) == 40 );
787 C_ASSERT( FIELD_OFFSET(struct dup_handle_reply
, handle
) == 8 );
788 C_ASSERT( FIELD_OFFSET(struct dup_handle_reply
, self
) == 12 );
789 C_ASSERT( FIELD_OFFSET(struct dup_handle_reply
, closed
) == 16 );
790 C_ASSERT( sizeof(struct dup_handle_reply
) == 24 );
791 C_ASSERT( FIELD_OFFSET(struct open_process_request
, pid
) == 12 );
792 C_ASSERT( FIELD_OFFSET(struct open_process_request
, access
) == 16 );
793 C_ASSERT( FIELD_OFFSET(struct open_process_request
, attributes
) == 20 );
794 C_ASSERT( sizeof(struct open_process_request
) == 24 );
795 C_ASSERT( FIELD_OFFSET(struct open_process_reply
, handle
) == 8 );
796 C_ASSERT( sizeof(struct open_process_reply
) == 16 );
797 C_ASSERT( FIELD_OFFSET(struct open_thread_request
, tid
) == 12 );
798 C_ASSERT( FIELD_OFFSET(struct open_thread_request
, access
) == 16 );
799 C_ASSERT( FIELD_OFFSET(struct open_thread_request
, attributes
) == 20 );
800 C_ASSERT( sizeof(struct open_thread_request
) == 24 );
801 C_ASSERT( FIELD_OFFSET(struct open_thread_reply
, handle
) == 8 );
802 C_ASSERT( sizeof(struct open_thread_reply
) == 16 );
803 C_ASSERT( FIELD_OFFSET(struct select_request
, flags
) == 12 );
804 C_ASSERT( FIELD_OFFSET(struct select_request
, cookie
) == 16 );
805 C_ASSERT( FIELD_OFFSET(struct select_request
, signal
) == 24 );
806 C_ASSERT( FIELD_OFFSET(struct select_request
, prev_apc
) == 28 );
807 C_ASSERT( FIELD_OFFSET(struct select_request
, timeout
) == 32 );
808 C_ASSERT( sizeof(struct select_request
) == 40 );
809 C_ASSERT( FIELD_OFFSET(struct select_reply
, timeout
) == 8 );
810 C_ASSERT( FIELD_OFFSET(struct select_reply
, call
) == 16 );
811 C_ASSERT( FIELD_OFFSET(struct select_reply
, apc_handle
) == 56 );
812 C_ASSERT( sizeof(struct select_reply
) == 64 );
813 C_ASSERT( FIELD_OFFSET(struct create_event_request
, access
) == 12 );
814 C_ASSERT( FIELD_OFFSET(struct create_event_request
, attributes
) == 16 );
815 C_ASSERT( FIELD_OFFSET(struct create_event_request
, manual_reset
) == 20 );
816 C_ASSERT( FIELD_OFFSET(struct create_event_request
, initial_state
) == 24 );
817 C_ASSERT( sizeof(struct create_event_request
) == 32 );
818 C_ASSERT( FIELD_OFFSET(struct create_event_reply
, handle
) == 8 );
819 C_ASSERT( sizeof(struct create_event_reply
) == 16 );
820 C_ASSERT( FIELD_OFFSET(struct event_op_request
, handle
) == 12 );
821 C_ASSERT( FIELD_OFFSET(struct event_op_request
, op
) == 16 );
822 C_ASSERT( sizeof(struct event_op_request
) == 24 );
823 C_ASSERT( FIELD_OFFSET(struct open_event_request
, access
) == 12 );
824 C_ASSERT( FIELD_OFFSET(struct open_event_request
, attributes
) == 16 );
825 C_ASSERT( FIELD_OFFSET(struct open_event_request
, rootdir
) == 20 );
826 C_ASSERT( sizeof(struct open_event_request
) == 24 );
827 C_ASSERT( FIELD_OFFSET(struct open_event_reply
, handle
) == 8 );
828 C_ASSERT( sizeof(struct open_event_reply
) == 16 );
829 C_ASSERT( FIELD_OFFSET(struct create_mutex_request
, access
) == 12 );
830 C_ASSERT( FIELD_OFFSET(struct create_mutex_request
, attributes
) == 16 );
831 C_ASSERT( FIELD_OFFSET(struct create_mutex_request
, owned
) == 20 );
832 C_ASSERT( sizeof(struct create_mutex_request
) == 24 );
833 C_ASSERT( FIELD_OFFSET(struct create_mutex_reply
, handle
) == 8 );
834 C_ASSERT( sizeof(struct create_mutex_reply
) == 16 );
835 C_ASSERT( FIELD_OFFSET(struct release_mutex_request
, handle
) == 12 );
836 C_ASSERT( sizeof(struct release_mutex_request
) == 16 );
837 C_ASSERT( FIELD_OFFSET(struct release_mutex_reply
, prev_count
) == 8 );
838 C_ASSERT( sizeof(struct release_mutex_reply
) == 16 );
839 C_ASSERT( FIELD_OFFSET(struct open_mutex_request
, access
) == 12 );
840 C_ASSERT( FIELD_OFFSET(struct open_mutex_request
, attributes
) == 16 );
841 C_ASSERT( FIELD_OFFSET(struct open_mutex_request
, rootdir
) == 20 );
842 C_ASSERT( sizeof(struct open_mutex_request
) == 24 );
843 C_ASSERT( FIELD_OFFSET(struct open_mutex_reply
, handle
) == 8 );
844 C_ASSERT( sizeof(struct open_mutex_reply
) == 16 );
845 C_ASSERT( FIELD_OFFSET(struct create_semaphore_request
, access
) == 12 );
846 C_ASSERT( FIELD_OFFSET(struct create_semaphore_request
, attributes
) == 16 );
847 C_ASSERT( FIELD_OFFSET(struct create_semaphore_request
, initial
) == 20 );
848 C_ASSERT( FIELD_OFFSET(struct create_semaphore_request
, max
) == 24 );
849 C_ASSERT( sizeof(struct create_semaphore_request
) == 32 );
850 C_ASSERT( FIELD_OFFSET(struct create_semaphore_reply
, handle
) == 8 );
851 C_ASSERT( sizeof(struct create_semaphore_reply
) == 16 );
852 C_ASSERT( FIELD_OFFSET(struct release_semaphore_request
, handle
) == 12 );
853 C_ASSERT( FIELD_OFFSET(struct release_semaphore_request
, count
) == 16 );
854 C_ASSERT( sizeof(struct release_semaphore_request
) == 24 );
855 C_ASSERT( FIELD_OFFSET(struct release_semaphore_reply
, prev_count
) == 8 );
856 C_ASSERT( sizeof(struct release_semaphore_reply
) == 16 );
857 C_ASSERT( FIELD_OFFSET(struct open_semaphore_request
, access
) == 12 );
858 C_ASSERT( FIELD_OFFSET(struct open_semaphore_request
, attributes
) == 16 );
859 C_ASSERT( FIELD_OFFSET(struct open_semaphore_request
, rootdir
) == 20 );
860 C_ASSERT( sizeof(struct open_semaphore_request
) == 24 );
861 C_ASSERT( FIELD_OFFSET(struct open_semaphore_reply
, handle
) == 8 );
862 C_ASSERT( sizeof(struct open_semaphore_reply
) == 16 );
863 C_ASSERT( FIELD_OFFSET(struct create_file_request
, access
) == 12 );
864 C_ASSERT( FIELD_OFFSET(struct create_file_request
, attributes
) == 16 );
865 C_ASSERT( FIELD_OFFSET(struct create_file_request
, sharing
) == 20 );
866 C_ASSERT( FIELD_OFFSET(struct create_file_request
, create
) == 24 );
867 C_ASSERT( FIELD_OFFSET(struct create_file_request
, options
) == 28 );
868 C_ASSERT( FIELD_OFFSET(struct create_file_request
, attrs
) == 32 );
869 C_ASSERT( sizeof(struct create_file_request
) == 40 );
870 C_ASSERT( FIELD_OFFSET(struct create_file_reply
, handle
) == 8 );
871 C_ASSERT( sizeof(struct create_file_reply
) == 16 );
872 C_ASSERT( FIELD_OFFSET(struct open_file_object_request
, access
) == 12 );
873 C_ASSERT( FIELD_OFFSET(struct open_file_object_request
, attributes
) == 16 );
874 C_ASSERT( FIELD_OFFSET(struct open_file_object_request
, rootdir
) == 20 );
875 C_ASSERT( FIELD_OFFSET(struct open_file_object_request
, sharing
) == 24 );
876 C_ASSERT( FIELD_OFFSET(struct open_file_object_request
, options
) == 28 );
877 C_ASSERT( sizeof(struct open_file_object_request
) == 32 );
878 C_ASSERT( FIELD_OFFSET(struct open_file_object_reply
, handle
) == 8 );
879 C_ASSERT( sizeof(struct open_file_object_reply
) == 16 );
880 C_ASSERT( FIELD_OFFSET(struct alloc_file_handle_request
, access
) == 12 );
881 C_ASSERT( FIELD_OFFSET(struct alloc_file_handle_request
, attributes
) == 16 );
882 C_ASSERT( FIELD_OFFSET(struct alloc_file_handle_request
, fd
) == 20 );
883 C_ASSERT( sizeof(struct alloc_file_handle_request
) == 24 );
884 C_ASSERT( FIELD_OFFSET(struct alloc_file_handle_reply
, handle
) == 8 );
885 C_ASSERT( sizeof(struct alloc_file_handle_reply
) == 16 );
886 C_ASSERT( FIELD_OFFSET(struct get_handle_unix_name_request
, handle
) == 12 );
887 C_ASSERT( sizeof(struct get_handle_unix_name_request
) == 16 );
888 C_ASSERT( FIELD_OFFSET(struct get_handle_unix_name_reply
, name_len
) == 8 );
889 C_ASSERT( sizeof(struct get_handle_unix_name_reply
) == 16 );
890 C_ASSERT( FIELD_OFFSET(struct get_handle_fd_request
, handle
) == 12 );
891 C_ASSERT( sizeof(struct get_handle_fd_request
) == 16 );
892 C_ASSERT( FIELD_OFFSET(struct get_handle_fd_reply
, type
) == 8 );
893 C_ASSERT( FIELD_OFFSET(struct get_handle_fd_reply
, cacheable
) == 12 );
894 C_ASSERT( FIELD_OFFSET(struct get_handle_fd_reply
, access
) == 16 );
895 C_ASSERT( FIELD_OFFSET(struct get_handle_fd_reply
, options
) == 20 );
896 C_ASSERT( sizeof(struct get_handle_fd_reply
) == 24 );
897 C_ASSERT( FIELD_OFFSET(struct flush_file_request
, handle
) == 12 );
898 C_ASSERT( sizeof(struct flush_file_request
) == 16 );
899 C_ASSERT( FIELD_OFFSET(struct flush_file_reply
, event
) == 8 );
900 C_ASSERT( sizeof(struct flush_file_reply
) == 16 );
901 C_ASSERT( FIELD_OFFSET(struct lock_file_request
, handle
) == 12 );
902 C_ASSERT( FIELD_OFFSET(struct lock_file_request
, offset
) == 16 );
903 C_ASSERT( FIELD_OFFSET(struct lock_file_request
, count
) == 24 );
904 C_ASSERT( FIELD_OFFSET(struct lock_file_request
, shared
) == 32 );
905 C_ASSERT( FIELD_OFFSET(struct lock_file_request
, wait
) == 36 );
906 C_ASSERT( sizeof(struct lock_file_request
) == 40 );
907 C_ASSERT( FIELD_OFFSET(struct lock_file_reply
, handle
) == 8 );
908 C_ASSERT( FIELD_OFFSET(struct lock_file_reply
, overlapped
) == 12 );
909 C_ASSERT( sizeof(struct lock_file_reply
) == 16 );
910 C_ASSERT( FIELD_OFFSET(struct unlock_file_request
, handle
) == 12 );
911 C_ASSERT( FIELD_OFFSET(struct unlock_file_request
, offset
) == 16 );
912 C_ASSERT( FIELD_OFFSET(struct unlock_file_request
, count
) == 24 );
913 C_ASSERT( sizeof(struct unlock_file_request
) == 32 );
914 C_ASSERT( FIELD_OFFSET(struct create_socket_request
, access
) == 12 );
915 C_ASSERT( FIELD_OFFSET(struct create_socket_request
, attributes
) == 16 );
916 C_ASSERT( FIELD_OFFSET(struct create_socket_request
, family
) == 20 );
917 C_ASSERT( FIELD_OFFSET(struct create_socket_request
, type
) == 24 );
918 C_ASSERT( FIELD_OFFSET(struct create_socket_request
, protocol
) == 28 );
919 C_ASSERT( FIELD_OFFSET(struct create_socket_request
, flags
) == 32 );
920 C_ASSERT( sizeof(struct create_socket_request
) == 40 );
921 C_ASSERT( FIELD_OFFSET(struct create_socket_reply
, handle
) == 8 );
922 C_ASSERT( sizeof(struct create_socket_reply
) == 16 );
923 C_ASSERT( FIELD_OFFSET(struct accept_socket_request
, lhandle
) == 12 );
924 C_ASSERT( FIELD_OFFSET(struct accept_socket_request
, access
) == 16 );
925 C_ASSERT( FIELD_OFFSET(struct accept_socket_request
, attributes
) == 20 );
926 C_ASSERT( sizeof(struct accept_socket_request
) == 24 );
927 C_ASSERT( FIELD_OFFSET(struct accept_socket_reply
, handle
) == 8 );
928 C_ASSERT( sizeof(struct accept_socket_reply
) == 16 );
929 C_ASSERT( FIELD_OFFSET(struct accept_into_socket_request
, lhandle
) == 12 );
930 C_ASSERT( FIELD_OFFSET(struct accept_into_socket_request
, ahandle
) == 16 );
931 C_ASSERT( sizeof(struct accept_into_socket_request
) == 24 );
932 C_ASSERT( FIELD_OFFSET(struct set_socket_event_request
, handle
) == 12 );
933 C_ASSERT( FIELD_OFFSET(struct set_socket_event_request
, mask
) == 16 );
934 C_ASSERT( FIELD_OFFSET(struct set_socket_event_request
, event
) == 20 );
935 C_ASSERT( FIELD_OFFSET(struct set_socket_event_request
, window
) == 24 );
936 C_ASSERT( FIELD_OFFSET(struct set_socket_event_request
, msg
) == 28 );
937 C_ASSERT( sizeof(struct set_socket_event_request
) == 32 );
938 C_ASSERT( FIELD_OFFSET(struct get_socket_event_request
, handle
) == 12 );
939 C_ASSERT( FIELD_OFFSET(struct get_socket_event_request
, service
) == 16 );
940 C_ASSERT( FIELD_OFFSET(struct get_socket_event_request
, c_event
) == 20 );
941 C_ASSERT( sizeof(struct get_socket_event_request
) == 24 );
942 C_ASSERT( FIELD_OFFSET(struct get_socket_event_reply
, mask
) == 8 );
943 C_ASSERT( FIELD_OFFSET(struct get_socket_event_reply
, pmask
) == 12 );
944 C_ASSERT( FIELD_OFFSET(struct get_socket_event_reply
, state
) == 16 );
945 C_ASSERT( sizeof(struct get_socket_event_reply
) == 24 );
946 C_ASSERT( FIELD_OFFSET(struct enable_socket_event_request
, handle
) == 12 );
947 C_ASSERT( FIELD_OFFSET(struct enable_socket_event_request
, mask
) == 16 );
948 C_ASSERT( FIELD_OFFSET(struct enable_socket_event_request
, sstate
) == 20 );
949 C_ASSERT( FIELD_OFFSET(struct enable_socket_event_request
, cstate
) == 24 );
950 C_ASSERT( sizeof(struct enable_socket_event_request
) == 32 );
951 C_ASSERT( FIELD_OFFSET(struct set_socket_deferred_request
, handle
) == 12 );
952 C_ASSERT( FIELD_OFFSET(struct set_socket_deferred_request
, deferred
) == 16 );
953 C_ASSERT( sizeof(struct set_socket_deferred_request
) == 24 );
954 C_ASSERT( FIELD_OFFSET(struct alloc_console_request
, access
) == 12 );
955 C_ASSERT( FIELD_OFFSET(struct alloc_console_request
, attributes
) == 16 );
956 C_ASSERT( FIELD_OFFSET(struct alloc_console_request
, pid
) == 20 );
957 C_ASSERT( FIELD_OFFSET(struct alloc_console_request
, input_fd
) == 24 );
958 C_ASSERT( sizeof(struct alloc_console_request
) == 32 );
959 C_ASSERT( FIELD_OFFSET(struct alloc_console_reply
, handle_in
) == 8 );
960 C_ASSERT( FIELD_OFFSET(struct alloc_console_reply
, event
) == 12 );
961 C_ASSERT( sizeof(struct alloc_console_reply
) == 16 );
962 C_ASSERT( sizeof(struct free_console_request
) == 16 );
963 C_ASSERT( FIELD_OFFSET(struct get_console_renderer_events_request
, handle
) == 12 );
964 C_ASSERT( sizeof(struct get_console_renderer_events_request
) == 16 );
965 C_ASSERT( sizeof(struct get_console_renderer_events_reply
) == 8 );
966 C_ASSERT( FIELD_OFFSET(struct open_console_request
, from
) == 12 );
967 C_ASSERT( FIELD_OFFSET(struct open_console_request
, access
) == 16 );
968 C_ASSERT( FIELD_OFFSET(struct open_console_request
, attributes
) == 20 );
969 C_ASSERT( FIELD_OFFSET(struct open_console_request
, share
) == 24 );
970 C_ASSERT( sizeof(struct open_console_request
) == 32 );
971 C_ASSERT( FIELD_OFFSET(struct open_console_reply
, handle
) == 8 );
972 C_ASSERT( sizeof(struct open_console_reply
) == 16 );
973 C_ASSERT( sizeof(struct get_console_wait_event_request
) == 16 );
974 C_ASSERT( FIELD_OFFSET(struct get_console_wait_event_reply
, handle
) == 8 );
975 C_ASSERT( sizeof(struct get_console_wait_event_reply
) == 16 );
976 C_ASSERT( FIELD_OFFSET(struct get_console_mode_request
, handle
) == 12 );
977 C_ASSERT( sizeof(struct get_console_mode_request
) == 16 );
978 C_ASSERT( FIELD_OFFSET(struct get_console_mode_reply
, mode
) == 8 );
979 C_ASSERT( sizeof(struct get_console_mode_reply
) == 16 );
980 C_ASSERT( FIELD_OFFSET(struct set_console_mode_request
, handle
) == 12 );
981 C_ASSERT( FIELD_OFFSET(struct set_console_mode_request
, mode
) == 16 );
982 C_ASSERT( sizeof(struct set_console_mode_request
) == 24 );
983 C_ASSERT( FIELD_OFFSET(struct set_console_input_info_request
, handle
) == 12 );
984 C_ASSERT( FIELD_OFFSET(struct set_console_input_info_request
, mask
) == 16 );
985 C_ASSERT( FIELD_OFFSET(struct set_console_input_info_request
, active_sb
) == 20 );
986 C_ASSERT( FIELD_OFFSET(struct set_console_input_info_request
, history_mode
) == 24 );
987 C_ASSERT( FIELD_OFFSET(struct set_console_input_info_request
, history_size
) == 28 );
988 C_ASSERT( FIELD_OFFSET(struct set_console_input_info_request
, edition_mode
) == 32 );
989 C_ASSERT( FIELD_OFFSET(struct set_console_input_info_request
, input_cp
) == 36 );
990 C_ASSERT( FIELD_OFFSET(struct set_console_input_info_request
, output_cp
) == 40 );
991 C_ASSERT( FIELD_OFFSET(struct set_console_input_info_request
, win
) == 44 );
992 C_ASSERT( sizeof(struct set_console_input_info_request
) == 48 );
993 C_ASSERT( FIELD_OFFSET(struct get_console_input_info_request
, handle
) == 12 );
994 C_ASSERT( sizeof(struct get_console_input_info_request
) == 16 );
995 C_ASSERT( FIELD_OFFSET(struct get_console_input_info_reply
, history_mode
) == 8 );
996 C_ASSERT( FIELD_OFFSET(struct get_console_input_info_reply
, history_size
) == 12 );
997 C_ASSERT( FIELD_OFFSET(struct get_console_input_info_reply
, history_index
) == 16 );
998 C_ASSERT( FIELD_OFFSET(struct get_console_input_info_reply
, edition_mode
) == 20 );
999 C_ASSERT( FIELD_OFFSET(struct get_console_input_info_reply
, input_cp
) == 24 );
1000 C_ASSERT( FIELD_OFFSET(struct get_console_input_info_reply
, output_cp
) == 28 );
1001 C_ASSERT( FIELD_OFFSET(struct get_console_input_info_reply
, win
) == 32 );
1002 C_ASSERT( sizeof(struct get_console_input_info_reply
) == 40 );
1003 C_ASSERT( FIELD_OFFSET(struct append_console_input_history_request
, handle
) == 12 );
1004 C_ASSERT( sizeof(struct append_console_input_history_request
) == 16 );
1005 C_ASSERT( FIELD_OFFSET(struct get_console_input_history_request
, handle
) == 12 );
1006 C_ASSERT( FIELD_OFFSET(struct get_console_input_history_request
, index
) == 16 );
1007 C_ASSERT( sizeof(struct get_console_input_history_request
) == 24 );
1008 C_ASSERT( FIELD_OFFSET(struct get_console_input_history_reply
, total
) == 8 );
1009 C_ASSERT( sizeof(struct get_console_input_history_reply
) == 16 );
1010 C_ASSERT( FIELD_OFFSET(struct create_console_output_request
, handle_in
) == 12 );
1011 C_ASSERT( FIELD_OFFSET(struct create_console_output_request
, access
) == 16 );
1012 C_ASSERT( FIELD_OFFSET(struct create_console_output_request
, attributes
) == 20 );
1013 C_ASSERT( FIELD_OFFSET(struct create_console_output_request
, share
) == 24 );
1014 C_ASSERT( FIELD_OFFSET(struct create_console_output_request
, fd
) == 28 );
1015 C_ASSERT( sizeof(struct create_console_output_request
) == 32 );
1016 C_ASSERT( FIELD_OFFSET(struct create_console_output_reply
, handle_out
) == 8 );
1017 C_ASSERT( sizeof(struct create_console_output_reply
) == 16 );
1018 C_ASSERT( FIELD_OFFSET(struct set_console_output_info_request
, handle
) == 12 );
1019 C_ASSERT( FIELD_OFFSET(struct set_console_output_info_request
, mask
) == 16 );
1020 C_ASSERT( FIELD_OFFSET(struct set_console_output_info_request
, cursor_size
) == 20 );
1021 C_ASSERT( FIELD_OFFSET(struct set_console_output_info_request
, cursor_visible
) == 22 );
1022 C_ASSERT( FIELD_OFFSET(struct set_console_output_info_request
, cursor_x
) == 24 );
1023 C_ASSERT( FIELD_OFFSET(struct set_console_output_info_request
, cursor_y
) == 26 );
1024 C_ASSERT( FIELD_OFFSET(struct set_console_output_info_request
, width
) == 28 );
1025 C_ASSERT( FIELD_OFFSET(struct set_console_output_info_request
, height
) == 30 );
1026 C_ASSERT( FIELD_OFFSET(struct set_console_output_info_request
, attr
) == 32 );
1027 C_ASSERT( FIELD_OFFSET(struct set_console_output_info_request
, win_left
) == 34 );
1028 C_ASSERT( FIELD_OFFSET(struct set_console_output_info_request
, win_top
) == 36 );
1029 C_ASSERT( FIELD_OFFSET(struct set_console_output_info_request
, win_right
) == 38 );
1030 C_ASSERT( FIELD_OFFSET(struct set_console_output_info_request
, win_bottom
) == 40 );
1031 C_ASSERT( FIELD_OFFSET(struct set_console_output_info_request
, max_width
) == 42 );
1032 C_ASSERT( FIELD_OFFSET(struct set_console_output_info_request
, max_height
) == 44 );
1033 C_ASSERT( sizeof(struct set_console_output_info_request
) == 48 );
1034 C_ASSERT( FIELD_OFFSET(struct get_console_output_info_request
, handle
) == 12 );
1035 C_ASSERT( sizeof(struct get_console_output_info_request
) == 16 );
1036 C_ASSERT( FIELD_OFFSET(struct get_console_output_info_reply
, cursor_size
) == 8 );
1037 C_ASSERT( FIELD_OFFSET(struct get_console_output_info_reply
, cursor_visible
) == 10 );
1038 C_ASSERT( FIELD_OFFSET(struct get_console_output_info_reply
, cursor_x
) == 12 );
1039 C_ASSERT( FIELD_OFFSET(struct get_console_output_info_reply
, cursor_y
) == 14 );
1040 C_ASSERT( FIELD_OFFSET(struct get_console_output_info_reply
, width
) == 16 );
1041 C_ASSERT( FIELD_OFFSET(struct get_console_output_info_reply
, height
) == 18 );
1042 C_ASSERT( FIELD_OFFSET(struct get_console_output_info_reply
, attr
) == 20 );
1043 C_ASSERT( FIELD_OFFSET(struct get_console_output_info_reply
, win_left
) == 22 );
1044 C_ASSERT( FIELD_OFFSET(struct get_console_output_info_reply
, win_top
) == 24 );
1045 C_ASSERT( FIELD_OFFSET(struct get_console_output_info_reply
, win_right
) == 26 );
1046 C_ASSERT( FIELD_OFFSET(struct get_console_output_info_reply
, win_bottom
) == 28 );
1047 C_ASSERT( FIELD_OFFSET(struct get_console_output_info_reply
, max_width
) == 30 );
1048 C_ASSERT( FIELD_OFFSET(struct get_console_output_info_reply
, max_height
) == 32 );
1049 C_ASSERT( sizeof(struct get_console_output_info_reply
) == 40 );
1050 C_ASSERT( FIELD_OFFSET(struct write_console_input_request
, handle
) == 12 );
1051 C_ASSERT( sizeof(struct write_console_input_request
) == 16 );
1052 C_ASSERT( FIELD_OFFSET(struct write_console_input_reply
, written
) == 8 );
1053 C_ASSERT( sizeof(struct write_console_input_reply
) == 16 );
1054 C_ASSERT( FIELD_OFFSET(struct read_console_input_request
, handle
) == 12 );
1055 C_ASSERT( FIELD_OFFSET(struct read_console_input_request
, flush
) == 16 );
1056 C_ASSERT( sizeof(struct read_console_input_request
) == 24 );
1057 C_ASSERT( FIELD_OFFSET(struct read_console_input_reply
, read
) == 8 );
1058 C_ASSERT( sizeof(struct read_console_input_reply
) == 16 );
1059 C_ASSERT( FIELD_OFFSET(struct write_console_output_request
, handle
) == 12 );
1060 C_ASSERT( FIELD_OFFSET(struct write_console_output_request
, x
) == 16 );
1061 C_ASSERT( FIELD_OFFSET(struct write_console_output_request
, y
) == 20 );
1062 C_ASSERT( FIELD_OFFSET(struct write_console_output_request
, mode
) == 24 );
1063 C_ASSERT( FIELD_OFFSET(struct write_console_output_request
, wrap
) == 28 );
1064 C_ASSERT( sizeof(struct write_console_output_request
) == 32 );
1065 C_ASSERT( FIELD_OFFSET(struct write_console_output_reply
, written
) == 8 );
1066 C_ASSERT( FIELD_OFFSET(struct write_console_output_reply
, width
) == 12 );
1067 C_ASSERT( FIELD_OFFSET(struct write_console_output_reply
, height
) == 16 );
1068 C_ASSERT( sizeof(struct write_console_output_reply
) == 24 );
1069 C_ASSERT( FIELD_OFFSET(struct fill_console_output_request
, handle
) == 12 );
1070 C_ASSERT( FIELD_OFFSET(struct fill_console_output_request
, x
) == 16 );
1071 C_ASSERT( FIELD_OFFSET(struct fill_console_output_request
, y
) == 20 );
1072 C_ASSERT( FIELD_OFFSET(struct fill_console_output_request
, mode
) == 24 );
1073 C_ASSERT( FIELD_OFFSET(struct fill_console_output_request
, count
) == 28 );
1074 C_ASSERT( FIELD_OFFSET(struct fill_console_output_request
, wrap
) == 32 );
1075 C_ASSERT( FIELD_OFFSET(struct fill_console_output_request
, data
) == 36 );
1076 C_ASSERT( sizeof(struct fill_console_output_request
) == 40 );
1077 C_ASSERT( FIELD_OFFSET(struct fill_console_output_reply
, written
) == 8 );
1078 C_ASSERT( sizeof(struct fill_console_output_reply
) == 16 );
1079 C_ASSERT( FIELD_OFFSET(struct read_console_output_request
, handle
) == 12 );
1080 C_ASSERT( FIELD_OFFSET(struct read_console_output_request
, x
) == 16 );
1081 C_ASSERT( FIELD_OFFSET(struct read_console_output_request
, y
) == 20 );
1082 C_ASSERT( FIELD_OFFSET(struct read_console_output_request
, mode
) == 24 );
1083 C_ASSERT( FIELD_OFFSET(struct read_console_output_request
, wrap
) == 28 );
1084 C_ASSERT( sizeof(struct read_console_output_request
) == 32 );
1085 C_ASSERT( FIELD_OFFSET(struct read_console_output_reply
, width
) == 8 );
1086 C_ASSERT( FIELD_OFFSET(struct read_console_output_reply
, height
) == 12 );
1087 C_ASSERT( sizeof(struct read_console_output_reply
) == 16 );
1088 C_ASSERT( FIELD_OFFSET(struct move_console_output_request
, handle
) == 12 );
1089 C_ASSERT( FIELD_OFFSET(struct move_console_output_request
, x_src
) == 16 );
1090 C_ASSERT( FIELD_OFFSET(struct move_console_output_request
, y_src
) == 18 );
1091 C_ASSERT( FIELD_OFFSET(struct move_console_output_request
, x_dst
) == 20 );
1092 C_ASSERT( FIELD_OFFSET(struct move_console_output_request
, y_dst
) == 22 );
1093 C_ASSERT( FIELD_OFFSET(struct move_console_output_request
, w
) == 24 );
1094 C_ASSERT( FIELD_OFFSET(struct move_console_output_request
, h
) == 26 );
1095 C_ASSERT( sizeof(struct move_console_output_request
) == 32 );
1096 C_ASSERT( FIELD_OFFSET(struct send_console_signal_request
, signal
) == 12 );
1097 C_ASSERT( FIELD_OFFSET(struct send_console_signal_request
, group_id
) == 16 );
1098 C_ASSERT( sizeof(struct send_console_signal_request
) == 24 );
1099 C_ASSERT( FIELD_OFFSET(struct read_directory_changes_request
, filter
) == 12 );
1100 C_ASSERT( FIELD_OFFSET(struct read_directory_changes_request
, subtree
) == 16 );
1101 C_ASSERT( FIELD_OFFSET(struct read_directory_changes_request
, want_data
) == 20 );
1102 C_ASSERT( FIELD_OFFSET(struct read_directory_changes_request
, async
) == 24 );
1103 C_ASSERT( sizeof(struct read_directory_changes_request
) == 64 );
1104 C_ASSERT( FIELD_OFFSET(struct read_change_request
, handle
) == 12 );
1105 C_ASSERT( sizeof(struct read_change_request
) == 16 );
1106 C_ASSERT( FIELD_OFFSET(struct read_change_reply
, action
) == 8 );
1107 C_ASSERT( sizeof(struct read_change_reply
) == 16 );
1108 C_ASSERT( FIELD_OFFSET(struct create_mapping_request
, access
) == 12 );
1109 C_ASSERT( FIELD_OFFSET(struct create_mapping_request
, attributes
) == 16 );
1110 C_ASSERT( FIELD_OFFSET(struct create_mapping_request
, protect
) == 20 );
1111 C_ASSERT( FIELD_OFFSET(struct create_mapping_request
, size
) == 24 );
1112 C_ASSERT( FIELD_OFFSET(struct create_mapping_request
, file_handle
) == 32 );
1113 C_ASSERT( sizeof(struct create_mapping_request
) == 40 );
1114 C_ASSERT( FIELD_OFFSET(struct create_mapping_reply
, handle
) == 8 );
1115 C_ASSERT( sizeof(struct create_mapping_reply
) == 16 );
1116 C_ASSERT( FIELD_OFFSET(struct open_mapping_request
, access
) == 12 );
1117 C_ASSERT( FIELD_OFFSET(struct open_mapping_request
, attributes
) == 16 );
1118 C_ASSERT( FIELD_OFFSET(struct open_mapping_request
, rootdir
) == 20 );
1119 C_ASSERT( sizeof(struct open_mapping_request
) == 24 );
1120 C_ASSERT( FIELD_OFFSET(struct open_mapping_reply
, handle
) == 8 );
1121 C_ASSERT( sizeof(struct open_mapping_reply
) == 16 );
1122 C_ASSERT( FIELD_OFFSET(struct get_mapping_info_request
, handle
) == 12 );
1123 C_ASSERT( FIELD_OFFSET(struct get_mapping_info_request
, access
) == 16 );
1124 C_ASSERT( sizeof(struct get_mapping_info_request
) == 24 );
1125 C_ASSERT( FIELD_OFFSET(struct get_mapping_info_reply
, size
) == 8 );
1126 C_ASSERT( FIELD_OFFSET(struct get_mapping_info_reply
, protect
) == 16 );
1127 C_ASSERT( FIELD_OFFSET(struct get_mapping_info_reply
, header_size
) == 20 );
1128 C_ASSERT( FIELD_OFFSET(struct get_mapping_info_reply
, base
) == 24 );
1129 C_ASSERT( FIELD_OFFSET(struct get_mapping_info_reply
, mapping
) == 32 );
1130 C_ASSERT( FIELD_OFFSET(struct get_mapping_info_reply
, shared_file
) == 36 );
1131 C_ASSERT( sizeof(struct get_mapping_info_reply
) == 40 );
1132 C_ASSERT( FIELD_OFFSET(struct get_mapping_committed_range_request
, handle
) == 12 );
1133 C_ASSERT( FIELD_OFFSET(struct get_mapping_committed_range_request
, offset
) == 16 );
1134 C_ASSERT( sizeof(struct get_mapping_committed_range_request
) == 24 );
1135 C_ASSERT( FIELD_OFFSET(struct get_mapping_committed_range_reply
, size
) == 8 );
1136 C_ASSERT( FIELD_OFFSET(struct get_mapping_committed_range_reply
, committed
) == 16 );
1137 C_ASSERT( sizeof(struct get_mapping_committed_range_reply
) == 24 );
1138 C_ASSERT( FIELD_OFFSET(struct add_mapping_committed_range_request
, handle
) == 12 );
1139 C_ASSERT( FIELD_OFFSET(struct add_mapping_committed_range_request
, offset
) == 16 );
1140 C_ASSERT( FIELD_OFFSET(struct add_mapping_committed_range_request
, size
) == 24 );
1141 C_ASSERT( sizeof(struct add_mapping_committed_range_request
) == 32 );
1142 C_ASSERT( FIELD_OFFSET(struct create_snapshot_request
, attributes
) == 12 );
1143 C_ASSERT( FIELD_OFFSET(struct create_snapshot_request
, flags
) == 16 );
1144 C_ASSERT( sizeof(struct create_snapshot_request
) == 24 );
1145 C_ASSERT( FIELD_OFFSET(struct create_snapshot_reply
, handle
) == 8 );
1146 C_ASSERT( sizeof(struct create_snapshot_reply
) == 16 );
1147 C_ASSERT( FIELD_OFFSET(struct next_process_request
, handle
) == 12 );
1148 C_ASSERT( FIELD_OFFSET(struct next_process_request
, reset
) == 16 );
1149 C_ASSERT( sizeof(struct next_process_request
) == 24 );
1150 C_ASSERT( FIELD_OFFSET(struct next_process_reply
, count
) == 8 );
1151 C_ASSERT( FIELD_OFFSET(struct next_process_reply
, pid
) == 12 );
1152 C_ASSERT( FIELD_OFFSET(struct next_process_reply
, ppid
) == 16 );
1153 C_ASSERT( FIELD_OFFSET(struct next_process_reply
, threads
) == 20 );
1154 C_ASSERT( FIELD_OFFSET(struct next_process_reply
, priority
) == 24 );
1155 C_ASSERT( FIELD_OFFSET(struct next_process_reply
, handles
) == 28 );
1156 C_ASSERT( sizeof(struct next_process_reply
) == 32 );
1157 C_ASSERT( FIELD_OFFSET(struct next_thread_request
, handle
) == 12 );
1158 C_ASSERT( FIELD_OFFSET(struct next_thread_request
, reset
) == 16 );
1159 C_ASSERT( sizeof(struct next_thread_request
) == 24 );
1160 C_ASSERT( FIELD_OFFSET(struct next_thread_reply
, count
) == 8 );
1161 C_ASSERT( FIELD_OFFSET(struct next_thread_reply
, pid
) == 12 );
1162 C_ASSERT( FIELD_OFFSET(struct next_thread_reply
, tid
) == 16 );
1163 C_ASSERT( FIELD_OFFSET(struct next_thread_reply
, base_pri
) == 20 );
1164 C_ASSERT( FIELD_OFFSET(struct next_thread_reply
, delta_pri
) == 24 );
1165 C_ASSERT( sizeof(struct next_thread_reply
) == 32 );
1166 C_ASSERT( FIELD_OFFSET(struct wait_debug_event_request
, get_handle
) == 12 );
1167 C_ASSERT( sizeof(struct wait_debug_event_request
) == 16 );
1168 C_ASSERT( FIELD_OFFSET(struct wait_debug_event_reply
, pid
) == 8 );
1169 C_ASSERT( FIELD_OFFSET(struct wait_debug_event_reply
, tid
) == 12 );
1170 C_ASSERT( FIELD_OFFSET(struct wait_debug_event_reply
, wait
) == 16 );
1171 C_ASSERT( sizeof(struct wait_debug_event_reply
) == 24 );
1172 C_ASSERT( FIELD_OFFSET(struct queue_exception_event_request
, first
) == 12 );
1173 C_ASSERT( FIELD_OFFSET(struct queue_exception_event_request
, code
) == 16 );
1174 C_ASSERT( FIELD_OFFSET(struct queue_exception_event_request
, flags
) == 20 );
1175 C_ASSERT( FIELD_OFFSET(struct queue_exception_event_request
, record
) == 24 );
1176 C_ASSERT( FIELD_OFFSET(struct queue_exception_event_request
, address
) == 32 );
1177 C_ASSERT( FIELD_OFFSET(struct queue_exception_event_request
, len
) == 40 );
1178 C_ASSERT( sizeof(struct queue_exception_event_request
) == 48 );
1179 C_ASSERT( FIELD_OFFSET(struct queue_exception_event_reply
, handle
) == 8 );
1180 C_ASSERT( sizeof(struct queue_exception_event_reply
) == 16 );
1181 C_ASSERT( FIELD_OFFSET(struct get_exception_status_request
, handle
) == 12 );
1182 C_ASSERT( sizeof(struct get_exception_status_request
) == 16 );
1183 C_ASSERT( sizeof(struct get_exception_status_reply
) == 8 );
1184 C_ASSERT( FIELD_OFFSET(struct output_debug_string_request
, length
) == 12 );
1185 C_ASSERT( FIELD_OFFSET(struct output_debug_string_request
, string
) == 16 );
1186 C_ASSERT( sizeof(struct output_debug_string_request
) == 24 );
1187 C_ASSERT( FIELD_OFFSET(struct continue_debug_event_request
, pid
) == 12 );
1188 C_ASSERT( FIELD_OFFSET(struct continue_debug_event_request
, tid
) == 16 );
1189 C_ASSERT( FIELD_OFFSET(struct continue_debug_event_request
, status
) == 20 );
1190 C_ASSERT( sizeof(struct continue_debug_event_request
) == 24 );
1191 C_ASSERT( FIELD_OFFSET(struct debug_process_request
, pid
) == 12 );
1192 C_ASSERT( FIELD_OFFSET(struct debug_process_request
, attach
) == 16 );
1193 C_ASSERT( sizeof(struct debug_process_request
) == 24 );
1194 C_ASSERT( FIELD_OFFSET(struct debug_break_request
, handle
) == 12 );
1195 C_ASSERT( sizeof(struct debug_break_request
) == 16 );
1196 C_ASSERT( FIELD_OFFSET(struct debug_break_reply
, self
) == 8 );
1197 C_ASSERT( sizeof(struct debug_break_reply
) == 16 );
1198 C_ASSERT( FIELD_OFFSET(struct set_debugger_kill_on_exit_request
, kill_on_exit
) == 12 );
1199 C_ASSERT( sizeof(struct set_debugger_kill_on_exit_request
) == 16 );
1200 C_ASSERT( FIELD_OFFSET(struct read_process_memory_request
, handle
) == 12 );
1201 C_ASSERT( FIELD_OFFSET(struct read_process_memory_request
, addr
) == 16 );
1202 C_ASSERT( sizeof(struct read_process_memory_request
) == 24 );
1203 C_ASSERT( sizeof(struct read_process_memory_reply
) == 8 );
1204 C_ASSERT( FIELD_OFFSET(struct write_process_memory_request
, handle
) == 12 );
1205 C_ASSERT( FIELD_OFFSET(struct write_process_memory_request
, addr
) == 16 );
1206 C_ASSERT( sizeof(struct write_process_memory_request
) == 24 );
1207 C_ASSERT( FIELD_OFFSET(struct create_key_request
, parent
) == 12 );
1208 C_ASSERT( FIELD_OFFSET(struct create_key_request
, access
) == 16 );
1209 C_ASSERT( FIELD_OFFSET(struct create_key_request
, attributes
) == 20 );
1210 C_ASSERT( FIELD_OFFSET(struct create_key_request
, options
) == 24 );
1211 C_ASSERT( FIELD_OFFSET(struct create_key_request
, namelen
) == 28 );
1212 C_ASSERT( sizeof(struct create_key_request
) == 32 );
1213 C_ASSERT( FIELD_OFFSET(struct create_key_reply
, hkey
) == 8 );
1214 C_ASSERT( FIELD_OFFSET(struct create_key_reply
, created
) == 12 );
1215 C_ASSERT( sizeof(struct create_key_reply
) == 16 );
1216 C_ASSERT( FIELD_OFFSET(struct open_key_request
, parent
) == 12 );
1217 C_ASSERT( FIELD_OFFSET(struct open_key_request
, access
) == 16 );
1218 C_ASSERT( FIELD_OFFSET(struct open_key_request
, attributes
) == 20 );
1219 C_ASSERT( sizeof(struct open_key_request
) == 24 );
1220 C_ASSERT( FIELD_OFFSET(struct open_key_reply
, hkey
) == 8 );
1221 C_ASSERT( sizeof(struct open_key_reply
) == 16 );
1222 C_ASSERT( FIELD_OFFSET(struct delete_key_request
, hkey
) == 12 );
1223 C_ASSERT( sizeof(struct delete_key_request
) == 16 );
1224 C_ASSERT( FIELD_OFFSET(struct flush_key_request
, hkey
) == 12 );
1225 C_ASSERT( sizeof(struct flush_key_request
) == 16 );
1226 C_ASSERT( FIELD_OFFSET(struct enum_key_request
, hkey
) == 12 );
1227 C_ASSERT( FIELD_OFFSET(struct enum_key_request
, index
) == 16 );
1228 C_ASSERT( FIELD_OFFSET(struct enum_key_request
, info_class
) == 20 );
1229 C_ASSERT( sizeof(struct enum_key_request
) == 24 );
1230 C_ASSERT( FIELD_OFFSET(struct enum_key_reply
, subkeys
) == 8 );
1231 C_ASSERT( FIELD_OFFSET(struct enum_key_reply
, max_subkey
) == 12 );
1232 C_ASSERT( FIELD_OFFSET(struct enum_key_reply
, max_class
) == 16 );
1233 C_ASSERT( FIELD_OFFSET(struct enum_key_reply
, values
) == 20 );
1234 C_ASSERT( FIELD_OFFSET(struct enum_key_reply
, max_value
) == 24 );
1235 C_ASSERT( FIELD_OFFSET(struct enum_key_reply
, max_data
) == 28 );
1236 C_ASSERT( FIELD_OFFSET(struct enum_key_reply
, modif
) == 32 );
1237 C_ASSERT( FIELD_OFFSET(struct enum_key_reply
, total
) == 40 );
1238 C_ASSERT( FIELD_OFFSET(struct enum_key_reply
, namelen
) == 44 );
1239 C_ASSERT( sizeof(struct enum_key_reply
) == 48 );
1240 C_ASSERT( FIELD_OFFSET(struct set_key_value_request
, hkey
) == 12 );
1241 C_ASSERT( FIELD_OFFSET(struct set_key_value_request
, type
) == 16 );
1242 C_ASSERT( FIELD_OFFSET(struct set_key_value_request
, namelen
) == 20 );
1243 C_ASSERT( sizeof(struct set_key_value_request
) == 24 );
1244 C_ASSERT( FIELD_OFFSET(struct get_key_value_request
, hkey
) == 12 );
1245 C_ASSERT( sizeof(struct get_key_value_request
) == 16 );
1246 C_ASSERT( FIELD_OFFSET(struct get_key_value_reply
, type
) == 8 );
1247 C_ASSERT( FIELD_OFFSET(struct get_key_value_reply
, total
) == 12 );
1248 C_ASSERT( sizeof(struct get_key_value_reply
) == 16 );
1249 C_ASSERT( FIELD_OFFSET(struct enum_key_value_request
, hkey
) == 12 );
1250 C_ASSERT( FIELD_OFFSET(struct enum_key_value_request
, index
) == 16 );
1251 C_ASSERT( FIELD_OFFSET(struct enum_key_value_request
, info_class
) == 20 );
1252 C_ASSERT( sizeof(struct enum_key_value_request
) == 24 );
1253 C_ASSERT( FIELD_OFFSET(struct enum_key_value_reply
, type
) == 8 );
1254 C_ASSERT( FIELD_OFFSET(struct enum_key_value_reply
, total
) == 12 );
1255 C_ASSERT( FIELD_OFFSET(struct enum_key_value_reply
, namelen
) == 16 );
1256 C_ASSERT( sizeof(struct enum_key_value_reply
) == 24 );
1257 C_ASSERT( FIELD_OFFSET(struct delete_key_value_request
, hkey
) == 12 );
1258 C_ASSERT( sizeof(struct delete_key_value_request
) == 16 );
1259 C_ASSERT( FIELD_OFFSET(struct load_registry_request
, hkey
) == 12 );
1260 C_ASSERT( FIELD_OFFSET(struct load_registry_request
, file
) == 16 );
1261 C_ASSERT( sizeof(struct load_registry_request
) == 24 );
1262 C_ASSERT( FIELD_OFFSET(struct unload_registry_request
, hkey
) == 12 );
1263 C_ASSERT( sizeof(struct unload_registry_request
) == 16 );
1264 C_ASSERT( FIELD_OFFSET(struct save_registry_request
, hkey
) == 12 );
1265 C_ASSERT( FIELD_OFFSET(struct save_registry_request
, file
) == 16 );
1266 C_ASSERT( sizeof(struct save_registry_request
) == 24 );
1267 C_ASSERT( FIELD_OFFSET(struct set_registry_notification_request
, hkey
) == 12 );
1268 C_ASSERT( FIELD_OFFSET(struct set_registry_notification_request
, event
) == 16 );
1269 C_ASSERT( FIELD_OFFSET(struct set_registry_notification_request
, subtree
) == 20 );
1270 C_ASSERT( FIELD_OFFSET(struct set_registry_notification_request
, filter
) == 24 );
1271 C_ASSERT( sizeof(struct set_registry_notification_request
) == 32 );
1272 C_ASSERT( FIELD_OFFSET(struct create_timer_request
, access
) == 12 );
1273 C_ASSERT( FIELD_OFFSET(struct create_timer_request
, attributes
) == 16 );
1274 C_ASSERT( FIELD_OFFSET(struct create_timer_request
, rootdir
) == 20 );
1275 C_ASSERT( FIELD_OFFSET(struct create_timer_request
, manual
) == 24 );
1276 C_ASSERT( sizeof(struct create_timer_request
) == 32 );
1277 C_ASSERT( FIELD_OFFSET(struct create_timer_reply
, handle
) == 8 );
1278 C_ASSERT( sizeof(struct create_timer_reply
) == 16 );
1279 C_ASSERT( FIELD_OFFSET(struct open_timer_request
, access
) == 12 );
1280 C_ASSERT( FIELD_OFFSET(struct open_timer_request
, attributes
) == 16 );
1281 C_ASSERT( FIELD_OFFSET(struct open_timer_request
, rootdir
) == 20 );
1282 C_ASSERT( sizeof(struct open_timer_request
) == 24 );
1283 C_ASSERT( FIELD_OFFSET(struct open_timer_reply
, handle
) == 8 );
1284 C_ASSERT( sizeof(struct open_timer_reply
) == 16 );
1285 C_ASSERT( FIELD_OFFSET(struct set_timer_request
, handle
) == 12 );
1286 C_ASSERT( FIELD_OFFSET(struct set_timer_request
, expire
) == 16 );
1287 C_ASSERT( FIELD_OFFSET(struct set_timer_request
, callback
) == 24 );
1288 C_ASSERT( FIELD_OFFSET(struct set_timer_request
, arg
) == 32 );
1289 C_ASSERT( FIELD_OFFSET(struct set_timer_request
, period
) == 40 );
1290 C_ASSERT( sizeof(struct set_timer_request
) == 48 );
1291 C_ASSERT( FIELD_OFFSET(struct set_timer_reply
, signaled
) == 8 );
1292 C_ASSERT( sizeof(struct set_timer_reply
) == 16 );
1293 C_ASSERT( FIELD_OFFSET(struct cancel_timer_request
, handle
) == 12 );
1294 C_ASSERT( sizeof(struct cancel_timer_request
) == 16 );
1295 C_ASSERT( FIELD_OFFSET(struct cancel_timer_reply
, signaled
) == 8 );
1296 C_ASSERT( sizeof(struct cancel_timer_reply
) == 16 );
1297 C_ASSERT( FIELD_OFFSET(struct get_timer_info_request
, handle
) == 12 );
1298 C_ASSERT( sizeof(struct get_timer_info_request
) == 16 );
1299 C_ASSERT( FIELD_OFFSET(struct get_timer_info_reply
, when
) == 8 );
1300 C_ASSERT( FIELD_OFFSET(struct get_timer_info_reply
, signaled
) == 16 );
1301 C_ASSERT( sizeof(struct get_timer_info_reply
) == 24 );
1302 C_ASSERT( FIELD_OFFSET(struct get_thread_context_request
, handle
) == 12 );
1303 C_ASSERT( FIELD_OFFSET(struct get_thread_context_request
, flags
) == 16 );
1304 C_ASSERT( FIELD_OFFSET(struct get_thread_context_request
, suspend
) == 20 );
1305 C_ASSERT( sizeof(struct get_thread_context_request
) == 24 );
1306 C_ASSERT( FIELD_OFFSET(struct get_thread_context_reply
, self
) == 8 );
1307 C_ASSERT( sizeof(struct get_thread_context_reply
) == 16 );
1308 C_ASSERT( FIELD_OFFSET(struct set_thread_context_request
, handle
) == 12 );
1309 C_ASSERT( FIELD_OFFSET(struct set_thread_context_request
, suspend
) == 16 );
1310 C_ASSERT( sizeof(struct set_thread_context_request
) == 24 );
1311 C_ASSERT( FIELD_OFFSET(struct set_thread_context_reply
, self
) == 8 );
1312 C_ASSERT( sizeof(struct set_thread_context_reply
) == 16 );
1313 C_ASSERT( FIELD_OFFSET(struct get_selector_entry_request
, handle
) == 12 );
1314 C_ASSERT( FIELD_OFFSET(struct get_selector_entry_request
, entry
) == 16 );
1315 C_ASSERT( sizeof(struct get_selector_entry_request
) == 24 );
1316 C_ASSERT( FIELD_OFFSET(struct get_selector_entry_reply
, base
) == 8 );
1317 C_ASSERT( FIELD_OFFSET(struct get_selector_entry_reply
, limit
) == 12 );
1318 C_ASSERT( FIELD_OFFSET(struct get_selector_entry_reply
, flags
) == 16 );
1319 C_ASSERT( sizeof(struct get_selector_entry_reply
) == 24 );
1320 C_ASSERT( FIELD_OFFSET(struct add_atom_request
, table
) == 12 );
1321 C_ASSERT( sizeof(struct add_atom_request
) == 16 );
1322 C_ASSERT( FIELD_OFFSET(struct add_atom_reply
, atom
) == 8 );
1323 C_ASSERT( sizeof(struct add_atom_reply
) == 16 );
1324 C_ASSERT( FIELD_OFFSET(struct delete_atom_request
, table
) == 12 );
1325 C_ASSERT( FIELD_OFFSET(struct delete_atom_request
, atom
) == 16 );
1326 C_ASSERT( sizeof(struct delete_atom_request
) == 24 );
1327 C_ASSERT( FIELD_OFFSET(struct find_atom_request
, table
) == 12 );
1328 C_ASSERT( sizeof(struct find_atom_request
) == 16 );
1329 C_ASSERT( FIELD_OFFSET(struct find_atom_reply
, atom
) == 8 );
1330 C_ASSERT( sizeof(struct find_atom_reply
) == 16 );
1331 C_ASSERT( FIELD_OFFSET(struct get_atom_information_request
, table
) == 12 );
1332 C_ASSERT( FIELD_OFFSET(struct get_atom_information_request
, atom
) == 16 );
1333 C_ASSERT( sizeof(struct get_atom_information_request
) == 24 );
1334 C_ASSERT( FIELD_OFFSET(struct get_atom_information_reply
, count
) == 8 );
1335 C_ASSERT( FIELD_OFFSET(struct get_atom_information_reply
, pinned
) == 12 );
1336 C_ASSERT( FIELD_OFFSET(struct get_atom_information_reply
, total
) == 16 );
1337 C_ASSERT( sizeof(struct get_atom_information_reply
) == 24 );
1338 C_ASSERT( FIELD_OFFSET(struct set_atom_information_request
, table
) == 12 );
1339 C_ASSERT( FIELD_OFFSET(struct set_atom_information_request
, atom
) == 16 );
1340 C_ASSERT( FIELD_OFFSET(struct set_atom_information_request
, pinned
) == 20 );
1341 C_ASSERT( sizeof(struct set_atom_information_request
) == 24 );
1342 C_ASSERT( FIELD_OFFSET(struct empty_atom_table_request
, table
) == 12 );
1343 C_ASSERT( FIELD_OFFSET(struct empty_atom_table_request
, if_pinned
) == 16 );
1344 C_ASSERT( sizeof(struct empty_atom_table_request
) == 24 );
1345 C_ASSERT( FIELD_OFFSET(struct init_atom_table_request
, entries
) == 12 );
1346 C_ASSERT( sizeof(struct init_atom_table_request
) == 16 );
1347 C_ASSERT( FIELD_OFFSET(struct init_atom_table_reply
, table
) == 8 );
1348 C_ASSERT( sizeof(struct init_atom_table_reply
) == 16 );
1349 C_ASSERT( sizeof(struct get_msg_queue_request
) == 16 );
1350 C_ASSERT( FIELD_OFFSET(struct get_msg_queue_reply
, handle
) == 8 );
1351 C_ASSERT( sizeof(struct get_msg_queue_reply
) == 16 );
1352 C_ASSERT( FIELD_OFFSET(struct set_queue_fd_request
, handle
) == 12 );
1353 C_ASSERT( sizeof(struct set_queue_fd_request
) == 16 );
1354 C_ASSERT( FIELD_OFFSET(struct set_queue_mask_request
, wake_mask
) == 12 );
1355 C_ASSERT( FIELD_OFFSET(struct set_queue_mask_request
, changed_mask
) == 16 );
1356 C_ASSERT( FIELD_OFFSET(struct set_queue_mask_request
, skip_wait
) == 20 );
1357 C_ASSERT( sizeof(struct set_queue_mask_request
) == 24 );
1358 C_ASSERT( FIELD_OFFSET(struct set_queue_mask_reply
, wake_bits
) == 8 );
1359 C_ASSERT( FIELD_OFFSET(struct set_queue_mask_reply
, changed_bits
) == 12 );
1360 C_ASSERT( sizeof(struct set_queue_mask_reply
) == 16 );
1361 C_ASSERT( FIELD_OFFSET(struct get_queue_status_request
, clear
) == 12 );
1362 C_ASSERT( sizeof(struct get_queue_status_request
) == 16 );
1363 C_ASSERT( FIELD_OFFSET(struct get_queue_status_reply
, wake_bits
) == 8 );
1364 C_ASSERT( FIELD_OFFSET(struct get_queue_status_reply
, changed_bits
) == 12 );
1365 C_ASSERT( sizeof(struct get_queue_status_reply
) == 16 );
1366 C_ASSERT( FIELD_OFFSET(struct get_process_idle_event_request
, handle
) == 12 );
1367 C_ASSERT( sizeof(struct get_process_idle_event_request
) == 16 );
1368 C_ASSERT( FIELD_OFFSET(struct get_process_idle_event_reply
, event
) == 8 );
1369 C_ASSERT( sizeof(struct get_process_idle_event_reply
) == 16 );
1370 C_ASSERT( FIELD_OFFSET(struct send_message_request
, id
) == 12 );
1371 C_ASSERT( FIELD_OFFSET(struct send_message_request
, type
) == 16 );
1372 C_ASSERT( FIELD_OFFSET(struct send_message_request
, flags
) == 20 );
1373 C_ASSERT( FIELD_OFFSET(struct send_message_request
, win
) == 24 );
1374 C_ASSERT( FIELD_OFFSET(struct send_message_request
, msg
) == 28 );
1375 C_ASSERT( FIELD_OFFSET(struct send_message_request
, wparam
) == 32 );
1376 C_ASSERT( FIELD_OFFSET(struct send_message_request
, lparam
) == 40 );
1377 C_ASSERT( FIELD_OFFSET(struct send_message_request
, timeout
) == 48 );
1378 C_ASSERT( sizeof(struct send_message_request
) == 56 );
1379 C_ASSERT( FIELD_OFFSET(struct post_quit_message_request
, exit_code
) == 12 );
1380 C_ASSERT( sizeof(struct post_quit_message_request
) == 16 );
1381 C_ASSERT( FIELD_OFFSET(struct send_hardware_message_request
, id
) == 12 );
1382 C_ASSERT( FIELD_OFFSET(struct send_hardware_message_request
, win
) == 16 );
1383 C_ASSERT( FIELD_OFFSET(struct send_hardware_message_request
, msg
) == 20 );
1384 C_ASSERT( FIELD_OFFSET(struct send_hardware_message_request
, wparam
) == 24 );
1385 C_ASSERT( FIELD_OFFSET(struct send_hardware_message_request
, lparam
) == 32 );
1386 C_ASSERT( FIELD_OFFSET(struct send_hardware_message_request
, info
) == 40 );
1387 C_ASSERT( FIELD_OFFSET(struct send_hardware_message_request
, x
) == 48 );
1388 C_ASSERT( FIELD_OFFSET(struct send_hardware_message_request
, y
) == 52 );
1389 C_ASSERT( FIELD_OFFSET(struct send_hardware_message_request
, time
) == 56 );
1390 C_ASSERT( sizeof(struct send_hardware_message_request
) == 64 );
1391 C_ASSERT( FIELD_OFFSET(struct send_hardware_message_reply
, cursor
) == 8 );
1392 C_ASSERT( FIELD_OFFSET(struct send_hardware_message_reply
, count
) == 12 );
1393 C_ASSERT( sizeof(struct send_hardware_message_reply
) == 16 );
1394 C_ASSERT( FIELD_OFFSET(struct get_message_request
, flags
) == 12 );
1395 C_ASSERT( FIELD_OFFSET(struct get_message_request
, get_win
) == 16 );
1396 C_ASSERT( FIELD_OFFSET(struct get_message_request
, get_first
) == 20 );
1397 C_ASSERT( FIELD_OFFSET(struct get_message_request
, get_last
) == 24 );
1398 C_ASSERT( FIELD_OFFSET(struct get_message_request
, hw_id
) == 28 );
1399 C_ASSERT( FIELD_OFFSET(struct get_message_request
, wake_mask
) == 32 );
1400 C_ASSERT( FIELD_OFFSET(struct get_message_request
, changed_mask
) == 36 );
1401 C_ASSERT( sizeof(struct get_message_request
) == 40 );
1402 C_ASSERT( FIELD_OFFSET(struct get_message_reply
, win
) == 8 );
1403 C_ASSERT( FIELD_OFFSET(struct get_message_reply
, msg
) == 12 );
1404 C_ASSERT( FIELD_OFFSET(struct get_message_reply
, wparam
) == 16 );
1405 C_ASSERT( FIELD_OFFSET(struct get_message_reply
, lparam
) == 24 );
1406 C_ASSERT( FIELD_OFFSET(struct get_message_reply
, type
) == 32 );
1407 C_ASSERT( FIELD_OFFSET(struct get_message_reply
, time
) == 36 );
1408 C_ASSERT( FIELD_OFFSET(struct get_message_reply
, active_hooks
) == 40 );
1409 C_ASSERT( FIELD_OFFSET(struct get_message_reply
, total
) == 44 );
1410 C_ASSERT( sizeof(struct get_message_reply
) == 48 );
1411 C_ASSERT( FIELD_OFFSET(struct reply_message_request
, remove
) == 12 );
1412 C_ASSERT( FIELD_OFFSET(struct reply_message_request
, result
) == 16 );
1413 C_ASSERT( sizeof(struct reply_message_request
) == 24 );
1414 C_ASSERT( FIELD_OFFSET(struct accept_hardware_message_request
, hw_id
) == 12 );
1415 C_ASSERT( FIELD_OFFSET(struct accept_hardware_message_request
, remove
) == 16 );
1416 C_ASSERT( FIELD_OFFSET(struct accept_hardware_message_request
, new_win
) == 20 );
1417 C_ASSERT( sizeof(struct accept_hardware_message_request
) == 24 );
1418 C_ASSERT( FIELD_OFFSET(struct get_message_reply_request
, cancel
) == 12 );
1419 C_ASSERT( sizeof(struct get_message_reply_request
) == 16 );
1420 C_ASSERT( FIELD_OFFSET(struct get_message_reply_reply
, result
) == 8 );
1421 C_ASSERT( sizeof(struct get_message_reply_reply
) == 16 );
1422 C_ASSERT( FIELD_OFFSET(struct set_win_timer_request
, win
) == 12 );
1423 C_ASSERT( FIELD_OFFSET(struct set_win_timer_request
, msg
) == 16 );
1424 C_ASSERT( FIELD_OFFSET(struct set_win_timer_request
, rate
) == 20 );
1425 C_ASSERT( FIELD_OFFSET(struct set_win_timer_request
, id
) == 24 );
1426 C_ASSERT( FIELD_OFFSET(struct set_win_timer_request
, lparam
) == 32 );
1427 C_ASSERT( sizeof(struct set_win_timer_request
) == 40 );
1428 C_ASSERT( FIELD_OFFSET(struct set_win_timer_reply
, id
) == 8 );
1429 C_ASSERT( sizeof(struct set_win_timer_reply
) == 16 );
1430 C_ASSERT( FIELD_OFFSET(struct kill_win_timer_request
, win
) == 12 );
1431 C_ASSERT( FIELD_OFFSET(struct kill_win_timer_request
, id
) == 16 );
1432 C_ASSERT( FIELD_OFFSET(struct kill_win_timer_request
, msg
) == 24 );
1433 C_ASSERT( sizeof(struct kill_win_timer_request
) == 32 );
1434 C_ASSERT( FIELD_OFFSET(struct is_window_hung_request
, win
) == 12 );
1435 C_ASSERT( sizeof(struct is_window_hung_request
) == 16 );
1436 C_ASSERT( FIELD_OFFSET(struct is_window_hung_reply
, is_hung
) == 8 );
1437 C_ASSERT( sizeof(struct is_window_hung_reply
) == 16 );
1438 C_ASSERT( FIELD_OFFSET(struct get_serial_info_request
, handle
) == 12 );
1439 C_ASSERT( sizeof(struct get_serial_info_request
) == 16 );
1440 C_ASSERT( FIELD_OFFSET(struct get_serial_info_reply
, readinterval
) == 8 );
1441 C_ASSERT( FIELD_OFFSET(struct get_serial_info_reply
, readconst
) == 12 );
1442 C_ASSERT( FIELD_OFFSET(struct get_serial_info_reply
, readmult
) == 16 );
1443 C_ASSERT( FIELD_OFFSET(struct get_serial_info_reply
, writeconst
) == 20 );
1444 C_ASSERT( FIELD_OFFSET(struct get_serial_info_reply
, writemult
) == 24 );
1445 C_ASSERT( FIELD_OFFSET(struct get_serial_info_reply
, eventmask
) == 28 );
1446 C_ASSERT( sizeof(struct get_serial_info_reply
) == 32 );
1447 C_ASSERT( FIELD_OFFSET(struct set_serial_info_request
, handle
) == 12 );
1448 C_ASSERT( FIELD_OFFSET(struct set_serial_info_request
, flags
) == 16 );
1449 C_ASSERT( FIELD_OFFSET(struct set_serial_info_request
, readinterval
) == 20 );
1450 C_ASSERT( FIELD_OFFSET(struct set_serial_info_request
, readconst
) == 24 );
1451 C_ASSERT( FIELD_OFFSET(struct set_serial_info_request
, readmult
) == 28 );
1452 C_ASSERT( FIELD_OFFSET(struct set_serial_info_request
, writeconst
) == 32 );
1453 C_ASSERT( FIELD_OFFSET(struct set_serial_info_request
, writemult
) == 36 );
1454 C_ASSERT( FIELD_OFFSET(struct set_serial_info_request
, eventmask
) == 40 );
1455 C_ASSERT( sizeof(struct set_serial_info_request
) == 48 );
1456 C_ASSERT( FIELD_OFFSET(struct register_async_request
, type
) == 12 );
1457 C_ASSERT( FIELD_OFFSET(struct register_async_request
, async
) == 16 );
1458 C_ASSERT( FIELD_OFFSET(struct register_async_request
, count
) == 56 );
1459 C_ASSERT( sizeof(struct register_async_request
) == 64 );
1460 C_ASSERT( FIELD_OFFSET(struct cancel_async_request
, handle
) == 12 );
1461 C_ASSERT( FIELD_OFFSET(struct cancel_async_request
, iosb
) == 16 );
1462 C_ASSERT( FIELD_OFFSET(struct cancel_async_request
, only_thread
) == 24 );
1463 C_ASSERT( sizeof(struct cancel_async_request
) == 32 );
1464 C_ASSERT( FIELD_OFFSET(struct ioctl_request
, code
) == 12 );
1465 C_ASSERT( FIELD_OFFSET(struct ioctl_request
, async
) == 16 );
1466 C_ASSERT( FIELD_OFFSET(struct ioctl_request
, blocking
) == 56 );
1467 C_ASSERT( sizeof(struct ioctl_request
) == 64 );
1468 C_ASSERT( FIELD_OFFSET(struct ioctl_reply
, wait
) == 8 );
1469 C_ASSERT( FIELD_OFFSET(struct ioctl_reply
, options
) == 12 );
1470 C_ASSERT( sizeof(struct ioctl_reply
) == 16 );
1471 C_ASSERT( FIELD_OFFSET(struct get_ioctl_result_request
, handle
) == 12 );
1472 C_ASSERT( FIELD_OFFSET(struct get_ioctl_result_request
, user_arg
) == 16 );
1473 C_ASSERT( sizeof(struct get_ioctl_result_request
) == 24 );
1474 C_ASSERT( sizeof(struct get_ioctl_result_reply
) == 8 );
1475 C_ASSERT( FIELD_OFFSET(struct create_named_pipe_request
, access
) == 12 );
1476 C_ASSERT( FIELD_OFFSET(struct create_named_pipe_request
, attributes
) == 16 );
1477 C_ASSERT( FIELD_OFFSET(struct create_named_pipe_request
, rootdir
) == 20 );
1478 C_ASSERT( FIELD_OFFSET(struct create_named_pipe_request
, options
) == 24 );
1479 C_ASSERT( FIELD_OFFSET(struct create_named_pipe_request
, maxinstances
) == 28 );
1480 C_ASSERT( FIELD_OFFSET(struct create_named_pipe_request
, outsize
) == 32 );
1481 C_ASSERT( FIELD_OFFSET(struct create_named_pipe_request
, insize
) == 36 );
1482 C_ASSERT( FIELD_OFFSET(struct create_named_pipe_request
, timeout
) == 40 );
1483 C_ASSERT( FIELD_OFFSET(struct create_named_pipe_request
, flags
) == 48 );
1484 C_ASSERT( sizeof(struct create_named_pipe_request
) == 56 );
1485 C_ASSERT( FIELD_OFFSET(struct create_named_pipe_reply
, handle
) == 8 );
1486 C_ASSERT( sizeof(struct create_named_pipe_reply
) == 16 );
1487 C_ASSERT( FIELD_OFFSET(struct get_named_pipe_info_request
, handle
) == 12 );
1488 C_ASSERT( sizeof(struct get_named_pipe_info_request
) == 16 );
1489 C_ASSERT( FIELD_OFFSET(struct get_named_pipe_info_reply
, flags
) == 8 );
1490 C_ASSERT( FIELD_OFFSET(struct get_named_pipe_info_reply
, maxinstances
) == 12 );
1491 C_ASSERT( FIELD_OFFSET(struct get_named_pipe_info_reply
, instances
) == 16 );
1492 C_ASSERT( FIELD_OFFSET(struct get_named_pipe_info_reply
, outsize
) == 20 );
1493 C_ASSERT( FIELD_OFFSET(struct get_named_pipe_info_reply
, insize
) == 24 );
1494 C_ASSERT( sizeof(struct get_named_pipe_info_reply
) == 32 );
1495 C_ASSERT( FIELD_OFFSET(struct create_window_request
, parent
) == 12 );
1496 C_ASSERT( FIELD_OFFSET(struct create_window_request
, owner
) == 16 );
1497 C_ASSERT( FIELD_OFFSET(struct create_window_request
, atom
) == 20 );
1498 C_ASSERT( FIELD_OFFSET(struct create_window_request
, instance
) == 24 );
1499 C_ASSERT( sizeof(struct create_window_request
) == 32 );
1500 C_ASSERT( FIELD_OFFSET(struct create_window_reply
, handle
) == 8 );
1501 C_ASSERT( FIELD_OFFSET(struct create_window_reply
, parent
) == 12 );
1502 C_ASSERT( FIELD_OFFSET(struct create_window_reply
, owner
) == 16 );
1503 C_ASSERT( FIELD_OFFSET(struct create_window_reply
, extra
) == 20 );
1504 C_ASSERT( FIELD_OFFSET(struct create_window_reply
, class_ptr
) == 24 );
1505 C_ASSERT( sizeof(struct create_window_reply
) == 32 );
1506 C_ASSERT( FIELD_OFFSET(struct destroy_window_request
, handle
) == 12 );
1507 C_ASSERT( sizeof(struct destroy_window_request
) == 16 );
1508 C_ASSERT( FIELD_OFFSET(struct get_desktop_window_request
, force
) == 12 );
1509 C_ASSERT( sizeof(struct get_desktop_window_request
) == 16 );
1510 C_ASSERT( FIELD_OFFSET(struct get_desktop_window_reply
, top_window
) == 8 );
1511 C_ASSERT( FIELD_OFFSET(struct get_desktop_window_reply
, msg_window
) == 12 );
1512 C_ASSERT( sizeof(struct get_desktop_window_reply
) == 16 );
1513 C_ASSERT( FIELD_OFFSET(struct set_window_owner_request
, handle
) == 12 );
1514 C_ASSERT( FIELD_OFFSET(struct set_window_owner_request
, owner
) == 16 );
1515 C_ASSERT( sizeof(struct set_window_owner_request
) == 24 );
1516 C_ASSERT( FIELD_OFFSET(struct set_window_owner_reply
, full_owner
) == 8 );
1517 C_ASSERT( FIELD_OFFSET(struct set_window_owner_reply
, prev_owner
) == 12 );
1518 C_ASSERT( sizeof(struct set_window_owner_reply
) == 16 );
1519 C_ASSERT( FIELD_OFFSET(struct get_window_info_request
, handle
) == 12 );
1520 C_ASSERT( sizeof(struct get_window_info_request
) == 16 );
1521 C_ASSERT( FIELD_OFFSET(struct get_window_info_reply
, full_handle
) == 8 );
1522 C_ASSERT( FIELD_OFFSET(struct get_window_info_reply
, last_active
) == 12 );
1523 C_ASSERT( FIELD_OFFSET(struct get_window_info_reply
, pid
) == 16 );
1524 C_ASSERT( FIELD_OFFSET(struct get_window_info_reply
, tid
) == 20 );
1525 C_ASSERT( FIELD_OFFSET(struct get_window_info_reply
, atom
) == 24 );
1526 C_ASSERT( FIELD_OFFSET(struct get_window_info_reply
, is_unicode
) == 28 );
1527 C_ASSERT( sizeof(struct get_window_info_reply
) == 32 );
1528 C_ASSERT( FIELD_OFFSET(struct set_window_info_request
, flags
) == 12 );
1529 C_ASSERT( FIELD_OFFSET(struct set_window_info_request
, is_unicode
) == 14 );
1530 C_ASSERT( FIELD_OFFSET(struct set_window_info_request
, handle
) == 16 );
1531 C_ASSERT( FIELD_OFFSET(struct set_window_info_request
, style
) == 20 );
1532 C_ASSERT( FIELD_OFFSET(struct set_window_info_request
, ex_style
) == 24 );
1533 C_ASSERT( FIELD_OFFSET(struct set_window_info_request
, id
) == 28 );
1534 C_ASSERT( FIELD_OFFSET(struct set_window_info_request
, instance
) == 32 );
1535 C_ASSERT( FIELD_OFFSET(struct set_window_info_request
, user_data
) == 40 );
1536 C_ASSERT( FIELD_OFFSET(struct set_window_info_request
, extra_offset
) == 48 );
1537 C_ASSERT( FIELD_OFFSET(struct set_window_info_request
, extra_size
) == 52 );
1538 C_ASSERT( FIELD_OFFSET(struct set_window_info_request
, extra_value
) == 56 );
1539 C_ASSERT( sizeof(struct set_window_info_request
) == 64 );
1540 C_ASSERT( FIELD_OFFSET(struct set_window_info_reply
, old_style
) == 8 );
1541 C_ASSERT( FIELD_OFFSET(struct set_window_info_reply
, old_ex_style
) == 12 );
1542 C_ASSERT( FIELD_OFFSET(struct set_window_info_reply
, old_instance
) == 16 );
1543 C_ASSERT( FIELD_OFFSET(struct set_window_info_reply
, old_user_data
) == 24 );
1544 C_ASSERT( FIELD_OFFSET(struct set_window_info_reply
, old_extra_value
) == 32 );
1545 C_ASSERT( FIELD_OFFSET(struct set_window_info_reply
, old_id
) == 40 );
1546 C_ASSERT( sizeof(struct set_window_info_reply
) == 48 );
1547 C_ASSERT( FIELD_OFFSET(struct set_parent_request
, handle
) == 12 );
1548 C_ASSERT( FIELD_OFFSET(struct set_parent_request
, parent
) == 16 );
1549 C_ASSERT( sizeof(struct set_parent_request
) == 24 );
1550 C_ASSERT( FIELD_OFFSET(struct set_parent_reply
, old_parent
) == 8 );
1551 C_ASSERT( FIELD_OFFSET(struct set_parent_reply
, full_parent
) == 12 );
1552 C_ASSERT( sizeof(struct set_parent_reply
) == 16 );
1553 C_ASSERT( FIELD_OFFSET(struct get_window_parents_request
, handle
) == 12 );
1554 C_ASSERT( sizeof(struct get_window_parents_request
) == 16 );
1555 C_ASSERT( FIELD_OFFSET(struct get_window_parents_reply
, count
) == 8 );
1556 C_ASSERT( sizeof(struct get_window_parents_reply
) == 16 );
1557 C_ASSERT( FIELD_OFFSET(struct get_window_children_request
, desktop
) == 12 );
1558 C_ASSERT( FIELD_OFFSET(struct get_window_children_request
, parent
) == 16 );
1559 C_ASSERT( FIELD_OFFSET(struct get_window_children_request
, atom
) == 20 );
1560 C_ASSERT( FIELD_OFFSET(struct get_window_children_request
, tid
) == 24 );
1561 C_ASSERT( sizeof(struct get_window_children_request
) == 32 );
1562 C_ASSERT( FIELD_OFFSET(struct get_window_children_reply
, count
) == 8 );
1563 C_ASSERT( sizeof(struct get_window_children_reply
) == 16 );
1564 C_ASSERT( FIELD_OFFSET(struct get_window_children_from_point_request
, parent
) == 12 );
1565 C_ASSERT( FIELD_OFFSET(struct get_window_children_from_point_request
, x
) == 16 );
1566 C_ASSERT( FIELD_OFFSET(struct get_window_children_from_point_request
, y
) == 20 );
1567 C_ASSERT( sizeof(struct get_window_children_from_point_request
) == 24 );
1568 C_ASSERT( FIELD_OFFSET(struct get_window_children_from_point_reply
, count
) == 8 );
1569 C_ASSERT( sizeof(struct get_window_children_from_point_reply
) == 16 );
1570 C_ASSERT( FIELD_OFFSET(struct get_window_tree_request
, handle
) == 12 );
1571 C_ASSERT( sizeof(struct get_window_tree_request
) == 16 );
1572 C_ASSERT( FIELD_OFFSET(struct get_window_tree_reply
, parent
) == 8 );
1573 C_ASSERT( FIELD_OFFSET(struct get_window_tree_reply
, owner
) == 12 );
1574 C_ASSERT( FIELD_OFFSET(struct get_window_tree_reply
, next_sibling
) == 16 );
1575 C_ASSERT( FIELD_OFFSET(struct get_window_tree_reply
, prev_sibling
) == 20 );
1576 C_ASSERT( FIELD_OFFSET(struct get_window_tree_reply
, first_sibling
) == 24 );
1577 C_ASSERT( FIELD_OFFSET(struct get_window_tree_reply
, last_sibling
) == 28 );
1578 C_ASSERT( FIELD_OFFSET(struct get_window_tree_reply
, first_child
) == 32 );
1579 C_ASSERT( FIELD_OFFSET(struct get_window_tree_reply
, last_child
) == 36 );
1580 C_ASSERT( sizeof(struct get_window_tree_reply
) == 40 );
1581 C_ASSERT( FIELD_OFFSET(struct set_window_pos_request
, flags
) == 12 );
1582 C_ASSERT( FIELD_OFFSET(struct set_window_pos_request
, handle
) == 16 );
1583 C_ASSERT( FIELD_OFFSET(struct set_window_pos_request
, previous
) == 20 );
1584 C_ASSERT( FIELD_OFFSET(struct set_window_pos_request
, window
) == 24 );
1585 C_ASSERT( FIELD_OFFSET(struct set_window_pos_request
, client
) == 40 );
1586 C_ASSERT( sizeof(struct set_window_pos_request
) == 56 );
1587 C_ASSERT( FIELD_OFFSET(struct set_window_pos_reply
, new_style
) == 8 );
1588 C_ASSERT( FIELD_OFFSET(struct set_window_pos_reply
, new_ex_style
) == 12 );
1589 C_ASSERT( sizeof(struct set_window_pos_reply
) == 16 );
1590 C_ASSERT( FIELD_OFFSET(struct get_window_rectangles_request
, handle
) == 12 );
1591 C_ASSERT( FIELD_OFFSET(struct get_window_rectangles_request
, relative
) == 16 );
1592 C_ASSERT( sizeof(struct get_window_rectangles_request
) == 24 );
1593 C_ASSERT( FIELD_OFFSET(struct get_window_rectangles_reply
, window
) == 8 );
1594 C_ASSERT( FIELD_OFFSET(struct get_window_rectangles_reply
, visible
) == 24 );
1595 C_ASSERT( FIELD_OFFSET(struct get_window_rectangles_reply
, client
) == 40 );
1596 C_ASSERT( sizeof(struct get_window_rectangles_reply
) == 56 );
1597 C_ASSERT( FIELD_OFFSET(struct get_window_text_request
, handle
) == 12 );
1598 C_ASSERT( sizeof(struct get_window_text_request
) == 16 );
1599 C_ASSERT( sizeof(struct get_window_text_reply
) == 8 );
1600 C_ASSERT( FIELD_OFFSET(struct set_window_text_request
, handle
) == 12 );
1601 C_ASSERT( sizeof(struct set_window_text_request
) == 16 );
1602 C_ASSERT( FIELD_OFFSET(struct get_windows_offset_request
, from
) == 12 );
1603 C_ASSERT( FIELD_OFFSET(struct get_windows_offset_request
, to
) == 16 );
1604 C_ASSERT( sizeof(struct get_windows_offset_request
) == 24 );
1605 C_ASSERT( FIELD_OFFSET(struct get_windows_offset_reply
, x
) == 8 );
1606 C_ASSERT( FIELD_OFFSET(struct get_windows_offset_reply
, y
) == 12 );
1607 C_ASSERT( FIELD_OFFSET(struct get_windows_offset_reply
, mirror
) == 16 );
1608 C_ASSERT( sizeof(struct get_windows_offset_reply
) == 24 );
1609 C_ASSERT( FIELD_OFFSET(struct get_visible_region_request
, window
) == 12 );
1610 C_ASSERT( FIELD_OFFSET(struct get_visible_region_request
, flags
) == 16 );
1611 C_ASSERT( sizeof(struct get_visible_region_request
) == 24 );
1612 C_ASSERT( FIELD_OFFSET(struct get_visible_region_reply
, top_win
) == 8 );
1613 C_ASSERT( FIELD_OFFSET(struct get_visible_region_reply
, top_rect
) == 12 );
1614 C_ASSERT( FIELD_OFFSET(struct get_visible_region_reply
, win_rect
) == 28 );
1615 C_ASSERT( FIELD_OFFSET(struct get_visible_region_reply
, total_size
) == 44 );
1616 C_ASSERT( sizeof(struct get_visible_region_reply
) == 48 );
1617 C_ASSERT( FIELD_OFFSET(struct get_window_region_request
, window
) == 12 );
1618 C_ASSERT( sizeof(struct get_window_region_request
) == 16 );
1619 C_ASSERT( FIELD_OFFSET(struct get_window_region_reply
, total_size
) == 8 );
1620 C_ASSERT( sizeof(struct get_window_region_reply
) == 16 );
1621 C_ASSERT( FIELD_OFFSET(struct set_window_region_request
, window
) == 12 );
1622 C_ASSERT( FIELD_OFFSET(struct set_window_region_request
, redraw
) == 16 );
1623 C_ASSERT( sizeof(struct set_window_region_request
) == 24 );
1624 C_ASSERT( FIELD_OFFSET(struct get_update_region_request
, window
) == 12 );
1625 C_ASSERT( FIELD_OFFSET(struct get_update_region_request
, from_child
) == 16 );
1626 C_ASSERT( FIELD_OFFSET(struct get_update_region_request
, flags
) == 20 );
1627 C_ASSERT( sizeof(struct get_update_region_request
) == 24 );
1628 C_ASSERT( FIELD_OFFSET(struct get_update_region_reply
, child
) == 8 );
1629 C_ASSERT( FIELD_OFFSET(struct get_update_region_reply
, flags
) == 12 );
1630 C_ASSERT( FIELD_OFFSET(struct get_update_region_reply
, total_size
) == 16 );
1631 C_ASSERT( sizeof(struct get_update_region_reply
) == 24 );
1632 C_ASSERT( FIELD_OFFSET(struct update_window_zorder_request
, window
) == 12 );
1633 C_ASSERT( FIELD_OFFSET(struct update_window_zorder_request
, rect
) == 16 );
1634 C_ASSERT( sizeof(struct update_window_zorder_request
) == 32 );
1635 C_ASSERT( FIELD_OFFSET(struct redraw_window_request
, window
) == 12 );
1636 C_ASSERT( FIELD_OFFSET(struct redraw_window_request
, flags
) == 16 );
1637 C_ASSERT( sizeof(struct redraw_window_request
) == 24 );
1638 C_ASSERT( FIELD_OFFSET(struct set_window_property_request
, window
) == 12 );
1639 C_ASSERT( FIELD_OFFSET(struct set_window_property_request
, data
) == 16 );
1640 C_ASSERT( FIELD_OFFSET(struct set_window_property_request
, atom
) == 24 );
1641 C_ASSERT( sizeof(struct set_window_property_request
) == 32 );
1642 C_ASSERT( FIELD_OFFSET(struct remove_window_property_request
, window
) == 12 );
1643 C_ASSERT( FIELD_OFFSET(struct remove_window_property_request
, atom
) == 16 );
1644 C_ASSERT( sizeof(struct remove_window_property_request
) == 24 );
1645 C_ASSERT( FIELD_OFFSET(struct remove_window_property_reply
, data
) == 8 );
1646 C_ASSERT( sizeof(struct remove_window_property_reply
) == 16 );
1647 C_ASSERT( FIELD_OFFSET(struct get_window_property_request
, window
) == 12 );
1648 C_ASSERT( FIELD_OFFSET(struct get_window_property_request
, atom
) == 16 );
1649 C_ASSERT( sizeof(struct get_window_property_request
) == 24 );
1650 C_ASSERT( FIELD_OFFSET(struct get_window_property_reply
, data
) == 8 );
1651 C_ASSERT( sizeof(struct get_window_property_reply
) == 16 );
1652 C_ASSERT( FIELD_OFFSET(struct get_window_properties_request
, window
) == 12 );
1653 C_ASSERT( sizeof(struct get_window_properties_request
) == 16 );
1654 C_ASSERT( FIELD_OFFSET(struct get_window_properties_reply
, total
) == 8 );
1655 C_ASSERT( sizeof(struct get_window_properties_reply
) == 16 );
1656 C_ASSERT( FIELD_OFFSET(struct create_winstation_request
, flags
) == 12 );
1657 C_ASSERT( FIELD_OFFSET(struct create_winstation_request
, access
) == 16 );
1658 C_ASSERT( FIELD_OFFSET(struct create_winstation_request
, attributes
) == 20 );
1659 C_ASSERT( sizeof(struct create_winstation_request
) == 24 );
1660 C_ASSERT( FIELD_OFFSET(struct create_winstation_reply
, handle
) == 8 );
1661 C_ASSERT( sizeof(struct create_winstation_reply
) == 16 );
1662 C_ASSERT( FIELD_OFFSET(struct open_winstation_request
, access
) == 12 );
1663 C_ASSERT( FIELD_OFFSET(struct open_winstation_request
, attributes
) == 16 );
1664 C_ASSERT( sizeof(struct open_winstation_request
) == 24 );
1665 C_ASSERT( FIELD_OFFSET(struct open_winstation_reply
, handle
) == 8 );
1666 C_ASSERT( sizeof(struct open_winstation_reply
) == 16 );
1667 C_ASSERT( FIELD_OFFSET(struct close_winstation_request
, handle
) == 12 );
1668 C_ASSERT( sizeof(struct close_winstation_request
) == 16 );
1669 C_ASSERT( sizeof(struct get_process_winstation_request
) == 16 );
1670 C_ASSERT( FIELD_OFFSET(struct get_process_winstation_reply
, handle
) == 8 );
1671 C_ASSERT( sizeof(struct get_process_winstation_reply
) == 16 );
1672 C_ASSERT( FIELD_OFFSET(struct set_process_winstation_request
, handle
) == 12 );
1673 C_ASSERT( sizeof(struct set_process_winstation_request
) == 16 );
1674 C_ASSERT( FIELD_OFFSET(struct enum_winstation_request
, index
) == 12 );
1675 C_ASSERT( sizeof(struct enum_winstation_request
) == 16 );
1676 C_ASSERT( FIELD_OFFSET(struct enum_winstation_reply
, next
) == 8 );
1677 C_ASSERT( sizeof(struct enum_winstation_reply
) == 16 );
1678 C_ASSERT( FIELD_OFFSET(struct create_desktop_request
, flags
) == 12 );
1679 C_ASSERT( FIELD_OFFSET(struct create_desktop_request
, access
) == 16 );
1680 C_ASSERT( FIELD_OFFSET(struct create_desktop_request
, attributes
) == 20 );
1681 C_ASSERT( sizeof(struct create_desktop_request
) == 24 );
1682 C_ASSERT( FIELD_OFFSET(struct create_desktop_reply
, handle
) == 8 );
1683 C_ASSERT( sizeof(struct create_desktop_reply
) == 16 );
1684 C_ASSERT( FIELD_OFFSET(struct open_desktop_request
, winsta
) == 12 );
1685 C_ASSERT( FIELD_OFFSET(struct open_desktop_request
, flags
) == 16 );
1686 C_ASSERT( FIELD_OFFSET(struct open_desktop_request
, access
) == 20 );
1687 C_ASSERT( FIELD_OFFSET(struct open_desktop_request
, attributes
) == 24 );
1688 C_ASSERT( sizeof(struct open_desktop_request
) == 32 );
1689 C_ASSERT( FIELD_OFFSET(struct open_desktop_reply
, handle
) == 8 );
1690 C_ASSERT( sizeof(struct open_desktop_reply
) == 16 );
1691 C_ASSERT( FIELD_OFFSET(struct close_desktop_request
, handle
) == 12 );
1692 C_ASSERT( sizeof(struct close_desktop_request
) == 16 );
1693 C_ASSERT( FIELD_OFFSET(struct get_thread_desktop_request
, tid
) == 12 );
1694 C_ASSERT( sizeof(struct get_thread_desktop_request
) == 16 );
1695 C_ASSERT( FIELD_OFFSET(struct get_thread_desktop_reply
, handle
) == 8 );
1696 C_ASSERT( sizeof(struct get_thread_desktop_reply
) == 16 );
1697 C_ASSERT( FIELD_OFFSET(struct set_thread_desktop_request
, handle
) == 12 );
1698 C_ASSERT( sizeof(struct set_thread_desktop_request
) == 16 );
1699 C_ASSERT( FIELD_OFFSET(struct enum_desktop_request
, winstation
) == 12 );
1700 C_ASSERT( FIELD_OFFSET(struct enum_desktop_request
, index
) == 16 );
1701 C_ASSERT( sizeof(struct enum_desktop_request
) == 24 );
1702 C_ASSERT( FIELD_OFFSET(struct enum_desktop_reply
, next
) == 8 );
1703 C_ASSERT( sizeof(struct enum_desktop_reply
) == 16 );
1704 C_ASSERT( FIELD_OFFSET(struct set_user_object_info_request
, handle
) == 12 );
1705 C_ASSERT( FIELD_OFFSET(struct set_user_object_info_request
, flags
) == 16 );
1706 C_ASSERT( FIELD_OFFSET(struct set_user_object_info_request
, obj_flags
) == 20 );
1707 C_ASSERT( sizeof(struct set_user_object_info_request
) == 24 );
1708 C_ASSERT( FIELD_OFFSET(struct set_user_object_info_reply
, is_desktop
) == 8 );
1709 C_ASSERT( FIELD_OFFSET(struct set_user_object_info_reply
, old_obj_flags
) == 12 );
1710 C_ASSERT( sizeof(struct set_user_object_info_reply
) == 16 );
1711 C_ASSERT( FIELD_OFFSET(struct attach_thread_input_request
, tid_from
) == 12 );
1712 C_ASSERT( FIELD_OFFSET(struct attach_thread_input_request
, tid_to
) == 16 );
1713 C_ASSERT( FIELD_OFFSET(struct attach_thread_input_request
, attach
) == 20 );
1714 C_ASSERT( sizeof(struct attach_thread_input_request
) == 24 );
1715 C_ASSERT( FIELD_OFFSET(struct get_thread_input_request
, tid
) == 12 );
1716 C_ASSERT( sizeof(struct get_thread_input_request
) == 16 );
1717 C_ASSERT( FIELD_OFFSET(struct get_thread_input_reply
, focus
) == 8 );
1718 C_ASSERT( FIELD_OFFSET(struct get_thread_input_reply
, capture
) == 12 );
1719 C_ASSERT( FIELD_OFFSET(struct get_thread_input_reply
, active
) == 16 );
1720 C_ASSERT( FIELD_OFFSET(struct get_thread_input_reply
, foreground
) == 20 );
1721 C_ASSERT( FIELD_OFFSET(struct get_thread_input_reply
, menu_owner
) == 24 );
1722 C_ASSERT( FIELD_OFFSET(struct get_thread_input_reply
, move_size
) == 28 );
1723 C_ASSERT( FIELD_OFFSET(struct get_thread_input_reply
, caret
) == 32 );
1724 C_ASSERT( FIELD_OFFSET(struct get_thread_input_reply
, cursor
) == 36 );
1725 C_ASSERT( FIELD_OFFSET(struct get_thread_input_reply
, show_count
) == 40 );
1726 C_ASSERT( FIELD_OFFSET(struct get_thread_input_reply
, rect
) == 44 );
1727 C_ASSERT( sizeof(struct get_thread_input_reply
) == 64 );
1728 C_ASSERT( sizeof(struct get_last_input_time_request
) == 16 );
1729 C_ASSERT( FIELD_OFFSET(struct get_last_input_time_reply
, time
) == 8 );
1730 C_ASSERT( sizeof(struct get_last_input_time_reply
) == 16 );
1731 C_ASSERT( FIELD_OFFSET(struct get_key_state_request
, tid
) == 12 );
1732 C_ASSERT( FIELD_OFFSET(struct get_key_state_request
, key
) == 16 );
1733 C_ASSERT( sizeof(struct get_key_state_request
) == 24 );
1734 C_ASSERT( FIELD_OFFSET(struct get_key_state_reply
, state
) == 8 );
1735 C_ASSERT( sizeof(struct get_key_state_reply
) == 16 );
1736 C_ASSERT( FIELD_OFFSET(struct set_key_state_request
, tid
) == 12 );
1737 C_ASSERT( sizeof(struct set_key_state_request
) == 16 );
1738 C_ASSERT( FIELD_OFFSET(struct set_foreground_window_request
, handle
) == 12 );
1739 C_ASSERT( sizeof(struct set_foreground_window_request
) == 16 );
1740 C_ASSERT( FIELD_OFFSET(struct set_foreground_window_reply
, previous
) == 8 );
1741 C_ASSERT( FIELD_OFFSET(struct set_foreground_window_reply
, send_msg_old
) == 12 );
1742 C_ASSERT( FIELD_OFFSET(struct set_foreground_window_reply
, send_msg_new
) == 16 );
1743 C_ASSERT( sizeof(struct set_foreground_window_reply
) == 24 );
1744 C_ASSERT( FIELD_OFFSET(struct set_focus_window_request
, handle
) == 12 );
1745 C_ASSERT( sizeof(struct set_focus_window_request
) == 16 );
1746 C_ASSERT( FIELD_OFFSET(struct set_focus_window_reply
, previous
) == 8 );
1747 C_ASSERT( sizeof(struct set_focus_window_reply
) == 16 );
1748 C_ASSERT( FIELD_OFFSET(struct set_active_window_request
, handle
) == 12 );
1749 C_ASSERT( sizeof(struct set_active_window_request
) == 16 );
1750 C_ASSERT( FIELD_OFFSET(struct set_active_window_reply
, previous
) == 8 );
1751 C_ASSERT( sizeof(struct set_active_window_reply
) == 16 );
1752 C_ASSERT( FIELD_OFFSET(struct set_capture_window_request
, handle
) == 12 );
1753 C_ASSERT( FIELD_OFFSET(struct set_capture_window_request
, flags
) == 16 );
1754 C_ASSERT( sizeof(struct set_capture_window_request
) == 24 );
1755 C_ASSERT( FIELD_OFFSET(struct set_capture_window_reply
, previous
) == 8 );
1756 C_ASSERT( FIELD_OFFSET(struct set_capture_window_reply
, full_handle
) == 12 );
1757 C_ASSERT( sizeof(struct set_capture_window_reply
) == 16 );
1758 C_ASSERT( FIELD_OFFSET(struct set_caret_window_request
, handle
) == 12 );
1759 C_ASSERT( FIELD_OFFSET(struct set_caret_window_request
, width
) == 16 );
1760 C_ASSERT( FIELD_OFFSET(struct set_caret_window_request
, height
) == 20 );
1761 C_ASSERT( sizeof(struct set_caret_window_request
) == 24 );
1762 C_ASSERT( FIELD_OFFSET(struct set_caret_window_reply
, previous
) == 8 );
1763 C_ASSERT( FIELD_OFFSET(struct set_caret_window_reply
, old_rect
) == 12 );
1764 C_ASSERT( FIELD_OFFSET(struct set_caret_window_reply
, old_hide
) == 28 );
1765 C_ASSERT( FIELD_OFFSET(struct set_caret_window_reply
, old_state
) == 32 );
1766 C_ASSERT( sizeof(struct set_caret_window_reply
) == 40 );
1767 C_ASSERT( FIELD_OFFSET(struct set_caret_info_request
, flags
) == 12 );
1768 C_ASSERT( FIELD_OFFSET(struct set_caret_info_request
, handle
) == 16 );
1769 C_ASSERT( FIELD_OFFSET(struct set_caret_info_request
, x
) == 20 );
1770 C_ASSERT( FIELD_OFFSET(struct set_caret_info_request
, y
) == 24 );
1771 C_ASSERT( FIELD_OFFSET(struct set_caret_info_request
, hide
) == 28 );
1772 C_ASSERT( FIELD_OFFSET(struct set_caret_info_request
, state
) == 32 );
1773 C_ASSERT( sizeof(struct set_caret_info_request
) == 40 );
1774 C_ASSERT( FIELD_OFFSET(struct set_caret_info_reply
, full_handle
) == 8 );
1775 C_ASSERT( FIELD_OFFSET(struct set_caret_info_reply
, old_rect
) == 12 );
1776 C_ASSERT( FIELD_OFFSET(struct set_caret_info_reply
, old_hide
) == 28 );
1777 C_ASSERT( FIELD_OFFSET(struct set_caret_info_reply
, old_state
) == 32 );
1778 C_ASSERT( sizeof(struct set_caret_info_reply
) == 40 );
1779 C_ASSERT( FIELD_OFFSET(struct set_hook_request
, id
) == 12 );
1780 C_ASSERT( FIELD_OFFSET(struct set_hook_request
, pid
) == 16 );
1781 C_ASSERT( FIELD_OFFSET(struct set_hook_request
, tid
) == 20 );
1782 C_ASSERT( FIELD_OFFSET(struct set_hook_request
, event_min
) == 24 );
1783 C_ASSERT( FIELD_OFFSET(struct set_hook_request
, event_max
) == 28 );
1784 C_ASSERT( FIELD_OFFSET(struct set_hook_request
, proc
) == 32 );
1785 C_ASSERT( FIELD_OFFSET(struct set_hook_request
, flags
) == 40 );
1786 C_ASSERT( FIELD_OFFSET(struct set_hook_request
, unicode
) == 44 );
1787 C_ASSERT( sizeof(struct set_hook_request
) == 48 );
1788 C_ASSERT( FIELD_OFFSET(struct set_hook_reply
, handle
) == 8 );
1789 C_ASSERT( FIELD_OFFSET(struct set_hook_reply
, active_hooks
) == 12 );
1790 C_ASSERT( sizeof(struct set_hook_reply
) == 16 );
1791 C_ASSERT( FIELD_OFFSET(struct remove_hook_request
, handle
) == 12 );
1792 C_ASSERT( FIELD_OFFSET(struct remove_hook_request
, proc
) == 16 );
1793 C_ASSERT( FIELD_OFFSET(struct remove_hook_request
, id
) == 24 );
1794 C_ASSERT( sizeof(struct remove_hook_request
) == 32 );
1795 C_ASSERT( FIELD_OFFSET(struct remove_hook_reply
, active_hooks
) == 8 );
1796 C_ASSERT( sizeof(struct remove_hook_reply
) == 16 );
1797 C_ASSERT( FIELD_OFFSET(struct start_hook_chain_request
, id
) == 12 );
1798 C_ASSERT( FIELD_OFFSET(struct start_hook_chain_request
, event
) == 16 );
1799 C_ASSERT( FIELD_OFFSET(struct start_hook_chain_request
, window
) == 20 );
1800 C_ASSERT( FIELD_OFFSET(struct start_hook_chain_request
, object_id
) == 24 );
1801 C_ASSERT( FIELD_OFFSET(struct start_hook_chain_request
, child_id
) == 28 );
1802 C_ASSERT( sizeof(struct start_hook_chain_request
) == 32 );
1803 C_ASSERT( FIELD_OFFSET(struct start_hook_chain_reply
, handle
) == 8 );
1804 C_ASSERT( FIELD_OFFSET(struct start_hook_chain_reply
, pid
) == 12 );
1805 C_ASSERT( FIELD_OFFSET(struct start_hook_chain_reply
, tid
) == 16 );
1806 C_ASSERT( FIELD_OFFSET(struct start_hook_chain_reply
, unicode
) == 20 );
1807 C_ASSERT( FIELD_OFFSET(struct start_hook_chain_reply
, proc
) == 24 );
1808 C_ASSERT( FIELD_OFFSET(struct start_hook_chain_reply
, active_hooks
) == 32 );
1809 C_ASSERT( sizeof(struct start_hook_chain_reply
) == 40 );
1810 C_ASSERT( FIELD_OFFSET(struct finish_hook_chain_request
, id
) == 12 );
1811 C_ASSERT( sizeof(struct finish_hook_chain_request
) == 16 );
1812 C_ASSERT( FIELD_OFFSET(struct get_hook_info_request
, handle
) == 12 );
1813 C_ASSERT( FIELD_OFFSET(struct get_hook_info_request
, get_next
) == 16 );
1814 C_ASSERT( FIELD_OFFSET(struct get_hook_info_request
, event
) == 20 );
1815 C_ASSERT( FIELD_OFFSET(struct get_hook_info_request
, window
) == 24 );
1816 C_ASSERT( FIELD_OFFSET(struct get_hook_info_request
, object_id
) == 28 );
1817 C_ASSERT( FIELD_OFFSET(struct get_hook_info_request
, child_id
) == 32 );
1818 C_ASSERT( sizeof(struct get_hook_info_request
) == 40 );
1819 C_ASSERT( FIELD_OFFSET(struct get_hook_info_reply
, handle
) == 8 );
1820 C_ASSERT( FIELD_OFFSET(struct get_hook_info_reply
, id
) == 12 );
1821 C_ASSERT( FIELD_OFFSET(struct get_hook_info_reply
, pid
) == 16 );
1822 C_ASSERT( FIELD_OFFSET(struct get_hook_info_reply
, tid
) == 20 );
1823 C_ASSERT( FIELD_OFFSET(struct get_hook_info_reply
, proc
) == 24 );
1824 C_ASSERT( FIELD_OFFSET(struct get_hook_info_reply
, unicode
) == 32 );
1825 C_ASSERT( sizeof(struct get_hook_info_reply
) == 40 );
1826 C_ASSERT( FIELD_OFFSET(struct create_class_request
, local
) == 12 );
1827 C_ASSERT( FIELD_OFFSET(struct create_class_request
, atom
) == 16 );
1828 C_ASSERT( FIELD_OFFSET(struct create_class_request
, style
) == 20 );
1829 C_ASSERT( FIELD_OFFSET(struct create_class_request
, instance
) == 24 );
1830 C_ASSERT( FIELD_OFFSET(struct create_class_request
, extra
) == 32 );
1831 C_ASSERT( FIELD_OFFSET(struct create_class_request
, win_extra
) == 36 );
1832 C_ASSERT( FIELD_OFFSET(struct create_class_request
, client_ptr
) == 40 );
1833 C_ASSERT( sizeof(struct create_class_request
) == 48 );
1834 C_ASSERT( FIELD_OFFSET(struct create_class_reply
, atom
) == 8 );
1835 C_ASSERT( sizeof(struct create_class_reply
) == 16 );
1836 C_ASSERT( FIELD_OFFSET(struct destroy_class_request
, atom
) == 12 );
1837 C_ASSERT( FIELD_OFFSET(struct destroy_class_request
, instance
) == 16 );
1838 C_ASSERT( sizeof(struct destroy_class_request
) == 24 );
1839 C_ASSERT( FIELD_OFFSET(struct destroy_class_reply
, client_ptr
) == 8 );
1840 C_ASSERT( sizeof(struct destroy_class_reply
) == 16 );
1841 C_ASSERT( FIELD_OFFSET(struct set_class_info_request
, window
) == 12 );
1842 C_ASSERT( FIELD_OFFSET(struct set_class_info_request
, flags
) == 16 );
1843 C_ASSERT( FIELD_OFFSET(struct set_class_info_request
, atom
) == 20 );
1844 C_ASSERT( FIELD_OFFSET(struct set_class_info_request
, style
) == 24 );
1845 C_ASSERT( FIELD_OFFSET(struct set_class_info_request
, win_extra
) == 28 );
1846 C_ASSERT( FIELD_OFFSET(struct set_class_info_request
, instance
) == 32 );
1847 C_ASSERT( FIELD_OFFSET(struct set_class_info_request
, extra_offset
) == 40 );
1848 C_ASSERT( FIELD_OFFSET(struct set_class_info_request
, extra_size
) == 44 );
1849 C_ASSERT( FIELD_OFFSET(struct set_class_info_request
, extra_value
) == 48 );
1850 C_ASSERT( sizeof(struct set_class_info_request
) == 56 );
1851 C_ASSERT( FIELD_OFFSET(struct set_class_info_reply
, old_atom
) == 8 );
1852 C_ASSERT( FIELD_OFFSET(struct set_class_info_reply
, old_style
) == 12 );
1853 C_ASSERT( FIELD_OFFSET(struct set_class_info_reply
, old_extra
) == 16 );
1854 C_ASSERT( FIELD_OFFSET(struct set_class_info_reply
, old_win_extra
) == 20 );
1855 C_ASSERT( FIELD_OFFSET(struct set_class_info_reply
, old_instance
) == 24 );
1856 C_ASSERT( FIELD_OFFSET(struct set_class_info_reply
, old_extra_value
) == 32 );
1857 C_ASSERT( sizeof(struct set_class_info_reply
) == 40 );
1858 C_ASSERT( FIELD_OFFSET(struct set_clipboard_info_request
, flags
) == 12 );
1859 C_ASSERT( FIELD_OFFSET(struct set_clipboard_info_request
, clipboard
) == 16 );
1860 C_ASSERT( FIELD_OFFSET(struct set_clipboard_info_request
, owner
) == 20 );
1861 C_ASSERT( FIELD_OFFSET(struct set_clipboard_info_request
, viewer
) == 24 );
1862 C_ASSERT( FIELD_OFFSET(struct set_clipboard_info_request
, seqno
) == 28 );
1863 C_ASSERT( sizeof(struct set_clipboard_info_request
) == 32 );
1864 C_ASSERT( FIELD_OFFSET(struct set_clipboard_info_reply
, flags
) == 8 );
1865 C_ASSERT( FIELD_OFFSET(struct set_clipboard_info_reply
, old_clipboard
) == 12 );
1866 C_ASSERT( FIELD_OFFSET(struct set_clipboard_info_reply
, old_owner
) == 16 );
1867 C_ASSERT( FIELD_OFFSET(struct set_clipboard_info_reply
, old_viewer
) == 20 );
1868 C_ASSERT( FIELD_OFFSET(struct set_clipboard_info_reply
, seqno
) == 24 );
1869 C_ASSERT( sizeof(struct set_clipboard_info_reply
) == 32 );
1870 C_ASSERT( FIELD_OFFSET(struct open_token_request
, handle
) == 12 );
1871 C_ASSERT( FIELD_OFFSET(struct open_token_request
, access
) == 16 );
1872 C_ASSERT( FIELD_OFFSET(struct open_token_request
, attributes
) == 20 );
1873 C_ASSERT( FIELD_OFFSET(struct open_token_request
, flags
) == 24 );
1874 C_ASSERT( sizeof(struct open_token_request
) == 32 );
1875 C_ASSERT( FIELD_OFFSET(struct open_token_reply
, token
) == 8 );
1876 C_ASSERT( sizeof(struct open_token_reply
) == 16 );
1877 C_ASSERT( FIELD_OFFSET(struct set_global_windows_request
, flags
) == 12 );
1878 C_ASSERT( FIELD_OFFSET(struct set_global_windows_request
, shell_window
) == 16 );
1879 C_ASSERT( FIELD_OFFSET(struct set_global_windows_request
, shell_listview
) == 20 );
1880 C_ASSERT( FIELD_OFFSET(struct set_global_windows_request
, progman_window
) == 24 );
1881 C_ASSERT( FIELD_OFFSET(struct set_global_windows_request
, taskman_window
) == 28 );
1882 C_ASSERT( sizeof(struct set_global_windows_request
) == 32 );
1883 C_ASSERT( FIELD_OFFSET(struct set_global_windows_reply
, old_shell_window
) == 8 );
1884 C_ASSERT( FIELD_OFFSET(struct set_global_windows_reply
, old_shell_listview
) == 12 );
1885 C_ASSERT( FIELD_OFFSET(struct set_global_windows_reply
, old_progman_window
) == 16 );
1886 C_ASSERT( FIELD_OFFSET(struct set_global_windows_reply
, old_taskman_window
) == 20 );
1887 C_ASSERT( sizeof(struct set_global_windows_reply
) == 24 );
1888 C_ASSERT( FIELD_OFFSET(struct adjust_token_privileges_request
, handle
) == 12 );
1889 C_ASSERT( FIELD_OFFSET(struct adjust_token_privileges_request
, disable_all
) == 16 );
1890 C_ASSERT( FIELD_OFFSET(struct adjust_token_privileges_request
, get_modified_state
) == 20 );
1891 C_ASSERT( sizeof(struct adjust_token_privileges_request
) == 24 );
1892 C_ASSERT( FIELD_OFFSET(struct adjust_token_privileges_reply
, len
) == 8 );
1893 C_ASSERT( sizeof(struct adjust_token_privileges_reply
) == 16 );
1894 C_ASSERT( FIELD_OFFSET(struct get_token_privileges_request
, handle
) == 12 );
1895 C_ASSERT( sizeof(struct get_token_privileges_request
) == 16 );
1896 C_ASSERT( FIELD_OFFSET(struct get_token_privileges_reply
, len
) == 8 );
1897 C_ASSERT( sizeof(struct get_token_privileges_reply
) == 16 );
1898 C_ASSERT( FIELD_OFFSET(struct check_token_privileges_request
, handle
) == 12 );
1899 C_ASSERT( FIELD_OFFSET(struct check_token_privileges_request
, all_required
) == 16 );
1900 C_ASSERT( sizeof(struct check_token_privileges_request
) == 24 );
1901 C_ASSERT( FIELD_OFFSET(struct check_token_privileges_reply
, has_privileges
) == 8 );
1902 C_ASSERT( sizeof(struct check_token_privileges_reply
) == 16 );
1903 C_ASSERT( FIELD_OFFSET(struct duplicate_token_request
, handle
) == 12 );
1904 C_ASSERT( FIELD_OFFSET(struct duplicate_token_request
, access
) == 16 );
1905 C_ASSERT( FIELD_OFFSET(struct duplicate_token_request
, attributes
) == 20 );
1906 C_ASSERT( FIELD_OFFSET(struct duplicate_token_request
, primary
) == 24 );
1907 C_ASSERT( FIELD_OFFSET(struct duplicate_token_request
, impersonation_level
) == 28 );
1908 C_ASSERT( sizeof(struct duplicate_token_request
) == 32 );
1909 C_ASSERT( FIELD_OFFSET(struct duplicate_token_reply
, new_handle
) == 8 );
1910 C_ASSERT( sizeof(struct duplicate_token_reply
) == 16 );
1911 C_ASSERT( FIELD_OFFSET(struct access_check_request
, handle
) == 12 );
1912 C_ASSERT( FIELD_OFFSET(struct access_check_request
, desired_access
) == 16 );
1913 C_ASSERT( FIELD_OFFSET(struct access_check_request
, mapping_read
) == 20 );
1914 C_ASSERT( FIELD_OFFSET(struct access_check_request
, mapping_write
) == 24 );
1915 C_ASSERT( FIELD_OFFSET(struct access_check_request
, mapping_execute
) == 28 );
1916 C_ASSERT( FIELD_OFFSET(struct access_check_request
, mapping_all
) == 32 );
1917 C_ASSERT( sizeof(struct access_check_request
) == 40 );
1918 C_ASSERT( FIELD_OFFSET(struct access_check_reply
, access_granted
) == 8 );
1919 C_ASSERT( FIELD_OFFSET(struct access_check_reply
, access_status
) == 12 );
1920 C_ASSERT( FIELD_OFFSET(struct access_check_reply
, privileges_len
) == 16 );
1921 C_ASSERT( sizeof(struct access_check_reply
) == 24 );
1922 C_ASSERT( FIELD_OFFSET(struct get_token_sid_request
, handle
) == 12 );
1923 C_ASSERT( FIELD_OFFSET(struct get_token_sid_request
, which_sid
) == 16 );
1924 C_ASSERT( sizeof(struct get_token_sid_request
) == 24 );
1925 C_ASSERT( FIELD_OFFSET(struct get_token_sid_reply
, sid_len
) == 8 );
1926 C_ASSERT( sizeof(struct get_token_sid_reply
) == 16 );
1927 C_ASSERT( FIELD_OFFSET(struct get_token_groups_request
, handle
) == 12 );
1928 C_ASSERT( sizeof(struct get_token_groups_request
) == 16 );
1929 C_ASSERT( FIELD_OFFSET(struct get_token_groups_reply
, user_len
) == 8 );
1930 C_ASSERT( sizeof(struct get_token_groups_reply
) == 16 );
1931 C_ASSERT( FIELD_OFFSET(struct get_token_default_dacl_request
, handle
) == 12 );
1932 C_ASSERT( sizeof(struct get_token_default_dacl_request
) == 16 );
1933 C_ASSERT( FIELD_OFFSET(struct get_token_default_dacl_reply
, acl_len
) == 8 );
1934 C_ASSERT( sizeof(struct get_token_default_dacl_reply
) == 16 );
1935 C_ASSERT( FIELD_OFFSET(struct set_token_default_dacl_request
, handle
) == 12 );
1936 C_ASSERT( sizeof(struct set_token_default_dacl_request
) == 16 );
1937 C_ASSERT( FIELD_OFFSET(struct set_security_object_request
, handle
) == 12 );
1938 C_ASSERT( FIELD_OFFSET(struct set_security_object_request
, security_info
) == 16 );
1939 C_ASSERT( sizeof(struct set_security_object_request
) == 24 );
1940 C_ASSERT( FIELD_OFFSET(struct get_security_object_request
, handle
) == 12 );
1941 C_ASSERT( FIELD_OFFSET(struct get_security_object_request
, security_info
) == 16 );
1942 C_ASSERT( sizeof(struct get_security_object_request
) == 24 );
1943 C_ASSERT( FIELD_OFFSET(struct get_security_object_reply
, sd_len
) == 8 );
1944 C_ASSERT( sizeof(struct get_security_object_reply
) == 16 );
1945 C_ASSERT( FIELD_OFFSET(struct create_mailslot_request
, access
) == 12 );
1946 C_ASSERT( FIELD_OFFSET(struct create_mailslot_request
, attributes
) == 16 );
1947 C_ASSERT( FIELD_OFFSET(struct create_mailslot_request
, rootdir
) == 20 );
1948 C_ASSERT( FIELD_OFFSET(struct create_mailslot_request
, read_timeout
) == 24 );
1949 C_ASSERT( FIELD_OFFSET(struct create_mailslot_request
, max_msgsize
) == 32 );
1950 C_ASSERT( sizeof(struct create_mailslot_request
) == 40 );
1951 C_ASSERT( FIELD_OFFSET(struct create_mailslot_reply
, handle
) == 8 );
1952 C_ASSERT( sizeof(struct create_mailslot_reply
) == 16 );
1953 C_ASSERT( FIELD_OFFSET(struct set_mailslot_info_request
, handle
) == 12 );
1954 C_ASSERT( FIELD_OFFSET(struct set_mailslot_info_request
, read_timeout
) == 16 );
1955 C_ASSERT( FIELD_OFFSET(struct set_mailslot_info_request
, flags
) == 24 );
1956 C_ASSERT( sizeof(struct set_mailslot_info_request
) == 32 );
1957 C_ASSERT( FIELD_OFFSET(struct set_mailslot_info_reply
, read_timeout
) == 8 );
1958 C_ASSERT( FIELD_OFFSET(struct set_mailslot_info_reply
, max_msgsize
) == 16 );
1959 C_ASSERT( sizeof(struct set_mailslot_info_reply
) == 24 );
1960 C_ASSERT( FIELD_OFFSET(struct create_directory_request
, access
) == 12 );
1961 C_ASSERT( FIELD_OFFSET(struct create_directory_request
, attributes
) == 16 );
1962 C_ASSERT( FIELD_OFFSET(struct create_directory_request
, rootdir
) == 20 );
1963 C_ASSERT( sizeof(struct create_directory_request
) == 24 );
1964 C_ASSERT( FIELD_OFFSET(struct create_directory_reply
, handle
) == 8 );
1965 C_ASSERT( sizeof(struct create_directory_reply
) == 16 );
1966 C_ASSERT( FIELD_OFFSET(struct open_directory_request
, access
) == 12 );
1967 C_ASSERT( FIELD_OFFSET(struct open_directory_request
, attributes
) == 16 );
1968 C_ASSERT( FIELD_OFFSET(struct open_directory_request
, rootdir
) == 20 );
1969 C_ASSERT( sizeof(struct open_directory_request
) == 24 );
1970 C_ASSERT( FIELD_OFFSET(struct open_directory_reply
, handle
) == 8 );
1971 C_ASSERT( sizeof(struct open_directory_reply
) == 16 );
1972 C_ASSERT( FIELD_OFFSET(struct get_directory_entry_request
, handle
) == 12 );
1973 C_ASSERT( FIELD_OFFSET(struct get_directory_entry_request
, index
) == 16 );
1974 C_ASSERT( sizeof(struct get_directory_entry_request
) == 24 );
1975 C_ASSERT( FIELD_OFFSET(struct get_directory_entry_reply
, name_len
) == 8 );
1976 C_ASSERT( sizeof(struct get_directory_entry_reply
) == 16 );
1977 C_ASSERT( FIELD_OFFSET(struct create_symlink_request
, access
) == 12 );
1978 C_ASSERT( FIELD_OFFSET(struct create_symlink_request
, attributes
) == 16 );
1979 C_ASSERT( FIELD_OFFSET(struct create_symlink_request
, rootdir
) == 20 );
1980 C_ASSERT( FIELD_OFFSET(struct create_symlink_request
, name_len
) == 24 );
1981 C_ASSERT( sizeof(struct create_symlink_request
) == 32 );
1982 C_ASSERT( FIELD_OFFSET(struct create_symlink_reply
, handle
) == 8 );
1983 C_ASSERT( sizeof(struct create_symlink_reply
) == 16 );
1984 C_ASSERT( FIELD_OFFSET(struct open_symlink_request
, access
) == 12 );
1985 C_ASSERT( FIELD_OFFSET(struct open_symlink_request
, attributes
) == 16 );
1986 C_ASSERT( FIELD_OFFSET(struct open_symlink_request
, rootdir
) == 20 );
1987 C_ASSERT( sizeof(struct open_symlink_request
) == 24 );
1988 C_ASSERT( FIELD_OFFSET(struct open_symlink_reply
, handle
) == 8 );
1989 C_ASSERT( sizeof(struct open_symlink_reply
) == 16 );
1990 C_ASSERT( FIELD_OFFSET(struct query_symlink_request
, handle
) == 12 );
1991 C_ASSERT( sizeof(struct query_symlink_request
) == 16 );
1992 C_ASSERT( FIELD_OFFSET(struct query_symlink_reply
, total
) == 8 );
1993 C_ASSERT( sizeof(struct query_symlink_reply
) == 16 );
1994 C_ASSERT( FIELD_OFFSET(struct get_object_info_request
, handle
) == 12 );
1995 C_ASSERT( sizeof(struct get_object_info_request
) == 16 );
1996 C_ASSERT( FIELD_OFFSET(struct get_object_info_reply
, access
) == 8 );
1997 C_ASSERT( FIELD_OFFSET(struct get_object_info_reply
, ref_count
) == 12 );
1998 C_ASSERT( FIELD_OFFSET(struct get_object_info_reply
, total
) == 16 );
1999 C_ASSERT( sizeof(struct get_object_info_reply
) == 24 );
2000 C_ASSERT( FIELD_OFFSET(struct unlink_object_request
, handle
) == 12 );
2001 C_ASSERT( sizeof(struct unlink_object_request
) == 16 );
2002 C_ASSERT( FIELD_OFFSET(struct get_token_impersonation_level_request
, handle
) == 12 );
2003 C_ASSERT( sizeof(struct get_token_impersonation_level_request
) == 16 );
2004 C_ASSERT( FIELD_OFFSET(struct get_token_impersonation_level_reply
, impersonation_level
) == 8 );
2005 C_ASSERT( sizeof(struct get_token_impersonation_level_reply
) == 16 );
2006 C_ASSERT( sizeof(struct allocate_locally_unique_id_request
) == 16 );
2007 C_ASSERT( FIELD_OFFSET(struct allocate_locally_unique_id_reply
, luid
) == 8 );
2008 C_ASSERT( sizeof(struct allocate_locally_unique_id_reply
) == 16 );
2009 C_ASSERT( FIELD_OFFSET(struct create_device_manager_request
, access
) == 12 );
2010 C_ASSERT( FIELD_OFFSET(struct create_device_manager_request
, attributes
) == 16 );
2011 C_ASSERT( sizeof(struct create_device_manager_request
) == 24 );
2012 C_ASSERT( FIELD_OFFSET(struct create_device_manager_reply
, handle
) == 8 );
2013 C_ASSERT( sizeof(struct create_device_manager_reply
) == 16 );
2014 C_ASSERT( FIELD_OFFSET(struct create_device_request
, access
) == 12 );
2015 C_ASSERT( FIELD_OFFSET(struct create_device_request
, attributes
) == 16 );
2016 C_ASSERT( FIELD_OFFSET(struct create_device_request
, rootdir
) == 20 );
2017 C_ASSERT( FIELD_OFFSET(struct create_device_request
, user_ptr
) == 24 );
2018 C_ASSERT( FIELD_OFFSET(struct create_device_request
, manager
) == 32 );
2019 C_ASSERT( sizeof(struct create_device_request
) == 40 );
2020 C_ASSERT( FIELD_OFFSET(struct create_device_reply
, handle
) == 8 );
2021 C_ASSERT( sizeof(struct create_device_reply
) == 16 );
2022 C_ASSERT( FIELD_OFFSET(struct delete_device_request
, handle
) == 12 );
2023 C_ASSERT( sizeof(struct delete_device_request
) == 16 );
2024 C_ASSERT( FIELD_OFFSET(struct get_next_device_request_request
, manager
) == 12 );
2025 C_ASSERT( FIELD_OFFSET(struct get_next_device_request_request
, prev
) == 16 );
2026 C_ASSERT( FIELD_OFFSET(struct get_next_device_request_request
, status
) == 20 );
2027 C_ASSERT( sizeof(struct get_next_device_request_request
) == 24 );
2028 C_ASSERT( FIELD_OFFSET(struct get_next_device_request_reply
, next
) == 8 );
2029 C_ASSERT( FIELD_OFFSET(struct get_next_device_request_reply
, code
) == 12 );
2030 C_ASSERT( FIELD_OFFSET(struct get_next_device_request_reply
, user_ptr
) == 16 );
2031 C_ASSERT( FIELD_OFFSET(struct get_next_device_request_reply
, in_size
) == 24 );
2032 C_ASSERT( FIELD_OFFSET(struct get_next_device_request_reply
, out_size
) == 28 );
2033 C_ASSERT( sizeof(struct get_next_device_request_reply
) == 32 );
2034 C_ASSERT( sizeof(struct make_process_system_request
) == 16 );
2035 C_ASSERT( FIELD_OFFSET(struct make_process_system_reply
, event
) == 8 );
2036 C_ASSERT( sizeof(struct make_process_system_reply
) == 16 );
2037 C_ASSERT( FIELD_OFFSET(struct get_token_statistics_request
, handle
) == 12 );
2038 C_ASSERT( sizeof(struct get_token_statistics_request
) == 16 );
2039 C_ASSERT( FIELD_OFFSET(struct get_token_statistics_reply
, token_id
) == 8 );
2040 C_ASSERT( FIELD_OFFSET(struct get_token_statistics_reply
, modified_id
) == 16 );
2041 C_ASSERT( FIELD_OFFSET(struct get_token_statistics_reply
, primary
) == 24 );
2042 C_ASSERT( FIELD_OFFSET(struct get_token_statistics_reply
, impersonation_level
) == 28 );
2043 C_ASSERT( FIELD_OFFSET(struct get_token_statistics_reply
, group_count
) == 32 );
2044 C_ASSERT( FIELD_OFFSET(struct get_token_statistics_reply
, privilege_count
) == 36 );
2045 C_ASSERT( sizeof(struct get_token_statistics_reply
) == 40 );
2046 C_ASSERT( FIELD_OFFSET(struct create_completion_request
, access
) == 12 );
2047 C_ASSERT( FIELD_OFFSET(struct create_completion_request
, attributes
) == 16 );
2048 C_ASSERT( FIELD_OFFSET(struct create_completion_request
, concurrent
) == 20 );
2049 C_ASSERT( FIELD_OFFSET(struct create_completion_request
, rootdir
) == 24 );
2050 C_ASSERT( sizeof(struct create_completion_request
) == 32 );
2051 C_ASSERT( FIELD_OFFSET(struct create_completion_reply
, handle
) == 8 );
2052 C_ASSERT( sizeof(struct create_completion_reply
) == 16 );
2053 C_ASSERT( FIELD_OFFSET(struct open_completion_request
, access
) == 12 );
2054 C_ASSERT( FIELD_OFFSET(struct open_completion_request
, attributes
) == 16 );
2055 C_ASSERT( FIELD_OFFSET(struct open_completion_request
, rootdir
) == 20 );
2056 C_ASSERT( sizeof(struct open_completion_request
) == 24 );
2057 C_ASSERT( FIELD_OFFSET(struct open_completion_reply
, handle
) == 8 );
2058 C_ASSERT( sizeof(struct open_completion_reply
) == 16 );
2059 C_ASSERT( FIELD_OFFSET(struct add_completion_request
, handle
) == 12 );
2060 C_ASSERT( FIELD_OFFSET(struct add_completion_request
, ckey
) == 16 );
2061 C_ASSERT( FIELD_OFFSET(struct add_completion_request
, cvalue
) == 24 );
2062 C_ASSERT( FIELD_OFFSET(struct add_completion_request
, information
) == 32 );
2063 C_ASSERT( FIELD_OFFSET(struct add_completion_request
, status
) == 36 );
2064 C_ASSERT( sizeof(struct add_completion_request
) == 40 );
2065 C_ASSERT( FIELD_OFFSET(struct remove_completion_request
, handle
) == 12 );
2066 C_ASSERT( sizeof(struct remove_completion_request
) == 16 );
2067 C_ASSERT( FIELD_OFFSET(struct remove_completion_reply
, ckey
) == 8 );
2068 C_ASSERT( FIELD_OFFSET(struct remove_completion_reply
, cvalue
) == 16 );
2069 C_ASSERT( FIELD_OFFSET(struct remove_completion_reply
, information
) == 24 );
2070 C_ASSERT( FIELD_OFFSET(struct remove_completion_reply
, status
) == 28 );
2071 C_ASSERT( sizeof(struct remove_completion_reply
) == 32 );
2072 C_ASSERT( FIELD_OFFSET(struct query_completion_request
, handle
) == 12 );
2073 C_ASSERT( sizeof(struct query_completion_request
) == 16 );
2074 C_ASSERT( FIELD_OFFSET(struct query_completion_reply
, depth
) == 8 );
2075 C_ASSERT( sizeof(struct query_completion_reply
) == 16 );
2076 C_ASSERT( FIELD_OFFSET(struct set_completion_info_request
, handle
) == 12 );
2077 C_ASSERT( FIELD_OFFSET(struct set_completion_info_request
, ckey
) == 16 );
2078 C_ASSERT( FIELD_OFFSET(struct set_completion_info_request
, chandle
) == 24 );
2079 C_ASSERT( sizeof(struct set_completion_info_request
) == 32 );
2080 C_ASSERT( FIELD_OFFSET(struct add_fd_completion_request
, handle
) == 12 );
2081 C_ASSERT( FIELD_OFFSET(struct add_fd_completion_request
, cvalue
) == 16 );
2082 C_ASSERT( FIELD_OFFSET(struct add_fd_completion_request
, status
) == 24 );
2083 C_ASSERT( FIELD_OFFSET(struct add_fd_completion_request
, information
) == 28 );
2084 C_ASSERT( sizeof(struct add_fd_completion_request
) == 32 );
2085 C_ASSERT( FIELD_OFFSET(struct get_window_layered_info_request
, handle
) == 12 );
2086 C_ASSERT( sizeof(struct get_window_layered_info_request
) == 16 );
2087 C_ASSERT( FIELD_OFFSET(struct get_window_layered_info_reply
, color_key
) == 8 );
2088 C_ASSERT( FIELD_OFFSET(struct get_window_layered_info_reply
, alpha
) == 12 );
2089 C_ASSERT( FIELD_OFFSET(struct get_window_layered_info_reply
, flags
) == 16 );
2090 C_ASSERT( sizeof(struct get_window_layered_info_reply
) == 24 );
2091 C_ASSERT( FIELD_OFFSET(struct set_window_layered_info_request
, handle
) == 12 );
2092 C_ASSERT( FIELD_OFFSET(struct set_window_layered_info_request
, color_key
) == 16 );
2093 C_ASSERT( FIELD_OFFSET(struct set_window_layered_info_request
, alpha
) == 20 );
2094 C_ASSERT( FIELD_OFFSET(struct set_window_layered_info_request
, flags
) == 24 );
2095 C_ASSERT( sizeof(struct set_window_layered_info_request
) == 32 );
2096 C_ASSERT( sizeof(struct alloc_user_handle_request
) == 16 );
2097 C_ASSERT( FIELD_OFFSET(struct alloc_user_handle_reply
, handle
) == 8 );
2098 C_ASSERT( sizeof(struct alloc_user_handle_reply
) == 16 );
2099 C_ASSERT( FIELD_OFFSET(struct free_user_handle_request
, handle
) == 12 );
2100 C_ASSERT( sizeof(struct free_user_handle_request
) == 16 );
2101 C_ASSERT( FIELD_OFFSET(struct set_cursor_request
, flags
) == 12 );
2102 C_ASSERT( FIELD_OFFSET(struct set_cursor_request
, handle
) == 16 );
2103 C_ASSERT( FIELD_OFFSET(struct set_cursor_request
, show_count
) == 20 );
2104 C_ASSERT( sizeof(struct set_cursor_request
) == 24 );
2105 C_ASSERT( FIELD_OFFSET(struct set_cursor_reply
, prev_handle
) == 8 );
2106 C_ASSERT( FIELD_OFFSET(struct set_cursor_reply
, prev_count
) == 12 );
2107 C_ASSERT( sizeof(struct set_cursor_reply
) == 16 );
2109 #endif /* WANT_REQUEST_HANDLERS */
2111 /* ### make_requests end ### */
2112 /* Everything above this line is generated automatically by tools/make_requests */
2114 #endif /* __WINE_SERVER_REQUEST_H */
