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_error( const char *err
, ... ) __attribute__((noreturn
,format(printf
,1,2)));
43 extern void fatal_protocol_error( struct thread
*thread
, const char *err
, ... );
44 extern void fatal_error( const char *err
, ... );
47 extern const char *get_config_dir(void);
48 extern void *set_reply_data_size( data_size_t size
);
49 extern const struct object_attributes
*get_req_object_attributes( const struct security_descriptor
**sd
,
50 struct unicode_str
*name
,
51 struct object
**root
);
52 extern const void *get_req_data_after_objattr( const struct object_attributes
*attr
, data_size_t
*len
);
53 extern int receive_fd( struct process
*process
);
54 extern int send_client_fd( struct process
*process
, int fd
, obj_handle_t handle
);
55 extern void read_request( struct thread
*thread
);
56 extern void write_reply( struct thread
*thread
);
57 extern timeout_t
monotonic_counter(void);
58 extern void open_master_socket(void);
59 extern void close_master_socket( timeout_t timeout
);
60 extern void shutdown_master_socket(void);
61 extern int wait_for_lock(void);
62 extern int kill_lock_owner( int sig
);
63 extern char *server_dir
;
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 current tick count to return to client */
70 static inline unsigned int get_tick_count(void)
72 return monotonic_counter() / 10000;
75 /* get the request vararg data */
76 static inline const void *get_req_data(void)
78 return current
->req_data
;
81 /* get the request vararg size */
82 static inline data_size_t
get_req_data_size(void)
84 return current
->req
.request_header
.request_size
;
87 /* get the request vararg as unicode string */
88 static inline struct unicode_str
get_req_unicode_str(void)
90 struct unicode_str ret
;
91 ret
.str
= get_req_data();
92 ret
.len
= (get_req_data_size() / sizeof(WCHAR
)) * sizeof(WCHAR
);
96 /* get the reply maximum vararg size */
97 static inline data_size_t
get_reply_max_size(void)
99 return current
->req
.request_header
.reply_size
;
102 /* allocate and fill the reply data */
103 static inline void *set_reply_data( const void *data
, data_size_t size
)
105 void *ret
= set_reply_data_size( size
);
106 if (ret
) memcpy( ret
, data
, size
);
110 /* set the reply data pointer directly (will be freed by request code) */
111 static inline void set_reply_data_ptr( void *data
, data_size_t size
)
113 assert( size
<= get_reply_max_size() );
114 current
->reply_size
= size
;
115 current
->reply_data
= data
;
119 /* Everything below this line is generated automatically by tools/make_requests */
120 /* ### make_requests begin ### */
122 DECL_HANDLER(new_process
);
123 DECL_HANDLER(get_new_process_info
);
124 DECL_HANDLER(new_thread
);
125 DECL_HANDLER(get_startup_info
);
126 DECL_HANDLER(init_process_done
);
127 DECL_HANDLER(init_first_thread
);
128 DECL_HANDLER(init_thread
);
129 DECL_HANDLER(terminate_process
);
130 DECL_HANDLER(terminate_thread
);
131 DECL_HANDLER(get_process_info
);
132 DECL_HANDLER(get_process_debug_info
);
133 DECL_HANDLER(get_process_image_name
);
134 DECL_HANDLER(get_process_vm_counters
);
135 DECL_HANDLER(set_process_info
);
136 DECL_HANDLER(get_thread_info
);
137 DECL_HANDLER(get_thread_times
);
138 DECL_HANDLER(set_thread_info
);
139 DECL_HANDLER(suspend_thread
);
140 DECL_HANDLER(resume_thread
);
141 DECL_HANDLER(queue_apc
);
142 DECL_HANDLER(get_apc_result
);
143 DECL_HANDLER(close_handle
);
144 DECL_HANDLER(set_handle_info
);
145 DECL_HANDLER(dup_handle
);
146 DECL_HANDLER(compare_objects
);
147 DECL_HANDLER(make_temporary
);
148 DECL_HANDLER(open_process
);
149 DECL_HANDLER(open_thread
);
150 DECL_HANDLER(select
);
151 DECL_HANDLER(create_event
);
152 DECL_HANDLER(event_op
);
153 DECL_HANDLER(query_event
);
154 DECL_HANDLER(open_event
);
155 DECL_HANDLER(create_keyed_event
);
156 DECL_HANDLER(open_keyed_event
);
157 DECL_HANDLER(create_mutex
);
158 DECL_HANDLER(release_mutex
);
159 DECL_HANDLER(open_mutex
);
160 DECL_HANDLER(query_mutex
);
161 DECL_HANDLER(create_semaphore
);
162 DECL_HANDLER(release_semaphore
);
163 DECL_HANDLER(query_semaphore
);
164 DECL_HANDLER(open_semaphore
);
165 DECL_HANDLER(create_file
);
166 DECL_HANDLER(open_file_object
);
167 DECL_HANDLER(alloc_file_handle
);
168 DECL_HANDLER(get_handle_unix_name
);
169 DECL_HANDLER(get_handle_fd
);
170 DECL_HANDLER(get_directory_cache_entry
);
172 DECL_HANDLER(get_file_info
);
173 DECL_HANDLER(get_volume_info
);
174 DECL_HANDLER(lock_file
);
175 DECL_HANDLER(unlock_file
);
176 DECL_HANDLER(recv_socket
);
177 DECL_HANDLER(send_socket
);
178 DECL_HANDLER(socket_send_icmp_id
);
179 DECL_HANDLER(socket_get_icmp_id
);
180 DECL_HANDLER(get_next_console_request
);
181 DECL_HANDLER(read_directory_changes
);
182 DECL_HANDLER(read_change
);
183 DECL_HANDLER(create_mapping
);
184 DECL_HANDLER(open_mapping
);
185 DECL_HANDLER(get_mapping_info
);
186 DECL_HANDLER(map_view
);
187 DECL_HANDLER(map_image_view
);
188 DECL_HANDLER(map_builtin_view
);
189 DECL_HANDLER(unmap_view
);
190 DECL_HANDLER(get_mapping_committed_range
);
191 DECL_HANDLER(add_mapping_committed_range
);
192 DECL_HANDLER(is_same_mapping
);
193 DECL_HANDLER(get_mapping_filename
);
194 DECL_HANDLER(list_processes
);
195 DECL_HANDLER(create_debug_obj
);
196 DECL_HANDLER(wait_debug_event
);
197 DECL_HANDLER(queue_exception_event
);
198 DECL_HANDLER(get_exception_status
);
199 DECL_HANDLER(continue_debug_event
);
200 DECL_HANDLER(debug_process
);
201 DECL_HANDLER(set_debug_obj_info
);
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(rename_key
);
218 DECL_HANDLER(create_timer
);
219 DECL_HANDLER(open_timer
);
220 DECL_HANDLER(set_timer
);
221 DECL_HANDLER(cancel_timer
);
222 DECL_HANDLER(get_timer_info
);
223 DECL_HANDLER(get_thread_context
);
224 DECL_HANDLER(set_thread_context
);
225 DECL_HANDLER(get_selector_entry
);
226 DECL_HANDLER(add_atom
);
227 DECL_HANDLER(delete_atom
);
228 DECL_HANDLER(find_atom
);
229 DECL_HANDLER(get_atom_information
);
230 DECL_HANDLER(get_msg_queue
);
231 DECL_HANDLER(set_queue_fd
);
232 DECL_HANDLER(set_queue_mask
);
233 DECL_HANDLER(get_queue_status
);
234 DECL_HANDLER(get_process_idle_event
);
235 DECL_HANDLER(send_message
);
236 DECL_HANDLER(post_quit_message
);
237 DECL_HANDLER(send_hardware_message
);
238 DECL_HANDLER(get_message
);
239 DECL_HANDLER(reply_message
);
240 DECL_HANDLER(accept_hardware_message
);
241 DECL_HANDLER(get_message_reply
);
242 DECL_HANDLER(set_win_timer
);
243 DECL_HANDLER(kill_win_timer
);
244 DECL_HANDLER(is_window_hung
);
245 DECL_HANDLER(get_serial_info
);
246 DECL_HANDLER(set_serial_info
);
247 DECL_HANDLER(cancel_sync
);
248 DECL_HANDLER(register_async
);
249 DECL_HANDLER(cancel_async
);
250 DECL_HANDLER(get_async_result
);
251 DECL_HANDLER(set_async_direct_result
);
255 DECL_HANDLER(set_irp_result
);
256 DECL_HANDLER(create_named_pipe
);
257 DECL_HANDLER(set_named_pipe_info
);
258 DECL_HANDLER(create_window
);
259 DECL_HANDLER(destroy_window
);
260 DECL_HANDLER(get_desktop_window
);
261 DECL_HANDLER(set_window_owner
);
262 DECL_HANDLER(get_window_info
);
263 DECL_HANDLER(set_window_info
);
264 DECL_HANDLER(set_parent
);
265 DECL_HANDLER(get_window_parents
);
266 DECL_HANDLER(get_window_children
);
267 DECL_HANDLER(get_window_children_from_point
);
268 DECL_HANDLER(get_window_tree
);
269 DECL_HANDLER(set_window_pos
);
270 DECL_HANDLER(get_window_rectangles
);
271 DECL_HANDLER(get_window_text
);
272 DECL_HANDLER(set_window_text
);
273 DECL_HANDLER(get_windows_offset
);
274 DECL_HANDLER(get_visible_region
);
275 DECL_HANDLER(get_surface_region
);
276 DECL_HANDLER(get_window_region
);
277 DECL_HANDLER(set_window_region
);
278 DECL_HANDLER(get_update_region
);
279 DECL_HANDLER(update_window_zorder
);
280 DECL_HANDLER(redraw_window
);
281 DECL_HANDLER(set_window_property
);
282 DECL_HANDLER(remove_window_property
);
283 DECL_HANDLER(get_window_property
);
284 DECL_HANDLER(get_window_properties
);
285 DECL_HANDLER(create_winstation
);
286 DECL_HANDLER(open_winstation
);
287 DECL_HANDLER(close_winstation
);
288 DECL_HANDLER(get_process_winstation
);
289 DECL_HANDLER(set_process_winstation
);
290 DECL_HANDLER(enum_winstation
);
291 DECL_HANDLER(create_desktop
);
292 DECL_HANDLER(open_desktop
);
293 DECL_HANDLER(open_input_desktop
);
294 DECL_HANDLER(close_desktop
);
295 DECL_HANDLER(get_thread_desktop
);
296 DECL_HANDLER(set_thread_desktop
);
297 DECL_HANDLER(enum_desktop
);
298 DECL_HANDLER(set_user_object_info
);
299 DECL_HANDLER(register_hotkey
);
300 DECL_HANDLER(unregister_hotkey
);
301 DECL_HANDLER(attach_thread_input
);
302 DECL_HANDLER(get_thread_input
);
303 DECL_HANDLER(get_last_input_time
);
304 DECL_HANDLER(get_key_state
);
305 DECL_HANDLER(set_key_state
);
306 DECL_HANDLER(set_foreground_window
);
307 DECL_HANDLER(set_focus_window
);
308 DECL_HANDLER(set_active_window
);
309 DECL_HANDLER(set_capture_window
);
310 DECL_HANDLER(set_caret_window
);
311 DECL_HANDLER(set_caret_info
);
312 DECL_HANDLER(set_hook
);
313 DECL_HANDLER(remove_hook
);
314 DECL_HANDLER(start_hook_chain
);
315 DECL_HANDLER(finish_hook_chain
);
316 DECL_HANDLER(get_hook_info
);
317 DECL_HANDLER(create_class
);
318 DECL_HANDLER(destroy_class
);
319 DECL_HANDLER(set_class_info
);
320 DECL_HANDLER(open_clipboard
);
321 DECL_HANDLER(close_clipboard
);
322 DECL_HANDLER(empty_clipboard
);
323 DECL_HANDLER(set_clipboard_data
);
324 DECL_HANDLER(get_clipboard_data
);
325 DECL_HANDLER(get_clipboard_formats
);
326 DECL_HANDLER(enum_clipboard_formats
);
327 DECL_HANDLER(release_clipboard
);
328 DECL_HANDLER(get_clipboard_info
);
329 DECL_HANDLER(set_clipboard_viewer
);
330 DECL_HANDLER(add_clipboard_listener
);
331 DECL_HANDLER(remove_clipboard_listener
);
332 DECL_HANDLER(open_token
);
333 DECL_HANDLER(set_global_windows
);
334 DECL_HANDLER(adjust_token_privileges
);
335 DECL_HANDLER(get_token_privileges
);
336 DECL_HANDLER(check_token_privileges
);
337 DECL_HANDLER(duplicate_token
);
338 DECL_HANDLER(filter_token
);
339 DECL_HANDLER(access_check
);
340 DECL_HANDLER(get_token_sid
);
341 DECL_HANDLER(get_token_groups
);
342 DECL_HANDLER(get_token_default_dacl
);
343 DECL_HANDLER(set_token_default_dacl
);
344 DECL_HANDLER(set_security_object
);
345 DECL_HANDLER(get_security_object
);
346 DECL_HANDLER(get_system_handles
);
347 DECL_HANDLER(create_mailslot
);
348 DECL_HANDLER(set_mailslot_info
);
349 DECL_HANDLER(create_directory
);
350 DECL_HANDLER(open_directory
);
351 DECL_HANDLER(get_directory_entry
);
352 DECL_HANDLER(create_symlink
);
353 DECL_HANDLER(open_symlink
);
354 DECL_HANDLER(query_symlink
);
355 DECL_HANDLER(get_object_info
);
356 DECL_HANDLER(get_object_name
);
357 DECL_HANDLER(get_object_type
);
358 DECL_HANDLER(get_object_types
);
359 DECL_HANDLER(allocate_locally_unique_id
);
360 DECL_HANDLER(create_device_manager
);
361 DECL_HANDLER(create_device
);
362 DECL_HANDLER(delete_device
);
363 DECL_HANDLER(get_next_device_request
);
364 DECL_HANDLER(get_kernel_object_ptr
);
365 DECL_HANDLER(set_kernel_object_ptr
);
366 DECL_HANDLER(grab_kernel_object
);
367 DECL_HANDLER(release_kernel_object
);
368 DECL_HANDLER(get_kernel_object_handle
);
369 DECL_HANDLER(make_process_system
);
370 DECL_HANDLER(get_token_info
);
371 DECL_HANDLER(create_linked_token
);
372 DECL_HANDLER(create_completion
);
373 DECL_HANDLER(open_completion
);
374 DECL_HANDLER(add_completion
);
375 DECL_HANDLER(remove_completion
);
376 DECL_HANDLER(query_completion
);
377 DECL_HANDLER(set_completion_info
);
378 DECL_HANDLER(add_fd_completion
);
379 DECL_HANDLER(set_fd_completion_mode
);
380 DECL_HANDLER(set_fd_disp_info
);
381 DECL_HANDLER(set_fd_name_info
);
382 DECL_HANDLER(set_fd_eof_info
);
383 DECL_HANDLER(get_window_layered_info
);
384 DECL_HANDLER(set_window_layered_info
);
385 DECL_HANDLER(alloc_user_handle
);
386 DECL_HANDLER(free_user_handle
);
387 DECL_HANDLER(set_cursor
);
388 DECL_HANDLER(get_cursor_history
);
389 DECL_HANDLER(get_rawinput_buffer
);
390 DECL_HANDLER(update_rawinput_devices
);
391 DECL_HANDLER(create_job
);
392 DECL_HANDLER(open_job
);
393 DECL_HANDLER(assign_job
);
394 DECL_HANDLER(process_in_job
);
395 DECL_HANDLER(set_job_limits
);
396 DECL_HANDLER(set_job_completion_port
);
397 DECL_HANDLER(get_job_info
);
398 DECL_HANDLER(terminate_job
);
399 DECL_HANDLER(suspend_process
);
400 DECL_HANDLER(resume_process
);
401 DECL_HANDLER(get_next_thread
);
403 #ifdef WANT_REQUEST_HANDLERS
405 typedef void (*req_handler
)( const void *req
, void *reply
);
406 static const req_handler req_handlers
[REQ_NB_REQUESTS
] =
408 (req_handler
)req_new_process
,
409 (req_handler
)req_get_new_process_info
,
410 (req_handler
)req_new_thread
,
411 (req_handler
)req_get_startup_info
,
412 (req_handler
)req_init_process_done
,
413 (req_handler
)req_init_first_thread
,
414 (req_handler
)req_init_thread
,
415 (req_handler
)req_terminate_process
,
416 (req_handler
)req_terminate_thread
,
417 (req_handler
)req_get_process_info
,
418 (req_handler
)req_get_process_debug_info
,
419 (req_handler
)req_get_process_image_name
,
420 (req_handler
)req_get_process_vm_counters
,
421 (req_handler
)req_set_process_info
,
422 (req_handler
)req_get_thread_info
,
423 (req_handler
)req_get_thread_times
,
424 (req_handler
)req_set_thread_info
,
425 (req_handler
)req_suspend_thread
,
426 (req_handler
)req_resume_thread
,
427 (req_handler
)req_queue_apc
,
428 (req_handler
)req_get_apc_result
,
429 (req_handler
)req_close_handle
,
430 (req_handler
)req_set_handle_info
,
431 (req_handler
)req_dup_handle
,
432 (req_handler
)req_compare_objects
,
433 (req_handler
)req_make_temporary
,
434 (req_handler
)req_open_process
,
435 (req_handler
)req_open_thread
,
436 (req_handler
)req_select
,
437 (req_handler
)req_create_event
,
438 (req_handler
)req_event_op
,
439 (req_handler
)req_query_event
,
440 (req_handler
)req_open_event
,
441 (req_handler
)req_create_keyed_event
,
442 (req_handler
)req_open_keyed_event
,
443 (req_handler
)req_create_mutex
,
444 (req_handler
)req_release_mutex
,
445 (req_handler
)req_open_mutex
,
446 (req_handler
)req_query_mutex
,
447 (req_handler
)req_create_semaphore
,
448 (req_handler
)req_release_semaphore
,
449 (req_handler
)req_query_semaphore
,
450 (req_handler
)req_open_semaphore
,
451 (req_handler
)req_create_file
,
452 (req_handler
)req_open_file_object
,
453 (req_handler
)req_alloc_file_handle
,
454 (req_handler
)req_get_handle_unix_name
,
455 (req_handler
)req_get_handle_fd
,
456 (req_handler
)req_get_directory_cache_entry
,
457 (req_handler
)req_flush
,
458 (req_handler
)req_get_file_info
,
459 (req_handler
)req_get_volume_info
,
460 (req_handler
)req_lock_file
,
461 (req_handler
)req_unlock_file
,
462 (req_handler
)req_recv_socket
,
463 (req_handler
)req_send_socket
,
464 (req_handler
)req_socket_send_icmp_id
,
465 (req_handler
)req_socket_get_icmp_id
,
466 (req_handler
)req_get_next_console_request
,
467 (req_handler
)req_read_directory_changes
,
468 (req_handler
)req_read_change
,
469 (req_handler
)req_create_mapping
,
470 (req_handler
)req_open_mapping
,
471 (req_handler
)req_get_mapping_info
,
472 (req_handler
)req_map_view
,
473 (req_handler
)req_map_image_view
,
474 (req_handler
)req_map_builtin_view
,
475 (req_handler
)req_unmap_view
,
476 (req_handler
)req_get_mapping_committed_range
,
477 (req_handler
)req_add_mapping_committed_range
,
478 (req_handler
)req_is_same_mapping
,
479 (req_handler
)req_get_mapping_filename
,
480 (req_handler
)req_list_processes
,
481 (req_handler
)req_create_debug_obj
,
482 (req_handler
)req_wait_debug_event
,
483 (req_handler
)req_queue_exception_event
,
484 (req_handler
)req_get_exception_status
,
485 (req_handler
)req_continue_debug_event
,
486 (req_handler
)req_debug_process
,
487 (req_handler
)req_set_debug_obj_info
,
488 (req_handler
)req_read_process_memory
,
489 (req_handler
)req_write_process_memory
,
490 (req_handler
)req_create_key
,
491 (req_handler
)req_open_key
,
492 (req_handler
)req_delete_key
,
493 (req_handler
)req_flush_key
,
494 (req_handler
)req_enum_key
,
495 (req_handler
)req_set_key_value
,
496 (req_handler
)req_get_key_value
,
497 (req_handler
)req_enum_key_value
,
498 (req_handler
)req_delete_key_value
,
499 (req_handler
)req_load_registry
,
500 (req_handler
)req_unload_registry
,
501 (req_handler
)req_save_registry
,
502 (req_handler
)req_set_registry_notification
,
503 (req_handler
)req_rename_key
,
504 (req_handler
)req_create_timer
,
505 (req_handler
)req_open_timer
,
506 (req_handler
)req_set_timer
,
507 (req_handler
)req_cancel_timer
,
508 (req_handler
)req_get_timer_info
,
509 (req_handler
)req_get_thread_context
,
510 (req_handler
)req_set_thread_context
,
511 (req_handler
)req_get_selector_entry
,
512 (req_handler
)req_add_atom
,
513 (req_handler
)req_delete_atom
,
514 (req_handler
)req_find_atom
,
515 (req_handler
)req_get_atom_information
,
516 (req_handler
)req_get_msg_queue
,
517 (req_handler
)req_set_queue_fd
,
518 (req_handler
)req_set_queue_mask
,
519 (req_handler
)req_get_queue_status
,
520 (req_handler
)req_get_process_idle_event
,
521 (req_handler
)req_send_message
,
522 (req_handler
)req_post_quit_message
,
523 (req_handler
)req_send_hardware_message
,
524 (req_handler
)req_get_message
,
525 (req_handler
)req_reply_message
,
526 (req_handler
)req_accept_hardware_message
,
527 (req_handler
)req_get_message_reply
,
528 (req_handler
)req_set_win_timer
,
529 (req_handler
)req_kill_win_timer
,
530 (req_handler
)req_is_window_hung
,
531 (req_handler
)req_get_serial_info
,
532 (req_handler
)req_set_serial_info
,
533 (req_handler
)req_cancel_sync
,
534 (req_handler
)req_register_async
,
535 (req_handler
)req_cancel_async
,
536 (req_handler
)req_get_async_result
,
537 (req_handler
)req_set_async_direct_result
,
538 (req_handler
)req_read
,
539 (req_handler
)req_write
,
540 (req_handler
)req_ioctl
,
541 (req_handler
)req_set_irp_result
,
542 (req_handler
)req_create_named_pipe
,
543 (req_handler
)req_set_named_pipe_info
,
544 (req_handler
)req_create_window
,
545 (req_handler
)req_destroy_window
,
546 (req_handler
)req_get_desktop_window
,
547 (req_handler
)req_set_window_owner
,
548 (req_handler
)req_get_window_info
,
549 (req_handler
)req_set_window_info
,
550 (req_handler
)req_set_parent
,
551 (req_handler
)req_get_window_parents
,
552 (req_handler
)req_get_window_children
,
553 (req_handler
)req_get_window_children_from_point
,
554 (req_handler
)req_get_window_tree
,
555 (req_handler
)req_set_window_pos
,
556 (req_handler
)req_get_window_rectangles
,
557 (req_handler
)req_get_window_text
,
558 (req_handler
)req_set_window_text
,
559 (req_handler
)req_get_windows_offset
,
560 (req_handler
)req_get_visible_region
,
561 (req_handler
)req_get_surface_region
,
562 (req_handler
)req_get_window_region
,
563 (req_handler
)req_set_window_region
,
564 (req_handler
)req_get_update_region
,
565 (req_handler
)req_update_window_zorder
,
566 (req_handler
)req_redraw_window
,
567 (req_handler
)req_set_window_property
,
568 (req_handler
)req_remove_window_property
,
569 (req_handler
)req_get_window_property
,
570 (req_handler
)req_get_window_properties
,
571 (req_handler
)req_create_winstation
,
572 (req_handler
)req_open_winstation
,
573 (req_handler
)req_close_winstation
,
574 (req_handler
)req_get_process_winstation
,
575 (req_handler
)req_set_process_winstation
,
576 (req_handler
)req_enum_winstation
,
577 (req_handler
)req_create_desktop
,
578 (req_handler
)req_open_desktop
,
579 (req_handler
)req_open_input_desktop
,
580 (req_handler
)req_close_desktop
,
581 (req_handler
)req_get_thread_desktop
,
582 (req_handler
)req_set_thread_desktop
,
583 (req_handler
)req_enum_desktop
,
584 (req_handler
)req_set_user_object_info
,
585 (req_handler
)req_register_hotkey
,
586 (req_handler
)req_unregister_hotkey
,
587 (req_handler
)req_attach_thread_input
,
588 (req_handler
)req_get_thread_input
,
589 (req_handler
)req_get_last_input_time
,
590 (req_handler
)req_get_key_state
,
591 (req_handler
)req_set_key_state
,
592 (req_handler
)req_set_foreground_window
,
593 (req_handler
)req_set_focus_window
,
594 (req_handler
)req_set_active_window
,
595 (req_handler
)req_set_capture_window
,
596 (req_handler
)req_set_caret_window
,
597 (req_handler
)req_set_caret_info
,
598 (req_handler
)req_set_hook
,
599 (req_handler
)req_remove_hook
,
600 (req_handler
)req_start_hook_chain
,
601 (req_handler
)req_finish_hook_chain
,
602 (req_handler
)req_get_hook_info
,
603 (req_handler
)req_create_class
,
604 (req_handler
)req_destroy_class
,
605 (req_handler
)req_set_class_info
,
606 (req_handler
)req_open_clipboard
,
607 (req_handler
)req_close_clipboard
,
608 (req_handler
)req_empty_clipboard
,
609 (req_handler
)req_set_clipboard_data
,
610 (req_handler
)req_get_clipboard_data
,
611 (req_handler
)req_get_clipboard_formats
,
612 (req_handler
)req_enum_clipboard_formats
,
613 (req_handler
)req_release_clipboard
,
614 (req_handler
)req_get_clipboard_info
,
615 (req_handler
)req_set_clipboard_viewer
,
616 (req_handler
)req_add_clipboard_listener
,
617 (req_handler
)req_remove_clipboard_listener
,
618 (req_handler
)req_open_token
,
619 (req_handler
)req_set_global_windows
,
620 (req_handler
)req_adjust_token_privileges
,
621 (req_handler
)req_get_token_privileges
,
622 (req_handler
)req_check_token_privileges
,
623 (req_handler
)req_duplicate_token
,
624 (req_handler
)req_filter_token
,
625 (req_handler
)req_access_check
,
626 (req_handler
)req_get_token_sid
,
627 (req_handler
)req_get_token_groups
,
628 (req_handler
)req_get_token_default_dacl
,
629 (req_handler
)req_set_token_default_dacl
,
630 (req_handler
)req_set_security_object
,
631 (req_handler
)req_get_security_object
,
632 (req_handler
)req_get_system_handles
,
633 (req_handler
)req_create_mailslot
,
634 (req_handler
)req_set_mailslot_info
,
635 (req_handler
)req_create_directory
,
636 (req_handler
)req_open_directory
,
637 (req_handler
)req_get_directory_entry
,
638 (req_handler
)req_create_symlink
,
639 (req_handler
)req_open_symlink
,
640 (req_handler
)req_query_symlink
,
641 (req_handler
)req_get_object_info
,
642 (req_handler
)req_get_object_name
,
643 (req_handler
)req_get_object_type
,
644 (req_handler
)req_get_object_types
,
645 (req_handler
)req_allocate_locally_unique_id
,
646 (req_handler
)req_create_device_manager
,
647 (req_handler
)req_create_device
,
648 (req_handler
)req_delete_device
,
649 (req_handler
)req_get_next_device_request
,
650 (req_handler
)req_get_kernel_object_ptr
,
651 (req_handler
)req_set_kernel_object_ptr
,
652 (req_handler
)req_grab_kernel_object
,
653 (req_handler
)req_release_kernel_object
,
654 (req_handler
)req_get_kernel_object_handle
,
655 (req_handler
)req_make_process_system
,
656 (req_handler
)req_get_token_info
,
657 (req_handler
)req_create_linked_token
,
658 (req_handler
)req_create_completion
,
659 (req_handler
)req_open_completion
,
660 (req_handler
)req_add_completion
,
661 (req_handler
)req_remove_completion
,
662 (req_handler
)req_query_completion
,
663 (req_handler
)req_set_completion_info
,
664 (req_handler
)req_add_fd_completion
,
665 (req_handler
)req_set_fd_completion_mode
,
666 (req_handler
)req_set_fd_disp_info
,
667 (req_handler
)req_set_fd_name_info
,
668 (req_handler
)req_set_fd_eof_info
,
669 (req_handler
)req_get_window_layered_info
,
670 (req_handler
)req_set_window_layered_info
,
671 (req_handler
)req_alloc_user_handle
,
672 (req_handler
)req_free_user_handle
,
673 (req_handler
)req_set_cursor
,
674 (req_handler
)req_get_cursor_history
,
675 (req_handler
)req_get_rawinput_buffer
,
676 (req_handler
)req_update_rawinput_devices
,
677 (req_handler
)req_create_job
,
678 (req_handler
)req_open_job
,
679 (req_handler
)req_assign_job
,
680 (req_handler
)req_process_in_job
,
681 (req_handler
)req_set_job_limits
,
682 (req_handler
)req_set_job_completion_port
,
683 (req_handler
)req_get_job_info
,
684 (req_handler
)req_terminate_job
,
685 (req_handler
)req_suspend_process
,
686 (req_handler
)req_resume_process
,
687 (req_handler
)req_get_next_thread
,
690 C_ASSERT( sizeof(abstime_t
) == 8 );
691 C_ASSERT( sizeof(affinity_t
) == 8 );
692 C_ASSERT( sizeof(apc_call_t
) == 48 );
693 C_ASSERT( sizeof(apc_param_t
) == 8 );
694 C_ASSERT( sizeof(apc_result_t
) == 40 );
695 C_ASSERT( sizeof(async_data_t
) == 40 );
696 C_ASSERT( sizeof(atom_t
) == 4 );
697 C_ASSERT( sizeof(char) == 1 );
698 C_ASSERT( sizeof(client_ptr_t
) == 8 );
699 C_ASSERT( sizeof(data_size_t
) == 4 );
700 C_ASSERT( sizeof(file_pos_t
) == 8 );
701 C_ASSERT( sizeof(generic_map_t
) == 16 );
702 C_ASSERT( sizeof(hw_input_t
) == 40 );
703 C_ASSERT( sizeof(int) == 4 );
704 C_ASSERT( sizeof(ioctl_code_t
) == 4 );
705 C_ASSERT( sizeof(irp_params_t
) == 32 );
706 C_ASSERT( sizeof(lparam_t
) == 8 );
707 C_ASSERT( sizeof(mem_size_t
) == 8 );
708 C_ASSERT( sizeof(mod_handle_t
) == 8 );
709 C_ASSERT( sizeof(obj_handle_t
) == 4 );
710 C_ASSERT( sizeof(process_id_t
) == 4 );
711 C_ASSERT( sizeof(rectangle_t
) == 16 );
712 C_ASSERT( sizeof(short int) == 2 );
713 C_ASSERT( sizeof(struct luid
) == 8 );
714 C_ASSERT( sizeof(thread_id_t
) == 4 );
715 C_ASSERT( sizeof(timeout_t
) == 8 );
716 C_ASSERT( sizeof(unsigned char) == 1 );
717 C_ASSERT( sizeof(unsigned int) == 4 );
718 C_ASSERT( sizeof(unsigned short) == 2 );
719 C_ASSERT( sizeof(user_handle_t
) == 4 );
720 C_ASSERT( FIELD_OFFSET(struct new_process_request
, token
) == 12 );
721 C_ASSERT( FIELD_OFFSET(struct new_process_request
, debug
) == 16 );
722 C_ASSERT( FIELD_OFFSET(struct new_process_request
, parent_process
) == 20 );
723 C_ASSERT( FIELD_OFFSET(struct new_process_request
, flags
) == 24 );
724 C_ASSERT( FIELD_OFFSET(struct new_process_request
, socket_fd
) == 28 );
725 C_ASSERT( FIELD_OFFSET(struct new_process_request
, access
) == 32 );
726 C_ASSERT( FIELD_OFFSET(struct new_process_request
, machine
) == 36 );
727 C_ASSERT( FIELD_OFFSET(struct new_process_request
, info_size
) == 40 );
728 C_ASSERT( FIELD_OFFSET(struct new_process_request
, handles_size
) == 44 );
729 C_ASSERT( FIELD_OFFSET(struct new_process_request
, jobs_size
) == 48 );
730 C_ASSERT( sizeof(struct new_process_request
) == 56 );
731 C_ASSERT( FIELD_OFFSET(struct new_process_reply
, info
) == 8 );
732 C_ASSERT( FIELD_OFFSET(struct new_process_reply
, pid
) == 12 );
733 C_ASSERT( FIELD_OFFSET(struct new_process_reply
, handle
) == 16 );
734 C_ASSERT( sizeof(struct new_process_reply
) == 24 );
735 C_ASSERT( FIELD_OFFSET(struct get_new_process_info_request
, info
) == 12 );
736 C_ASSERT( sizeof(struct get_new_process_info_request
) == 16 );
737 C_ASSERT( FIELD_OFFSET(struct get_new_process_info_reply
, success
) == 8 );
738 C_ASSERT( FIELD_OFFSET(struct get_new_process_info_reply
, exit_code
) == 12 );
739 C_ASSERT( sizeof(struct get_new_process_info_reply
) == 16 );
740 C_ASSERT( FIELD_OFFSET(struct new_thread_request
, process
) == 12 );
741 C_ASSERT( FIELD_OFFSET(struct new_thread_request
, access
) == 16 );
742 C_ASSERT( FIELD_OFFSET(struct new_thread_request
, flags
) == 20 );
743 C_ASSERT( FIELD_OFFSET(struct new_thread_request
, request_fd
) == 24 );
744 C_ASSERT( sizeof(struct new_thread_request
) == 32 );
745 C_ASSERT( FIELD_OFFSET(struct new_thread_reply
, tid
) == 8 );
746 C_ASSERT( FIELD_OFFSET(struct new_thread_reply
, handle
) == 12 );
747 C_ASSERT( sizeof(struct new_thread_reply
) == 16 );
748 C_ASSERT( sizeof(struct get_startup_info_request
) == 16 );
749 C_ASSERT( FIELD_OFFSET(struct get_startup_info_reply
, info_size
) == 8 );
750 C_ASSERT( FIELD_OFFSET(struct get_startup_info_reply
, machine
) == 12 );
751 C_ASSERT( sizeof(struct get_startup_info_reply
) == 16 );
752 C_ASSERT( FIELD_OFFSET(struct init_process_done_request
, teb
) == 16 );
753 C_ASSERT( FIELD_OFFSET(struct init_process_done_request
, peb
) == 24 );
754 C_ASSERT( FIELD_OFFSET(struct init_process_done_request
, ldt_copy
) == 32 );
755 C_ASSERT( sizeof(struct init_process_done_request
) == 40 );
756 C_ASSERT( FIELD_OFFSET(struct init_process_done_reply
, entry
) == 8 );
757 C_ASSERT( FIELD_OFFSET(struct init_process_done_reply
, suspend
) == 16 );
758 C_ASSERT( sizeof(struct init_process_done_reply
) == 24 );
759 C_ASSERT( FIELD_OFFSET(struct init_first_thread_request
, unix_pid
) == 12 );
760 C_ASSERT( FIELD_OFFSET(struct init_first_thread_request
, unix_tid
) == 16 );
761 C_ASSERT( FIELD_OFFSET(struct init_first_thread_request
, debug_level
) == 20 );
762 C_ASSERT( FIELD_OFFSET(struct init_first_thread_request
, reply_fd
) == 24 );
763 C_ASSERT( FIELD_OFFSET(struct init_first_thread_request
, wait_fd
) == 28 );
764 C_ASSERT( sizeof(struct init_first_thread_request
) == 32 );
765 C_ASSERT( FIELD_OFFSET(struct init_first_thread_reply
, pid
) == 8 );
766 C_ASSERT( FIELD_OFFSET(struct init_first_thread_reply
, tid
) == 12 );
767 C_ASSERT( FIELD_OFFSET(struct init_first_thread_reply
, server_start
) == 16 );
768 C_ASSERT( FIELD_OFFSET(struct init_first_thread_reply
, session_id
) == 24 );
769 C_ASSERT( FIELD_OFFSET(struct init_first_thread_reply
, info_size
) == 28 );
770 C_ASSERT( sizeof(struct init_first_thread_reply
) == 32 );
771 C_ASSERT( FIELD_OFFSET(struct init_thread_request
, unix_tid
) == 12 );
772 C_ASSERT( FIELD_OFFSET(struct init_thread_request
, reply_fd
) == 16 );
773 C_ASSERT( FIELD_OFFSET(struct init_thread_request
, wait_fd
) == 20 );
774 C_ASSERT( FIELD_OFFSET(struct init_thread_request
, teb
) == 24 );
775 C_ASSERT( FIELD_OFFSET(struct init_thread_request
, entry
) == 32 );
776 C_ASSERT( sizeof(struct init_thread_request
) == 40 );
777 C_ASSERT( FIELD_OFFSET(struct init_thread_reply
, suspend
) == 8 );
778 C_ASSERT( sizeof(struct init_thread_reply
) == 16 );
779 C_ASSERT( FIELD_OFFSET(struct terminate_process_request
, handle
) == 12 );
780 C_ASSERT( FIELD_OFFSET(struct terminate_process_request
, exit_code
) == 16 );
781 C_ASSERT( sizeof(struct terminate_process_request
) == 24 );
782 C_ASSERT( FIELD_OFFSET(struct terminate_process_reply
, self
) == 8 );
783 C_ASSERT( sizeof(struct terminate_process_reply
) == 16 );
784 C_ASSERT( FIELD_OFFSET(struct terminate_thread_request
, handle
) == 12 );
785 C_ASSERT( FIELD_OFFSET(struct terminate_thread_request
, exit_code
) == 16 );
786 C_ASSERT( sizeof(struct terminate_thread_request
) == 24 );
787 C_ASSERT( FIELD_OFFSET(struct terminate_thread_reply
, self
) == 8 );
788 C_ASSERT( sizeof(struct terminate_thread_reply
) == 16 );
789 C_ASSERT( FIELD_OFFSET(struct get_process_info_request
, handle
) == 12 );
790 C_ASSERT( sizeof(struct get_process_info_request
) == 16 );
791 C_ASSERT( FIELD_OFFSET(struct get_process_info_reply
, pid
) == 8 );
792 C_ASSERT( FIELD_OFFSET(struct get_process_info_reply
, ppid
) == 12 );
793 C_ASSERT( FIELD_OFFSET(struct get_process_info_reply
, affinity
) == 16 );
794 C_ASSERT( FIELD_OFFSET(struct get_process_info_reply
, peb
) == 24 );
795 C_ASSERT( FIELD_OFFSET(struct get_process_info_reply
, start_time
) == 32 );
796 C_ASSERT( FIELD_OFFSET(struct get_process_info_reply
, end_time
) == 40 );
797 C_ASSERT( FIELD_OFFSET(struct get_process_info_reply
, session_id
) == 48 );
798 C_ASSERT( FIELD_OFFSET(struct get_process_info_reply
, exit_code
) == 52 );
799 C_ASSERT( FIELD_OFFSET(struct get_process_info_reply
, priority
) == 56 );
800 C_ASSERT( FIELD_OFFSET(struct get_process_info_reply
, machine
) == 60 );
801 C_ASSERT( sizeof(struct get_process_info_reply
) == 64 );
802 C_ASSERT( FIELD_OFFSET(struct get_process_debug_info_request
, handle
) == 12 );
803 C_ASSERT( sizeof(struct get_process_debug_info_request
) == 16 );
804 C_ASSERT( FIELD_OFFSET(struct get_process_debug_info_reply
, debug
) == 8 );
805 C_ASSERT( FIELD_OFFSET(struct get_process_debug_info_reply
, debug_children
) == 12 );
806 C_ASSERT( sizeof(struct get_process_debug_info_reply
) == 16 );
807 C_ASSERT( FIELD_OFFSET(struct get_process_image_name_request
, handle
) == 12 );
808 C_ASSERT( FIELD_OFFSET(struct get_process_image_name_request
, win32
) == 16 );
809 C_ASSERT( sizeof(struct get_process_image_name_request
) == 24 );
810 C_ASSERT( FIELD_OFFSET(struct get_process_image_name_reply
, len
) == 8 );
811 C_ASSERT( sizeof(struct get_process_image_name_reply
) == 16 );
812 C_ASSERT( FIELD_OFFSET(struct get_process_vm_counters_request
, handle
) == 12 );
813 C_ASSERT( sizeof(struct get_process_vm_counters_request
) == 16 );
814 C_ASSERT( FIELD_OFFSET(struct get_process_vm_counters_reply
, peak_virtual_size
) == 8 );
815 C_ASSERT( FIELD_OFFSET(struct get_process_vm_counters_reply
, virtual_size
) == 16 );
816 C_ASSERT( FIELD_OFFSET(struct get_process_vm_counters_reply
, peak_working_set_size
) == 24 );
817 C_ASSERT( FIELD_OFFSET(struct get_process_vm_counters_reply
, working_set_size
) == 32 );
818 C_ASSERT( FIELD_OFFSET(struct get_process_vm_counters_reply
, pagefile_usage
) == 40 );
819 C_ASSERT( FIELD_OFFSET(struct get_process_vm_counters_reply
, peak_pagefile_usage
) == 48 );
820 C_ASSERT( sizeof(struct get_process_vm_counters_reply
) == 56 );
821 C_ASSERT( FIELD_OFFSET(struct set_process_info_request
, handle
) == 12 );
822 C_ASSERT( FIELD_OFFSET(struct set_process_info_request
, mask
) == 16 );
823 C_ASSERT( FIELD_OFFSET(struct set_process_info_request
, priority
) == 20 );
824 C_ASSERT( FIELD_OFFSET(struct set_process_info_request
, affinity
) == 24 );
825 C_ASSERT( sizeof(struct set_process_info_request
) == 32 );
826 C_ASSERT( FIELD_OFFSET(struct get_thread_info_request
, handle
) == 12 );
827 C_ASSERT( FIELD_OFFSET(struct get_thread_info_request
, access
) == 16 );
828 C_ASSERT( sizeof(struct get_thread_info_request
) == 24 );
829 C_ASSERT( FIELD_OFFSET(struct get_thread_info_reply
, pid
) == 8 );
830 C_ASSERT( FIELD_OFFSET(struct get_thread_info_reply
, tid
) == 12 );
831 C_ASSERT( FIELD_OFFSET(struct get_thread_info_reply
, teb
) == 16 );
832 C_ASSERT( FIELD_OFFSET(struct get_thread_info_reply
, entry_point
) == 24 );
833 C_ASSERT( FIELD_OFFSET(struct get_thread_info_reply
, affinity
) == 32 );
834 C_ASSERT( FIELD_OFFSET(struct get_thread_info_reply
, exit_code
) == 40 );
835 C_ASSERT( FIELD_OFFSET(struct get_thread_info_reply
, priority
) == 44 );
836 C_ASSERT( FIELD_OFFSET(struct get_thread_info_reply
, last
) == 48 );
837 C_ASSERT( FIELD_OFFSET(struct get_thread_info_reply
, suspend_count
) == 52 );
838 C_ASSERT( FIELD_OFFSET(struct get_thread_info_reply
, dbg_hidden
) == 56 );
839 C_ASSERT( FIELD_OFFSET(struct get_thread_info_reply
, desc_len
) == 60 );
840 C_ASSERT( sizeof(struct get_thread_info_reply
) == 64 );
841 C_ASSERT( FIELD_OFFSET(struct get_thread_times_request
, handle
) == 12 );
842 C_ASSERT( sizeof(struct get_thread_times_request
) == 16 );
843 C_ASSERT( FIELD_OFFSET(struct get_thread_times_reply
, creation_time
) == 8 );
844 C_ASSERT( FIELD_OFFSET(struct get_thread_times_reply
, exit_time
) == 16 );
845 C_ASSERT( FIELD_OFFSET(struct get_thread_times_reply
, unix_pid
) == 24 );
846 C_ASSERT( FIELD_OFFSET(struct get_thread_times_reply
, unix_tid
) == 28 );
847 C_ASSERT( sizeof(struct get_thread_times_reply
) == 32 );
848 C_ASSERT( FIELD_OFFSET(struct set_thread_info_request
, handle
) == 12 );
849 C_ASSERT( FIELD_OFFSET(struct set_thread_info_request
, mask
) == 16 );
850 C_ASSERT( FIELD_OFFSET(struct set_thread_info_request
, priority
) == 20 );
851 C_ASSERT( FIELD_OFFSET(struct set_thread_info_request
, affinity
) == 24 );
852 C_ASSERT( FIELD_OFFSET(struct set_thread_info_request
, entry_point
) == 32 );
853 C_ASSERT( FIELD_OFFSET(struct set_thread_info_request
, token
) == 40 );
854 C_ASSERT( sizeof(struct set_thread_info_request
) == 48 );
855 C_ASSERT( FIELD_OFFSET(struct suspend_thread_request
, handle
) == 12 );
856 C_ASSERT( sizeof(struct suspend_thread_request
) == 16 );
857 C_ASSERT( FIELD_OFFSET(struct suspend_thread_reply
, count
) == 8 );
858 C_ASSERT( sizeof(struct suspend_thread_reply
) == 16 );
859 C_ASSERT( FIELD_OFFSET(struct resume_thread_request
, handle
) == 12 );
860 C_ASSERT( sizeof(struct resume_thread_request
) == 16 );
861 C_ASSERT( FIELD_OFFSET(struct resume_thread_reply
, count
) == 8 );
862 C_ASSERT( sizeof(struct resume_thread_reply
) == 16 );
863 C_ASSERT( FIELD_OFFSET(struct queue_apc_request
, handle
) == 12 );
864 C_ASSERT( FIELD_OFFSET(struct queue_apc_request
, call
) == 16 );
865 C_ASSERT( sizeof(struct queue_apc_request
) == 64 );
866 C_ASSERT( FIELD_OFFSET(struct queue_apc_reply
, handle
) == 8 );
867 C_ASSERT( FIELD_OFFSET(struct queue_apc_reply
, self
) == 12 );
868 C_ASSERT( sizeof(struct queue_apc_reply
) == 16 );
869 C_ASSERT( FIELD_OFFSET(struct get_apc_result_request
, handle
) == 12 );
870 C_ASSERT( sizeof(struct get_apc_result_request
) == 16 );
871 C_ASSERT( FIELD_OFFSET(struct get_apc_result_reply
, result
) == 8 );
872 C_ASSERT( sizeof(struct get_apc_result_reply
) == 48 );
873 C_ASSERT( FIELD_OFFSET(struct close_handle_request
, handle
) == 12 );
874 C_ASSERT( sizeof(struct close_handle_request
) == 16 );
875 C_ASSERT( FIELD_OFFSET(struct set_handle_info_request
, handle
) == 12 );
876 C_ASSERT( FIELD_OFFSET(struct set_handle_info_request
, flags
) == 16 );
877 C_ASSERT( FIELD_OFFSET(struct set_handle_info_request
, mask
) == 20 );
878 C_ASSERT( sizeof(struct set_handle_info_request
) == 24 );
879 C_ASSERT( FIELD_OFFSET(struct set_handle_info_reply
, old_flags
) == 8 );
880 C_ASSERT( sizeof(struct set_handle_info_reply
) == 16 );
881 C_ASSERT( FIELD_OFFSET(struct dup_handle_request
, src_process
) == 12 );
882 C_ASSERT( FIELD_OFFSET(struct dup_handle_request
, src_handle
) == 16 );
883 C_ASSERT( FIELD_OFFSET(struct dup_handle_request
, dst_process
) == 20 );
884 C_ASSERT( FIELD_OFFSET(struct dup_handle_request
, access
) == 24 );
885 C_ASSERT( FIELD_OFFSET(struct dup_handle_request
, attributes
) == 28 );
886 C_ASSERT( FIELD_OFFSET(struct dup_handle_request
, options
) == 32 );
887 C_ASSERT( sizeof(struct dup_handle_request
) == 40 );
888 C_ASSERT( FIELD_OFFSET(struct dup_handle_reply
, handle
) == 8 );
889 C_ASSERT( sizeof(struct dup_handle_reply
) == 16 );
890 C_ASSERT( FIELD_OFFSET(struct compare_objects_request
, first
) == 12 );
891 C_ASSERT( FIELD_OFFSET(struct compare_objects_request
, second
) == 16 );
892 C_ASSERT( sizeof(struct compare_objects_request
) == 24 );
893 C_ASSERT( FIELD_OFFSET(struct make_temporary_request
, handle
) == 12 );
894 C_ASSERT( sizeof(struct make_temporary_request
) == 16 );
895 C_ASSERT( FIELD_OFFSET(struct open_process_request
, pid
) == 12 );
896 C_ASSERT( FIELD_OFFSET(struct open_process_request
, access
) == 16 );
897 C_ASSERT( FIELD_OFFSET(struct open_process_request
, attributes
) == 20 );
898 C_ASSERT( sizeof(struct open_process_request
) == 24 );
899 C_ASSERT( FIELD_OFFSET(struct open_process_reply
, handle
) == 8 );
900 C_ASSERT( sizeof(struct open_process_reply
) == 16 );
901 C_ASSERT( FIELD_OFFSET(struct open_thread_request
, tid
) == 12 );
902 C_ASSERT( FIELD_OFFSET(struct open_thread_request
, access
) == 16 );
903 C_ASSERT( FIELD_OFFSET(struct open_thread_request
, attributes
) == 20 );
904 C_ASSERT( sizeof(struct open_thread_request
) == 24 );
905 C_ASSERT( FIELD_OFFSET(struct open_thread_reply
, handle
) == 8 );
906 C_ASSERT( sizeof(struct open_thread_reply
) == 16 );
907 C_ASSERT( FIELD_OFFSET(struct select_request
, flags
) == 12 );
908 C_ASSERT( FIELD_OFFSET(struct select_request
, cookie
) == 16 );
909 C_ASSERT( FIELD_OFFSET(struct select_request
, timeout
) == 24 );
910 C_ASSERT( FIELD_OFFSET(struct select_request
, size
) == 32 );
911 C_ASSERT( FIELD_OFFSET(struct select_request
, prev_apc
) == 36 );
912 C_ASSERT( sizeof(struct select_request
) == 40 );
913 C_ASSERT( FIELD_OFFSET(struct select_reply
, call
) == 8 );
914 C_ASSERT( FIELD_OFFSET(struct select_reply
, apc_handle
) == 56 );
915 C_ASSERT( FIELD_OFFSET(struct select_reply
, signaled
) == 60 );
916 C_ASSERT( sizeof(struct select_reply
) == 64 );
917 C_ASSERT( FIELD_OFFSET(struct create_event_request
, access
) == 12 );
918 C_ASSERT( FIELD_OFFSET(struct create_event_request
, manual_reset
) == 16 );
919 C_ASSERT( FIELD_OFFSET(struct create_event_request
, initial_state
) == 20 );
920 C_ASSERT( sizeof(struct create_event_request
) == 24 );
921 C_ASSERT( FIELD_OFFSET(struct create_event_reply
, handle
) == 8 );
922 C_ASSERT( sizeof(struct create_event_reply
) == 16 );
923 C_ASSERT( FIELD_OFFSET(struct event_op_request
, handle
) == 12 );
924 C_ASSERT( FIELD_OFFSET(struct event_op_request
, op
) == 16 );
925 C_ASSERT( sizeof(struct event_op_request
) == 24 );
926 C_ASSERT( FIELD_OFFSET(struct event_op_reply
, state
) == 8 );
927 C_ASSERT( sizeof(struct event_op_reply
) == 16 );
928 C_ASSERT( FIELD_OFFSET(struct query_event_request
, handle
) == 12 );
929 C_ASSERT( sizeof(struct query_event_request
) == 16 );
930 C_ASSERT( FIELD_OFFSET(struct query_event_reply
, manual_reset
) == 8 );
931 C_ASSERT( FIELD_OFFSET(struct query_event_reply
, state
) == 12 );
932 C_ASSERT( sizeof(struct query_event_reply
) == 16 );
933 C_ASSERT( FIELD_OFFSET(struct open_event_request
, access
) == 12 );
934 C_ASSERT( FIELD_OFFSET(struct open_event_request
, attributes
) == 16 );
935 C_ASSERT( FIELD_OFFSET(struct open_event_request
, rootdir
) == 20 );
936 C_ASSERT( sizeof(struct open_event_request
) == 24 );
937 C_ASSERT( FIELD_OFFSET(struct open_event_reply
, handle
) == 8 );
938 C_ASSERT( sizeof(struct open_event_reply
) == 16 );
939 C_ASSERT( FIELD_OFFSET(struct create_keyed_event_request
, access
) == 12 );
940 C_ASSERT( sizeof(struct create_keyed_event_request
) == 16 );
941 C_ASSERT( FIELD_OFFSET(struct create_keyed_event_reply
, handle
) == 8 );
942 C_ASSERT( sizeof(struct create_keyed_event_reply
) == 16 );
943 C_ASSERT( FIELD_OFFSET(struct open_keyed_event_request
, access
) == 12 );
944 C_ASSERT( FIELD_OFFSET(struct open_keyed_event_request
, attributes
) == 16 );
945 C_ASSERT( FIELD_OFFSET(struct open_keyed_event_request
, rootdir
) == 20 );
946 C_ASSERT( sizeof(struct open_keyed_event_request
) == 24 );
947 C_ASSERT( FIELD_OFFSET(struct open_keyed_event_reply
, handle
) == 8 );
948 C_ASSERT( sizeof(struct open_keyed_event_reply
) == 16 );
949 C_ASSERT( FIELD_OFFSET(struct create_mutex_request
, access
) == 12 );
950 C_ASSERT( FIELD_OFFSET(struct create_mutex_request
, owned
) == 16 );
951 C_ASSERT( sizeof(struct create_mutex_request
) == 24 );
952 C_ASSERT( FIELD_OFFSET(struct create_mutex_reply
, handle
) == 8 );
953 C_ASSERT( sizeof(struct create_mutex_reply
) == 16 );
954 C_ASSERT( FIELD_OFFSET(struct release_mutex_request
, handle
) == 12 );
955 C_ASSERT( sizeof(struct release_mutex_request
) == 16 );
956 C_ASSERT( FIELD_OFFSET(struct release_mutex_reply
, prev_count
) == 8 );
957 C_ASSERT( sizeof(struct release_mutex_reply
) == 16 );
958 C_ASSERT( FIELD_OFFSET(struct open_mutex_request
, access
) == 12 );
959 C_ASSERT( FIELD_OFFSET(struct open_mutex_request
, attributes
) == 16 );
960 C_ASSERT( FIELD_OFFSET(struct open_mutex_request
, rootdir
) == 20 );
961 C_ASSERT( sizeof(struct open_mutex_request
) == 24 );
962 C_ASSERT( FIELD_OFFSET(struct open_mutex_reply
, handle
) == 8 );
963 C_ASSERT( sizeof(struct open_mutex_reply
) == 16 );
964 C_ASSERT( FIELD_OFFSET(struct query_mutex_request
, handle
) == 12 );
965 C_ASSERT( sizeof(struct query_mutex_request
) == 16 );
966 C_ASSERT( FIELD_OFFSET(struct query_mutex_reply
, count
) == 8 );
967 C_ASSERT( FIELD_OFFSET(struct query_mutex_reply
, owned
) == 12 );
968 C_ASSERT( FIELD_OFFSET(struct query_mutex_reply
, abandoned
) == 16 );
969 C_ASSERT( sizeof(struct query_mutex_reply
) == 24 );
970 C_ASSERT( FIELD_OFFSET(struct create_semaphore_request
, access
) == 12 );
971 C_ASSERT( FIELD_OFFSET(struct create_semaphore_request
, initial
) == 16 );
972 C_ASSERT( FIELD_OFFSET(struct create_semaphore_request
, max
) == 20 );
973 C_ASSERT( sizeof(struct create_semaphore_request
) == 24 );
974 C_ASSERT( FIELD_OFFSET(struct create_semaphore_reply
, handle
) == 8 );
975 C_ASSERT( sizeof(struct create_semaphore_reply
) == 16 );
976 C_ASSERT( FIELD_OFFSET(struct release_semaphore_request
, handle
) == 12 );
977 C_ASSERT( FIELD_OFFSET(struct release_semaphore_request
, count
) == 16 );
978 C_ASSERT( sizeof(struct release_semaphore_request
) == 24 );
979 C_ASSERT( FIELD_OFFSET(struct release_semaphore_reply
, prev_count
) == 8 );
980 C_ASSERT( sizeof(struct release_semaphore_reply
) == 16 );
981 C_ASSERT( FIELD_OFFSET(struct query_semaphore_request
, handle
) == 12 );
982 C_ASSERT( sizeof(struct query_semaphore_request
) == 16 );
983 C_ASSERT( FIELD_OFFSET(struct query_semaphore_reply
, current
) == 8 );
984 C_ASSERT( FIELD_OFFSET(struct query_semaphore_reply
, max
) == 12 );
985 C_ASSERT( sizeof(struct query_semaphore_reply
) == 16 );
986 C_ASSERT( FIELD_OFFSET(struct open_semaphore_request
, access
) == 12 );
987 C_ASSERT( FIELD_OFFSET(struct open_semaphore_request
, attributes
) == 16 );
988 C_ASSERT( FIELD_OFFSET(struct open_semaphore_request
, rootdir
) == 20 );
989 C_ASSERT( sizeof(struct open_semaphore_request
) == 24 );
990 C_ASSERT( FIELD_OFFSET(struct open_semaphore_reply
, handle
) == 8 );
991 C_ASSERT( sizeof(struct open_semaphore_reply
) == 16 );
992 C_ASSERT( FIELD_OFFSET(struct create_file_request
, access
) == 12 );
993 C_ASSERT( FIELD_OFFSET(struct create_file_request
, sharing
) == 16 );
994 C_ASSERT( FIELD_OFFSET(struct create_file_request
, create
) == 20 );
995 C_ASSERT( FIELD_OFFSET(struct create_file_request
, options
) == 24 );
996 C_ASSERT( FIELD_OFFSET(struct create_file_request
, attrs
) == 28 );
997 C_ASSERT( sizeof(struct create_file_request
) == 32 );
998 C_ASSERT( FIELD_OFFSET(struct create_file_reply
, handle
) == 8 );
999 C_ASSERT( sizeof(struct create_file_reply
) == 16 );
1000 C_ASSERT( FIELD_OFFSET(struct open_file_object_request
, access
) == 12 );
1001 C_ASSERT( FIELD_OFFSET(struct open_file_object_request
, attributes
) == 16 );
1002 C_ASSERT( FIELD_OFFSET(struct open_file_object_request
, rootdir
) == 20 );
1003 C_ASSERT( FIELD_OFFSET(struct open_file_object_request
, sharing
) == 24 );
1004 C_ASSERT( FIELD_OFFSET(struct open_file_object_request
, options
) == 28 );
1005 C_ASSERT( sizeof(struct open_file_object_request
) == 32 );
1006 C_ASSERT( FIELD_OFFSET(struct open_file_object_reply
, handle
) == 8 );
1007 C_ASSERT( sizeof(struct open_file_object_reply
) == 16 );
1008 C_ASSERT( FIELD_OFFSET(struct alloc_file_handle_request
, access
) == 12 );
1009 C_ASSERT( FIELD_OFFSET(struct alloc_file_handle_request
, attributes
) == 16 );
1010 C_ASSERT( FIELD_OFFSET(struct alloc_file_handle_request
, fd
) == 20 );
1011 C_ASSERT( sizeof(struct alloc_file_handle_request
) == 24 );
1012 C_ASSERT( FIELD_OFFSET(struct alloc_file_handle_reply
, handle
) == 8 );
1013 C_ASSERT( sizeof(struct alloc_file_handle_reply
) == 16 );
1014 C_ASSERT( FIELD_OFFSET(struct get_handle_unix_name_request
, handle
) == 12 );
1015 C_ASSERT( sizeof(struct get_handle_unix_name_request
) == 16 );
1016 C_ASSERT( FIELD_OFFSET(struct get_handle_unix_name_reply
, name_len
) == 8 );
1017 C_ASSERT( sizeof(struct get_handle_unix_name_reply
) == 16 );
1018 C_ASSERT( FIELD_OFFSET(struct get_handle_fd_request
, handle
) == 12 );
1019 C_ASSERT( sizeof(struct get_handle_fd_request
) == 16 );
1020 C_ASSERT( FIELD_OFFSET(struct get_handle_fd_reply
, type
) == 8 );
1021 C_ASSERT( FIELD_OFFSET(struct get_handle_fd_reply
, cacheable
) == 12 );
1022 C_ASSERT( FIELD_OFFSET(struct get_handle_fd_reply
, access
) == 16 );
1023 C_ASSERT( FIELD_OFFSET(struct get_handle_fd_reply
, options
) == 20 );
1024 C_ASSERT( sizeof(struct get_handle_fd_reply
) == 24 );
1025 C_ASSERT( FIELD_OFFSET(struct get_directory_cache_entry_request
, handle
) == 12 );
1026 C_ASSERT( sizeof(struct get_directory_cache_entry_request
) == 16 );
1027 C_ASSERT( FIELD_OFFSET(struct get_directory_cache_entry_reply
, entry
) == 8 );
1028 C_ASSERT( sizeof(struct get_directory_cache_entry_reply
) == 16 );
1029 C_ASSERT( FIELD_OFFSET(struct flush_request
, async
) == 16 );
1030 C_ASSERT( sizeof(struct flush_request
) == 56 );
1031 C_ASSERT( FIELD_OFFSET(struct flush_reply
, event
) == 8 );
1032 C_ASSERT( sizeof(struct flush_reply
) == 16 );
1033 C_ASSERT( FIELD_OFFSET(struct get_file_info_request
, handle
) == 12 );
1034 C_ASSERT( FIELD_OFFSET(struct get_file_info_request
, info_class
) == 16 );
1035 C_ASSERT( sizeof(struct get_file_info_request
) == 24 );
1036 C_ASSERT( sizeof(struct get_file_info_reply
) == 8 );
1037 C_ASSERT( FIELD_OFFSET(struct get_volume_info_request
, handle
) == 12 );
1038 C_ASSERT( FIELD_OFFSET(struct get_volume_info_request
, async
) == 16 );
1039 C_ASSERT( FIELD_OFFSET(struct get_volume_info_request
, info_class
) == 56 );
1040 C_ASSERT( sizeof(struct get_volume_info_request
) == 64 );
1041 C_ASSERT( FIELD_OFFSET(struct get_volume_info_reply
, wait
) == 8 );
1042 C_ASSERT( sizeof(struct get_volume_info_reply
) == 16 );
1043 C_ASSERT( FIELD_OFFSET(struct lock_file_request
, handle
) == 12 );
1044 C_ASSERT( FIELD_OFFSET(struct lock_file_request
, offset
) == 16 );
1045 C_ASSERT( FIELD_OFFSET(struct lock_file_request
, count
) == 24 );
1046 C_ASSERT( FIELD_OFFSET(struct lock_file_request
, shared
) == 32 );
1047 C_ASSERT( FIELD_OFFSET(struct lock_file_request
, wait
) == 36 );
1048 C_ASSERT( sizeof(struct lock_file_request
) == 40 );
1049 C_ASSERT( FIELD_OFFSET(struct lock_file_reply
, handle
) == 8 );
1050 C_ASSERT( FIELD_OFFSET(struct lock_file_reply
, overlapped
) == 12 );
1051 C_ASSERT( sizeof(struct lock_file_reply
) == 16 );
1052 C_ASSERT( FIELD_OFFSET(struct unlock_file_request
, handle
) == 12 );
1053 C_ASSERT( FIELD_OFFSET(struct unlock_file_request
, offset
) == 16 );
1054 C_ASSERT( FIELD_OFFSET(struct unlock_file_request
, count
) == 24 );
1055 C_ASSERT( sizeof(struct unlock_file_request
) == 32 );
1056 C_ASSERT( FIELD_OFFSET(struct recv_socket_request
, oob
) == 12 );
1057 C_ASSERT( FIELD_OFFSET(struct recv_socket_request
, async
) == 16 );
1058 C_ASSERT( FIELD_OFFSET(struct recv_socket_request
, force_async
) == 56 );
1059 C_ASSERT( sizeof(struct recv_socket_request
) == 64 );
1060 C_ASSERT( FIELD_OFFSET(struct recv_socket_reply
, wait
) == 8 );
1061 C_ASSERT( FIELD_OFFSET(struct recv_socket_reply
, options
) == 12 );
1062 C_ASSERT( FIELD_OFFSET(struct recv_socket_reply
, nonblocking
) == 16 );
1063 C_ASSERT( sizeof(struct recv_socket_reply
) == 24 );
1064 C_ASSERT( FIELD_OFFSET(struct send_socket_request
, async
) == 16 );
1065 C_ASSERT( FIELD_OFFSET(struct send_socket_request
, force_async
) == 56 );
1066 C_ASSERT( sizeof(struct send_socket_request
) == 64 );
1067 C_ASSERT( FIELD_OFFSET(struct send_socket_reply
, wait
) == 8 );
1068 C_ASSERT( FIELD_OFFSET(struct send_socket_reply
, options
) == 12 );
1069 C_ASSERT( FIELD_OFFSET(struct send_socket_reply
, nonblocking
) == 16 );
1070 C_ASSERT( sizeof(struct send_socket_reply
) == 24 );
1071 C_ASSERT( FIELD_OFFSET(struct socket_send_icmp_id_request
, handle
) == 12 );
1072 C_ASSERT( FIELD_OFFSET(struct socket_send_icmp_id_request
, icmp_id
) == 16 );
1073 C_ASSERT( FIELD_OFFSET(struct socket_send_icmp_id_request
, icmp_seq
) == 18 );
1074 C_ASSERT( sizeof(struct socket_send_icmp_id_request
) == 24 );
1075 C_ASSERT( sizeof(struct socket_send_icmp_id_reply
) == 8 );
1076 C_ASSERT( FIELD_OFFSET(struct socket_get_icmp_id_request
, handle
) == 12 );
1077 C_ASSERT( FIELD_OFFSET(struct socket_get_icmp_id_request
, icmp_seq
) == 16 );
1078 C_ASSERT( sizeof(struct socket_get_icmp_id_request
) == 24 );
1079 C_ASSERT( FIELD_OFFSET(struct socket_get_icmp_id_reply
, icmp_id
) == 8 );
1080 C_ASSERT( sizeof(struct socket_get_icmp_id_reply
) == 16 );
1081 C_ASSERT( FIELD_OFFSET(struct get_next_console_request_request
, handle
) == 12 );
1082 C_ASSERT( FIELD_OFFSET(struct get_next_console_request_request
, signal
) == 16 );
1083 C_ASSERT( FIELD_OFFSET(struct get_next_console_request_request
, read
) == 20 );
1084 C_ASSERT( FIELD_OFFSET(struct get_next_console_request_request
, status
) == 24 );
1085 C_ASSERT( sizeof(struct get_next_console_request_request
) == 32 );
1086 C_ASSERT( FIELD_OFFSET(struct get_next_console_request_reply
, code
) == 8 );
1087 C_ASSERT( FIELD_OFFSET(struct get_next_console_request_reply
, output
) == 12 );
1088 C_ASSERT( FIELD_OFFSET(struct get_next_console_request_reply
, out_size
) == 16 );
1089 C_ASSERT( sizeof(struct get_next_console_request_reply
) == 24 );
1090 C_ASSERT( FIELD_OFFSET(struct read_directory_changes_request
, filter
) == 12 );
1091 C_ASSERT( FIELD_OFFSET(struct read_directory_changes_request
, subtree
) == 16 );
1092 C_ASSERT( FIELD_OFFSET(struct read_directory_changes_request
, want_data
) == 20 );
1093 C_ASSERT( FIELD_OFFSET(struct read_directory_changes_request
, async
) == 24 );
1094 C_ASSERT( sizeof(struct read_directory_changes_request
) == 64 );
1095 C_ASSERT( FIELD_OFFSET(struct read_change_request
, handle
) == 12 );
1096 C_ASSERT( sizeof(struct read_change_request
) == 16 );
1097 C_ASSERT( sizeof(struct read_change_reply
) == 8 );
1098 C_ASSERT( FIELD_OFFSET(struct create_mapping_request
, access
) == 12 );
1099 C_ASSERT( FIELD_OFFSET(struct create_mapping_request
, flags
) == 16 );
1100 C_ASSERT( FIELD_OFFSET(struct create_mapping_request
, file_access
) == 20 );
1101 C_ASSERT( FIELD_OFFSET(struct create_mapping_request
, size
) == 24 );
1102 C_ASSERT( FIELD_OFFSET(struct create_mapping_request
, file_handle
) == 32 );
1103 C_ASSERT( sizeof(struct create_mapping_request
) == 40 );
1104 C_ASSERT( FIELD_OFFSET(struct create_mapping_reply
, handle
) == 8 );
1105 C_ASSERT( sizeof(struct create_mapping_reply
) == 16 );
1106 C_ASSERT( FIELD_OFFSET(struct open_mapping_request
, access
) == 12 );
1107 C_ASSERT( FIELD_OFFSET(struct open_mapping_request
, attributes
) == 16 );
1108 C_ASSERT( FIELD_OFFSET(struct open_mapping_request
, rootdir
) == 20 );
1109 C_ASSERT( sizeof(struct open_mapping_request
) == 24 );
1110 C_ASSERT( FIELD_OFFSET(struct open_mapping_reply
, handle
) == 8 );
1111 C_ASSERT( sizeof(struct open_mapping_reply
) == 16 );
1112 C_ASSERT( FIELD_OFFSET(struct get_mapping_info_request
, handle
) == 12 );
1113 C_ASSERT( FIELD_OFFSET(struct get_mapping_info_request
, access
) == 16 );
1114 C_ASSERT( sizeof(struct get_mapping_info_request
) == 24 );
1115 C_ASSERT( FIELD_OFFSET(struct get_mapping_info_reply
, size
) == 8 );
1116 C_ASSERT( FIELD_OFFSET(struct get_mapping_info_reply
, flags
) == 16 );
1117 C_ASSERT( FIELD_OFFSET(struct get_mapping_info_reply
, shared_file
) == 20 );
1118 C_ASSERT( FIELD_OFFSET(struct get_mapping_info_reply
, total
) == 24 );
1119 C_ASSERT( sizeof(struct get_mapping_info_reply
) == 32 );
1120 C_ASSERT( FIELD_OFFSET(struct map_view_request
, mapping
) == 12 );
1121 C_ASSERT( FIELD_OFFSET(struct map_view_request
, access
) == 16 );
1122 C_ASSERT( FIELD_OFFSET(struct map_view_request
, base
) == 24 );
1123 C_ASSERT( FIELD_OFFSET(struct map_view_request
, size
) == 32 );
1124 C_ASSERT( FIELD_OFFSET(struct map_view_request
, start
) == 40 );
1125 C_ASSERT( sizeof(struct map_view_request
) == 48 );
1126 C_ASSERT( FIELD_OFFSET(struct map_image_view_request
, mapping
) == 12 );
1127 C_ASSERT( FIELD_OFFSET(struct map_image_view_request
, base
) == 16 );
1128 C_ASSERT( FIELD_OFFSET(struct map_image_view_request
, size
) == 24 );
1129 C_ASSERT( FIELD_OFFSET(struct map_image_view_request
, entry
) == 32 );
1130 C_ASSERT( FIELD_OFFSET(struct map_image_view_request
, machine
) == 36 );
1131 C_ASSERT( sizeof(struct map_image_view_request
) == 40 );
1132 C_ASSERT( sizeof(struct map_builtin_view_request
) == 16 );
1133 C_ASSERT( FIELD_OFFSET(struct unmap_view_request
, base
) == 16 );
1134 C_ASSERT( sizeof(struct unmap_view_request
) == 24 );
1135 C_ASSERT( FIELD_OFFSET(struct get_mapping_committed_range_request
, base
) == 16 );
1136 C_ASSERT( FIELD_OFFSET(struct get_mapping_committed_range_request
, offset
) == 24 );
1137 C_ASSERT( sizeof(struct get_mapping_committed_range_request
) == 32 );
1138 C_ASSERT( FIELD_OFFSET(struct get_mapping_committed_range_reply
, size
) == 8 );
1139 C_ASSERT( FIELD_OFFSET(struct get_mapping_committed_range_reply
, committed
) == 16 );
1140 C_ASSERT( sizeof(struct get_mapping_committed_range_reply
) == 24 );
1141 C_ASSERT( FIELD_OFFSET(struct add_mapping_committed_range_request
, base
) == 16 );
1142 C_ASSERT( FIELD_OFFSET(struct add_mapping_committed_range_request
, offset
) == 24 );
1143 C_ASSERT( FIELD_OFFSET(struct add_mapping_committed_range_request
, size
) == 32 );
1144 C_ASSERT( sizeof(struct add_mapping_committed_range_request
) == 40 );
1145 C_ASSERT( FIELD_OFFSET(struct is_same_mapping_request
, base1
) == 16 );
1146 C_ASSERT( FIELD_OFFSET(struct is_same_mapping_request
, base2
) == 24 );
1147 C_ASSERT( sizeof(struct is_same_mapping_request
) == 32 );
1148 C_ASSERT( FIELD_OFFSET(struct get_mapping_filename_request
, process
) == 12 );
1149 C_ASSERT( FIELD_OFFSET(struct get_mapping_filename_request
, addr
) == 16 );
1150 C_ASSERT( sizeof(struct get_mapping_filename_request
) == 24 );
1151 C_ASSERT( FIELD_OFFSET(struct get_mapping_filename_reply
, len
) == 8 );
1152 C_ASSERT( sizeof(struct get_mapping_filename_reply
) == 16 );
1153 C_ASSERT( sizeof(struct list_processes_request
) == 16 );
1154 C_ASSERT( FIELD_OFFSET(struct list_processes_reply
, info_size
) == 8 );
1155 C_ASSERT( FIELD_OFFSET(struct list_processes_reply
, process_count
) == 12 );
1156 C_ASSERT( FIELD_OFFSET(struct list_processes_reply
, total_thread_count
) == 16 );
1157 C_ASSERT( FIELD_OFFSET(struct list_processes_reply
, total_name_len
) == 20 );
1158 C_ASSERT( sizeof(struct list_processes_reply
) == 24 );
1159 C_ASSERT( FIELD_OFFSET(struct create_debug_obj_request
, access
) == 12 );
1160 C_ASSERT( FIELD_OFFSET(struct create_debug_obj_request
, flags
) == 16 );
1161 C_ASSERT( sizeof(struct create_debug_obj_request
) == 24 );
1162 C_ASSERT( FIELD_OFFSET(struct create_debug_obj_reply
, handle
) == 8 );
1163 C_ASSERT( sizeof(struct create_debug_obj_reply
) == 16 );
1164 C_ASSERT( FIELD_OFFSET(struct wait_debug_event_request
, debug
) == 12 );
1165 C_ASSERT( sizeof(struct wait_debug_event_request
) == 16 );
1166 C_ASSERT( FIELD_OFFSET(struct wait_debug_event_reply
, pid
) == 8 );
1167 C_ASSERT( FIELD_OFFSET(struct wait_debug_event_reply
, tid
) == 12 );
1168 C_ASSERT( sizeof(struct wait_debug_event_reply
) == 16 );
1169 C_ASSERT( FIELD_OFFSET(struct queue_exception_event_request
, first
) == 12 );
1170 C_ASSERT( FIELD_OFFSET(struct queue_exception_event_request
, code
) == 16 );
1171 C_ASSERT( FIELD_OFFSET(struct queue_exception_event_request
, flags
) == 20 );
1172 C_ASSERT( FIELD_OFFSET(struct queue_exception_event_request
, record
) == 24 );
1173 C_ASSERT( FIELD_OFFSET(struct queue_exception_event_request
, address
) == 32 );
1174 C_ASSERT( FIELD_OFFSET(struct queue_exception_event_request
, len
) == 40 );
1175 C_ASSERT( sizeof(struct queue_exception_event_request
) == 48 );
1176 C_ASSERT( FIELD_OFFSET(struct queue_exception_event_reply
, handle
) == 8 );
1177 C_ASSERT( sizeof(struct queue_exception_event_reply
) == 16 );
1178 C_ASSERT( FIELD_OFFSET(struct get_exception_status_request
, handle
) == 12 );
1179 C_ASSERT( sizeof(struct get_exception_status_request
) == 16 );
1180 C_ASSERT( FIELD_OFFSET(struct continue_debug_event_request
, debug
) == 12 );
1181 C_ASSERT( FIELD_OFFSET(struct continue_debug_event_request
, pid
) == 16 );
1182 C_ASSERT( FIELD_OFFSET(struct continue_debug_event_request
, tid
) == 20 );
1183 C_ASSERT( FIELD_OFFSET(struct continue_debug_event_request
, status
) == 24 );
1184 C_ASSERT( sizeof(struct continue_debug_event_request
) == 32 );
1185 C_ASSERT( FIELD_OFFSET(struct debug_process_request
, handle
) == 12 );
1186 C_ASSERT( FIELD_OFFSET(struct debug_process_request
, debug
) == 16 );
1187 C_ASSERT( FIELD_OFFSET(struct debug_process_request
, attach
) == 20 );
1188 C_ASSERT( sizeof(struct debug_process_request
) == 24 );
1189 C_ASSERT( FIELD_OFFSET(struct set_debug_obj_info_request
, debug
) == 12 );
1190 C_ASSERT( FIELD_OFFSET(struct set_debug_obj_info_request
, flags
) == 16 );
1191 C_ASSERT( sizeof(struct set_debug_obj_info_request
) == 24 );
1192 C_ASSERT( FIELD_OFFSET(struct read_process_memory_request
, handle
) == 12 );
1193 C_ASSERT( FIELD_OFFSET(struct read_process_memory_request
, addr
) == 16 );
1194 C_ASSERT( sizeof(struct read_process_memory_request
) == 24 );
1195 C_ASSERT( sizeof(struct read_process_memory_reply
) == 8 );
1196 C_ASSERT( FIELD_OFFSET(struct write_process_memory_request
, handle
) == 12 );
1197 C_ASSERT( FIELD_OFFSET(struct write_process_memory_request
, addr
) == 16 );
1198 C_ASSERT( sizeof(struct write_process_memory_request
) == 24 );
1199 C_ASSERT( FIELD_OFFSET(struct create_key_request
, access
) == 12 );
1200 C_ASSERT( FIELD_OFFSET(struct create_key_request
, options
) == 16 );
1201 C_ASSERT( sizeof(struct create_key_request
) == 24 );
1202 C_ASSERT( FIELD_OFFSET(struct create_key_reply
, hkey
) == 8 );
1203 C_ASSERT( sizeof(struct create_key_reply
) == 16 );
1204 C_ASSERT( FIELD_OFFSET(struct open_key_request
, parent
) == 12 );
1205 C_ASSERT( FIELD_OFFSET(struct open_key_request
, access
) == 16 );
1206 C_ASSERT( FIELD_OFFSET(struct open_key_request
, attributes
) == 20 );
1207 C_ASSERT( sizeof(struct open_key_request
) == 24 );
1208 C_ASSERT( FIELD_OFFSET(struct open_key_reply
, hkey
) == 8 );
1209 C_ASSERT( sizeof(struct open_key_reply
) == 16 );
1210 C_ASSERT( FIELD_OFFSET(struct delete_key_request
, hkey
) == 12 );
1211 C_ASSERT( sizeof(struct delete_key_request
) == 16 );
1212 C_ASSERT( FIELD_OFFSET(struct flush_key_request
, hkey
) == 12 );
1213 C_ASSERT( sizeof(struct flush_key_request
) == 16 );
1214 C_ASSERT( FIELD_OFFSET(struct enum_key_request
, hkey
) == 12 );
1215 C_ASSERT( FIELD_OFFSET(struct enum_key_request
, index
) == 16 );
1216 C_ASSERT( FIELD_OFFSET(struct enum_key_request
, info_class
) == 20 );
1217 C_ASSERT( sizeof(struct enum_key_request
) == 24 );
1218 C_ASSERT( FIELD_OFFSET(struct enum_key_reply
, subkeys
) == 8 );
1219 C_ASSERT( FIELD_OFFSET(struct enum_key_reply
, max_subkey
) == 12 );
1220 C_ASSERT( FIELD_OFFSET(struct enum_key_reply
, max_class
) == 16 );
1221 C_ASSERT( FIELD_OFFSET(struct enum_key_reply
, values
) == 20 );
1222 C_ASSERT( FIELD_OFFSET(struct enum_key_reply
, max_value
) == 24 );
1223 C_ASSERT( FIELD_OFFSET(struct enum_key_reply
, max_data
) == 28 );
1224 C_ASSERT( FIELD_OFFSET(struct enum_key_reply
, modif
) == 32 );
1225 C_ASSERT( FIELD_OFFSET(struct enum_key_reply
, total
) == 40 );
1226 C_ASSERT( FIELD_OFFSET(struct enum_key_reply
, namelen
) == 44 );
1227 C_ASSERT( sizeof(struct enum_key_reply
) == 48 );
1228 C_ASSERT( FIELD_OFFSET(struct set_key_value_request
, hkey
) == 12 );
1229 C_ASSERT( FIELD_OFFSET(struct set_key_value_request
, type
) == 16 );
1230 C_ASSERT( FIELD_OFFSET(struct set_key_value_request
, namelen
) == 20 );
1231 C_ASSERT( sizeof(struct set_key_value_request
) == 24 );
1232 C_ASSERT( FIELD_OFFSET(struct get_key_value_request
, hkey
) == 12 );
1233 C_ASSERT( sizeof(struct get_key_value_request
) == 16 );
1234 C_ASSERT( FIELD_OFFSET(struct get_key_value_reply
, type
) == 8 );
1235 C_ASSERT( FIELD_OFFSET(struct get_key_value_reply
, total
) == 12 );
1236 C_ASSERT( sizeof(struct get_key_value_reply
) == 16 );
1237 C_ASSERT( FIELD_OFFSET(struct enum_key_value_request
, hkey
) == 12 );
1238 C_ASSERT( FIELD_OFFSET(struct enum_key_value_request
, index
) == 16 );
1239 C_ASSERT( FIELD_OFFSET(struct enum_key_value_request
, info_class
) == 20 );
1240 C_ASSERT( sizeof(struct enum_key_value_request
) == 24 );
1241 C_ASSERT( FIELD_OFFSET(struct enum_key_value_reply
, type
) == 8 );
1242 C_ASSERT( FIELD_OFFSET(struct enum_key_value_reply
, total
) == 12 );
1243 C_ASSERT( FIELD_OFFSET(struct enum_key_value_reply
, namelen
) == 16 );
1244 C_ASSERT( sizeof(struct enum_key_value_reply
) == 24 );
1245 C_ASSERT( FIELD_OFFSET(struct delete_key_value_request
, hkey
) == 12 );
1246 C_ASSERT( sizeof(struct delete_key_value_request
) == 16 );
1247 C_ASSERT( FIELD_OFFSET(struct load_registry_request
, file
) == 12 );
1248 C_ASSERT( sizeof(struct load_registry_request
) == 16 );
1249 C_ASSERT( FIELD_OFFSET(struct unload_registry_request
, parent
) == 12 );
1250 C_ASSERT( FIELD_OFFSET(struct unload_registry_request
, attributes
) == 16 );
1251 C_ASSERT( sizeof(struct unload_registry_request
) == 24 );
1252 C_ASSERT( FIELD_OFFSET(struct save_registry_request
, hkey
) == 12 );
1253 C_ASSERT( FIELD_OFFSET(struct save_registry_request
, file
) == 16 );
1254 C_ASSERT( sizeof(struct save_registry_request
) == 24 );
1255 C_ASSERT( FIELD_OFFSET(struct set_registry_notification_request
, hkey
) == 12 );
1256 C_ASSERT( FIELD_OFFSET(struct set_registry_notification_request
, event
) == 16 );
1257 C_ASSERT( FIELD_OFFSET(struct set_registry_notification_request
, subtree
) == 20 );
1258 C_ASSERT( FIELD_OFFSET(struct set_registry_notification_request
, filter
) == 24 );
1259 C_ASSERT( sizeof(struct set_registry_notification_request
) == 32 );
1260 C_ASSERT( FIELD_OFFSET(struct rename_key_request
, hkey
) == 12 );
1261 C_ASSERT( sizeof(struct rename_key_request
) == 16 );
1262 C_ASSERT( FIELD_OFFSET(struct create_timer_request
, access
) == 12 );
1263 C_ASSERT( FIELD_OFFSET(struct create_timer_request
, manual
) == 16 );
1264 C_ASSERT( sizeof(struct create_timer_request
) == 24 );
1265 C_ASSERT( FIELD_OFFSET(struct create_timer_reply
, handle
) == 8 );
1266 C_ASSERT( sizeof(struct create_timer_reply
) == 16 );
1267 C_ASSERT( FIELD_OFFSET(struct open_timer_request
, access
) == 12 );
1268 C_ASSERT( FIELD_OFFSET(struct open_timer_request
, attributes
) == 16 );
1269 C_ASSERT( FIELD_OFFSET(struct open_timer_request
, rootdir
) == 20 );
1270 C_ASSERT( sizeof(struct open_timer_request
) == 24 );
1271 C_ASSERT( FIELD_OFFSET(struct open_timer_reply
, handle
) == 8 );
1272 C_ASSERT( sizeof(struct open_timer_reply
) == 16 );
1273 C_ASSERT( FIELD_OFFSET(struct set_timer_request
, handle
) == 12 );
1274 C_ASSERT( FIELD_OFFSET(struct set_timer_request
, expire
) == 16 );
1275 C_ASSERT( FIELD_OFFSET(struct set_timer_request
, callback
) == 24 );
1276 C_ASSERT( FIELD_OFFSET(struct set_timer_request
, arg
) == 32 );
1277 C_ASSERT( FIELD_OFFSET(struct set_timer_request
, period
) == 40 );
1278 C_ASSERT( sizeof(struct set_timer_request
) == 48 );
1279 C_ASSERT( FIELD_OFFSET(struct set_timer_reply
, signaled
) == 8 );
1280 C_ASSERT( sizeof(struct set_timer_reply
) == 16 );
1281 C_ASSERT( FIELD_OFFSET(struct cancel_timer_request
, handle
) == 12 );
1282 C_ASSERT( sizeof(struct cancel_timer_request
) == 16 );
1283 C_ASSERT( FIELD_OFFSET(struct cancel_timer_reply
, signaled
) == 8 );
1284 C_ASSERT( sizeof(struct cancel_timer_reply
) == 16 );
1285 C_ASSERT( FIELD_OFFSET(struct get_timer_info_request
, handle
) == 12 );
1286 C_ASSERT( sizeof(struct get_timer_info_request
) == 16 );
1287 C_ASSERT( FIELD_OFFSET(struct get_timer_info_reply
, when
) == 8 );
1288 C_ASSERT( FIELD_OFFSET(struct get_timer_info_reply
, signaled
) == 16 );
1289 C_ASSERT( sizeof(struct get_timer_info_reply
) == 24 );
1290 C_ASSERT( FIELD_OFFSET(struct get_thread_context_request
, handle
) == 12 );
1291 C_ASSERT( FIELD_OFFSET(struct get_thread_context_request
, context
) == 16 );
1292 C_ASSERT( FIELD_OFFSET(struct get_thread_context_request
, flags
) == 20 );
1293 C_ASSERT( FIELD_OFFSET(struct get_thread_context_request
, native_flags
) == 24 );
1294 C_ASSERT( FIELD_OFFSET(struct get_thread_context_request
, machine
) == 28 );
1295 C_ASSERT( sizeof(struct get_thread_context_request
) == 32 );
1296 C_ASSERT( FIELD_OFFSET(struct get_thread_context_reply
, self
) == 8 );
1297 C_ASSERT( FIELD_OFFSET(struct get_thread_context_reply
, handle
) == 12 );
1298 C_ASSERT( sizeof(struct get_thread_context_reply
) == 16 );
1299 C_ASSERT( FIELD_OFFSET(struct set_thread_context_request
, handle
) == 12 );
1300 C_ASSERT( FIELD_OFFSET(struct set_thread_context_request
, native_flags
) == 16 );
1301 C_ASSERT( sizeof(struct set_thread_context_request
) == 24 );
1302 C_ASSERT( FIELD_OFFSET(struct set_thread_context_reply
, self
) == 8 );
1303 C_ASSERT( sizeof(struct set_thread_context_reply
) == 16 );
1304 C_ASSERT( FIELD_OFFSET(struct get_selector_entry_request
, handle
) == 12 );
1305 C_ASSERT( FIELD_OFFSET(struct get_selector_entry_request
, entry
) == 16 );
1306 C_ASSERT( sizeof(struct get_selector_entry_request
) == 24 );
1307 C_ASSERT( FIELD_OFFSET(struct get_selector_entry_reply
, base
) == 8 );
1308 C_ASSERT( FIELD_OFFSET(struct get_selector_entry_reply
, limit
) == 12 );
1309 C_ASSERT( FIELD_OFFSET(struct get_selector_entry_reply
, flags
) == 16 );
1310 C_ASSERT( sizeof(struct get_selector_entry_reply
) == 24 );
1311 C_ASSERT( sizeof(struct add_atom_request
) == 16 );
1312 C_ASSERT( FIELD_OFFSET(struct add_atom_reply
, atom
) == 8 );
1313 C_ASSERT( sizeof(struct add_atom_reply
) == 16 );
1314 C_ASSERT( FIELD_OFFSET(struct delete_atom_request
, atom
) == 12 );
1315 C_ASSERT( sizeof(struct delete_atom_request
) == 16 );
1316 C_ASSERT( sizeof(struct find_atom_request
) == 16 );
1317 C_ASSERT( FIELD_OFFSET(struct find_atom_reply
, atom
) == 8 );
1318 C_ASSERT( sizeof(struct find_atom_reply
) == 16 );
1319 C_ASSERT( FIELD_OFFSET(struct get_atom_information_request
, atom
) == 12 );
1320 C_ASSERT( sizeof(struct get_atom_information_request
) == 16 );
1321 C_ASSERT( FIELD_OFFSET(struct get_atom_information_reply
, count
) == 8 );
1322 C_ASSERT( FIELD_OFFSET(struct get_atom_information_reply
, pinned
) == 12 );
1323 C_ASSERT( FIELD_OFFSET(struct get_atom_information_reply
, total
) == 16 );
1324 C_ASSERT( sizeof(struct get_atom_information_reply
) == 24 );
1325 C_ASSERT( sizeof(struct get_msg_queue_request
) == 16 );
1326 C_ASSERT( FIELD_OFFSET(struct get_msg_queue_reply
, handle
) == 8 );
1327 C_ASSERT( sizeof(struct get_msg_queue_reply
) == 16 );
1328 C_ASSERT( FIELD_OFFSET(struct set_queue_fd_request
, handle
) == 12 );
1329 C_ASSERT( sizeof(struct set_queue_fd_request
) == 16 );
1330 C_ASSERT( FIELD_OFFSET(struct set_queue_mask_request
, wake_mask
) == 12 );
1331 C_ASSERT( FIELD_OFFSET(struct set_queue_mask_request
, changed_mask
) == 16 );
1332 C_ASSERT( FIELD_OFFSET(struct set_queue_mask_request
, skip_wait
) == 20 );
1333 C_ASSERT( sizeof(struct set_queue_mask_request
) == 24 );
1334 C_ASSERT( FIELD_OFFSET(struct set_queue_mask_reply
, wake_bits
) == 8 );
1335 C_ASSERT( FIELD_OFFSET(struct set_queue_mask_reply
, changed_bits
) == 12 );
1336 C_ASSERT( sizeof(struct set_queue_mask_reply
) == 16 );
1337 C_ASSERT( FIELD_OFFSET(struct get_queue_status_request
, clear_bits
) == 12 );
1338 C_ASSERT( sizeof(struct get_queue_status_request
) == 16 );
1339 C_ASSERT( FIELD_OFFSET(struct get_queue_status_reply
, wake_bits
) == 8 );
1340 C_ASSERT( FIELD_OFFSET(struct get_queue_status_reply
, changed_bits
) == 12 );
1341 C_ASSERT( sizeof(struct get_queue_status_reply
) == 16 );
1342 C_ASSERT( FIELD_OFFSET(struct get_process_idle_event_request
, handle
) == 12 );
1343 C_ASSERT( sizeof(struct get_process_idle_event_request
) == 16 );
1344 C_ASSERT( FIELD_OFFSET(struct get_process_idle_event_reply
, event
) == 8 );
1345 C_ASSERT( sizeof(struct get_process_idle_event_reply
) == 16 );
1346 C_ASSERT( FIELD_OFFSET(struct send_message_request
, id
) == 12 );
1347 C_ASSERT( FIELD_OFFSET(struct send_message_request
, type
) == 16 );
1348 C_ASSERT( FIELD_OFFSET(struct send_message_request
, flags
) == 20 );
1349 C_ASSERT( FIELD_OFFSET(struct send_message_request
, win
) == 24 );
1350 C_ASSERT( FIELD_OFFSET(struct send_message_request
, msg
) == 28 );
1351 C_ASSERT( FIELD_OFFSET(struct send_message_request
, wparam
) == 32 );
1352 C_ASSERT( FIELD_OFFSET(struct send_message_request
, lparam
) == 40 );
1353 C_ASSERT( FIELD_OFFSET(struct send_message_request
, timeout
) == 48 );
1354 C_ASSERT( sizeof(struct send_message_request
) == 56 );
1355 C_ASSERT( FIELD_OFFSET(struct post_quit_message_request
, exit_code
) == 12 );
1356 C_ASSERT( sizeof(struct post_quit_message_request
) == 16 );
1357 C_ASSERT( FIELD_OFFSET(struct send_hardware_message_request
, win
) == 12 );
1358 C_ASSERT( FIELD_OFFSET(struct send_hardware_message_request
, input
) == 16 );
1359 C_ASSERT( FIELD_OFFSET(struct send_hardware_message_request
, flags
) == 56 );
1360 C_ASSERT( sizeof(struct send_hardware_message_request
) == 64 );
1361 C_ASSERT( FIELD_OFFSET(struct send_hardware_message_reply
, wait
) == 8 );
1362 C_ASSERT( FIELD_OFFSET(struct send_hardware_message_reply
, prev_x
) == 12 );
1363 C_ASSERT( FIELD_OFFSET(struct send_hardware_message_reply
, prev_y
) == 16 );
1364 C_ASSERT( FIELD_OFFSET(struct send_hardware_message_reply
, new_x
) == 20 );
1365 C_ASSERT( FIELD_OFFSET(struct send_hardware_message_reply
, new_y
) == 24 );
1366 C_ASSERT( sizeof(struct send_hardware_message_reply
) == 32 );
1367 C_ASSERT( FIELD_OFFSET(struct get_message_request
, flags
) == 12 );
1368 C_ASSERT( FIELD_OFFSET(struct get_message_request
, get_win
) == 16 );
1369 C_ASSERT( FIELD_OFFSET(struct get_message_request
, get_first
) == 20 );
1370 C_ASSERT( FIELD_OFFSET(struct get_message_request
, get_last
) == 24 );
1371 C_ASSERT( FIELD_OFFSET(struct get_message_request
, hw_id
) == 28 );
1372 C_ASSERT( FIELD_OFFSET(struct get_message_request
, wake_mask
) == 32 );
1373 C_ASSERT( FIELD_OFFSET(struct get_message_request
, changed_mask
) == 36 );
1374 C_ASSERT( sizeof(struct get_message_request
) == 40 );
1375 C_ASSERT( FIELD_OFFSET(struct get_message_reply
, win
) == 8 );
1376 C_ASSERT( FIELD_OFFSET(struct get_message_reply
, msg
) == 12 );
1377 C_ASSERT( FIELD_OFFSET(struct get_message_reply
, wparam
) == 16 );
1378 C_ASSERT( FIELD_OFFSET(struct get_message_reply
, lparam
) == 24 );
1379 C_ASSERT( FIELD_OFFSET(struct get_message_reply
, type
) == 32 );
1380 C_ASSERT( FIELD_OFFSET(struct get_message_reply
, x
) == 36 );
1381 C_ASSERT( FIELD_OFFSET(struct get_message_reply
, y
) == 40 );
1382 C_ASSERT( FIELD_OFFSET(struct get_message_reply
, time
) == 44 );
1383 C_ASSERT( FIELD_OFFSET(struct get_message_reply
, active_hooks
) == 48 );
1384 C_ASSERT( FIELD_OFFSET(struct get_message_reply
, total
) == 52 );
1385 C_ASSERT( sizeof(struct get_message_reply
) == 56 );
1386 C_ASSERT( FIELD_OFFSET(struct reply_message_request
, remove
) == 12 );
1387 C_ASSERT( FIELD_OFFSET(struct reply_message_request
, result
) == 16 );
1388 C_ASSERT( sizeof(struct reply_message_request
) == 24 );
1389 C_ASSERT( FIELD_OFFSET(struct accept_hardware_message_request
, hw_id
) == 12 );
1390 C_ASSERT( sizeof(struct accept_hardware_message_request
) == 16 );
1391 C_ASSERT( FIELD_OFFSET(struct get_message_reply_request
, cancel
) == 12 );
1392 C_ASSERT( sizeof(struct get_message_reply_request
) == 16 );
1393 C_ASSERT( FIELD_OFFSET(struct get_message_reply_reply
, result
) == 8 );
1394 C_ASSERT( sizeof(struct get_message_reply_reply
) == 16 );
1395 C_ASSERT( FIELD_OFFSET(struct set_win_timer_request
, win
) == 12 );
1396 C_ASSERT( FIELD_OFFSET(struct set_win_timer_request
, msg
) == 16 );
1397 C_ASSERT( FIELD_OFFSET(struct set_win_timer_request
, rate
) == 20 );
1398 C_ASSERT( FIELD_OFFSET(struct set_win_timer_request
, id
) == 24 );
1399 C_ASSERT( FIELD_OFFSET(struct set_win_timer_request
, lparam
) == 32 );
1400 C_ASSERT( sizeof(struct set_win_timer_request
) == 40 );
1401 C_ASSERT( FIELD_OFFSET(struct set_win_timer_reply
, id
) == 8 );
1402 C_ASSERT( sizeof(struct set_win_timer_reply
) == 16 );
1403 C_ASSERT( FIELD_OFFSET(struct kill_win_timer_request
, win
) == 12 );
1404 C_ASSERT( FIELD_OFFSET(struct kill_win_timer_request
, id
) == 16 );
1405 C_ASSERT( FIELD_OFFSET(struct kill_win_timer_request
, msg
) == 24 );
1406 C_ASSERT( sizeof(struct kill_win_timer_request
) == 32 );
1407 C_ASSERT( FIELD_OFFSET(struct is_window_hung_request
, win
) == 12 );
1408 C_ASSERT( sizeof(struct is_window_hung_request
) == 16 );
1409 C_ASSERT( FIELD_OFFSET(struct is_window_hung_reply
, is_hung
) == 8 );
1410 C_ASSERT( sizeof(struct is_window_hung_reply
) == 16 );
1411 C_ASSERT( FIELD_OFFSET(struct get_serial_info_request
, handle
) == 12 );
1412 C_ASSERT( FIELD_OFFSET(struct get_serial_info_request
, flags
) == 16 );
1413 C_ASSERT( sizeof(struct get_serial_info_request
) == 24 );
1414 C_ASSERT( FIELD_OFFSET(struct get_serial_info_reply
, eventmask
) == 8 );
1415 C_ASSERT( FIELD_OFFSET(struct get_serial_info_reply
, cookie
) == 12 );
1416 C_ASSERT( FIELD_OFFSET(struct get_serial_info_reply
, pending_write
) == 16 );
1417 C_ASSERT( sizeof(struct get_serial_info_reply
) == 24 );
1418 C_ASSERT( FIELD_OFFSET(struct set_serial_info_request
, handle
) == 12 );
1419 C_ASSERT( FIELD_OFFSET(struct set_serial_info_request
, flags
) == 16 );
1420 C_ASSERT( sizeof(struct set_serial_info_request
) == 24 );
1421 C_ASSERT( FIELD_OFFSET(struct cancel_sync_request
, handle
) == 12 );
1422 C_ASSERT( FIELD_OFFSET(struct cancel_sync_request
, iosb
) == 16 );
1423 C_ASSERT( sizeof(struct cancel_sync_request
) == 24 );
1424 C_ASSERT( FIELD_OFFSET(struct register_async_request
, type
) == 12 );
1425 C_ASSERT( FIELD_OFFSET(struct register_async_request
, async
) == 16 );
1426 C_ASSERT( FIELD_OFFSET(struct register_async_request
, count
) == 56 );
1427 C_ASSERT( sizeof(struct register_async_request
) == 64 );
1428 C_ASSERT( FIELD_OFFSET(struct cancel_async_request
, handle
) == 12 );
1429 C_ASSERT( FIELD_OFFSET(struct cancel_async_request
, iosb
) == 16 );
1430 C_ASSERT( FIELD_OFFSET(struct cancel_async_request
, only_thread
) == 24 );
1431 C_ASSERT( sizeof(struct cancel_async_request
) == 32 );
1432 C_ASSERT( FIELD_OFFSET(struct get_async_result_request
, user_arg
) == 16 );
1433 C_ASSERT( sizeof(struct get_async_result_request
) == 24 );
1434 C_ASSERT( sizeof(struct get_async_result_reply
) == 8 );
1435 C_ASSERT( FIELD_OFFSET(struct set_async_direct_result_request
, handle
) == 12 );
1436 C_ASSERT( FIELD_OFFSET(struct set_async_direct_result_request
, information
) == 16 );
1437 C_ASSERT( FIELD_OFFSET(struct set_async_direct_result_request
, status
) == 24 );
1438 C_ASSERT( FIELD_OFFSET(struct set_async_direct_result_request
, mark_pending
) == 28 );
1439 C_ASSERT( sizeof(struct set_async_direct_result_request
) == 32 );
1440 C_ASSERT( FIELD_OFFSET(struct set_async_direct_result_reply
, handle
) == 8 );
1441 C_ASSERT( sizeof(struct set_async_direct_result_reply
) == 16 );
1442 C_ASSERT( FIELD_OFFSET(struct read_request
, async
) == 16 );
1443 C_ASSERT( FIELD_OFFSET(struct read_request
, pos
) == 56 );
1444 C_ASSERT( sizeof(struct read_request
) == 64 );
1445 C_ASSERT( FIELD_OFFSET(struct read_reply
, wait
) == 8 );
1446 C_ASSERT( FIELD_OFFSET(struct read_reply
, options
) == 12 );
1447 C_ASSERT( sizeof(struct read_reply
) == 16 );
1448 C_ASSERT( FIELD_OFFSET(struct write_request
, async
) == 16 );
1449 C_ASSERT( FIELD_OFFSET(struct write_request
, pos
) == 56 );
1450 C_ASSERT( sizeof(struct write_request
) == 64 );
1451 C_ASSERT( FIELD_OFFSET(struct write_reply
, wait
) == 8 );
1452 C_ASSERT( FIELD_OFFSET(struct write_reply
, options
) == 12 );
1453 C_ASSERT( FIELD_OFFSET(struct write_reply
, size
) == 16 );
1454 C_ASSERT( sizeof(struct write_reply
) == 24 );
1455 C_ASSERT( FIELD_OFFSET(struct ioctl_request
, code
) == 12 );
1456 C_ASSERT( FIELD_OFFSET(struct ioctl_request
, async
) == 16 );
1457 C_ASSERT( sizeof(struct ioctl_request
) == 56 );
1458 C_ASSERT( FIELD_OFFSET(struct ioctl_reply
, wait
) == 8 );
1459 C_ASSERT( FIELD_OFFSET(struct ioctl_reply
, options
) == 12 );
1460 C_ASSERT( sizeof(struct ioctl_reply
) == 16 );
1461 C_ASSERT( FIELD_OFFSET(struct set_irp_result_request
, handle
) == 12 );
1462 C_ASSERT( FIELD_OFFSET(struct set_irp_result_request
, status
) == 16 );
1463 C_ASSERT( FIELD_OFFSET(struct set_irp_result_request
, size
) == 20 );
1464 C_ASSERT( sizeof(struct set_irp_result_request
) == 24 );
1465 C_ASSERT( FIELD_OFFSET(struct create_named_pipe_request
, access
) == 12 );
1466 C_ASSERT( FIELD_OFFSET(struct create_named_pipe_request
, options
) == 16 );
1467 C_ASSERT( FIELD_OFFSET(struct create_named_pipe_request
, sharing
) == 20 );
1468 C_ASSERT( FIELD_OFFSET(struct create_named_pipe_request
, disposition
) == 24 );
1469 C_ASSERT( FIELD_OFFSET(struct create_named_pipe_request
, maxinstances
) == 28 );
1470 C_ASSERT( FIELD_OFFSET(struct create_named_pipe_request
, outsize
) == 32 );
1471 C_ASSERT( FIELD_OFFSET(struct create_named_pipe_request
, insize
) == 36 );
1472 C_ASSERT( FIELD_OFFSET(struct create_named_pipe_request
, timeout
) == 40 );
1473 C_ASSERT( FIELD_OFFSET(struct create_named_pipe_request
, flags
) == 48 );
1474 C_ASSERT( sizeof(struct create_named_pipe_request
) == 56 );
1475 C_ASSERT( FIELD_OFFSET(struct create_named_pipe_reply
, handle
) == 8 );
1476 C_ASSERT( FIELD_OFFSET(struct create_named_pipe_reply
, created
) == 12 );
1477 C_ASSERT( sizeof(struct create_named_pipe_reply
) == 16 );
1478 C_ASSERT( FIELD_OFFSET(struct set_named_pipe_info_request
, handle
) == 12 );
1479 C_ASSERT( FIELD_OFFSET(struct set_named_pipe_info_request
, flags
) == 16 );
1480 C_ASSERT( sizeof(struct set_named_pipe_info_request
) == 24 );
1481 C_ASSERT( FIELD_OFFSET(struct create_window_request
, parent
) == 12 );
1482 C_ASSERT( FIELD_OFFSET(struct create_window_request
, owner
) == 16 );
1483 C_ASSERT( FIELD_OFFSET(struct create_window_request
, atom
) == 20 );
1484 C_ASSERT( FIELD_OFFSET(struct create_window_request
, instance
) == 24 );
1485 C_ASSERT( FIELD_OFFSET(struct create_window_request
, dpi
) == 32 );
1486 C_ASSERT( FIELD_OFFSET(struct create_window_request
, awareness
) == 36 );
1487 C_ASSERT( FIELD_OFFSET(struct create_window_request
, style
) == 40 );
1488 C_ASSERT( FIELD_OFFSET(struct create_window_request
, ex_style
) == 44 );
1489 C_ASSERT( sizeof(struct create_window_request
) == 48 );
1490 C_ASSERT( FIELD_OFFSET(struct create_window_reply
, handle
) == 8 );
1491 C_ASSERT( FIELD_OFFSET(struct create_window_reply
, parent
) == 12 );
1492 C_ASSERT( FIELD_OFFSET(struct create_window_reply
, owner
) == 16 );
1493 C_ASSERT( FIELD_OFFSET(struct create_window_reply
, extra
) == 20 );
1494 C_ASSERT( FIELD_OFFSET(struct create_window_reply
, class_ptr
) == 24 );
1495 C_ASSERT( FIELD_OFFSET(struct create_window_reply
, dpi
) == 32 );
1496 C_ASSERT( FIELD_OFFSET(struct create_window_reply
, awareness
) == 36 );
1497 C_ASSERT( sizeof(struct create_window_reply
) == 40 );
1498 C_ASSERT( FIELD_OFFSET(struct destroy_window_request
, handle
) == 12 );
1499 C_ASSERT( sizeof(struct destroy_window_request
) == 16 );
1500 C_ASSERT( FIELD_OFFSET(struct get_desktop_window_request
, force
) == 12 );
1501 C_ASSERT( sizeof(struct get_desktop_window_request
) == 16 );
1502 C_ASSERT( FIELD_OFFSET(struct get_desktop_window_reply
, top_window
) == 8 );
1503 C_ASSERT( FIELD_OFFSET(struct get_desktop_window_reply
, msg_window
) == 12 );
1504 C_ASSERT( sizeof(struct get_desktop_window_reply
) == 16 );
1505 C_ASSERT( FIELD_OFFSET(struct set_window_owner_request
, handle
) == 12 );
1506 C_ASSERT( FIELD_OFFSET(struct set_window_owner_request
, owner
) == 16 );
1507 C_ASSERT( sizeof(struct set_window_owner_request
) == 24 );
1508 C_ASSERT( FIELD_OFFSET(struct set_window_owner_reply
, full_owner
) == 8 );
1509 C_ASSERT( FIELD_OFFSET(struct set_window_owner_reply
, prev_owner
) == 12 );
1510 C_ASSERT( sizeof(struct set_window_owner_reply
) == 16 );
1511 C_ASSERT( FIELD_OFFSET(struct get_window_info_request
, handle
) == 12 );
1512 C_ASSERT( sizeof(struct get_window_info_request
) == 16 );
1513 C_ASSERT( FIELD_OFFSET(struct get_window_info_reply
, full_handle
) == 8 );
1514 C_ASSERT( FIELD_OFFSET(struct get_window_info_reply
, last_active
) == 12 );
1515 C_ASSERT( FIELD_OFFSET(struct get_window_info_reply
, pid
) == 16 );
1516 C_ASSERT( FIELD_OFFSET(struct get_window_info_reply
, tid
) == 20 );
1517 C_ASSERT( FIELD_OFFSET(struct get_window_info_reply
, atom
) == 24 );
1518 C_ASSERT( FIELD_OFFSET(struct get_window_info_reply
, is_unicode
) == 28 );
1519 C_ASSERT( FIELD_OFFSET(struct get_window_info_reply
, dpi
) == 32 );
1520 C_ASSERT( FIELD_OFFSET(struct get_window_info_reply
, awareness
) == 36 );
1521 C_ASSERT( sizeof(struct get_window_info_reply
) == 40 );
1522 C_ASSERT( FIELD_OFFSET(struct set_window_info_request
, flags
) == 12 );
1523 C_ASSERT( FIELD_OFFSET(struct set_window_info_request
, is_unicode
) == 14 );
1524 C_ASSERT( FIELD_OFFSET(struct set_window_info_request
, handle
) == 16 );
1525 C_ASSERT( FIELD_OFFSET(struct set_window_info_request
, style
) == 20 );
1526 C_ASSERT( FIELD_OFFSET(struct set_window_info_request
, ex_style
) == 24 );
1527 C_ASSERT( FIELD_OFFSET(struct set_window_info_request
, extra_size
) == 28 );
1528 C_ASSERT( FIELD_OFFSET(struct set_window_info_request
, instance
) == 32 );
1529 C_ASSERT( FIELD_OFFSET(struct set_window_info_request
, user_data
) == 40 );
1530 C_ASSERT( FIELD_OFFSET(struct set_window_info_request
, extra_value
) == 48 );
1531 C_ASSERT( FIELD_OFFSET(struct set_window_info_request
, extra_offset
) == 56 );
1532 C_ASSERT( sizeof(struct set_window_info_request
) == 64 );
1533 C_ASSERT( FIELD_OFFSET(struct set_window_info_reply
, old_style
) == 8 );
1534 C_ASSERT( FIELD_OFFSET(struct set_window_info_reply
, old_ex_style
) == 12 );
1535 C_ASSERT( FIELD_OFFSET(struct set_window_info_reply
, old_instance
) == 16 );
1536 C_ASSERT( FIELD_OFFSET(struct set_window_info_reply
, old_user_data
) == 24 );
1537 C_ASSERT( FIELD_OFFSET(struct set_window_info_reply
, old_extra_value
) == 32 );
1538 C_ASSERT( FIELD_OFFSET(struct set_window_info_reply
, old_id
) == 40 );
1539 C_ASSERT( sizeof(struct set_window_info_reply
) == 48 );
1540 C_ASSERT( FIELD_OFFSET(struct set_parent_request
, handle
) == 12 );
1541 C_ASSERT( FIELD_OFFSET(struct set_parent_request
, parent
) == 16 );
1542 C_ASSERT( sizeof(struct set_parent_request
) == 24 );
1543 C_ASSERT( FIELD_OFFSET(struct set_parent_reply
, old_parent
) == 8 );
1544 C_ASSERT( FIELD_OFFSET(struct set_parent_reply
, full_parent
) == 12 );
1545 C_ASSERT( FIELD_OFFSET(struct set_parent_reply
, dpi
) == 16 );
1546 C_ASSERT( FIELD_OFFSET(struct set_parent_reply
, awareness
) == 20 );
1547 C_ASSERT( sizeof(struct set_parent_reply
) == 24 );
1548 C_ASSERT( FIELD_OFFSET(struct get_window_parents_request
, handle
) == 12 );
1549 C_ASSERT( sizeof(struct get_window_parents_request
) == 16 );
1550 C_ASSERT( FIELD_OFFSET(struct get_window_parents_reply
, count
) == 8 );
1551 C_ASSERT( sizeof(struct get_window_parents_reply
) == 16 );
1552 C_ASSERT( FIELD_OFFSET(struct get_window_children_request
, desktop
) == 12 );
1553 C_ASSERT( FIELD_OFFSET(struct get_window_children_request
, parent
) == 16 );
1554 C_ASSERT( FIELD_OFFSET(struct get_window_children_request
, atom
) == 20 );
1555 C_ASSERT( FIELD_OFFSET(struct get_window_children_request
, tid
) == 24 );
1556 C_ASSERT( sizeof(struct get_window_children_request
) == 32 );
1557 C_ASSERT( FIELD_OFFSET(struct get_window_children_reply
, count
) == 8 );
1558 C_ASSERT( sizeof(struct get_window_children_reply
) == 16 );
1559 C_ASSERT( FIELD_OFFSET(struct get_window_children_from_point_request
, parent
) == 12 );
1560 C_ASSERT( FIELD_OFFSET(struct get_window_children_from_point_request
, x
) == 16 );
1561 C_ASSERT( FIELD_OFFSET(struct get_window_children_from_point_request
, y
) == 20 );
1562 C_ASSERT( FIELD_OFFSET(struct get_window_children_from_point_request
, dpi
) == 24 );
1563 C_ASSERT( sizeof(struct get_window_children_from_point_request
) == 32 );
1564 C_ASSERT( FIELD_OFFSET(struct get_window_children_from_point_reply
, count
) == 8 );
1565 C_ASSERT( sizeof(struct get_window_children_from_point_reply
) == 16 );
1566 C_ASSERT( FIELD_OFFSET(struct get_window_tree_request
, handle
) == 12 );
1567 C_ASSERT( sizeof(struct get_window_tree_request
) == 16 );
1568 C_ASSERT( FIELD_OFFSET(struct get_window_tree_reply
, parent
) == 8 );
1569 C_ASSERT( FIELD_OFFSET(struct get_window_tree_reply
, owner
) == 12 );
1570 C_ASSERT( FIELD_OFFSET(struct get_window_tree_reply
, next_sibling
) == 16 );
1571 C_ASSERT( FIELD_OFFSET(struct get_window_tree_reply
, prev_sibling
) == 20 );
1572 C_ASSERT( FIELD_OFFSET(struct get_window_tree_reply
, first_sibling
) == 24 );
1573 C_ASSERT( FIELD_OFFSET(struct get_window_tree_reply
, last_sibling
) == 28 );
1574 C_ASSERT( FIELD_OFFSET(struct get_window_tree_reply
, first_child
) == 32 );
1575 C_ASSERT( FIELD_OFFSET(struct get_window_tree_reply
, last_child
) == 36 );
1576 C_ASSERT( sizeof(struct get_window_tree_reply
) == 40 );
1577 C_ASSERT( FIELD_OFFSET(struct set_window_pos_request
, swp_flags
) == 12 );
1578 C_ASSERT( FIELD_OFFSET(struct set_window_pos_request
, paint_flags
) == 14 );
1579 C_ASSERT( FIELD_OFFSET(struct set_window_pos_request
, handle
) == 16 );
1580 C_ASSERT( FIELD_OFFSET(struct set_window_pos_request
, previous
) == 20 );
1581 C_ASSERT( FIELD_OFFSET(struct set_window_pos_request
, window
) == 24 );
1582 C_ASSERT( FIELD_OFFSET(struct set_window_pos_request
, client
) == 40 );
1583 C_ASSERT( sizeof(struct set_window_pos_request
) == 56 );
1584 C_ASSERT( FIELD_OFFSET(struct set_window_pos_reply
, new_style
) == 8 );
1585 C_ASSERT( FIELD_OFFSET(struct set_window_pos_reply
, new_ex_style
) == 12 );
1586 C_ASSERT( FIELD_OFFSET(struct set_window_pos_reply
, surface_win
) == 16 );
1587 C_ASSERT( FIELD_OFFSET(struct set_window_pos_reply
, needs_update
) == 20 );
1588 C_ASSERT( sizeof(struct set_window_pos_reply
) == 24 );
1589 C_ASSERT( FIELD_OFFSET(struct get_window_rectangles_request
, handle
) == 12 );
1590 C_ASSERT( FIELD_OFFSET(struct get_window_rectangles_request
, relative
) == 16 );
1591 C_ASSERT( FIELD_OFFSET(struct get_window_rectangles_request
, dpi
) == 20 );
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
, client
) == 24 );
1595 C_ASSERT( sizeof(struct get_window_rectangles_reply
) == 40 );
1596 C_ASSERT( FIELD_OFFSET(struct get_window_text_request
, handle
) == 12 );
1597 C_ASSERT( sizeof(struct get_window_text_request
) == 16 );
1598 C_ASSERT( FIELD_OFFSET(struct get_window_text_reply
, length
) == 8 );
1599 C_ASSERT( sizeof(struct get_window_text_reply
) == 16 );
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( FIELD_OFFSET(struct get_windows_offset_request
, dpi
) == 20 );
1605 C_ASSERT( sizeof(struct get_windows_offset_request
) == 24 );
1606 C_ASSERT( FIELD_OFFSET(struct get_windows_offset_reply
, x
) == 8 );
1607 C_ASSERT( FIELD_OFFSET(struct get_windows_offset_reply
, y
) == 12 );
1608 C_ASSERT( FIELD_OFFSET(struct get_windows_offset_reply
, mirror
) == 16 );
1609 C_ASSERT( sizeof(struct get_windows_offset_reply
) == 24 );
1610 C_ASSERT( FIELD_OFFSET(struct get_visible_region_request
, window
) == 12 );
1611 C_ASSERT( FIELD_OFFSET(struct get_visible_region_request
, flags
) == 16 );
1612 C_ASSERT( sizeof(struct get_visible_region_request
) == 24 );
1613 C_ASSERT( FIELD_OFFSET(struct get_visible_region_reply
, top_win
) == 8 );
1614 C_ASSERT( FIELD_OFFSET(struct get_visible_region_reply
, top_rect
) == 12 );
1615 C_ASSERT( FIELD_OFFSET(struct get_visible_region_reply
, win_rect
) == 28 );
1616 C_ASSERT( FIELD_OFFSET(struct get_visible_region_reply
, paint_flags
) == 44 );
1617 C_ASSERT( FIELD_OFFSET(struct get_visible_region_reply
, total_size
) == 48 );
1618 C_ASSERT( sizeof(struct get_visible_region_reply
) == 56 );
1619 C_ASSERT( FIELD_OFFSET(struct get_surface_region_request
, window
) == 12 );
1620 C_ASSERT( sizeof(struct get_surface_region_request
) == 16 );
1621 C_ASSERT( FIELD_OFFSET(struct get_surface_region_reply
, visible_rect
) == 8 );
1622 C_ASSERT( FIELD_OFFSET(struct get_surface_region_reply
, total_size
) == 24 );
1623 C_ASSERT( sizeof(struct get_surface_region_reply
) == 32 );
1624 C_ASSERT( FIELD_OFFSET(struct get_window_region_request
, window
) == 12 );
1625 C_ASSERT( sizeof(struct get_window_region_request
) == 16 );
1626 C_ASSERT( FIELD_OFFSET(struct get_window_region_reply
, total_size
) == 8 );
1627 C_ASSERT( sizeof(struct get_window_region_reply
) == 16 );
1628 C_ASSERT( FIELD_OFFSET(struct set_window_region_request
, window
) == 12 );
1629 C_ASSERT( FIELD_OFFSET(struct set_window_region_request
, redraw
) == 16 );
1630 C_ASSERT( sizeof(struct set_window_region_request
) == 24 );
1631 C_ASSERT( FIELD_OFFSET(struct get_update_region_request
, window
) == 12 );
1632 C_ASSERT( FIELD_OFFSET(struct get_update_region_request
, from_child
) == 16 );
1633 C_ASSERT( FIELD_OFFSET(struct get_update_region_request
, flags
) == 20 );
1634 C_ASSERT( sizeof(struct get_update_region_request
) == 24 );
1635 C_ASSERT( FIELD_OFFSET(struct get_update_region_reply
, child
) == 8 );
1636 C_ASSERT( FIELD_OFFSET(struct get_update_region_reply
, flags
) == 12 );
1637 C_ASSERT( FIELD_OFFSET(struct get_update_region_reply
, total_size
) == 16 );
1638 C_ASSERT( sizeof(struct get_update_region_reply
) == 24 );
1639 C_ASSERT( FIELD_OFFSET(struct update_window_zorder_request
, window
) == 12 );
1640 C_ASSERT( FIELD_OFFSET(struct update_window_zorder_request
, rect
) == 16 );
1641 C_ASSERT( sizeof(struct update_window_zorder_request
) == 32 );
1642 C_ASSERT( FIELD_OFFSET(struct redraw_window_request
, window
) == 12 );
1643 C_ASSERT( FIELD_OFFSET(struct redraw_window_request
, flags
) == 16 );
1644 C_ASSERT( sizeof(struct redraw_window_request
) == 24 );
1645 C_ASSERT( FIELD_OFFSET(struct set_window_property_request
, window
) == 12 );
1646 C_ASSERT( FIELD_OFFSET(struct set_window_property_request
, data
) == 16 );
1647 C_ASSERT( FIELD_OFFSET(struct set_window_property_request
, atom
) == 24 );
1648 C_ASSERT( sizeof(struct set_window_property_request
) == 32 );
1649 C_ASSERT( FIELD_OFFSET(struct remove_window_property_request
, window
) == 12 );
1650 C_ASSERT( FIELD_OFFSET(struct remove_window_property_request
, atom
) == 16 );
1651 C_ASSERT( sizeof(struct remove_window_property_request
) == 24 );
1652 C_ASSERT( FIELD_OFFSET(struct remove_window_property_reply
, data
) == 8 );
1653 C_ASSERT( sizeof(struct remove_window_property_reply
) == 16 );
1654 C_ASSERT( FIELD_OFFSET(struct get_window_property_request
, window
) == 12 );
1655 C_ASSERT( FIELD_OFFSET(struct get_window_property_request
, atom
) == 16 );
1656 C_ASSERT( sizeof(struct get_window_property_request
) == 24 );
1657 C_ASSERT( FIELD_OFFSET(struct get_window_property_reply
, data
) == 8 );
1658 C_ASSERT( sizeof(struct get_window_property_reply
) == 16 );
1659 C_ASSERT( FIELD_OFFSET(struct get_window_properties_request
, window
) == 12 );
1660 C_ASSERT( sizeof(struct get_window_properties_request
) == 16 );
1661 C_ASSERT( FIELD_OFFSET(struct get_window_properties_reply
, total
) == 8 );
1662 C_ASSERT( sizeof(struct get_window_properties_reply
) == 16 );
1663 C_ASSERT( FIELD_OFFSET(struct create_winstation_request
, flags
) == 12 );
1664 C_ASSERT( FIELD_OFFSET(struct create_winstation_request
, access
) == 16 );
1665 C_ASSERT( FIELD_OFFSET(struct create_winstation_request
, attributes
) == 20 );
1666 C_ASSERT( FIELD_OFFSET(struct create_winstation_request
, rootdir
) == 24 );
1667 C_ASSERT( sizeof(struct create_winstation_request
) == 32 );
1668 C_ASSERT( FIELD_OFFSET(struct create_winstation_reply
, handle
) == 8 );
1669 C_ASSERT( sizeof(struct create_winstation_reply
) == 16 );
1670 C_ASSERT( FIELD_OFFSET(struct open_winstation_request
, access
) == 12 );
1671 C_ASSERT( FIELD_OFFSET(struct open_winstation_request
, attributes
) == 16 );
1672 C_ASSERT( FIELD_OFFSET(struct open_winstation_request
, rootdir
) == 20 );
1673 C_ASSERT( sizeof(struct open_winstation_request
) == 24 );
1674 C_ASSERT( FIELD_OFFSET(struct open_winstation_reply
, handle
) == 8 );
1675 C_ASSERT( sizeof(struct open_winstation_reply
) == 16 );
1676 C_ASSERT( FIELD_OFFSET(struct close_winstation_request
, handle
) == 12 );
1677 C_ASSERT( sizeof(struct close_winstation_request
) == 16 );
1678 C_ASSERT( sizeof(struct get_process_winstation_request
) == 16 );
1679 C_ASSERT( FIELD_OFFSET(struct get_process_winstation_reply
, handle
) == 8 );
1680 C_ASSERT( sizeof(struct get_process_winstation_reply
) == 16 );
1681 C_ASSERT( FIELD_OFFSET(struct set_process_winstation_request
, handle
) == 12 );
1682 C_ASSERT( sizeof(struct set_process_winstation_request
) == 16 );
1683 C_ASSERT( FIELD_OFFSET(struct enum_winstation_request
, index
) == 12 );
1684 C_ASSERT( sizeof(struct enum_winstation_request
) == 16 );
1685 C_ASSERT( FIELD_OFFSET(struct enum_winstation_reply
, next
) == 8 );
1686 C_ASSERT( sizeof(struct enum_winstation_reply
) == 16 );
1687 C_ASSERT( FIELD_OFFSET(struct create_desktop_request
, flags
) == 12 );
1688 C_ASSERT( FIELD_OFFSET(struct create_desktop_request
, access
) == 16 );
1689 C_ASSERT( FIELD_OFFSET(struct create_desktop_request
, attributes
) == 20 );
1690 C_ASSERT( sizeof(struct create_desktop_request
) == 24 );
1691 C_ASSERT( FIELD_OFFSET(struct create_desktop_reply
, handle
) == 8 );
1692 C_ASSERT( sizeof(struct create_desktop_reply
) == 16 );
1693 C_ASSERT( FIELD_OFFSET(struct open_desktop_request
, winsta
) == 12 );
1694 C_ASSERT( FIELD_OFFSET(struct open_desktop_request
, flags
) == 16 );
1695 C_ASSERT( FIELD_OFFSET(struct open_desktop_request
, access
) == 20 );
1696 C_ASSERT( FIELD_OFFSET(struct open_desktop_request
, attributes
) == 24 );
1697 C_ASSERT( sizeof(struct open_desktop_request
) == 32 );
1698 C_ASSERT( FIELD_OFFSET(struct open_desktop_reply
, handle
) == 8 );
1699 C_ASSERT( sizeof(struct open_desktop_reply
) == 16 );
1700 C_ASSERT( FIELD_OFFSET(struct open_input_desktop_request
, flags
) == 12 );
1701 C_ASSERT( FIELD_OFFSET(struct open_input_desktop_request
, access
) == 16 );
1702 C_ASSERT( FIELD_OFFSET(struct open_input_desktop_request
, attributes
) == 20 );
1703 C_ASSERT( sizeof(struct open_input_desktop_request
) == 24 );
1704 C_ASSERT( FIELD_OFFSET(struct open_input_desktop_reply
, handle
) == 8 );
1705 C_ASSERT( sizeof(struct open_input_desktop_reply
) == 16 );
1706 C_ASSERT( FIELD_OFFSET(struct close_desktop_request
, handle
) == 12 );
1707 C_ASSERT( sizeof(struct close_desktop_request
) == 16 );
1708 C_ASSERT( FIELD_OFFSET(struct get_thread_desktop_request
, tid
) == 12 );
1709 C_ASSERT( sizeof(struct get_thread_desktop_request
) == 16 );
1710 C_ASSERT( FIELD_OFFSET(struct get_thread_desktop_reply
, handle
) == 8 );
1711 C_ASSERT( sizeof(struct get_thread_desktop_reply
) == 16 );
1712 C_ASSERT( FIELD_OFFSET(struct set_thread_desktop_request
, handle
) == 12 );
1713 C_ASSERT( sizeof(struct set_thread_desktop_request
) == 16 );
1714 C_ASSERT( FIELD_OFFSET(struct enum_desktop_request
, winstation
) == 12 );
1715 C_ASSERT( FIELD_OFFSET(struct enum_desktop_request
, index
) == 16 );
1716 C_ASSERT( sizeof(struct enum_desktop_request
) == 24 );
1717 C_ASSERT( FIELD_OFFSET(struct enum_desktop_reply
, next
) == 8 );
1718 C_ASSERT( sizeof(struct enum_desktop_reply
) == 16 );
1719 C_ASSERT( FIELD_OFFSET(struct set_user_object_info_request
, handle
) == 12 );
1720 C_ASSERT( FIELD_OFFSET(struct set_user_object_info_request
, flags
) == 16 );
1721 C_ASSERT( FIELD_OFFSET(struct set_user_object_info_request
, obj_flags
) == 20 );
1722 C_ASSERT( sizeof(struct set_user_object_info_request
) == 24 );
1723 C_ASSERT( FIELD_OFFSET(struct set_user_object_info_reply
, is_desktop
) == 8 );
1724 C_ASSERT( FIELD_OFFSET(struct set_user_object_info_reply
, old_obj_flags
) == 12 );
1725 C_ASSERT( sizeof(struct set_user_object_info_reply
) == 16 );
1726 C_ASSERT( FIELD_OFFSET(struct register_hotkey_request
, window
) == 12 );
1727 C_ASSERT( FIELD_OFFSET(struct register_hotkey_request
, id
) == 16 );
1728 C_ASSERT( FIELD_OFFSET(struct register_hotkey_request
, flags
) == 20 );
1729 C_ASSERT( FIELD_OFFSET(struct register_hotkey_request
, vkey
) == 24 );
1730 C_ASSERT( sizeof(struct register_hotkey_request
) == 32 );
1731 C_ASSERT( FIELD_OFFSET(struct register_hotkey_reply
, replaced
) == 8 );
1732 C_ASSERT( FIELD_OFFSET(struct register_hotkey_reply
, flags
) == 12 );
1733 C_ASSERT( FIELD_OFFSET(struct register_hotkey_reply
, vkey
) == 16 );
1734 C_ASSERT( sizeof(struct register_hotkey_reply
) == 24 );
1735 C_ASSERT( FIELD_OFFSET(struct unregister_hotkey_request
, window
) == 12 );
1736 C_ASSERT( FIELD_OFFSET(struct unregister_hotkey_request
, id
) == 16 );
1737 C_ASSERT( sizeof(struct unregister_hotkey_request
) == 24 );
1738 C_ASSERT( FIELD_OFFSET(struct unregister_hotkey_reply
, flags
) == 8 );
1739 C_ASSERT( FIELD_OFFSET(struct unregister_hotkey_reply
, vkey
) == 12 );
1740 C_ASSERT( sizeof(struct unregister_hotkey_reply
) == 16 );
1741 C_ASSERT( FIELD_OFFSET(struct attach_thread_input_request
, tid_from
) == 12 );
1742 C_ASSERT( FIELD_OFFSET(struct attach_thread_input_request
, tid_to
) == 16 );
1743 C_ASSERT( FIELD_OFFSET(struct attach_thread_input_request
, attach
) == 20 );
1744 C_ASSERT( sizeof(struct attach_thread_input_request
) == 24 );
1745 C_ASSERT( FIELD_OFFSET(struct get_thread_input_request
, tid
) == 12 );
1746 C_ASSERT( sizeof(struct get_thread_input_request
) == 16 );
1747 C_ASSERT( FIELD_OFFSET(struct get_thread_input_reply
, focus
) == 8 );
1748 C_ASSERT( FIELD_OFFSET(struct get_thread_input_reply
, capture
) == 12 );
1749 C_ASSERT( FIELD_OFFSET(struct get_thread_input_reply
, active
) == 16 );
1750 C_ASSERT( FIELD_OFFSET(struct get_thread_input_reply
, foreground
) == 20 );
1751 C_ASSERT( FIELD_OFFSET(struct get_thread_input_reply
, menu_owner
) == 24 );
1752 C_ASSERT( FIELD_OFFSET(struct get_thread_input_reply
, move_size
) == 28 );
1753 C_ASSERT( FIELD_OFFSET(struct get_thread_input_reply
, caret
) == 32 );
1754 C_ASSERT( FIELD_OFFSET(struct get_thread_input_reply
, cursor
) == 36 );
1755 C_ASSERT( FIELD_OFFSET(struct get_thread_input_reply
, show_count
) == 40 );
1756 C_ASSERT( FIELD_OFFSET(struct get_thread_input_reply
, rect
) == 44 );
1757 C_ASSERT( sizeof(struct get_thread_input_reply
) == 64 );
1758 C_ASSERT( sizeof(struct get_last_input_time_request
) == 16 );
1759 C_ASSERT( FIELD_OFFSET(struct get_last_input_time_reply
, time
) == 8 );
1760 C_ASSERT( sizeof(struct get_last_input_time_reply
) == 16 );
1761 C_ASSERT( FIELD_OFFSET(struct get_key_state_request
, async
) == 12 );
1762 C_ASSERT( FIELD_OFFSET(struct get_key_state_request
, key
) == 16 );
1763 C_ASSERT( sizeof(struct get_key_state_request
) == 24 );
1764 C_ASSERT( FIELD_OFFSET(struct get_key_state_reply
, state
) == 8 );
1765 C_ASSERT( sizeof(struct get_key_state_reply
) == 16 );
1766 C_ASSERT( FIELD_OFFSET(struct set_key_state_request
, async
) == 12 );
1767 C_ASSERT( sizeof(struct set_key_state_request
) == 16 );
1768 C_ASSERT( FIELD_OFFSET(struct set_foreground_window_request
, handle
) == 12 );
1769 C_ASSERT( sizeof(struct set_foreground_window_request
) == 16 );
1770 C_ASSERT( FIELD_OFFSET(struct set_foreground_window_reply
, previous
) == 8 );
1771 C_ASSERT( FIELD_OFFSET(struct set_foreground_window_reply
, send_msg_old
) == 12 );
1772 C_ASSERT( FIELD_OFFSET(struct set_foreground_window_reply
, send_msg_new
) == 16 );
1773 C_ASSERT( sizeof(struct set_foreground_window_reply
) == 24 );
1774 C_ASSERT( FIELD_OFFSET(struct set_focus_window_request
, handle
) == 12 );
1775 C_ASSERT( sizeof(struct set_focus_window_request
) == 16 );
1776 C_ASSERT( FIELD_OFFSET(struct set_focus_window_reply
, previous
) == 8 );
1777 C_ASSERT( sizeof(struct set_focus_window_reply
) == 16 );
1778 C_ASSERT( FIELD_OFFSET(struct set_active_window_request
, handle
) == 12 );
1779 C_ASSERT( sizeof(struct set_active_window_request
) == 16 );
1780 C_ASSERT( FIELD_OFFSET(struct set_active_window_reply
, previous
) == 8 );
1781 C_ASSERT( sizeof(struct set_active_window_reply
) == 16 );
1782 C_ASSERT( FIELD_OFFSET(struct set_capture_window_request
, handle
) == 12 );
1783 C_ASSERT( FIELD_OFFSET(struct set_capture_window_request
, flags
) == 16 );
1784 C_ASSERT( sizeof(struct set_capture_window_request
) == 24 );
1785 C_ASSERT( FIELD_OFFSET(struct set_capture_window_reply
, previous
) == 8 );
1786 C_ASSERT( FIELD_OFFSET(struct set_capture_window_reply
, full_handle
) == 12 );
1787 C_ASSERT( sizeof(struct set_capture_window_reply
) == 16 );
1788 C_ASSERT( FIELD_OFFSET(struct set_caret_window_request
, handle
) == 12 );
1789 C_ASSERT( FIELD_OFFSET(struct set_caret_window_request
, width
) == 16 );
1790 C_ASSERT( FIELD_OFFSET(struct set_caret_window_request
, height
) == 20 );
1791 C_ASSERT( sizeof(struct set_caret_window_request
) == 24 );
1792 C_ASSERT( FIELD_OFFSET(struct set_caret_window_reply
, previous
) == 8 );
1793 C_ASSERT( FIELD_OFFSET(struct set_caret_window_reply
, old_rect
) == 12 );
1794 C_ASSERT( FIELD_OFFSET(struct set_caret_window_reply
, old_hide
) == 28 );
1795 C_ASSERT( FIELD_OFFSET(struct set_caret_window_reply
, old_state
) == 32 );
1796 C_ASSERT( sizeof(struct set_caret_window_reply
) == 40 );
1797 C_ASSERT( FIELD_OFFSET(struct set_caret_info_request
, flags
) == 12 );
1798 C_ASSERT( FIELD_OFFSET(struct set_caret_info_request
, handle
) == 16 );
1799 C_ASSERT( FIELD_OFFSET(struct set_caret_info_request
, x
) == 20 );
1800 C_ASSERT( FIELD_OFFSET(struct set_caret_info_request
, y
) == 24 );
1801 C_ASSERT( FIELD_OFFSET(struct set_caret_info_request
, hide
) == 28 );
1802 C_ASSERT( FIELD_OFFSET(struct set_caret_info_request
, state
) == 32 );
1803 C_ASSERT( sizeof(struct set_caret_info_request
) == 40 );
1804 C_ASSERT( FIELD_OFFSET(struct set_caret_info_reply
, full_handle
) == 8 );
1805 C_ASSERT( FIELD_OFFSET(struct set_caret_info_reply
, old_rect
) == 12 );
1806 C_ASSERT( FIELD_OFFSET(struct set_caret_info_reply
, old_hide
) == 28 );
1807 C_ASSERT( FIELD_OFFSET(struct set_caret_info_reply
, old_state
) == 32 );
1808 C_ASSERT( sizeof(struct set_caret_info_reply
) == 40 );
1809 C_ASSERT( FIELD_OFFSET(struct set_hook_request
, id
) == 12 );
1810 C_ASSERT( FIELD_OFFSET(struct set_hook_request
, pid
) == 16 );
1811 C_ASSERT( FIELD_OFFSET(struct set_hook_request
, tid
) == 20 );
1812 C_ASSERT( FIELD_OFFSET(struct set_hook_request
, event_min
) == 24 );
1813 C_ASSERT( FIELD_OFFSET(struct set_hook_request
, event_max
) == 28 );
1814 C_ASSERT( FIELD_OFFSET(struct set_hook_request
, proc
) == 32 );
1815 C_ASSERT( FIELD_OFFSET(struct set_hook_request
, flags
) == 40 );
1816 C_ASSERT( FIELD_OFFSET(struct set_hook_request
, unicode
) == 44 );
1817 C_ASSERT( sizeof(struct set_hook_request
) == 48 );
1818 C_ASSERT( FIELD_OFFSET(struct set_hook_reply
, handle
) == 8 );
1819 C_ASSERT( FIELD_OFFSET(struct set_hook_reply
, active_hooks
) == 12 );
1820 C_ASSERT( sizeof(struct set_hook_reply
) == 16 );
1821 C_ASSERT( FIELD_OFFSET(struct remove_hook_request
, handle
) == 12 );
1822 C_ASSERT( FIELD_OFFSET(struct remove_hook_request
, proc
) == 16 );
1823 C_ASSERT( FIELD_OFFSET(struct remove_hook_request
, id
) == 24 );
1824 C_ASSERT( sizeof(struct remove_hook_request
) == 32 );
1825 C_ASSERT( FIELD_OFFSET(struct remove_hook_reply
, active_hooks
) == 8 );
1826 C_ASSERT( sizeof(struct remove_hook_reply
) == 16 );
1827 C_ASSERT( FIELD_OFFSET(struct start_hook_chain_request
, id
) == 12 );
1828 C_ASSERT( FIELD_OFFSET(struct start_hook_chain_request
, event
) == 16 );
1829 C_ASSERT( FIELD_OFFSET(struct start_hook_chain_request
, window
) == 20 );
1830 C_ASSERT( FIELD_OFFSET(struct start_hook_chain_request
, object_id
) == 24 );
1831 C_ASSERT( FIELD_OFFSET(struct start_hook_chain_request
, child_id
) == 28 );
1832 C_ASSERT( sizeof(struct start_hook_chain_request
) == 32 );
1833 C_ASSERT( FIELD_OFFSET(struct start_hook_chain_reply
, handle
) == 8 );
1834 C_ASSERT( FIELD_OFFSET(struct start_hook_chain_reply
, pid
) == 12 );
1835 C_ASSERT( FIELD_OFFSET(struct start_hook_chain_reply
, tid
) == 16 );
1836 C_ASSERT( FIELD_OFFSET(struct start_hook_chain_reply
, unicode
) == 20 );
1837 C_ASSERT( FIELD_OFFSET(struct start_hook_chain_reply
, proc
) == 24 );
1838 C_ASSERT( FIELD_OFFSET(struct start_hook_chain_reply
, active_hooks
) == 32 );
1839 C_ASSERT( sizeof(struct start_hook_chain_reply
) == 40 );
1840 C_ASSERT( FIELD_OFFSET(struct finish_hook_chain_request
, id
) == 12 );
1841 C_ASSERT( sizeof(struct finish_hook_chain_request
) == 16 );
1842 C_ASSERT( FIELD_OFFSET(struct get_hook_info_request
, handle
) == 12 );
1843 C_ASSERT( FIELD_OFFSET(struct get_hook_info_request
, get_next
) == 16 );
1844 C_ASSERT( FIELD_OFFSET(struct get_hook_info_request
, event
) == 20 );
1845 C_ASSERT( FIELD_OFFSET(struct get_hook_info_request
, window
) == 24 );
1846 C_ASSERT( FIELD_OFFSET(struct get_hook_info_request
, object_id
) == 28 );
1847 C_ASSERT( FIELD_OFFSET(struct get_hook_info_request
, child_id
) == 32 );
1848 C_ASSERT( sizeof(struct get_hook_info_request
) == 40 );
1849 C_ASSERT( FIELD_OFFSET(struct get_hook_info_reply
, handle
) == 8 );
1850 C_ASSERT( FIELD_OFFSET(struct get_hook_info_reply
, id
) == 12 );
1851 C_ASSERT( FIELD_OFFSET(struct get_hook_info_reply
, pid
) == 16 );
1852 C_ASSERT( FIELD_OFFSET(struct get_hook_info_reply
, tid
) == 20 );
1853 C_ASSERT( FIELD_OFFSET(struct get_hook_info_reply
, proc
) == 24 );
1854 C_ASSERT( FIELD_OFFSET(struct get_hook_info_reply
, unicode
) == 32 );
1855 C_ASSERT( sizeof(struct get_hook_info_reply
) == 40 );
1856 C_ASSERT( FIELD_OFFSET(struct create_class_request
, local
) == 12 );
1857 C_ASSERT( FIELD_OFFSET(struct create_class_request
, atom
) == 16 );
1858 C_ASSERT( FIELD_OFFSET(struct create_class_request
, style
) == 20 );
1859 C_ASSERT( FIELD_OFFSET(struct create_class_request
, instance
) == 24 );
1860 C_ASSERT( FIELD_OFFSET(struct create_class_request
, extra
) == 32 );
1861 C_ASSERT( FIELD_OFFSET(struct create_class_request
, win_extra
) == 36 );
1862 C_ASSERT( FIELD_OFFSET(struct create_class_request
, client_ptr
) == 40 );
1863 C_ASSERT( FIELD_OFFSET(struct create_class_request
, name_offset
) == 48 );
1864 C_ASSERT( sizeof(struct create_class_request
) == 56 );
1865 C_ASSERT( FIELD_OFFSET(struct create_class_reply
, atom
) == 8 );
1866 C_ASSERT( sizeof(struct create_class_reply
) == 16 );
1867 C_ASSERT( FIELD_OFFSET(struct destroy_class_request
, atom
) == 12 );
1868 C_ASSERT( FIELD_OFFSET(struct destroy_class_request
, instance
) == 16 );
1869 C_ASSERT( sizeof(struct destroy_class_request
) == 24 );
1870 C_ASSERT( FIELD_OFFSET(struct destroy_class_reply
, client_ptr
) == 8 );
1871 C_ASSERT( sizeof(struct destroy_class_reply
) == 16 );
1872 C_ASSERT( FIELD_OFFSET(struct set_class_info_request
, window
) == 12 );
1873 C_ASSERT( FIELD_OFFSET(struct set_class_info_request
, flags
) == 16 );
1874 C_ASSERT( FIELD_OFFSET(struct set_class_info_request
, atom
) == 20 );
1875 C_ASSERT( FIELD_OFFSET(struct set_class_info_request
, style
) == 24 );
1876 C_ASSERT( FIELD_OFFSET(struct set_class_info_request
, win_extra
) == 28 );
1877 C_ASSERT( FIELD_OFFSET(struct set_class_info_request
, instance
) == 32 );
1878 C_ASSERT( FIELD_OFFSET(struct set_class_info_request
, extra_offset
) == 40 );
1879 C_ASSERT( FIELD_OFFSET(struct set_class_info_request
, extra_size
) == 44 );
1880 C_ASSERT( FIELD_OFFSET(struct set_class_info_request
, extra_value
) == 48 );
1881 C_ASSERT( sizeof(struct set_class_info_request
) == 56 );
1882 C_ASSERT( FIELD_OFFSET(struct set_class_info_reply
, old_atom
) == 8 );
1883 C_ASSERT( FIELD_OFFSET(struct set_class_info_reply
, base_atom
) == 12 );
1884 C_ASSERT( FIELD_OFFSET(struct set_class_info_reply
, old_instance
) == 16 );
1885 C_ASSERT( FIELD_OFFSET(struct set_class_info_reply
, old_extra_value
) == 24 );
1886 C_ASSERT( FIELD_OFFSET(struct set_class_info_reply
, old_style
) == 32 );
1887 C_ASSERT( FIELD_OFFSET(struct set_class_info_reply
, old_extra
) == 36 );
1888 C_ASSERT( FIELD_OFFSET(struct set_class_info_reply
, old_win_extra
) == 40 );
1889 C_ASSERT( sizeof(struct set_class_info_reply
) == 48 );
1890 C_ASSERT( FIELD_OFFSET(struct open_clipboard_request
, window
) == 12 );
1891 C_ASSERT( sizeof(struct open_clipboard_request
) == 16 );
1892 C_ASSERT( FIELD_OFFSET(struct open_clipboard_reply
, owner
) == 8 );
1893 C_ASSERT( sizeof(struct open_clipboard_reply
) == 16 );
1894 C_ASSERT( sizeof(struct close_clipboard_request
) == 16 );
1895 C_ASSERT( FIELD_OFFSET(struct close_clipboard_reply
, viewer
) == 8 );
1896 C_ASSERT( FIELD_OFFSET(struct close_clipboard_reply
, owner
) == 12 );
1897 C_ASSERT( sizeof(struct close_clipboard_reply
) == 16 );
1898 C_ASSERT( sizeof(struct empty_clipboard_request
) == 16 );
1899 C_ASSERT( FIELD_OFFSET(struct set_clipboard_data_request
, format
) == 12 );
1900 C_ASSERT( FIELD_OFFSET(struct set_clipboard_data_request
, lcid
) == 16 );
1901 C_ASSERT( sizeof(struct set_clipboard_data_request
) == 24 );
1902 C_ASSERT( FIELD_OFFSET(struct set_clipboard_data_reply
, seqno
) == 8 );
1903 C_ASSERT( sizeof(struct set_clipboard_data_reply
) == 16 );
1904 C_ASSERT( FIELD_OFFSET(struct get_clipboard_data_request
, format
) == 12 );
1905 C_ASSERT( FIELD_OFFSET(struct get_clipboard_data_request
, render
) == 16 );
1906 C_ASSERT( FIELD_OFFSET(struct get_clipboard_data_request
, cached
) == 20 );
1907 C_ASSERT( FIELD_OFFSET(struct get_clipboard_data_request
, seqno
) == 24 );
1908 C_ASSERT( sizeof(struct get_clipboard_data_request
) == 32 );
1909 C_ASSERT( FIELD_OFFSET(struct get_clipboard_data_reply
, from
) == 8 );
1910 C_ASSERT( FIELD_OFFSET(struct get_clipboard_data_reply
, owner
) == 12 );
1911 C_ASSERT( FIELD_OFFSET(struct get_clipboard_data_reply
, seqno
) == 16 );
1912 C_ASSERT( FIELD_OFFSET(struct get_clipboard_data_reply
, total
) == 20 );
1913 C_ASSERT( sizeof(struct get_clipboard_data_reply
) == 24 );
1914 C_ASSERT( FIELD_OFFSET(struct get_clipboard_formats_request
, format
) == 12 );
1915 C_ASSERT( sizeof(struct get_clipboard_formats_request
) == 16 );
1916 C_ASSERT( FIELD_OFFSET(struct get_clipboard_formats_reply
, count
) == 8 );
1917 C_ASSERT( sizeof(struct get_clipboard_formats_reply
) == 16 );
1918 C_ASSERT( FIELD_OFFSET(struct enum_clipboard_formats_request
, previous
) == 12 );
1919 C_ASSERT( sizeof(struct enum_clipboard_formats_request
) == 16 );
1920 C_ASSERT( FIELD_OFFSET(struct enum_clipboard_formats_reply
, format
) == 8 );
1921 C_ASSERT( sizeof(struct enum_clipboard_formats_reply
) == 16 );
1922 C_ASSERT( FIELD_OFFSET(struct release_clipboard_request
, owner
) == 12 );
1923 C_ASSERT( sizeof(struct release_clipboard_request
) == 16 );
1924 C_ASSERT( FIELD_OFFSET(struct release_clipboard_reply
, viewer
) == 8 );
1925 C_ASSERT( FIELD_OFFSET(struct release_clipboard_reply
, owner
) == 12 );
1926 C_ASSERT( sizeof(struct release_clipboard_reply
) == 16 );
1927 C_ASSERT( sizeof(struct get_clipboard_info_request
) == 16 );
1928 C_ASSERT( FIELD_OFFSET(struct get_clipboard_info_reply
, window
) == 8 );
1929 C_ASSERT( FIELD_OFFSET(struct get_clipboard_info_reply
, owner
) == 12 );
1930 C_ASSERT( FIELD_OFFSET(struct get_clipboard_info_reply
, viewer
) == 16 );
1931 C_ASSERT( FIELD_OFFSET(struct get_clipboard_info_reply
, seqno
) == 20 );
1932 C_ASSERT( sizeof(struct get_clipboard_info_reply
) == 24 );
1933 C_ASSERT( FIELD_OFFSET(struct set_clipboard_viewer_request
, viewer
) == 12 );
1934 C_ASSERT( FIELD_OFFSET(struct set_clipboard_viewer_request
, previous
) == 16 );
1935 C_ASSERT( sizeof(struct set_clipboard_viewer_request
) == 24 );
1936 C_ASSERT( FIELD_OFFSET(struct set_clipboard_viewer_reply
, old_viewer
) == 8 );
1937 C_ASSERT( FIELD_OFFSET(struct set_clipboard_viewer_reply
, owner
) == 12 );
1938 C_ASSERT( sizeof(struct set_clipboard_viewer_reply
) == 16 );
1939 C_ASSERT( FIELD_OFFSET(struct add_clipboard_listener_request
, window
) == 12 );
1940 C_ASSERT( sizeof(struct add_clipboard_listener_request
) == 16 );
1941 C_ASSERT( FIELD_OFFSET(struct remove_clipboard_listener_request
, window
) == 12 );
1942 C_ASSERT( sizeof(struct remove_clipboard_listener_request
) == 16 );
1943 C_ASSERT( FIELD_OFFSET(struct open_token_request
, handle
) == 12 );
1944 C_ASSERT( FIELD_OFFSET(struct open_token_request
, access
) == 16 );
1945 C_ASSERT( FIELD_OFFSET(struct open_token_request
, attributes
) == 20 );
1946 C_ASSERT( FIELD_OFFSET(struct open_token_request
, flags
) == 24 );
1947 C_ASSERT( sizeof(struct open_token_request
) == 32 );
1948 C_ASSERT( FIELD_OFFSET(struct open_token_reply
, token
) == 8 );
1949 C_ASSERT( sizeof(struct open_token_reply
) == 16 );
1950 C_ASSERT( FIELD_OFFSET(struct set_global_windows_request
, flags
) == 12 );
1951 C_ASSERT( FIELD_OFFSET(struct set_global_windows_request
, shell_window
) == 16 );
1952 C_ASSERT( FIELD_OFFSET(struct set_global_windows_request
, shell_listview
) == 20 );
1953 C_ASSERT( FIELD_OFFSET(struct set_global_windows_request
, progman_window
) == 24 );
1954 C_ASSERT( FIELD_OFFSET(struct set_global_windows_request
, taskman_window
) == 28 );
1955 C_ASSERT( sizeof(struct set_global_windows_request
) == 32 );
1956 C_ASSERT( FIELD_OFFSET(struct set_global_windows_reply
, old_shell_window
) == 8 );
1957 C_ASSERT( FIELD_OFFSET(struct set_global_windows_reply
, old_shell_listview
) == 12 );
1958 C_ASSERT( FIELD_OFFSET(struct set_global_windows_reply
, old_progman_window
) == 16 );
1959 C_ASSERT( FIELD_OFFSET(struct set_global_windows_reply
, old_taskman_window
) == 20 );
1960 C_ASSERT( sizeof(struct set_global_windows_reply
) == 24 );
1961 C_ASSERT( FIELD_OFFSET(struct adjust_token_privileges_request
, handle
) == 12 );
1962 C_ASSERT( FIELD_OFFSET(struct adjust_token_privileges_request
, disable_all
) == 16 );
1963 C_ASSERT( FIELD_OFFSET(struct adjust_token_privileges_request
, get_modified_state
) == 20 );
1964 C_ASSERT( sizeof(struct adjust_token_privileges_request
) == 24 );
1965 C_ASSERT( FIELD_OFFSET(struct adjust_token_privileges_reply
, len
) == 8 );
1966 C_ASSERT( sizeof(struct adjust_token_privileges_reply
) == 16 );
1967 C_ASSERT( FIELD_OFFSET(struct get_token_privileges_request
, handle
) == 12 );
1968 C_ASSERT( sizeof(struct get_token_privileges_request
) == 16 );
1969 C_ASSERT( FIELD_OFFSET(struct get_token_privileges_reply
, len
) == 8 );
1970 C_ASSERT( sizeof(struct get_token_privileges_reply
) == 16 );
1971 C_ASSERT( FIELD_OFFSET(struct check_token_privileges_request
, handle
) == 12 );
1972 C_ASSERT( FIELD_OFFSET(struct check_token_privileges_request
, all_required
) == 16 );
1973 C_ASSERT( sizeof(struct check_token_privileges_request
) == 24 );
1974 C_ASSERT( FIELD_OFFSET(struct check_token_privileges_reply
, has_privileges
) == 8 );
1975 C_ASSERT( sizeof(struct check_token_privileges_reply
) == 16 );
1976 C_ASSERT( FIELD_OFFSET(struct duplicate_token_request
, handle
) == 12 );
1977 C_ASSERT( FIELD_OFFSET(struct duplicate_token_request
, access
) == 16 );
1978 C_ASSERT( FIELD_OFFSET(struct duplicate_token_request
, primary
) == 20 );
1979 C_ASSERT( FIELD_OFFSET(struct duplicate_token_request
, impersonation_level
) == 24 );
1980 C_ASSERT( sizeof(struct duplicate_token_request
) == 32 );
1981 C_ASSERT( FIELD_OFFSET(struct duplicate_token_reply
, new_handle
) == 8 );
1982 C_ASSERT( sizeof(struct duplicate_token_reply
) == 16 );
1983 C_ASSERT( FIELD_OFFSET(struct filter_token_request
, handle
) == 12 );
1984 C_ASSERT( FIELD_OFFSET(struct filter_token_request
, flags
) == 16 );
1985 C_ASSERT( FIELD_OFFSET(struct filter_token_request
, privileges_size
) == 20 );
1986 C_ASSERT( sizeof(struct filter_token_request
) == 24 );
1987 C_ASSERT( FIELD_OFFSET(struct filter_token_reply
, new_handle
) == 8 );
1988 C_ASSERT( sizeof(struct filter_token_reply
) == 16 );
1989 C_ASSERT( FIELD_OFFSET(struct access_check_request
, handle
) == 12 );
1990 C_ASSERT( FIELD_OFFSET(struct access_check_request
, desired_access
) == 16 );
1991 C_ASSERT( FIELD_OFFSET(struct access_check_request
, mapping
) == 20 );
1992 C_ASSERT( sizeof(struct access_check_request
) == 40 );
1993 C_ASSERT( FIELD_OFFSET(struct access_check_reply
, access_granted
) == 8 );
1994 C_ASSERT( FIELD_OFFSET(struct access_check_reply
, access_status
) == 12 );
1995 C_ASSERT( FIELD_OFFSET(struct access_check_reply
, privileges_len
) == 16 );
1996 C_ASSERT( sizeof(struct access_check_reply
) == 24 );
1997 C_ASSERT( FIELD_OFFSET(struct get_token_sid_request
, handle
) == 12 );
1998 C_ASSERT( FIELD_OFFSET(struct get_token_sid_request
, which_sid
) == 16 );
1999 C_ASSERT( sizeof(struct get_token_sid_request
) == 24 );
2000 C_ASSERT( FIELD_OFFSET(struct get_token_sid_reply
, sid_len
) == 8 );
2001 C_ASSERT( sizeof(struct get_token_sid_reply
) == 16 );
2002 C_ASSERT( FIELD_OFFSET(struct get_token_groups_request
, handle
) == 12 );
2003 C_ASSERT( FIELD_OFFSET(struct get_token_groups_request
, attr_mask
) == 16 );
2004 C_ASSERT( sizeof(struct get_token_groups_request
) == 24 );
2005 C_ASSERT( FIELD_OFFSET(struct get_token_groups_reply
, attr_len
) == 8 );
2006 C_ASSERT( FIELD_OFFSET(struct get_token_groups_reply
, sid_len
) == 12 );
2007 C_ASSERT( sizeof(struct get_token_groups_reply
) == 16 );
2008 C_ASSERT( FIELD_OFFSET(struct get_token_default_dacl_request
, handle
) == 12 );
2009 C_ASSERT( sizeof(struct get_token_default_dacl_request
) == 16 );
2010 C_ASSERT( FIELD_OFFSET(struct get_token_default_dacl_reply
, acl_len
) == 8 );
2011 C_ASSERT( sizeof(struct get_token_default_dacl_reply
) == 16 );
2012 C_ASSERT( FIELD_OFFSET(struct set_token_default_dacl_request
, handle
) == 12 );
2013 C_ASSERT( sizeof(struct set_token_default_dacl_request
) == 16 );
2014 C_ASSERT( FIELD_OFFSET(struct set_security_object_request
, handle
) == 12 );
2015 C_ASSERT( FIELD_OFFSET(struct set_security_object_request
, security_info
) == 16 );
2016 C_ASSERT( sizeof(struct set_security_object_request
) == 24 );
2017 C_ASSERT( FIELD_OFFSET(struct get_security_object_request
, handle
) == 12 );
2018 C_ASSERT( FIELD_OFFSET(struct get_security_object_request
, security_info
) == 16 );
2019 C_ASSERT( sizeof(struct get_security_object_request
) == 24 );
2020 C_ASSERT( FIELD_OFFSET(struct get_security_object_reply
, sd_len
) == 8 );
2021 C_ASSERT( sizeof(struct get_security_object_reply
) == 16 );
2022 C_ASSERT( sizeof(struct get_system_handles_request
) == 16 );
2023 C_ASSERT( FIELD_OFFSET(struct get_system_handles_reply
, count
) == 8 );
2024 C_ASSERT( sizeof(struct get_system_handles_reply
) == 16 );
2025 C_ASSERT( FIELD_OFFSET(struct create_mailslot_request
, access
) == 12 );
2026 C_ASSERT( FIELD_OFFSET(struct create_mailslot_request
, read_timeout
) == 16 );
2027 C_ASSERT( FIELD_OFFSET(struct create_mailslot_request
, max_msgsize
) == 24 );
2028 C_ASSERT( sizeof(struct create_mailslot_request
) == 32 );
2029 C_ASSERT( FIELD_OFFSET(struct create_mailslot_reply
, handle
) == 8 );
2030 C_ASSERT( sizeof(struct create_mailslot_reply
) == 16 );
2031 C_ASSERT( FIELD_OFFSET(struct set_mailslot_info_request
, handle
) == 12 );
2032 C_ASSERT( FIELD_OFFSET(struct set_mailslot_info_request
, read_timeout
) == 16 );
2033 C_ASSERT( FIELD_OFFSET(struct set_mailslot_info_request
, flags
) == 24 );
2034 C_ASSERT( sizeof(struct set_mailslot_info_request
) == 32 );
2035 C_ASSERT( FIELD_OFFSET(struct set_mailslot_info_reply
, read_timeout
) == 8 );
2036 C_ASSERT( FIELD_OFFSET(struct set_mailslot_info_reply
, max_msgsize
) == 16 );
2037 C_ASSERT( sizeof(struct set_mailslot_info_reply
) == 24 );
2038 C_ASSERT( FIELD_OFFSET(struct create_directory_request
, access
) == 12 );
2039 C_ASSERT( sizeof(struct create_directory_request
) == 16 );
2040 C_ASSERT( FIELD_OFFSET(struct create_directory_reply
, handle
) == 8 );
2041 C_ASSERT( sizeof(struct create_directory_reply
) == 16 );
2042 C_ASSERT( FIELD_OFFSET(struct open_directory_request
, access
) == 12 );
2043 C_ASSERT( FIELD_OFFSET(struct open_directory_request
, attributes
) == 16 );
2044 C_ASSERT( FIELD_OFFSET(struct open_directory_request
, rootdir
) == 20 );
2045 C_ASSERT( sizeof(struct open_directory_request
) == 24 );
2046 C_ASSERT( FIELD_OFFSET(struct open_directory_reply
, handle
) == 8 );
2047 C_ASSERT( sizeof(struct open_directory_reply
) == 16 );
2048 C_ASSERT( FIELD_OFFSET(struct get_directory_entry_request
, handle
) == 12 );
2049 C_ASSERT( FIELD_OFFSET(struct get_directory_entry_request
, index
) == 16 );
2050 C_ASSERT( sizeof(struct get_directory_entry_request
) == 24 );
2051 C_ASSERT( FIELD_OFFSET(struct get_directory_entry_reply
, total_len
) == 8 );
2052 C_ASSERT( FIELD_OFFSET(struct get_directory_entry_reply
, name_len
) == 12 );
2053 C_ASSERT( sizeof(struct get_directory_entry_reply
) == 16 );
2054 C_ASSERT( FIELD_OFFSET(struct create_symlink_request
, access
) == 12 );
2055 C_ASSERT( sizeof(struct create_symlink_request
) == 16 );
2056 C_ASSERT( FIELD_OFFSET(struct create_symlink_reply
, handle
) == 8 );
2057 C_ASSERT( sizeof(struct create_symlink_reply
) == 16 );
2058 C_ASSERT( FIELD_OFFSET(struct open_symlink_request
, access
) == 12 );
2059 C_ASSERT( FIELD_OFFSET(struct open_symlink_request
, attributes
) == 16 );
2060 C_ASSERT( FIELD_OFFSET(struct open_symlink_request
, rootdir
) == 20 );
2061 C_ASSERT( sizeof(struct open_symlink_request
) == 24 );
2062 C_ASSERT( FIELD_OFFSET(struct open_symlink_reply
, handle
) == 8 );
2063 C_ASSERT( sizeof(struct open_symlink_reply
) == 16 );
2064 C_ASSERT( FIELD_OFFSET(struct query_symlink_request
, handle
) == 12 );
2065 C_ASSERT( sizeof(struct query_symlink_request
) == 16 );
2066 C_ASSERT( FIELD_OFFSET(struct query_symlink_reply
, total
) == 8 );
2067 C_ASSERT( sizeof(struct query_symlink_reply
) == 16 );
2068 C_ASSERT( FIELD_OFFSET(struct get_object_info_request
, handle
) == 12 );
2069 C_ASSERT( sizeof(struct get_object_info_request
) == 16 );
2070 C_ASSERT( FIELD_OFFSET(struct get_object_info_reply
, access
) == 8 );
2071 C_ASSERT( FIELD_OFFSET(struct get_object_info_reply
, ref_count
) == 12 );
2072 C_ASSERT( FIELD_OFFSET(struct get_object_info_reply
, handle_count
) == 16 );
2073 C_ASSERT( sizeof(struct get_object_info_reply
) == 24 );
2074 C_ASSERT( FIELD_OFFSET(struct get_object_name_request
, handle
) == 12 );
2075 C_ASSERT( sizeof(struct get_object_name_request
) == 16 );
2076 C_ASSERT( FIELD_OFFSET(struct get_object_name_reply
, total
) == 8 );
2077 C_ASSERT( sizeof(struct get_object_name_reply
) == 16 );
2078 C_ASSERT( FIELD_OFFSET(struct get_object_type_request
, handle
) == 12 );
2079 C_ASSERT( sizeof(struct get_object_type_request
) == 16 );
2080 C_ASSERT( sizeof(struct get_object_type_reply
) == 8 );
2081 C_ASSERT( sizeof(struct get_object_types_request
) == 16 );
2082 C_ASSERT( FIELD_OFFSET(struct get_object_types_reply
, count
) == 8 );
2083 C_ASSERT( sizeof(struct get_object_types_reply
) == 16 );
2084 C_ASSERT( sizeof(struct allocate_locally_unique_id_request
) == 16 );
2085 C_ASSERT( FIELD_OFFSET(struct allocate_locally_unique_id_reply
, luid
) == 8 );
2086 C_ASSERT( sizeof(struct allocate_locally_unique_id_reply
) == 16 );
2087 C_ASSERT( FIELD_OFFSET(struct create_device_manager_request
, access
) == 12 );
2088 C_ASSERT( FIELD_OFFSET(struct create_device_manager_request
, attributes
) == 16 );
2089 C_ASSERT( sizeof(struct create_device_manager_request
) == 24 );
2090 C_ASSERT( FIELD_OFFSET(struct create_device_manager_reply
, handle
) == 8 );
2091 C_ASSERT( sizeof(struct create_device_manager_reply
) == 16 );
2092 C_ASSERT( FIELD_OFFSET(struct create_device_request
, rootdir
) == 12 );
2093 C_ASSERT( FIELD_OFFSET(struct create_device_request
, user_ptr
) == 16 );
2094 C_ASSERT( FIELD_OFFSET(struct create_device_request
, manager
) == 24 );
2095 C_ASSERT( sizeof(struct create_device_request
) == 32 );
2096 C_ASSERT( FIELD_OFFSET(struct delete_device_request
, manager
) == 12 );
2097 C_ASSERT( FIELD_OFFSET(struct delete_device_request
, device
) == 16 );
2098 C_ASSERT( sizeof(struct delete_device_request
) == 24 );
2099 C_ASSERT( FIELD_OFFSET(struct get_next_device_request_request
, manager
) == 12 );
2100 C_ASSERT( FIELD_OFFSET(struct get_next_device_request_request
, prev
) == 16 );
2101 C_ASSERT( FIELD_OFFSET(struct get_next_device_request_request
, status
) == 20 );
2102 C_ASSERT( FIELD_OFFSET(struct get_next_device_request_request
, user_ptr
) == 24 );
2103 C_ASSERT( FIELD_OFFSET(struct get_next_device_request_request
, pending
) == 32 );
2104 C_ASSERT( FIELD_OFFSET(struct get_next_device_request_request
, iosb_status
) == 36 );
2105 C_ASSERT( FIELD_OFFSET(struct get_next_device_request_request
, result
) == 40 );
2106 C_ASSERT( sizeof(struct get_next_device_request_request
) == 48 );
2107 C_ASSERT( FIELD_OFFSET(struct get_next_device_request_reply
, params
) == 8 );
2108 C_ASSERT( FIELD_OFFSET(struct get_next_device_request_reply
, next
) == 40 );
2109 C_ASSERT( FIELD_OFFSET(struct get_next_device_request_reply
, client_tid
) == 44 );
2110 C_ASSERT( FIELD_OFFSET(struct get_next_device_request_reply
, client_thread
) == 48 );
2111 C_ASSERT( FIELD_OFFSET(struct get_next_device_request_reply
, in_size
) == 56 );
2112 C_ASSERT( sizeof(struct get_next_device_request_reply
) == 64 );
2113 C_ASSERT( FIELD_OFFSET(struct get_kernel_object_ptr_request
, manager
) == 12 );
2114 C_ASSERT( FIELD_OFFSET(struct get_kernel_object_ptr_request
, handle
) == 16 );
2115 C_ASSERT( sizeof(struct get_kernel_object_ptr_request
) == 24 );
2116 C_ASSERT( FIELD_OFFSET(struct get_kernel_object_ptr_reply
, user_ptr
) == 8 );
2117 C_ASSERT( sizeof(struct get_kernel_object_ptr_reply
) == 16 );
2118 C_ASSERT( FIELD_OFFSET(struct set_kernel_object_ptr_request
, manager
) == 12 );
2119 C_ASSERT( FIELD_OFFSET(struct set_kernel_object_ptr_request
, handle
) == 16 );
2120 C_ASSERT( FIELD_OFFSET(struct set_kernel_object_ptr_request
, user_ptr
) == 24 );
2121 C_ASSERT( sizeof(struct set_kernel_object_ptr_request
) == 32 );
2122 C_ASSERT( FIELD_OFFSET(struct grab_kernel_object_request
, manager
) == 12 );
2123 C_ASSERT( FIELD_OFFSET(struct grab_kernel_object_request
, user_ptr
) == 16 );
2124 C_ASSERT( sizeof(struct grab_kernel_object_request
) == 24 );
2125 C_ASSERT( FIELD_OFFSET(struct release_kernel_object_request
, manager
) == 12 );
2126 C_ASSERT( FIELD_OFFSET(struct release_kernel_object_request
, user_ptr
) == 16 );
2127 C_ASSERT( sizeof(struct release_kernel_object_request
) == 24 );
2128 C_ASSERT( FIELD_OFFSET(struct get_kernel_object_handle_request
, manager
) == 12 );
2129 C_ASSERT( FIELD_OFFSET(struct get_kernel_object_handle_request
, user_ptr
) == 16 );
2130 C_ASSERT( FIELD_OFFSET(struct get_kernel_object_handle_request
, access
) == 24 );
2131 C_ASSERT( sizeof(struct get_kernel_object_handle_request
) == 32 );
2132 C_ASSERT( FIELD_OFFSET(struct get_kernel_object_handle_reply
, handle
) == 8 );
2133 C_ASSERT( sizeof(struct get_kernel_object_handle_reply
) == 16 );
2134 C_ASSERT( FIELD_OFFSET(struct make_process_system_request
, handle
) == 12 );
2135 C_ASSERT( sizeof(struct make_process_system_request
) == 16 );
2136 C_ASSERT( FIELD_OFFSET(struct make_process_system_reply
, event
) == 8 );
2137 C_ASSERT( sizeof(struct make_process_system_reply
) == 16 );
2138 C_ASSERT( FIELD_OFFSET(struct get_token_info_request
, handle
) == 12 );
2139 C_ASSERT( sizeof(struct get_token_info_request
) == 16 );
2140 C_ASSERT( FIELD_OFFSET(struct get_token_info_reply
, token_id
) == 8 );
2141 C_ASSERT( FIELD_OFFSET(struct get_token_info_reply
, modified_id
) == 16 );
2142 C_ASSERT( FIELD_OFFSET(struct get_token_info_reply
, session_id
) == 24 );
2143 C_ASSERT( FIELD_OFFSET(struct get_token_info_reply
, primary
) == 28 );
2144 C_ASSERT( FIELD_OFFSET(struct get_token_info_reply
, impersonation_level
) == 32 );
2145 C_ASSERT( FIELD_OFFSET(struct get_token_info_reply
, elevation
) == 36 );
2146 C_ASSERT( FIELD_OFFSET(struct get_token_info_reply
, group_count
) == 40 );
2147 C_ASSERT( FIELD_OFFSET(struct get_token_info_reply
, privilege_count
) == 44 );
2148 C_ASSERT( sizeof(struct get_token_info_reply
) == 48 );
2149 C_ASSERT( FIELD_OFFSET(struct create_linked_token_request
, handle
) == 12 );
2150 C_ASSERT( sizeof(struct create_linked_token_request
) == 16 );
2151 C_ASSERT( FIELD_OFFSET(struct create_linked_token_reply
, linked
) == 8 );
2152 C_ASSERT( sizeof(struct create_linked_token_reply
) == 16 );
2153 C_ASSERT( FIELD_OFFSET(struct create_completion_request
, access
) == 12 );
2154 C_ASSERT( FIELD_OFFSET(struct create_completion_request
, concurrent
) == 16 );
2155 C_ASSERT( sizeof(struct create_completion_request
) == 24 );
2156 C_ASSERT( FIELD_OFFSET(struct create_completion_reply
, handle
) == 8 );
2157 C_ASSERT( sizeof(struct create_completion_reply
) == 16 );
2158 C_ASSERT( FIELD_OFFSET(struct open_completion_request
, access
) == 12 );
2159 C_ASSERT( FIELD_OFFSET(struct open_completion_request
, attributes
) == 16 );
2160 C_ASSERT( FIELD_OFFSET(struct open_completion_request
, rootdir
) == 20 );
2161 C_ASSERT( sizeof(struct open_completion_request
) == 24 );
2162 C_ASSERT( FIELD_OFFSET(struct open_completion_reply
, handle
) == 8 );
2163 C_ASSERT( sizeof(struct open_completion_reply
) == 16 );
2164 C_ASSERT( FIELD_OFFSET(struct add_completion_request
, handle
) == 12 );
2165 C_ASSERT( FIELD_OFFSET(struct add_completion_request
, ckey
) == 16 );
2166 C_ASSERT( FIELD_OFFSET(struct add_completion_request
, cvalue
) == 24 );
2167 C_ASSERT( FIELD_OFFSET(struct add_completion_request
, information
) == 32 );
2168 C_ASSERT( FIELD_OFFSET(struct add_completion_request
, status
) == 40 );
2169 C_ASSERT( sizeof(struct add_completion_request
) == 48 );
2170 C_ASSERT( FIELD_OFFSET(struct remove_completion_request
, handle
) == 12 );
2171 C_ASSERT( sizeof(struct remove_completion_request
) == 16 );
2172 C_ASSERT( FIELD_OFFSET(struct remove_completion_reply
, ckey
) == 8 );
2173 C_ASSERT( FIELD_OFFSET(struct remove_completion_reply
, cvalue
) == 16 );
2174 C_ASSERT( FIELD_OFFSET(struct remove_completion_reply
, information
) == 24 );
2175 C_ASSERT( FIELD_OFFSET(struct remove_completion_reply
, status
) == 32 );
2176 C_ASSERT( sizeof(struct remove_completion_reply
) == 40 );
2177 C_ASSERT( FIELD_OFFSET(struct query_completion_request
, handle
) == 12 );
2178 C_ASSERT( sizeof(struct query_completion_request
) == 16 );
2179 C_ASSERT( FIELD_OFFSET(struct query_completion_reply
, depth
) == 8 );
2180 C_ASSERT( sizeof(struct query_completion_reply
) == 16 );
2181 C_ASSERT( FIELD_OFFSET(struct set_completion_info_request
, handle
) == 12 );
2182 C_ASSERT( FIELD_OFFSET(struct set_completion_info_request
, ckey
) == 16 );
2183 C_ASSERT( FIELD_OFFSET(struct set_completion_info_request
, chandle
) == 24 );
2184 C_ASSERT( sizeof(struct set_completion_info_request
) == 32 );
2185 C_ASSERT( FIELD_OFFSET(struct add_fd_completion_request
, handle
) == 12 );
2186 C_ASSERT( FIELD_OFFSET(struct add_fd_completion_request
, cvalue
) == 16 );
2187 C_ASSERT( FIELD_OFFSET(struct add_fd_completion_request
, information
) == 24 );
2188 C_ASSERT( FIELD_OFFSET(struct add_fd_completion_request
, status
) == 32 );
2189 C_ASSERT( FIELD_OFFSET(struct add_fd_completion_request
, async
) == 36 );
2190 C_ASSERT( sizeof(struct add_fd_completion_request
) == 40 );
2191 C_ASSERT( FIELD_OFFSET(struct set_fd_completion_mode_request
, handle
) == 12 );
2192 C_ASSERT( FIELD_OFFSET(struct set_fd_completion_mode_request
, flags
) == 16 );
2193 C_ASSERT( sizeof(struct set_fd_completion_mode_request
) == 24 );
2194 C_ASSERT( FIELD_OFFSET(struct set_fd_disp_info_request
, handle
) == 12 );
2195 C_ASSERT( FIELD_OFFSET(struct set_fd_disp_info_request
, unlink
) == 16 );
2196 C_ASSERT( sizeof(struct set_fd_disp_info_request
) == 24 );
2197 C_ASSERT( FIELD_OFFSET(struct set_fd_name_info_request
, handle
) == 12 );
2198 C_ASSERT( FIELD_OFFSET(struct set_fd_name_info_request
, rootdir
) == 16 );
2199 C_ASSERT( FIELD_OFFSET(struct set_fd_name_info_request
, namelen
) == 20 );
2200 C_ASSERT( FIELD_OFFSET(struct set_fd_name_info_request
, link
) == 24 );
2201 C_ASSERT( FIELD_OFFSET(struct set_fd_name_info_request
, replace
) == 28 );
2202 C_ASSERT( sizeof(struct set_fd_name_info_request
) == 32 );
2203 C_ASSERT( FIELD_OFFSET(struct set_fd_eof_info_request
, handle
) == 12 );
2204 C_ASSERT( FIELD_OFFSET(struct set_fd_eof_info_request
, eof
) == 16 );
2205 C_ASSERT( sizeof(struct set_fd_eof_info_request
) == 24 );
2206 C_ASSERT( FIELD_OFFSET(struct get_window_layered_info_request
, handle
) == 12 );
2207 C_ASSERT( sizeof(struct get_window_layered_info_request
) == 16 );
2208 C_ASSERT( FIELD_OFFSET(struct get_window_layered_info_reply
, color_key
) == 8 );
2209 C_ASSERT( FIELD_OFFSET(struct get_window_layered_info_reply
, alpha
) == 12 );
2210 C_ASSERT( FIELD_OFFSET(struct get_window_layered_info_reply
, flags
) == 16 );
2211 C_ASSERT( sizeof(struct get_window_layered_info_reply
) == 24 );
2212 C_ASSERT( FIELD_OFFSET(struct set_window_layered_info_request
, handle
) == 12 );
2213 C_ASSERT( FIELD_OFFSET(struct set_window_layered_info_request
, color_key
) == 16 );
2214 C_ASSERT( FIELD_OFFSET(struct set_window_layered_info_request
, alpha
) == 20 );
2215 C_ASSERT( FIELD_OFFSET(struct set_window_layered_info_request
, flags
) == 24 );
2216 C_ASSERT( sizeof(struct set_window_layered_info_request
) == 32 );
2217 C_ASSERT( sizeof(struct alloc_user_handle_request
) == 16 );
2218 C_ASSERT( FIELD_OFFSET(struct alloc_user_handle_reply
, handle
) == 8 );
2219 C_ASSERT( sizeof(struct alloc_user_handle_reply
) == 16 );
2220 C_ASSERT( FIELD_OFFSET(struct free_user_handle_request
, handle
) == 12 );
2221 C_ASSERT( sizeof(struct free_user_handle_request
) == 16 );
2222 C_ASSERT( FIELD_OFFSET(struct set_cursor_request
, flags
) == 12 );
2223 C_ASSERT( FIELD_OFFSET(struct set_cursor_request
, handle
) == 16 );
2224 C_ASSERT( FIELD_OFFSET(struct set_cursor_request
, show_count
) == 20 );
2225 C_ASSERT( FIELD_OFFSET(struct set_cursor_request
, x
) == 24 );
2226 C_ASSERT( FIELD_OFFSET(struct set_cursor_request
, y
) == 28 );
2227 C_ASSERT( FIELD_OFFSET(struct set_cursor_request
, clip
) == 32 );
2228 C_ASSERT( sizeof(struct set_cursor_request
) == 48 );
2229 C_ASSERT( FIELD_OFFSET(struct set_cursor_reply
, prev_handle
) == 8 );
2230 C_ASSERT( FIELD_OFFSET(struct set_cursor_reply
, prev_count
) == 12 );
2231 C_ASSERT( FIELD_OFFSET(struct set_cursor_reply
, prev_x
) == 16 );
2232 C_ASSERT( FIELD_OFFSET(struct set_cursor_reply
, prev_y
) == 20 );
2233 C_ASSERT( FIELD_OFFSET(struct set_cursor_reply
, new_x
) == 24 );
2234 C_ASSERT( FIELD_OFFSET(struct set_cursor_reply
, new_y
) == 28 );
2235 C_ASSERT( FIELD_OFFSET(struct set_cursor_reply
, new_clip
) == 32 );
2236 C_ASSERT( FIELD_OFFSET(struct set_cursor_reply
, last_change
) == 48 );
2237 C_ASSERT( sizeof(struct set_cursor_reply
) == 56 );
2238 C_ASSERT( sizeof(struct get_cursor_history_request
) == 16 );
2239 C_ASSERT( sizeof(struct get_cursor_history_reply
) == 8 );
2240 C_ASSERT( FIELD_OFFSET(struct get_rawinput_buffer_request
, rawinput_size
) == 12 );
2241 C_ASSERT( FIELD_OFFSET(struct get_rawinput_buffer_request
, buffer_size
) == 16 );
2242 C_ASSERT( sizeof(struct get_rawinput_buffer_request
) == 24 );
2243 C_ASSERT( FIELD_OFFSET(struct get_rawinput_buffer_reply
, next_size
) == 8 );
2244 C_ASSERT( FIELD_OFFSET(struct get_rawinput_buffer_reply
, count
) == 12 );
2245 C_ASSERT( sizeof(struct get_rawinput_buffer_reply
) == 16 );
2246 C_ASSERT( sizeof(struct update_rawinput_devices_request
) == 16 );
2247 C_ASSERT( FIELD_OFFSET(struct create_job_request
, access
) == 12 );
2248 C_ASSERT( sizeof(struct create_job_request
) == 16 );
2249 C_ASSERT( FIELD_OFFSET(struct create_job_reply
, handle
) == 8 );
2250 C_ASSERT( sizeof(struct create_job_reply
) == 16 );
2251 C_ASSERT( FIELD_OFFSET(struct open_job_request
, access
) == 12 );
2252 C_ASSERT( FIELD_OFFSET(struct open_job_request
, attributes
) == 16 );
2253 C_ASSERT( FIELD_OFFSET(struct open_job_request
, rootdir
) == 20 );
2254 C_ASSERT( sizeof(struct open_job_request
) == 24 );
2255 C_ASSERT( FIELD_OFFSET(struct open_job_reply
, handle
) == 8 );
2256 C_ASSERT( sizeof(struct open_job_reply
) == 16 );
2257 C_ASSERT( FIELD_OFFSET(struct assign_job_request
, job
) == 12 );
2258 C_ASSERT( FIELD_OFFSET(struct assign_job_request
, process
) == 16 );
2259 C_ASSERT( sizeof(struct assign_job_request
) == 24 );
2260 C_ASSERT( FIELD_OFFSET(struct process_in_job_request
, job
) == 12 );
2261 C_ASSERT( FIELD_OFFSET(struct process_in_job_request
, process
) == 16 );
2262 C_ASSERT( sizeof(struct process_in_job_request
) == 24 );
2263 C_ASSERT( FIELD_OFFSET(struct set_job_limits_request
, handle
) == 12 );
2264 C_ASSERT( FIELD_OFFSET(struct set_job_limits_request
, limit_flags
) == 16 );
2265 C_ASSERT( sizeof(struct set_job_limits_request
) == 24 );
2266 C_ASSERT( FIELD_OFFSET(struct set_job_completion_port_request
, job
) == 12 );
2267 C_ASSERT( FIELD_OFFSET(struct set_job_completion_port_request
, port
) == 16 );
2268 C_ASSERT( FIELD_OFFSET(struct set_job_completion_port_request
, key
) == 24 );
2269 C_ASSERT( sizeof(struct set_job_completion_port_request
) == 32 );
2270 C_ASSERT( FIELD_OFFSET(struct get_job_info_request
, handle
) == 12 );
2271 C_ASSERT( sizeof(struct get_job_info_request
) == 16 );
2272 C_ASSERT( FIELD_OFFSET(struct get_job_info_reply
, total_processes
) == 8 );
2273 C_ASSERT( FIELD_OFFSET(struct get_job_info_reply
, active_processes
) == 12 );
2274 C_ASSERT( sizeof(struct get_job_info_reply
) == 16 );
2275 C_ASSERT( FIELD_OFFSET(struct terminate_job_request
, handle
) == 12 );
2276 C_ASSERT( FIELD_OFFSET(struct terminate_job_request
, status
) == 16 );
2277 C_ASSERT( sizeof(struct terminate_job_request
) == 24 );
2278 C_ASSERT( FIELD_OFFSET(struct suspend_process_request
, handle
) == 12 );
2279 C_ASSERT( sizeof(struct suspend_process_request
) == 16 );
2280 C_ASSERT( FIELD_OFFSET(struct resume_process_request
, handle
) == 12 );
2281 C_ASSERT( sizeof(struct resume_process_request
) == 16 );
2282 C_ASSERT( FIELD_OFFSET(struct get_next_thread_request
, process
) == 12 );
2283 C_ASSERT( FIELD_OFFSET(struct get_next_thread_request
, last
) == 16 );
2284 C_ASSERT( FIELD_OFFSET(struct get_next_thread_request
, access
) == 20 );
2285 C_ASSERT( FIELD_OFFSET(struct get_next_thread_request
, attributes
) == 24 );
2286 C_ASSERT( FIELD_OFFSET(struct get_next_thread_request
, flags
) == 28 );
2287 C_ASSERT( sizeof(struct get_next_thread_request
) == 32 );
2288 C_ASSERT( FIELD_OFFSET(struct get_next_thread_reply
, handle
) == 8 );
2289 C_ASSERT( sizeof(struct get_next_thread_reply
) == 16 );
2291 #endif /* WANT_REQUEST_HANDLERS */
2293 /* ### make_requests end ### */
2294 /* Everything above this line is generated automatically by tools/make_requests */
2296 #endif /* __WINE_SERVER_REQUEST_H */
