git.oblomov.eu Git - wine/blob - server/request.h

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