request.h 139 KB
Newer Older
1 2 3 4
/*
 * Wine server requests
 *
 * Copyright (C) 1999 Alexandre Julliard
5 6 7 8 9 10 11 12 13 14 15 16 17
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * 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
 */
Alexandre Julliard's avatar
Alexandre Julliard committed
20 21 22 23

#ifndef __WINE_SERVER_REQUEST_H
#define __WINE_SERVER_REQUEST_H

24 25
#include <assert.h>

26
#include "thread.h"
27
#include "wine/server_protocol.h"
28

29 30 31 32
/* max request length */
#define MAX_REQUEST_LENGTH  8192

/* request handler definition */
33 34
#define DECL_HANDLER(name) \
    void req_##name( const struct name##_request *req, struct name##_reply *reply )
35 36 37

/* request functions */

38 39 40
#ifdef __GNUC__
extern void fatal_protocol_error( struct thread *thread,
                                  const char *err, ... ) __attribute__((format (printf,2,3)));
41
extern void fatal_error( const char *err, ... )  __attribute__((noreturn,format(printf,1,2)));
42 43
#else
extern void fatal_protocol_error( struct thread *thread, const char *err, ... );
44
extern void fatal_error( const char *err, ... );
45 46
#endif

47
extern const char *get_config_dir(void);
48
extern void *set_reply_data_size( data_size_t size );
49
extern const struct object_attributes *get_req_object_attributes( const struct security_descriptor **sd,
50
                                                                  struct unicode_str *name,
51
                                                                  struct object **root );
52
extern const void *get_req_data_after_objattr( const struct object_attributes *attr, data_size_t *len );
53
extern int receive_fd( struct process *process );
54
extern int send_client_fd( struct process *process, int fd, obj_handle_t handle );
55
extern void read_request( struct thread *thread );
56
extern void write_reply( struct thread *thread );
57
extern unsigned int get_tick_count(void);
58
extern void open_master_socket(void);
59
extern void close_master_socket( timeout_t timeout );
60
extern void shutdown_master_socket(void);
61
extern int wait_for_lock(void);
62
extern int kill_lock_owner( int sig );
63
extern char *server_dir;
64
extern int server_dir_fd, config_dir_fd;
65

66 67
extern void trace_request(void);
extern void trace_reply( enum request req, const union generic_reply *reply );
Alexandre Julliard's avatar
Alexandre Julliard committed
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 79 80
{
    return current->req.request_header.request_size;
}

81
/* get the request vararg as unicode string */
82
static inline struct unicode_str get_req_unicode_str(void)
83
{
84 85 86 87
    struct unicode_str ret;
    ret.str = get_req_data();
    ret.len = (get_req_data_size() / sizeof(WCHAR)) * sizeof(WCHAR);
    return ret;
88 89
}

90
/* get the reply maximum vararg size */
91
static inline data_size_t get_reply_max_size(void)
92
{
93
    return current->req.request_header.reply_size;
94 95
}

96
/* allocate and fill the reply data */
97
static inline void *set_reply_data( const void *data, data_size_t size )
98
{
99 100 101
    void *ret = set_reply_data_size( size );
    if (ret) memcpy( ret, data, size );
    return ret;
102 103
}

104
/* set the reply data pointer directly (will be freed by request code) */
105
static inline void set_reply_data_ptr( void *data, data_size_t size )
106 107 108 109 110 111 112
{
    assert( size <= get_reply_max_size() );
    current->reply_size = size;
    current->reply_data = data;
}


113 114
/* Everything below this line is generated automatically by tools/make_requests */
/* ### make_requests begin ### */
Alexandre Julliard's avatar
Alexandre Julliard committed
115

116
DECL_HANDLER(new_process);
117
DECL_HANDLER(exec_process);
118
DECL_HANDLER(get_new_process_info);
Alexandre Julliard's avatar
Alexandre Julliard committed
119
DECL_HANDLER(new_thread);
120
DECL_HANDLER(get_startup_info);
121
DECL_HANDLER(init_process_done);
Alexandre Julliard's avatar
Alexandre Julliard committed
122 123 124 125
DECL_HANDLER(init_thread);
DECL_HANDLER(terminate_process);
DECL_HANDLER(terminate_thread);
DECL_HANDLER(get_process_info);
126
DECL_HANDLER(get_process_vm_counters);
127
DECL_HANDLER(set_process_info);
Alexandre Julliard's avatar
Alexandre Julliard committed
128
DECL_HANDLER(get_thread_info);
129
DECL_HANDLER(get_thread_times);
130
DECL_HANDLER(set_thread_info);
131
DECL_HANDLER(get_dll_info);
132 133
DECL_HANDLER(suspend_thread);
DECL_HANDLER(resume_thread);
134 135
DECL_HANDLER(load_dll);
DECL_HANDLER(unload_dll);
136
DECL_HANDLER(queue_apc);
137
DECL_HANDLER(get_apc_result);
Alexandre Julliard's avatar
Alexandre Julliard committed
138
DECL_HANDLER(close_handle);
139
DECL_HANDLER(set_handle_info);
Alexandre Julliard's avatar
Alexandre Julliard committed
140 141
DECL_HANDLER(dup_handle);
DECL_HANDLER(open_process);
142
DECL_HANDLER(open_thread);
Alexandre Julliard's avatar
Alexandre Julliard committed
143
DECL_HANDLER(select);
Alexandre Julliard's avatar
Alexandre Julliard committed
144 145
DECL_HANDLER(create_event);
DECL_HANDLER(event_op);
146
DECL_HANDLER(query_event);
147
DECL_HANDLER(open_event);
148 149
DECL_HANDLER(create_keyed_event);
DECL_HANDLER(open_keyed_event);
Alexandre Julliard's avatar
Alexandre Julliard committed
150 151
DECL_HANDLER(create_mutex);
DECL_HANDLER(release_mutex);
152
DECL_HANDLER(open_mutex);
153
DECL_HANDLER(query_mutex);
Alexandre Julliard's avatar
Alexandre Julliard committed
154 155
DECL_HANDLER(create_semaphore);
DECL_HANDLER(release_semaphore);
156
DECL_HANDLER(query_semaphore);
157
DECL_HANDLER(open_semaphore);
158
DECL_HANDLER(create_file);
159
DECL_HANDLER(open_file_object);
160
DECL_HANDLER(alloc_file_handle);
161
DECL_HANDLER(get_handle_unix_name);
162
DECL_HANDLER(get_handle_fd);
163
DECL_HANDLER(get_directory_cache_entry);
164
DECL_HANDLER(flush);
165
DECL_HANDLER(get_file_info);
166
DECL_HANDLER(get_volume_info);
167 168
DECL_HANDLER(lock_file);
DECL_HANDLER(unlock_file);
169 170
DECL_HANDLER(create_socket);
DECL_HANDLER(accept_socket);
171
DECL_HANDLER(accept_into_socket);
172 173
DECL_HANDLER(set_socket_event);
DECL_HANDLER(get_socket_event);
174
DECL_HANDLER(get_socket_info);
175
DECL_HANDLER(enable_socket_event);
176
DECL_HANDLER(set_socket_deferred);
177 178
DECL_HANDLER(alloc_console);
DECL_HANDLER(free_console);
179
DECL_HANDLER(get_console_renderer_events);
180
DECL_HANDLER(open_console);
181
DECL_HANDLER(attach_console);
182
DECL_HANDLER(get_console_wait_event);
183 184
DECL_HANDLER(get_console_mode);
DECL_HANDLER(set_console_mode);
185 186 187 188 189 190 191
DECL_HANDLER(set_console_input_info);
DECL_HANDLER(get_console_input_info);
DECL_HANDLER(append_console_input_history);
DECL_HANDLER(get_console_input_history);
DECL_HANDLER(create_console_output);
DECL_HANDLER(set_console_output_info);
DECL_HANDLER(get_console_output_info);
192 193
DECL_HANDLER(write_console_input);
DECL_HANDLER(read_console_input);
194
DECL_HANDLER(write_console_output);
195
DECL_HANDLER(fill_console_output);
196 197
DECL_HANDLER(read_console_output);
DECL_HANDLER(move_console_output);
198
DECL_HANDLER(send_console_signal);
199
DECL_HANDLER(read_directory_changes);
200
DECL_HANDLER(read_change);
201
DECL_HANDLER(create_mapping);
202
DECL_HANDLER(open_mapping);
203
DECL_HANDLER(get_mapping_info);
204 205
DECL_HANDLER(map_view);
DECL_HANDLER(unmap_view);
206 207
DECL_HANDLER(get_mapping_committed_range);
DECL_HANDLER(add_mapping_committed_range);
208
DECL_HANDLER(is_same_mapping);
209 210
DECL_HANDLER(create_snapshot);
DECL_HANDLER(next_process);
211
DECL_HANDLER(next_thread);
212
DECL_HANDLER(wait_debug_event);
213 214
DECL_HANDLER(queue_exception_event);
DECL_HANDLER(get_exception_status);
215 216
DECL_HANDLER(continue_debug_event);
DECL_HANDLER(debug_process);
217
DECL_HANDLER(set_debugger_kill_on_exit);
218
DECL_HANDLER(read_process_memory);
219
DECL_HANDLER(write_process_memory);
220 221 222
DECL_HANDLER(create_key);
DECL_HANDLER(open_key);
DECL_HANDLER(delete_key);
223
DECL_HANDLER(flush_key);
224 225 226 227 228 229
DECL_HANDLER(enum_key);
DECL_HANDLER(set_key_value);
DECL_HANDLER(get_key_value);
DECL_HANDLER(enum_key_value);
DECL_HANDLER(delete_key_value);
DECL_HANDLER(load_registry);
230
DECL_HANDLER(unload_registry);
231
DECL_HANDLER(save_registry);
232
DECL_HANDLER(set_registry_notification);
233 234 235 236
DECL_HANDLER(create_timer);
DECL_HANDLER(open_timer);
DECL_HANDLER(set_timer);
DECL_HANDLER(cancel_timer);
237
DECL_HANDLER(get_timer_info);
238 239
DECL_HANDLER(get_thread_context);
DECL_HANDLER(set_thread_context);
240
DECL_HANDLER(get_selector_entry);
241 242 243
DECL_HANDLER(add_atom);
DECL_HANDLER(delete_atom);
DECL_HANDLER(find_atom);
244 245 246
DECL_HANDLER(get_atom_information);
DECL_HANDLER(set_atom_information);
DECL_HANDLER(empty_atom_table);
247
DECL_HANDLER(init_atom_table);
248
DECL_HANDLER(get_msg_queue);
249
DECL_HANDLER(set_queue_fd);
250 251
DECL_HANDLER(set_queue_mask);
DECL_HANDLER(get_queue_status);
252
DECL_HANDLER(get_process_idle_event);
253
DECL_HANDLER(send_message);
254
DECL_HANDLER(post_quit_message);
255
DECL_HANDLER(send_hardware_message);
256 257
DECL_HANDLER(get_message);
DECL_HANDLER(reply_message);
258
DECL_HANDLER(accept_hardware_message);
259 260 261
DECL_HANDLER(get_message_reply);
DECL_HANDLER(set_win_timer);
DECL_HANDLER(kill_win_timer);
262
DECL_HANDLER(is_window_hung);
263 264
DECL_HANDLER(get_serial_info);
DECL_HANDLER(set_serial_info);
265
DECL_HANDLER(register_async);
266
DECL_HANDLER(cancel_async);
267
DECL_HANDLER(get_async_result);
268 269
DECL_HANDLER(read);
DECL_HANDLER(write);
270
DECL_HANDLER(ioctl);
271
DECL_HANDLER(set_irp_result);
272
DECL_HANDLER(create_named_pipe);
273
DECL_HANDLER(set_named_pipe_info);
274 275
DECL_HANDLER(create_window);
DECL_HANDLER(destroy_window);
276
DECL_HANDLER(get_desktop_window);
277
DECL_HANDLER(set_window_owner);
278
DECL_HANDLER(get_window_info);
279
DECL_HANDLER(set_window_info);
280
DECL_HANDLER(set_parent);
281 282
DECL_HANDLER(get_window_parents);
DECL_HANDLER(get_window_children);
283
DECL_HANDLER(get_window_children_from_point);
284
DECL_HANDLER(get_window_tree);
285
DECL_HANDLER(set_window_pos);
286
DECL_HANDLER(get_window_rectangles);
287 288
DECL_HANDLER(get_window_text);
DECL_HANDLER(set_window_text);
289
DECL_HANDLER(get_windows_offset);
290
DECL_HANDLER(get_visible_region);
291
DECL_HANDLER(get_surface_region);
292 293
DECL_HANDLER(get_window_region);
DECL_HANDLER(set_window_region);
294
DECL_HANDLER(get_update_region);
295
DECL_HANDLER(update_window_zorder);
296
DECL_HANDLER(redraw_window);
297 298 299 300
DECL_HANDLER(set_window_property);
DECL_HANDLER(remove_window_property);
DECL_HANDLER(get_window_property);
DECL_HANDLER(get_window_properties);
301 302 303 304 305
DECL_HANDLER(create_winstation);
DECL_HANDLER(open_winstation);
DECL_HANDLER(close_winstation);
DECL_HANDLER(get_process_winstation);
DECL_HANDLER(set_process_winstation);
306
DECL_HANDLER(enum_winstation);
307 308
DECL_HANDLER(create_desktop);
DECL_HANDLER(open_desktop);
309
DECL_HANDLER(open_input_desktop);
310 311 312
DECL_HANDLER(close_desktop);
DECL_HANDLER(get_thread_desktop);
DECL_HANDLER(set_thread_desktop);
313
DECL_HANDLER(enum_desktop);
314
DECL_HANDLER(set_user_object_info);
315 316
DECL_HANDLER(register_hotkey);
DECL_HANDLER(unregister_hotkey);
317 318
DECL_HANDLER(attach_thread_input);
DECL_HANDLER(get_thread_input);
319
DECL_HANDLER(get_last_input_time);
320 321
DECL_HANDLER(get_key_state);
DECL_HANDLER(set_key_state);
322 323 324
DECL_HANDLER(set_foreground_window);
DECL_HANDLER(set_focus_window);
DECL_HANDLER(set_active_window);
325
DECL_HANDLER(set_capture_window);
326 327
DECL_HANDLER(set_caret_window);
DECL_HANDLER(set_caret_info);
328 329 330 331
DECL_HANDLER(set_hook);
DECL_HANDLER(remove_hook);
DECL_HANDLER(start_hook_chain);
DECL_HANDLER(finish_hook_chain);
332
DECL_HANDLER(get_hook_info);
333 334 335
DECL_HANDLER(create_class);
DECL_HANDLER(destroy_class);
DECL_HANDLER(set_class_info);
336 337
DECL_HANDLER(open_clipboard);
DECL_HANDLER(close_clipboard);
338
DECL_HANDLER(empty_clipboard);
339
DECL_HANDLER(set_clipboard_data);
340
DECL_HANDLER(get_clipboard_data);
341 342
DECL_HANDLER(get_clipboard_formats);
DECL_HANDLER(enum_clipboard_formats);
343
DECL_HANDLER(release_clipboard);
344
DECL_HANDLER(get_clipboard_info);
345
DECL_HANDLER(set_clipboard_viewer);
346 347
DECL_HANDLER(add_clipboard_listener);
DECL_HANDLER(remove_clipboard_listener);
348
DECL_HANDLER(open_token);
349
DECL_HANDLER(set_global_windows);
350 351
DECL_HANDLER(adjust_token_privileges);
DECL_HANDLER(get_token_privileges);
352
DECL_HANDLER(check_token_privileges);
353
DECL_HANDLER(duplicate_token);
354
DECL_HANDLER(access_check);
355
DECL_HANDLER(get_token_sid);
356
DECL_HANDLER(get_token_groups);
357 358
DECL_HANDLER(get_token_default_dacl);
DECL_HANDLER(set_token_default_dacl);
359
DECL_HANDLER(set_security_object);
360
DECL_HANDLER(get_security_object);
361
DECL_HANDLER(get_system_handles);
Mike McCormack's avatar
Mike McCormack committed
362 363
DECL_HANDLER(create_mailslot);
DECL_HANDLER(set_mailslot_info);
364 365
DECL_HANDLER(create_directory);
DECL_HANDLER(open_directory);
366
DECL_HANDLER(get_directory_entry);
367 368 369
DECL_HANDLER(create_symlink);
DECL_HANDLER(open_symlink);
DECL_HANDLER(query_symlink);
370
DECL_HANDLER(get_object_info);
371
DECL_HANDLER(get_object_type);
372
DECL_HANDLER(unlink_object);
373
DECL_HANDLER(get_token_impersonation_level);
374
DECL_HANDLER(allocate_locally_unique_id);
375 376 377
DECL_HANDLER(create_device_manager);
DECL_HANDLER(create_device);
DECL_HANDLER(delete_device);
378
DECL_HANDLER(get_next_device_request);
379 380
DECL_HANDLER(get_kernel_object_ptr);
DECL_HANDLER(set_kernel_object_ptr);
381 382
DECL_HANDLER(grab_kernel_object);
DECL_HANDLER(release_kernel_object);
383
DECL_HANDLER(get_kernel_object_handle);
384
DECL_HANDLER(make_process_system);
385
DECL_HANDLER(get_token_statistics);
386 387 388 389 390
DECL_HANDLER(create_completion);
DECL_HANDLER(open_completion);
DECL_HANDLER(add_completion);
DECL_HANDLER(remove_completion);
DECL_HANDLER(query_completion);
391
DECL_HANDLER(set_completion_info);
392
DECL_HANDLER(add_fd_completion);
393
DECL_HANDLER(set_fd_completion_mode);
394 395
DECL_HANDLER(set_fd_disp_info);
DECL_HANDLER(set_fd_name_info);
396 397
DECL_HANDLER(get_window_layered_info);
DECL_HANDLER(set_window_layered_info);
398 399
DECL_HANDLER(alloc_user_handle);
DECL_HANDLER(free_user_handle);
400
DECL_HANDLER(set_cursor);
401
DECL_HANDLER(update_rawinput_devices);
402 403
DECL_HANDLER(get_suspend_context);
DECL_HANDLER(set_suspend_context);
404
DECL_HANDLER(create_job);
405
DECL_HANDLER(open_job);
406
DECL_HANDLER(assign_job);
407
DECL_HANDLER(process_in_job);
408
DECL_HANDLER(set_job_limits);
409
DECL_HANDLER(set_job_completion_port);
410
DECL_HANDLER(terminate_job);
411 412
DECL_HANDLER(suspend_process);
DECL_HANDLER(resume_process);
Alexandre Julliard's avatar
Alexandre Julliard committed
413

414 415
#ifdef WANT_REQUEST_HANDLERS

416
typedef void (*req_handler)( const void *req, void *reply );
417 418 419
static const req_handler req_handlers[REQ_NB_REQUESTS] =
{
    (req_handler)req_new_process,
420
    (req_handler)req_exec_process,
421
    (req_handler)req_get_new_process_info,
422
    (req_handler)req_new_thread,
423
    (req_handler)req_get_startup_info,
424 425 426 427 428
    (req_handler)req_init_process_done,
    (req_handler)req_init_thread,
    (req_handler)req_terminate_process,
    (req_handler)req_terminate_thread,
    (req_handler)req_get_process_info,
429
    (req_handler)req_get_process_vm_counters,
430 431
    (req_handler)req_set_process_info,
    (req_handler)req_get_thread_info,
432
    (req_handler)req_get_thread_times,
433
    (req_handler)req_set_thread_info,
434
    (req_handler)req_get_dll_info,
435 436 437 438 439
    (req_handler)req_suspend_thread,
    (req_handler)req_resume_thread,
    (req_handler)req_load_dll,
    (req_handler)req_unload_dll,
    (req_handler)req_queue_apc,
440
    (req_handler)req_get_apc_result,
441 442 443 444
    (req_handler)req_close_handle,
    (req_handler)req_set_handle_info,
    (req_handler)req_dup_handle,
    (req_handler)req_open_process,
445
    (req_handler)req_open_thread,
446 447 448
    (req_handler)req_select,
    (req_handler)req_create_event,
    (req_handler)req_event_op,
449
    (req_handler)req_query_event,
450
    (req_handler)req_open_event,
451 452
    (req_handler)req_create_keyed_event,
    (req_handler)req_open_keyed_event,
453 454 455
    (req_handler)req_create_mutex,
    (req_handler)req_release_mutex,
    (req_handler)req_open_mutex,
456
    (req_handler)req_query_mutex,
457 458
    (req_handler)req_create_semaphore,
    (req_handler)req_release_semaphore,
459
    (req_handler)req_query_semaphore,
460 461
    (req_handler)req_open_semaphore,
    (req_handler)req_create_file,
462
    (req_handler)req_open_file_object,
463
    (req_handler)req_alloc_file_handle,
464
    (req_handler)req_get_handle_unix_name,
465
    (req_handler)req_get_handle_fd,
466
    (req_handler)req_get_directory_cache_entry,
467
    (req_handler)req_flush,
468
    (req_handler)req_get_file_info,
469
    (req_handler)req_get_volume_info,
470 471 472 473
    (req_handler)req_lock_file,
    (req_handler)req_unlock_file,
    (req_handler)req_create_socket,
    (req_handler)req_accept_socket,
474
    (req_handler)req_accept_into_socket,
475 476
    (req_handler)req_set_socket_event,
    (req_handler)req_get_socket_event,
477
    (req_handler)req_get_socket_info,
478
    (req_handler)req_enable_socket_event,
479
    (req_handler)req_set_socket_deferred,
480 481
    (req_handler)req_alloc_console,
    (req_handler)req_free_console,
482
    (req_handler)req_get_console_renderer_events,
483
    (req_handler)req_open_console,
484
    (req_handler)req_attach_console,
485
    (req_handler)req_get_console_wait_event,
486 487
    (req_handler)req_get_console_mode,
    (req_handler)req_set_console_mode,
488 489 490 491 492 493 494
    (req_handler)req_set_console_input_info,
    (req_handler)req_get_console_input_info,
    (req_handler)req_append_console_input_history,
    (req_handler)req_get_console_input_history,
    (req_handler)req_create_console_output,
    (req_handler)req_set_console_output_info,
    (req_handler)req_get_console_output_info,
495 496
    (req_handler)req_write_console_input,
    (req_handler)req_read_console_input,
497
    (req_handler)req_write_console_output,
498
    (req_handler)req_fill_console_output,
499 500
    (req_handler)req_read_console_output,
    (req_handler)req_move_console_output,
501
    (req_handler)req_send_console_signal,
502
    (req_handler)req_read_directory_changes,
503
    (req_handler)req_read_change,
504 505 506
    (req_handler)req_create_mapping,
    (req_handler)req_open_mapping,
    (req_handler)req_get_mapping_info,
507 508
    (req_handler)req_map_view,
    (req_handler)req_unmap_view,
509 510
    (req_handler)req_get_mapping_committed_range,
    (req_handler)req_add_mapping_committed_range,
511
    (req_handler)req_is_same_mapping,
512 513
    (req_handler)req_create_snapshot,
    (req_handler)req_next_process,
514
    (req_handler)req_next_thread,
515
    (req_handler)req_wait_debug_event,
516 517
    (req_handler)req_queue_exception_event,
    (req_handler)req_get_exception_status,
518 519
    (req_handler)req_continue_debug_event,
    (req_handler)req_debug_process,
520
    (req_handler)req_set_debugger_kill_on_exit,
521 522 523 524 525
    (req_handler)req_read_process_memory,
    (req_handler)req_write_process_memory,
    (req_handler)req_create_key,
    (req_handler)req_open_key,
    (req_handler)req_delete_key,
526
    (req_handler)req_flush_key,
527 528 529 530 531 532
    (req_handler)req_enum_key,
    (req_handler)req_set_key_value,
    (req_handler)req_get_key_value,
    (req_handler)req_enum_key_value,
    (req_handler)req_delete_key_value,
    (req_handler)req_load_registry,
533
    (req_handler)req_unload_registry,
534
    (req_handler)req_save_registry,
535
    (req_handler)req_set_registry_notification,
536 537 538 539
    (req_handler)req_create_timer,
    (req_handler)req_open_timer,
    (req_handler)req_set_timer,
    (req_handler)req_cancel_timer,
540
    (req_handler)req_get_timer_info,
541 542 543 544 545 546
    (req_handler)req_get_thread_context,
    (req_handler)req_set_thread_context,
    (req_handler)req_get_selector_entry,
    (req_handler)req_add_atom,
    (req_handler)req_delete_atom,
    (req_handler)req_find_atom,
547 548 549
    (req_handler)req_get_atom_information,
    (req_handler)req_set_atom_information,
    (req_handler)req_empty_atom_table,
550
    (req_handler)req_init_atom_table,
551
    (req_handler)req_get_msg_queue,
552
    (req_handler)req_set_queue_fd,
553 554
    (req_handler)req_set_queue_mask,
    (req_handler)req_get_queue_status,
555
    (req_handler)req_get_process_idle_event,
556
    (req_handler)req_send_message,
557
    (req_handler)req_post_quit_message,
558
    (req_handler)req_send_hardware_message,
559 560
    (req_handler)req_get_message,
    (req_handler)req_reply_message,
561
    (req_handler)req_accept_hardware_message,
562 563 564
    (req_handler)req_get_message_reply,
    (req_handler)req_set_win_timer,
    (req_handler)req_kill_win_timer,
565
    (req_handler)req_is_window_hung,
566 567
    (req_handler)req_get_serial_info,
    (req_handler)req_set_serial_info,
568
    (req_handler)req_register_async,
569
    (req_handler)req_cancel_async,
570
    (req_handler)req_get_async_result,
571 572
    (req_handler)req_read,
    (req_handler)req_write,
573
    (req_handler)req_ioctl,
574
    (req_handler)req_set_irp_result,
575
    (req_handler)req_create_named_pipe,
576
    (req_handler)req_set_named_pipe_info,
577 578
    (req_handler)req_create_window,
    (req_handler)req_destroy_window,
579
    (req_handler)req_get_desktop_window,
580
    (req_handler)req_set_window_owner,
581
    (req_handler)req_get_window_info,
582
    (req_handler)req_set_window_info,
583
    (req_handler)req_set_parent,
584 585
    (req_handler)req_get_window_parents,
    (req_handler)req_get_window_children,
586
    (req_handler)req_get_window_children_from_point,
587
    (req_handler)req_get_window_tree,
588
    (req_handler)req_set_window_pos,
589
    (req_handler)req_get_window_rectangles,
590 591
    (req_handler)req_get_window_text,
    (req_handler)req_set_window_text,
592
    (req_handler)req_get_windows_offset,
593
    (req_handler)req_get_visible_region,
594
    (req_handler)req_get_surface_region,
595 596
    (req_handler)req_get_window_region,
    (req_handler)req_set_window_region,
597
    (req_handler)req_get_update_region,
598
    (req_handler)req_update_window_zorder,
599
    (req_handler)req_redraw_window,
600 601 602 603
    (req_handler)req_set_window_property,
    (req_handler)req_remove_window_property,
    (req_handler)req_get_window_property,
    (req_handler)req_get_window_properties,
604 605 606 607 608
    (req_handler)req_create_winstation,
    (req_handler)req_open_winstation,
    (req_handler)req_close_winstation,
    (req_handler)req_get_process_winstation,
    (req_handler)req_set_process_winstation,
609
    (req_handler)req_enum_winstation,
610 611
    (req_handler)req_create_desktop,
    (req_handler)req_open_desktop,
612
    (req_handler)req_open_input_desktop,
613 614 615
    (req_handler)req_close_desktop,
    (req_handler)req_get_thread_desktop,
    (req_handler)req_set_thread_desktop,
616
    (req_handler)req_enum_desktop,
617
    (req_handler)req_set_user_object_info,
618 619
    (req_handler)req_register_hotkey,
    (req_handler)req_unregister_hotkey,
620 621
    (req_handler)req_attach_thread_input,
    (req_handler)req_get_thread_input,
622
    (req_handler)req_get_last_input_time,
623 624
    (req_handler)req_get_key_state,
    (req_handler)req_set_key_state,
625 626 627
    (req_handler)req_set_foreground_window,
    (req_handler)req_set_focus_window,
    (req_handler)req_set_active_window,
628
    (req_handler)req_set_capture_window,
629 630
    (req_handler)req_set_caret_window,
    (req_handler)req_set_caret_info,
631 632 633 634
    (req_handler)req_set_hook,
    (req_handler)req_remove_hook,
    (req_handler)req_start_hook_chain,
    (req_handler)req_finish_hook_chain,
635
    (req_handler)req_get_hook_info,
636 637 638
    (req_handler)req_create_class,
    (req_handler)req_destroy_class,
    (req_handler)req_set_class_info,
639 640
    (req_handler)req_open_clipboard,
    (req_handler)req_close_clipboard,
641
    (req_handler)req_empty_clipboard,
642
    (req_handler)req_set_clipboard_data,
643
    (req_handler)req_get_clipboard_data,
644 645
    (req_handler)req_get_clipboard_formats,
    (req_handler)req_enum_clipboard_formats,
646
    (req_handler)req_release_clipboard,
647
    (req_handler)req_get_clipboard_info,
648
    (req_handler)req_set_clipboard_viewer,
649 650
    (req_handler)req_add_clipboard_listener,
    (req_handler)req_remove_clipboard_listener,
651
    (req_handler)req_open_token,
652
    (req_handler)req_set_global_windows,
653 654
    (req_handler)req_adjust_token_privileges,
    (req_handler)req_get_token_privileges,
655
    (req_handler)req_check_token_privileges,
656
    (req_handler)req_duplicate_token,
657
    (req_handler)req_access_check,
658
    (req_handler)req_get_token_sid,
659
    (req_handler)req_get_token_groups,
660 661
    (req_handler)req_get_token_default_dacl,
    (req_handler)req_set_token_default_dacl,
662
    (req_handler)req_set_security_object,
663
    (req_handler)req_get_security_object,
664
    (req_handler)req_get_system_handles,
Mike McCormack's avatar
Mike McCormack committed
665 666
    (req_handler)req_create_mailslot,
    (req_handler)req_set_mailslot_info,
667 668
    (req_handler)req_create_directory,
    (req_handler)req_open_directory,
669
    (req_handler)req_get_directory_entry,
670 671 672
    (req_handler)req_create_symlink,
    (req_handler)req_open_symlink,
    (req_handler)req_query_symlink,
673
    (req_handler)req_get_object_info,
674
    (req_handler)req_get_object_type,
675
    (req_handler)req_unlink_object,
676
    (req_handler)req_get_token_impersonation_level,
677
    (req_handler)req_allocate_locally_unique_id,
678 679 680
    (req_handler)req_create_device_manager,
    (req_handler)req_create_device,
    (req_handler)req_delete_device,
681
    (req_handler)req_get_next_device_request,
682 683
    (req_handler)req_get_kernel_object_ptr,
    (req_handler)req_set_kernel_object_ptr,
684 685
    (req_handler)req_grab_kernel_object,
    (req_handler)req_release_kernel_object,
686
    (req_handler)req_get_kernel_object_handle,
687
    (req_handler)req_make_process_system,
688
    (req_handler)req_get_token_statistics,
689 690 691 692 693
    (req_handler)req_create_completion,
    (req_handler)req_open_completion,
    (req_handler)req_add_completion,
    (req_handler)req_remove_completion,
    (req_handler)req_query_completion,
694
    (req_handler)req_set_completion_info,
695
    (req_handler)req_add_fd_completion,
696
    (req_handler)req_set_fd_completion_mode,
697 698
    (req_handler)req_set_fd_disp_info,
    (req_handler)req_set_fd_name_info,
699 700
    (req_handler)req_get_window_layered_info,
    (req_handler)req_set_window_layered_info,
701 702
    (req_handler)req_alloc_user_handle,
    (req_handler)req_free_user_handle,
703
    (req_handler)req_set_cursor,
704
    (req_handler)req_update_rawinput_devices,
705 706
    (req_handler)req_get_suspend_context,
    (req_handler)req_set_suspend_context,
707
    (req_handler)req_create_job,
708
    (req_handler)req_open_job,
709
    (req_handler)req_assign_job,
710
    (req_handler)req_process_in_job,
711
    (req_handler)req_set_job_limits,
712
    (req_handler)req_set_job_completion_port,
713
    (req_handler)req_terminate_job,
714 715
    (req_handler)req_suspend_process,
    (req_handler)req_resume_process,
Alexandre Julliard's avatar
Alexandre Julliard committed
716
};
717

718
C_ASSERT( sizeof(affinity_t) == 8 );
719 720 721 722 723 724 725
C_ASSERT( sizeof(apc_call_t) == 40 );
C_ASSERT( sizeof(apc_param_t) == 8 );
C_ASSERT( sizeof(apc_result_t) == 40 );
C_ASSERT( sizeof(async_data_t) == 40 );
C_ASSERT( sizeof(atom_t) == 4 );
C_ASSERT( sizeof(char) == 1 );
C_ASSERT( sizeof(char_info_t) == 4 );
726
C_ASSERT( sizeof(client_cpu_t) == 4 );
727 728 729
C_ASSERT( sizeof(client_ptr_t) == 8 );
C_ASSERT( sizeof(data_size_t) == 4 );
C_ASSERT( sizeof(file_pos_t) == 8 );
730
C_ASSERT( sizeof(hw_input_t) == 32 );
731 732
C_ASSERT( sizeof(int) == 4 );
C_ASSERT( sizeof(ioctl_code_t) == 4 );
733
C_ASSERT( sizeof(irp_params_t) == 32 );
734 735 736 737 738 739 740 741 742 743 744 745 746 747
C_ASSERT( sizeof(lparam_t) == 8 );
C_ASSERT( sizeof(luid_t) == 8 );
C_ASSERT( sizeof(mem_size_t) == 8 );
C_ASSERT( sizeof(mod_handle_t) == 8 );
C_ASSERT( sizeof(obj_handle_t) == 4 );
C_ASSERT( sizeof(process_id_t) == 4 );
C_ASSERT( sizeof(rectangle_t) == 16 );
C_ASSERT( sizeof(short int) == 2 );
C_ASSERT( sizeof(thread_id_t) == 4 );
C_ASSERT( sizeof(timeout_t) == 8 );
C_ASSERT( sizeof(unsigned char) == 1 );
C_ASSERT( sizeof(unsigned int) == 4 );
C_ASSERT( sizeof(unsigned short) == 2 );
C_ASSERT( sizeof(user_handle_t) == 4 );
748 749 750 751 752 753 754 755 756
C_ASSERT( FIELD_OFFSET(struct new_process_request, parent_process) == 12 );
C_ASSERT( FIELD_OFFSET(struct new_process_request, inherit_all) == 16 );
C_ASSERT( FIELD_OFFSET(struct new_process_request, create_flags) == 20 );
C_ASSERT( FIELD_OFFSET(struct new_process_request, socket_fd) == 24 );
C_ASSERT( FIELD_OFFSET(struct new_process_request, exe_file) == 28 );
C_ASSERT( FIELD_OFFSET(struct new_process_request, access) == 32 );
C_ASSERT( FIELD_OFFSET(struct new_process_request, cpu) == 36 );
C_ASSERT( FIELD_OFFSET(struct new_process_request, info_size) == 40 );
C_ASSERT( sizeof(struct new_process_request) == 48 );
757 758
C_ASSERT( FIELD_OFFSET(struct new_process_reply, info) == 8 );
C_ASSERT( FIELD_OFFSET(struct new_process_reply, pid) == 12 );
759 760
C_ASSERT( FIELD_OFFSET(struct new_process_reply, handle) == 16 );
C_ASSERT( sizeof(struct new_process_reply) == 24 );
761
C_ASSERT( FIELD_OFFSET(struct exec_process_request, socket_fd) == 12 );
762
C_ASSERT( FIELD_OFFSET(struct exec_process_request, cpu) == 16 );
763
C_ASSERT( sizeof(struct exec_process_request) == 24 );
764
C_ASSERT( FIELD_OFFSET(struct get_new_process_info_request, info) == 12 );
765
C_ASSERT( sizeof(struct get_new_process_info_request) == 16 );
766 767 768
C_ASSERT( FIELD_OFFSET(struct get_new_process_info_reply, success) == 8 );
C_ASSERT( FIELD_OFFSET(struct get_new_process_info_reply, exit_code) == 12 );
C_ASSERT( sizeof(struct get_new_process_info_reply) == 16 );
769 770 771 772 773
C_ASSERT( FIELD_OFFSET(struct new_thread_request, process) == 12 );
C_ASSERT( FIELD_OFFSET(struct new_thread_request, access) == 16 );
C_ASSERT( FIELD_OFFSET(struct new_thread_request, suspend) == 20 );
C_ASSERT( FIELD_OFFSET(struct new_thread_request, request_fd) == 24 );
C_ASSERT( sizeof(struct new_thread_request) == 32 );
774 775 776
C_ASSERT( FIELD_OFFSET(struct new_thread_reply, tid) == 8 );
C_ASSERT( FIELD_OFFSET(struct new_thread_reply, handle) == 12 );
C_ASSERT( sizeof(struct new_thread_reply) == 16 );
777
C_ASSERT( sizeof(struct get_startup_info_request) == 16 );
778
C_ASSERT( FIELD_OFFSET(struct get_startup_info_reply, info_size) == 8 );
779
C_ASSERT( sizeof(struct get_startup_info_reply) == 16 );
780 781 782 783 784
C_ASSERT( FIELD_OFFSET(struct init_process_done_request, gui) == 12 );
C_ASSERT( FIELD_OFFSET(struct init_process_done_request, module) == 16 );
C_ASSERT( FIELD_OFFSET(struct init_process_done_request, ldt_copy) == 24 );
C_ASSERT( FIELD_OFFSET(struct init_process_done_request, entry) == 32 );
C_ASSERT( sizeof(struct init_process_done_request) == 40 );
785 786
C_ASSERT( FIELD_OFFSET(struct init_process_done_reply, suspend) == 8 );
C_ASSERT( sizeof(struct init_process_done_reply) == 16 );
787 788 789 790 791 792 793
C_ASSERT( FIELD_OFFSET(struct init_thread_request, unix_pid) == 12 );
C_ASSERT( FIELD_OFFSET(struct init_thread_request, unix_tid) == 16 );
C_ASSERT( FIELD_OFFSET(struct init_thread_request, debug_level) == 20 );
C_ASSERT( FIELD_OFFSET(struct init_thread_request, teb) == 24 );
C_ASSERT( FIELD_OFFSET(struct init_thread_request, entry) == 32 );
C_ASSERT( FIELD_OFFSET(struct init_thread_request, reply_fd) == 40 );
C_ASSERT( FIELD_OFFSET(struct init_thread_request, wait_fd) == 44 );
794
C_ASSERT( FIELD_OFFSET(struct init_thread_request, cpu) == 48 );
795
C_ASSERT( sizeof(struct init_thread_request) == 56 );
796 797 798 799 800
C_ASSERT( FIELD_OFFSET(struct init_thread_reply, pid) == 8 );
C_ASSERT( FIELD_OFFSET(struct init_thread_reply, tid) == 12 );
C_ASSERT( FIELD_OFFSET(struct init_thread_reply, server_start) == 16 );
C_ASSERT( FIELD_OFFSET(struct init_thread_reply, info_size) == 24 );
C_ASSERT( FIELD_OFFSET(struct init_thread_reply, version) == 28 );
801
C_ASSERT( FIELD_OFFSET(struct init_thread_reply, all_cpus) == 32 );
802
C_ASSERT( FIELD_OFFSET(struct init_thread_reply, suspend) == 36 );
803
C_ASSERT( sizeof(struct init_thread_reply) == 40 );
804 805
C_ASSERT( FIELD_OFFSET(struct terminate_process_request, handle) == 12 );
C_ASSERT( FIELD_OFFSET(struct terminate_process_request, exit_code) == 16 );
806
C_ASSERT( sizeof(struct terminate_process_request) == 24 );
807 808 809 810
C_ASSERT( FIELD_OFFSET(struct terminate_process_reply, self) == 8 );
C_ASSERT( sizeof(struct terminate_process_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct terminate_thread_request, handle) == 12 );
C_ASSERT( FIELD_OFFSET(struct terminate_thread_request, exit_code) == 16 );
811
C_ASSERT( sizeof(struct terminate_thread_request) == 24 );
812 813 814 815
C_ASSERT( FIELD_OFFSET(struct terminate_thread_reply, self) == 8 );
C_ASSERT( FIELD_OFFSET(struct terminate_thread_reply, last) == 12 );
C_ASSERT( sizeof(struct terminate_thread_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct get_process_info_request, handle) == 12 );
816
C_ASSERT( sizeof(struct get_process_info_request) == 16 );
817 818
C_ASSERT( FIELD_OFFSET(struct get_process_info_reply, pid) == 8 );
C_ASSERT( FIELD_OFFSET(struct get_process_info_reply, ppid) == 12 );
819
C_ASSERT( FIELD_OFFSET(struct get_process_info_reply, affinity) == 16 );
820 821 822 823
C_ASSERT( FIELD_OFFSET(struct get_process_info_reply, peb) == 24 );
C_ASSERT( FIELD_OFFSET(struct get_process_info_reply, start_time) == 32 );
C_ASSERT( FIELD_OFFSET(struct get_process_info_reply, end_time) == 40 );
C_ASSERT( FIELD_OFFSET(struct get_process_info_reply, exit_code) == 48 );
824
C_ASSERT( FIELD_OFFSET(struct get_process_info_reply, priority) == 52 );
825
C_ASSERT( FIELD_OFFSET(struct get_process_info_reply, cpu) == 56 );
826
C_ASSERT( FIELD_OFFSET(struct get_process_info_reply, debugger_present) == 60 );
827
C_ASSERT( FIELD_OFFSET(struct get_process_info_reply, debug_children) == 62 );
828
C_ASSERT( sizeof(struct get_process_info_reply) == 64 );
829 830 831 832 833 834 835 836 837
C_ASSERT( FIELD_OFFSET(struct get_process_vm_counters_request, handle) == 12 );
C_ASSERT( sizeof(struct get_process_vm_counters_request) == 16 );
C_ASSERT( FIELD_OFFSET(struct get_process_vm_counters_reply, peak_virtual_size) == 8 );
C_ASSERT( FIELD_OFFSET(struct get_process_vm_counters_reply, virtual_size) == 16 );
C_ASSERT( FIELD_OFFSET(struct get_process_vm_counters_reply, peak_working_set_size) == 24 );
C_ASSERT( FIELD_OFFSET(struct get_process_vm_counters_reply, working_set_size) == 32 );
C_ASSERT( FIELD_OFFSET(struct get_process_vm_counters_reply, pagefile_usage) == 40 );
C_ASSERT( FIELD_OFFSET(struct get_process_vm_counters_reply, peak_pagefile_usage) == 48 );
C_ASSERT( sizeof(struct get_process_vm_counters_reply) == 56 );
838 839 840 841 842 843 844
C_ASSERT( FIELD_OFFSET(struct set_process_info_request, handle) == 12 );
C_ASSERT( FIELD_OFFSET(struct set_process_info_request, mask) == 16 );
C_ASSERT( FIELD_OFFSET(struct set_process_info_request, priority) == 20 );
C_ASSERT( FIELD_OFFSET(struct set_process_info_request, affinity) == 24 );
C_ASSERT( sizeof(struct set_process_info_request) == 32 );
C_ASSERT( FIELD_OFFSET(struct get_thread_info_request, handle) == 12 );
C_ASSERT( FIELD_OFFSET(struct get_thread_info_request, tid_in) == 16 );
845
C_ASSERT( sizeof(struct get_thread_info_request) == 24 );
846 847 848
C_ASSERT( FIELD_OFFSET(struct get_thread_info_reply, pid) == 8 );
C_ASSERT( FIELD_OFFSET(struct get_thread_info_reply, tid) == 12 );
C_ASSERT( FIELD_OFFSET(struct get_thread_info_reply, teb) == 16 );
849 850 851 852 853
C_ASSERT( FIELD_OFFSET(struct get_thread_info_reply, entry_point) == 24 );
C_ASSERT( FIELD_OFFSET(struct get_thread_info_reply, affinity) == 32 );
C_ASSERT( FIELD_OFFSET(struct get_thread_info_reply, exit_code) == 40 );
C_ASSERT( FIELD_OFFSET(struct get_thread_info_reply, priority) == 44 );
C_ASSERT( FIELD_OFFSET(struct get_thread_info_reply, last) == 48 );
854 855 856
C_ASSERT( FIELD_OFFSET(struct get_thread_info_reply, suspend_count) == 52 );
C_ASSERT( FIELD_OFFSET(struct get_thread_info_reply, desc_len) == 56 );
C_ASSERT( sizeof(struct get_thread_info_reply) == 64 );
857 858 859 860 861
C_ASSERT( FIELD_OFFSET(struct get_thread_times_request, handle) == 12 );
C_ASSERT( sizeof(struct get_thread_times_request) == 16 );
C_ASSERT( FIELD_OFFSET(struct get_thread_times_reply, creation_time) == 8 );
C_ASSERT( FIELD_OFFSET(struct get_thread_times_reply, exit_time) == 16 );
C_ASSERT( sizeof(struct get_thread_times_reply) == 24 );
862 863 864 865
C_ASSERT( FIELD_OFFSET(struct set_thread_info_request, handle) == 12 );
C_ASSERT( FIELD_OFFSET(struct set_thread_info_request, mask) == 16 );
C_ASSERT( FIELD_OFFSET(struct set_thread_info_request, priority) == 20 );
C_ASSERT( FIELD_OFFSET(struct set_thread_info_request, affinity) == 24 );
866 867 868
C_ASSERT( FIELD_OFFSET(struct set_thread_info_request, entry_point) == 32 );
C_ASSERT( FIELD_OFFSET(struct set_thread_info_request, token) == 40 );
C_ASSERT( sizeof(struct set_thread_info_request) == 48 );
869 870
C_ASSERT( FIELD_OFFSET(struct get_dll_info_request, handle) == 12 );
C_ASSERT( FIELD_OFFSET(struct get_dll_info_request, base_address) == 16 );
871
C_ASSERT( sizeof(struct get_dll_info_request) == 24 );
872
C_ASSERT( FIELD_OFFSET(struct get_dll_info_reply, entry_point) == 8 );
873
C_ASSERT( FIELD_OFFSET(struct get_dll_info_reply, filename_len) == 16 );
874 875
C_ASSERT( sizeof(struct get_dll_info_reply) == 24 );
C_ASSERT( FIELD_OFFSET(struct suspend_thread_request, handle) == 12 );
876
C_ASSERT( sizeof(struct suspend_thread_request) == 16 );
877 878 879
C_ASSERT( FIELD_OFFSET(struct suspend_thread_reply, count) == 8 );
C_ASSERT( sizeof(struct suspend_thread_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct resume_thread_request, handle) == 12 );
880
C_ASSERT( sizeof(struct resume_thread_request) == 16 );
881 882
C_ASSERT( FIELD_OFFSET(struct resume_thread_reply, count) == 8 );
C_ASSERT( sizeof(struct resume_thread_reply) == 16 );
883
C_ASSERT( FIELD_OFFSET(struct load_dll_request, dbg_offset) == 12 );
884 885
C_ASSERT( FIELD_OFFSET(struct load_dll_request, base) == 16 );
C_ASSERT( FIELD_OFFSET(struct load_dll_request, name) == 24 );
886 887
C_ASSERT( FIELD_OFFSET(struct load_dll_request, dbg_size) == 32 );
C_ASSERT( sizeof(struct load_dll_request) == 40 );
888 889 890 891
C_ASSERT( FIELD_OFFSET(struct unload_dll_request, base) == 16 );
C_ASSERT( sizeof(struct unload_dll_request) == 24 );
C_ASSERT( FIELD_OFFSET(struct queue_apc_request, handle) == 12 );
C_ASSERT( FIELD_OFFSET(struct queue_apc_request, call) == 16 );
892
C_ASSERT( sizeof(struct queue_apc_request) == 56 );
893 894 895 896
C_ASSERT( FIELD_OFFSET(struct queue_apc_reply, handle) == 8 );
C_ASSERT( FIELD_OFFSET(struct queue_apc_reply, self) == 12 );
C_ASSERT( sizeof(struct queue_apc_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct get_apc_result_request, handle) == 12 );
897
C_ASSERT( sizeof(struct get_apc_result_request) == 16 );
898 899 900 901 902 903 904
C_ASSERT( FIELD_OFFSET(struct get_apc_result_reply, result) == 8 );
C_ASSERT( sizeof(struct get_apc_result_reply) == 48 );
C_ASSERT( FIELD_OFFSET(struct close_handle_request, handle) == 12 );
C_ASSERT( sizeof(struct close_handle_request) == 16 );
C_ASSERT( FIELD_OFFSET(struct set_handle_info_request, handle) == 12 );
C_ASSERT( FIELD_OFFSET(struct set_handle_info_request, flags) == 16 );
C_ASSERT( FIELD_OFFSET(struct set_handle_info_request, mask) == 20 );
905
C_ASSERT( sizeof(struct set_handle_info_request) == 24 );
906 907 908 909 910 911 912 913
C_ASSERT( FIELD_OFFSET(struct set_handle_info_reply, old_flags) == 8 );
C_ASSERT( sizeof(struct set_handle_info_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct dup_handle_request, src_process) == 12 );
C_ASSERT( FIELD_OFFSET(struct dup_handle_request, src_handle) == 16 );
C_ASSERT( FIELD_OFFSET(struct dup_handle_request, dst_process) == 20 );
C_ASSERT( FIELD_OFFSET(struct dup_handle_request, access) == 24 );
C_ASSERT( FIELD_OFFSET(struct dup_handle_request, attributes) == 28 );
C_ASSERT( FIELD_OFFSET(struct dup_handle_request, options) == 32 );
914
C_ASSERT( sizeof(struct dup_handle_request) == 40 );
915 916 917 918 919 920 921
C_ASSERT( FIELD_OFFSET(struct dup_handle_reply, handle) == 8 );
C_ASSERT( FIELD_OFFSET(struct dup_handle_reply, self) == 12 );
C_ASSERT( FIELD_OFFSET(struct dup_handle_reply, closed) == 16 );
C_ASSERT( sizeof(struct dup_handle_reply) == 24 );
C_ASSERT( FIELD_OFFSET(struct open_process_request, pid) == 12 );
C_ASSERT( FIELD_OFFSET(struct open_process_request, access) == 16 );
C_ASSERT( FIELD_OFFSET(struct open_process_request, attributes) == 20 );
922
C_ASSERT( sizeof(struct open_process_request) == 24 );
923 924 925 926 927
C_ASSERT( FIELD_OFFSET(struct open_process_reply, handle) == 8 );
C_ASSERT( sizeof(struct open_process_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct open_thread_request, tid) == 12 );
C_ASSERT( FIELD_OFFSET(struct open_thread_request, access) == 16 );
C_ASSERT( FIELD_OFFSET(struct open_thread_request, attributes) == 20 );
928
C_ASSERT( sizeof(struct open_thread_request) == 24 );
929 930 931 932
C_ASSERT( FIELD_OFFSET(struct open_thread_reply, handle) == 8 );
C_ASSERT( sizeof(struct open_thread_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct select_request, flags) == 12 );
C_ASSERT( FIELD_OFFSET(struct select_request, cookie) == 16 );
933 934
C_ASSERT( FIELD_OFFSET(struct select_request, timeout) == 24 );
C_ASSERT( FIELD_OFFSET(struct select_request, prev_apc) == 32 );
935
C_ASSERT( sizeof(struct select_request) == 40 );
936 937 938 939 940
C_ASSERT( FIELD_OFFSET(struct select_reply, timeout) == 8 );
C_ASSERT( FIELD_OFFSET(struct select_reply, call) == 16 );
C_ASSERT( FIELD_OFFSET(struct select_reply, apc_handle) == 56 );
C_ASSERT( sizeof(struct select_reply) == 64 );
C_ASSERT( FIELD_OFFSET(struct create_event_request, access) == 12 );
941 942 943
C_ASSERT( FIELD_OFFSET(struct create_event_request, manual_reset) == 16 );
C_ASSERT( FIELD_OFFSET(struct create_event_request, initial_state) == 20 );
C_ASSERT( sizeof(struct create_event_request) == 24 );
944 945 946 947 948
C_ASSERT( FIELD_OFFSET(struct create_event_reply, handle) == 8 );
C_ASSERT( sizeof(struct create_event_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct event_op_request, handle) == 12 );
C_ASSERT( FIELD_OFFSET(struct event_op_request, op) == 16 );
C_ASSERT( sizeof(struct event_op_request) == 24 );
949 950
C_ASSERT( FIELD_OFFSET(struct event_op_reply, state) == 8 );
C_ASSERT( sizeof(struct event_op_reply) == 16 );
951 952 953 954 955
C_ASSERT( FIELD_OFFSET(struct query_event_request, handle) == 12 );
C_ASSERT( sizeof(struct query_event_request) == 16 );
C_ASSERT( FIELD_OFFSET(struct query_event_reply, manual_reset) == 8 );
C_ASSERT( FIELD_OFFSET(struct query_event_reply, state) == 12 );
C_ASSERT( sizeof(struct query_event_reply) == 16 );
956 957 958
C_ASSERT( FIELD_OFFSET(struct open_event_request, access) == 12 );
C_ASSERT( FIELD_OFFSET(struct open_event_request, attributes) == 16 );
C_ASSERT( FIELD_OFFSET(struct open_event_request, rootdir) == 20 );
959
C_ASSERT( sizeof(struct open_event_request) == 24 );
960 961
C_ASSERT( FIELD_OFFSET(struct open_event_reply, handle) == 8 );
C_ASSERT( sizeof(struct open_event_reply) == 16 );
962
C_ASSERT( FIELD_OFFSET(struct create_keyed_event_request, access) == 12 );
963
C_ASSERT( sizeof(struct create_keyed_event_request) == 16 );
964 965 966 967 968 969 970 971
C_ASSERT( FIELD_OFFSET(struct create_keyed_event_reply, handle) == 8 );
C_ASSERT( sizeof(struct create_keyed_event_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct open_keyed_event_request, access) == 12 );
C_ASSERT( FIELD_OFFSET(struct open_keyed_event_request, attributes) == 16 );
C_ASSERT( FIELD_OFFSET(struct open_keyed_event_request, rootdir) == 20 );
C_ASSERT( sizeof(struct open_keyed_event_request) == 24 );
C_ASSERT( FIELD_OFFSET(struct open_keyed_event_reply, handle) == 8 );
C_ASSERT( sizeof(struct open_keyed_event_reply) == 16 );
972
C_ASSERT( FIELD_OFFSET(struct create_mutex_request, access) == 12 );
973
C_ASSERT( FIELD_OFFSET(struct create_mutex_request, owned) == 16 );
974
C_ASSERT( sizeof(struct create_mutex_request) == 24 );
975 976 977
C_ASSERT( FIELD_OFFSET(struct create_mutex_reply, handle) == 8 );
C_ASSERT( sizeof(struct create_mutex_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct release_mutex_request, handle) == 12 );
978
C_ASSERT( sizeof(struct release_mutex_request) == 16 );
979 980 981 982 983
C_ASSERT( FIELD_OFFSET(struct release_mutex_reply, prev_count) == 8 );
C_ASSERT( sizeof(struct release_mutex_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct open_mutex_request, access) == 12 );
C_ASSERT( FIELD_OFFSET(struct open_mutex_request, attributes) == 16 );
C_ASSERT( FIELD_OFFSET(struct open_mutex_request, rootdir) == 20 );
984
C_ASSERT( sizeof(struct open_mutex_request) == 24 );
985 986
C_ASSERT( FIELD_OFFSET(struct open_mutex_reply, handle) == 8 );
C_ASSERT( sizeof(struct open_mutex_reply) == 16 );
987 988 989 990 991 992
C_ASSERT( FIELD_OFFSET(struct query_mutex_request, handle) == 12 );
C_ASSERT( sizeof(struct query_mutex_request) == 16 );
C_ASSERT( FIELD_OFFSET(struct query_mutex_reply, count) == 8 );
C_ASSERT( FIELD_OFFSET(struct query_mutex_reply, owned) == 12 );
C_ASSERT( FIELD_OFFSET(struct query_mutex_reply, abandoned) == 16 );
C_ASSERT( sizeof(struct query_mutex_reply) == 24 );
993
C_ASSERT( FIELD_OFFSET(struct create_semaphore_request, access) == 12 );
994 995 996
C_ASSERT( FIELD_OFFSET(struct create_semaphore_request, initial) == 16 );
C_ASSERT( FIELD_OFFSET(struct create_semaphore_request, max) == 20 );
C_ASSERT( sizeof(struct create_semaphore_request) == 24 );
997 998 999 1000
C_ASSERT( FIELD_OFFSET(struct create_semaphore_reply, handle) == 8 );
C_ASSERT( sizeof(struct create_semaphore_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct release_semaphore_request, handle) == 12 );
C_ASSERT( FIELD_OFFSET(struct release_semaphore_request, count) == 16 );
1001
C_ASSERT( sizeof(struct release_semaphore_request) == 24 );
1002 1003
C_ASSERT( FIELD_OFFSET(struct release_semaphore_reply, prev_count) == 8 );
C_ASSERT( sizeof(struct release_semaphore_reply) == 16 );
1004 1005 1006 1007 1008
C_ASSERT( FIELD_OFFSET(struct query_semaphore_request, handle) == 12 );
C_ASSERT( sizeof(struct query_semaphore_request) == 16 );
C_ASSERT( FIELD_OFFSET(struct query_semaphore_reply, current) == 8 );
C_ASSERT( FIELD_OFFSET(struct query_semaphore_reply, max) == 12 );
C_ASSERT( sizeof(struct query_semaphore_reply) == 16 );
1009 1010 1011
C_ASSERT( FIELD_OFFSET(struct open_semaphore_request, access) == 12 );
C_ASSERT( FIELD_OFFSET(struct open_semaphore_request, attributes) == 16 );
C_ASSERT( FIELD_OFFSET(struct open_semaphore_request, rootdir) == 20 );
1012
C_ASSERT( sizeof(struct open_semaphore_request) == 24 );
1013 1014 1015
C_ASSERT( FIELD_OFFSET(struct open_semaphore_reply, handle) == 8 );
C_ASSERT( sizeof(struct open_semaphore_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct create_file_request, access) == 12 );
1016 1017 1018 1019 1020
C_ASSERT( FIELD_OFFSET(struct create_file_request, sharing) == 16 );
C_ASSERT( FIELD_OFFSET(struct create_file_request, create) == 20 );
C_ASSERT( FIELD_OFFSET(struct create_file_request, options) == 24 );
C_ASSERT( FIELD_OFFSET(struct create_file_request, attrs) == 28 );
C_ASSERT( sizeof(struct create_file_request) == 32 );
1021 1022 1023 1024 1025 1026 1027
C_ASSERT( FIELD_OFFSET(struct create_file_reply, handle) == 8 );
C_ASSERT( sizeof(struct create_file_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct open_file_object_request, access) == 12 );
C_ASSERT( FIELD_OFFSET(struct open_file_object_request, attributes) == 16 );
C_ASSERT( FIELD_OFFSET(struct open_file_object_request, rootdir) == 20 );
C_ASSERT( FIELD_OFFSET(struct open_file_object_request, sharing) == 24 );
C_ASSERT( FIELD_OFFSET(struct open_file_object_request, options) == 28 );
1028
C_ASSERT( sizeof(struct open_file_object_request) == 32 );
1029 1030 1031 1032 1033
C_ASSERT( FIELD_OFFSET(struct open_file_object_reply, handle) == 8 );
C_ASSERT( sizeof(struct open_file_object_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct alloc_file_handle_request, access) == 12 );
C_ASSERT( FIELD_OFFSET(struct alloc_file_handle_request, attributes) == 16 );
C_ASSERT( FIELD_OFFSET(struct alloc_file_handle_request, fd) == 20 );
1034
C_ASSERT( sizeof(struct alloc_file_handle_request) == 24 );
1035 1036
C_ASSERT( FIELD_OFFSET(struct alloc_file_handle_reply, handle) == 8 );
C_ASSERT( sizeof(struct alloc_file_handle_reply) == 16 );
1037
C_ASSERT( FIELD_OFFSET(struct get_handle_unix_name_request, handle) == 12 );
1038
C_ASSERT( sizeof(struct get_handle_unix_name_request) == 16 );
1039 1040
C_ASSERT( FIELD_OFFSET(struct get_handle_unix_name_reply, name_len) == 8 );
C_ASSERT( sizeof(struct get_handle_unix_name_reply) == 16 );
1041
C_ASSERT( FIELD_OFFSET(struct get_handle_fd_request, handle) == 12 );
1042
C_ASSERT( sizeof(struct get_handle_fd_request) == 16 );
1043
C_ASSERT( FIELD_OFFSET(struct get_handle_fd_reply, type) == 8 );
1044
C_ASSERT( FIELD_OFFSET(struct get_handle_fd_reply, cacheable) == 12 );
1045 1046 1047
C_ASSERT( FIELD_OFFSET(struct get_handle_fd_reply, access) == 16 );
C_ASSERT( FIELD_OFFSET(struct get_handle_fd_reply, options) == 20 );
C_ASSERT( sizeof(struct get_handle_fd_reply) == 24 );
1048 1049 1050 1051
C_ASSERT( FIELD_OFFSET(struct get_directory_cache_entry_request, handle) == 12 );
C_ASSERT( sizeof(struct get_directory_cache_entry_request) == 16 );
C_ASSERT( FIELD_OFFSET(struct get_directory_cache_entry_reply, entry) == 8 );
C_ASSERT( sizeof(struct get_directory_cache_entry_reply) == 16 );
1052 1053 1054 1055
C_ASSERT( FIELD_OFFSET(struct flush_request, async) == 16 );
C_ASSERT( sizeof(struct flush_request) == 56 );
C_ASSERT( FIELD_OFFSET(struct flush_reply, event) == 8 );
C_ASSERT( sizeof(struct flush_reply) == 16 );
1056 1057 1058 1059
C_ASSERT( FIELD_OFFSET(struct get_file_info_request, handle) == 12 );
C_ASSERT( FIELD_OFFSET(struct get_file_info_request, info_class) == 16 );
C_ASSERT( sizeof(struct get_file_info_request) == 24 );
C_ASSERT( sizeof(struct get_file_info_reply) == 8 );
1060 1061 1062 1063
C_ASSERT( FIELD_OFFSET(struct get_volume_info_request, handle) == 12 );
C_ASSERT( FIELD_OFFSET(struct get_volume_info_request, info_class) == 16 );
C_ASSERT( sizeof(struct get_volume_info_request) == 24 );
C_ASSERT( sizeof(struct get_volume_info_reply) == 8 );
1064 1065 1066 1067 1068
C_ASSERT( FIELD_OFFSET(struct lock_file_request, handle) == 12 );
C_ASSERT( FIELD_OFFSET(struct lock_file_request, offset) == 16 );
C_ASSERT( FIELD_OFFSET(struct lock_file_request, count) == 24 );
C_ASSERT( FIELD_OFFSET(struct lock_file_request, shared) == 32 );
C_ASSERT( FIELD_OFFSET(struct lock_file_request, wait) == 36 );
1069
C_ASSERT( sizeof(struct lock_file_request) == 40 );
1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082
C_ASSERT( FIELD_OFFSET(struct lock_file_reply, handle) == 8 );
C_ASSERT( FIELD_OFFSET(struct lock_file_reply, overlapped) == 12 );
C_ASSERT( sizeof(struct lock_file_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct unlock_file_request, handle) == 12 );
C_ASSERT( FIELD_OFFSET(struct unlock_file_request, offset) == 16 );
C_ASSERT( FIELD_OFFSET(struct unlock_file_request, count) == 24 );
C_ASSERT( sizeof(struct unlock_file_request) == 32 );
C_ASSERT( FIELD_OFFSET(struct create_socket_request, access) == 12 );
C_ASSERT( FIELD_OFFSET(struct create_socket_request, attributes) == 16 );
C_ASSERT( FIELD_OFFSET(struct create_socket_request, family) == 20 );
C_ASSERT( FIELD_OFFSET(struct create_socket_request, type) == 24 );
C_ASSERT( FIELD_OFFSET(struct create_socket_request, protocol) == 28 );
C_ASSERT( FIELD_OFFSET(struct create_socket_request, flags) == 32 );
1083
C_ASSERT( sizeof(struct create_socket_request) == 40 );
1084 1085 1086 1087 1088
C_ASSERT( FIELD_OFFSET(struct create_socket_reply, handle) == 8 );
C_ASSERT( sizeof(struct create_socket_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct accept_socket_request, lhandle) == 12 );
C_ASSERT( FIELD_OFFSET(struct accept_socket_request, access) == 16 );
C_ASSERT( FIELD_OFFSET(struct accept_socket_request, attributes) == 20 );
1089
C_ASSERT( sizeof(struct accept_socket_request) == 24 );
1090 1091
C_ASSERT( FIELD_OFFSET(struct accept_socket_reply, handle) == 8 );
C_ASSERT( sizeof(struct accept_socket_reply) == 16 );
1092 1093 1094
C_ASSERT( FIELD_OFFSET(struct accept_into_socket_request, lhandle) == 12 );
C_ASSERT( FIELD_OFFSET(struct accept_into_socket_request, ahandle) == 16 );
C_ASSERT( sizeof(struct accept_into_socket_request) == 24 );
1095 1096 1097 1098 1099 1100 1101 1102 1103
C_ASSERT( FIELD_OFFSET(struct set_socket_event_request, handle) == 12 );
C_ASSERT( FIELD_OFFSET(struct set_socket_event_request, mask) == 16 );
C_ASSERT( FIELD_OFFSET(struct set_socket_event_request, event) == 20 );
C_ASSERT( FIELD_OFFSET(struct set_socket_event_request, window) == 24 );
C_ASSERT( FIELD_OFFSET(struct set_socket_event_request, msg) == 28 );
C_ASSERT( sizeof(struct set_socket_event_request) == 32 );
C_ASSERT( FIELD_OFFSET(struct get_socket_event_request, handle) == 12 );
C_ASSERT( FIELD_OFFSET(struct get_socket_event_request, service) == 16 );
C_ASSERT( FIELD_OFFSET(struct get_socket_event_request, c_event) == 20 );
1104
C_ASSERT( sizeof(struct get_socket_event_request) == 24 );
1105 1106 1107 1108
C_ASSERT( FIELD_OFFSET(struct get_socket_event_reply, mask) == 8 );
C_ASSERT( FIELD_OFFSET(struct get_socket_event_reply, pmask) == 12 );
C_ASSERT( FIELD_OFFSET(struct get_socket_event_reply, state) == 16 );
C_ASSERT( sizeof(struct get_socket_event_reply) == 24 );
1109 1110 1111 1112 1113 1114
C_ASSERT( FIELD_OFFSET(struct get_socket_info_request, handle) == 12 );
C_ASSERT( sizeof(struct get_socket_info_request) == 16 );
C_ASSERT( FIELD_OFFSET(struct get_socket_info_reply, family) == 8 );
C_ASSERT( FIELD_OFFSET(struct get_socket_info_reply, type) == 12 );
C_ASSERT( FIELD_OFFSET(struct get_socket_info_reply, protocol) == 16 );
C_ASSERT( sizeof(struct get_socket_info_reply) == 24 );
1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125
C_ASSERT( FIELD_OFFSET(struct enable_socket_event_request, handle) == 12 );
C_ASSERT( FIELD_OFFSET(struct enable_socket_event_request, mask) == 16 );
C_ASSERT( FIELD_OFFSET(struct enable_socket_event_request, sstate) == 20 );
C_ASSERT( FIELD_OFFSET(struct enable_socket_event_request, cstate) == 24 );
C_ASSERT( sizeof(struct enable_socket_event_request) == 32 );
C_ASSERT( FIELD_OFFSET(struct set_socket_deferred_request, handle) == 12 );
C_ASSERT( FIELD_OFFSET(struct set_socket_deferred_request, deferred) == 16 );
C_ASSERT( sizeof(struct set_socket_deferred_request) == 24 );
C_ASSERT( FIELD_OFFSET(struct alloc_console_request, access) == 12 );
C_ASSERT( FIELD_OFFSET(struct alloc_console_request, attributes) == 16 );
C_ASSERT( FIELD_OFFSET(struct alloc_console_request, pid) == 20 );
1126 1127
C_ASSERT( FIELD_OFFSET(struct alloc_console_request, input_fd) == 24 );
C_ASSERT( sizeof(struct alloc_console_request) == 32 );
1128 1129 1130 1131 1132
C_ASSERT( FIELD_OFFSET(struct alloc_console_reply, handle_in) == 8 );
C_ASSERT( FIELD_OFFSET(struct alloc_console_reply, event) == 12 );
C_ASSERT( sizeof(struct alloc_console_reply) == 16 );
C_ASSERT( sizeof(struct free_console_request) == 16 );
C_ASSERT( FIELD_OFFSET(struct get_console_renderer_events_request, handle) == 12 );
1133
C_ASSERT( sizeof(struct get_console_renderer_events_request) == 16 );
1134 1135 1136 1137 1138
C_ASSERT( sizeof(struct get_console_renderer_events_reply) == 8 );
C_ASSERT( FIELD_OFFSET(struct open_console_request, from) == 12 );
C_ASSERT( FIELD_OFFSET(struct open_console_request, access) == 16 );
C_ASSERT( FIELD_OFFSET(struct open_console_request, attributes) == 20 );
C_ASSERT( FIELD_OFFSET(struct open_console_request, share) == 24 );
1139
C_ASSERT( sizeof(struct open_console_request) == 32 );
1140 1141
C_ASSERT( FIELD_OFFSET(struct open_console_reply, handle) == 8 );
C_ASSERT( sizeof(struct open_console_reply) == 16 );
1142 1143 1144 1145 1146 1147
C_ASSERT( FIELD_OFFSET(struct attach_console_request, pid) == 12 );
C_ASSERT( sizeof(struct attach_console_request) == 16 );
C_ASSERT( FIELD_OFFSET(struct attach_console_reply, std_in) == 8 );
C_ASSERT( FIELD_OFFSET(struct attach_console_reply, std_out) == 12 );
C_ASSERT( FIELD_OFFSET(struct attach_console_reply, std_err) == 16 );
C_ASSERT( sizeof(struct attach_console_reply) == 24 );
1148
C_ASSERT( FIELD_OFFSET(struct get_console_wait_event_request, handle) == 12 );
1149
C_ASSERT( sizeof(struct get_console_wait_event_request) == 16 );
1150
C_ASSERT( FIELD_OFFSET(struct get_console_wait_event_reply, event) == 8 );
1151 1152
C_ASSERT( sizeof(struct get_console_wait_event_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct get_console_mode_request, handle) == 12 );
1153
C_ASSERT( sizeof(struct get_console_mode_request) == 16 );
1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169
C_ASSERT( FIELD_OFFSET(struct get_console_mode_reply, mode) == 8 );
C_ASSERT( sizeof(struct get_console_mode_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct set_console_mode_request, handle) == 12 );
C_ASSERT( FIELD_OFFSET(struct set_console_mode_request, mode) == 16 );
C_ASSERT( sizeof(struct set_console_mode_request) == 24 );
C_ASSERT( FIELD_OFFSET(struct set_console_input_info_request, handle) == 12 );
C_ASSERT( FIELD_OFFSET(struct set_console_input_info_request, mask) == 16 );
C_ASSERT( FIELD_OFFSET(struct set_console_input_info_request, active_sb) == 20 );
C_ASSERT( FIELD_OFFSET(struct set_console_input_info_request, history_mode) == 24 );
C_ASSERT( FIELD_OFFSET(struct set_console_input_info_request, history_size) == 28 );
C_ASSERT( FIELD_OFFSET(struct set_console_input_info_request, edition_mode) == 32 );
C_ASSERT( FIELD_OFFSET(struct set_console_input_info_request, input_cp) == 36 );
C_ASSERT( FIELD_OFFSET(struct set_console_input_info_request, output_cp) == 40 );
C_ASSERT( FIELD_OFFSET(struct set_console_input_info_request, win) == 44 );
C_ASSERT( sizeof(struct set_console_input_info_request) == 48 );
C_ASSERT( FIELD_OFFSET(struct get_console_input_info_request, handle) == 12 );
1170
C_ASSERT( sizeof(struct get_console_input_info_request) == 16 );
1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182
C_ASSERT( FIELD_OFFSET(struct get_console_input_info_reply, history_mode) == 8 );
C_ASSERT( FIELD_OFFSET(struct get_console_input_info_reply, history_size) == 12 );
C_ASSERT( FIELD_OFFSET(struct get_console_input_info_reply, history_index) == 16 );
C_ASSERT( FIELD_OFFSET(struct get_console_input_info_reply, edition_mode) == 20 );
C_ASSERT( FIELD_OFFSET(struct get_console_input_info_reply, input_cp) == 24 );
C_ASSERT( FIELD_OFFSET(struct get_console_input_info_reply, output_cp) == 28 );
C_ASSERT( FIELD_OFFSET(struct get_console_input_info_reply, win) == 32 );
C_ASSERT( sizeof(struct get_console_input_info_reply) == 40 );
C_ASSERT( FIELD_OFFSET(struct append_console_input_history_request, handle) == 12 );
C_ASSERT( sizeof(struct append_console_input_history_request) == 16 );
C_ASSERT( FIELD_OFFSET(struct get_console_input_history_request, handle) == 12 );
C_ASSERT( FIELD_OFFSET(struct get_console_input_history_request, index) == 16 );
1183
C_ASSERT( sizeof(struct get_console_input_history_request) == 24 );
1184 1185 1186 1187 1188 1189
C_ASSERT( FIELD_OFFSET(struct get_console_input_history_reply, total) == 8 );
C_ASSERT( sizeof(struct get_console_input_history_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct create_console_output_request, handle_in) == 12 );
C_ASSERT( FIELD_OFFSET(struct create_console_output_request, access) == 16 );
C_ASSERT( FIELD_OFFSET(struct create_console_output_request, attributes) == 20 );
C_ASSERT( FIELD_OFFSET(struct create_console_output_request, share) == 24 );
1190
C_ASSERT( FIELD_OFFSET(struct create_console_output_request, fd) == 28 );
1191
C_ASSERT( sizeof(struct create_console_output_request) == 32 );
1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202
C_ASSERT( FIELD_OFFSET(struct create_console_output_reply, handle_out) == 8 );
C_ASSERT( sizeof(struct create_console_output_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct set_console_output_info_request, handle) == 12 );
C_ASSERT( FIELD_OFFSET(struct set_console_output_info_request, mask) == 16 );
C_ASSERT( FIELD_OFFSET(struct set_console_output_info_request, cursor_size) == 20 );
C_ASSERT( FIELD_OFFSET(struct set_console_output_info_request, cursor_visible) == 22 );
C_ASSERT( FIELD_OFFSET(struct set_console_output_info_request, cursor_x) == 24 );
C_ASSERT( FIELD_OFFSET(struct set_console_output_info_request, cursor_y) == 26 );
C_ASSERT( FIELD_OFFSET(struct set_console_output_info_request, width) == 28 );
C_ASSERT( FIELD_OFFSET(struct set_console_output_info_request, height) == 30 );
C_ASSERT( FIELD_OFFSET(struct set_console_output_info_request, attr) == 32 );
1203 1204 1205 1206 1207 1208 1209 1210 1211
C_ASSERT( FIELD_OFFSET(struct set_console_output_info_request, popup_attr) == 34 );
C_ASSERT( FIELD_OFFSET(struct set_console_output_info_request, win_left) == 36 );
C_ASSERT( FIELD_OFFSET(struct set_console_output_info_request, win_top) == 38 );
C_ASSERT( FIELD_OFFSET(struct set_console_output_info_request, win_right) == 40 );
C_ASSERT( FIELD_OFFSET(struct set_console_output_info_request, win_bottom) == 42 );
C_ASSERT( FIELD_OFFSET(struct set_console_output_info_request, max_width) == 44 );
C_ASSERT( FIELD_OFFSET(struct set_console_output_info_request, max_height) == 46 );
C_ASSERT( FIELD_OFFSET(struct set_console_output_info_request, font_width) == 48 );
C_ASSERT( FIELD_OFFSET(struct set_console_output_info_request, font_height) == 50 );
1212 1213
C_ASSERT( FIELD_OFFSET(struct set_console_output_info_request, font_weight) == 52 );
C_ASSERT( FIELD_OFFSET(struct set_console_output_info_request, font_pitch_family) == 54 );
1214
C_ASSERT( sizeof(struct set_console_output_info_request) == 56 );
1215
C_ASSERT( FIELD_OFFSET(struct get_console_output_info_request, handle) == 12 );
1216
C_ASSERT( sizeof(struct get_console_output_info_request) == 16 );
1217 1218 1219 1220 1221 1222 1223
C_ASSERT( FIELD_OFFSET(struct get_console_output_info_reply, cursor_size) == 8 );
C_ASSERT( FIELD_OFFSET(struct get_console_output_info_reply, cursor_visible) == 10 );
C_ASSERT( FIELD_OFFSET(struct get_console_output_info_reply, cursor_x) == 12 );
C_ASSERT( FIELD_OFFSET(struct get_console_output_info_reply, cursor_y) == 14 );
C_ASSERT( FIELD_OFFSET(struct get_console_output_info_reply, width) == 16 );
C_ASSERT( FIELD_OFFSET(struct get_console_output_info_reply, height) == 18 );
C_ASSERT( FIELD_OFFSET(struct get_console_output_info_reply, attr) == 20 );
1224 1225 1226 1227 1228 1229 1230 1231 1232
C_ASSERT( FIELD_OFFSET(struct get_console_output_info_reply, popup_attr) == 22 );
C_ASSERT( FIELD_OFFSET(struct get_console_output_info_reply, win_left) == 24 );
C_ASSERT( FIELD_OFFSET(struct get_console_output_info_reply, win_top) == 26 );
C_ASSERT( FIELD_OFFSET(struct get_console_output_info_reply, win_right) == 28 );
C_ASSERT( FIELD_OFFSET(struct get_console_output_info_reply, win_bottom) == 30 );
C_ASSERT( FIELD_OFFSET(struct get_console_output_info_reply, max_width) == 32 );
C_ASSERT( FIELD_OFFSET(struct get_console_output_info_reply, max_height) == 34 );
C_ASSERT( FIELD_OFFSET(struct get_console_output_info_reply, font_width) == 36 );
C_ASSERT( FIELD_OFFSET(struct get_console_output_info_reply, font_height) == 38 );
1233 1234 1235
C_ASSERT( FIELD_OFFSET(struct get_console_output_info_reply, font_weight) == 40 );
C_ASSERT( FIELD_OFFSET(struct get_console_output_info_reply, font_pitch_family) == 42 );
C_ASSERT( sizeof(struct get_console_output_info_reply) == 48 );
1236
C_ASSERT( FIELD_OFFSET(struct write_console_input_request, handle) == 12 );
1237
C_ASSERT( sizeof(struct write_console_input_request) == 16 );
1238 1239 1240 1241
C_ASSERT( FIELD_OFFSET(struct write_console_input_reply, written) == 8 );
C_ASSERT( sizeof(struct write_console_input_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct read_console_input_request, handle) == 12 );
C_ASSERT( FIELD_OFFSET(struct read_console_input_request, flush) == 16 );
1242
C_ASSERT( sizeof(struct read_console_input_request) == 24 );
1243 1244 1245 1246 1247 1248 1249
C_ASSERT( FIELD_OFFSET(struct read_console_input_reply, read) == 8 );
C_ASSERT( sizeof(struct read_console_input_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct write_console_output_request, handle) == 12 );
C_ASSERT( FIELD_OFFSET(struct write_console_output_request, x) == 16 );
C_ASSERT( FIELD_OFFSET(struct write_console_output_request, y) == 20 );
C_ASSERT( FIELD_OFFSET(struct write_console_output_request, mode) == 24 );
C_ASSERT( FIELD_OFFSET(struct write_console_output_request, wrap) == 28 );
1250
C_ASSERT( sizeof(struct write_console_output_request) == 32 );
1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261
C_ASSERT( FIELD_OFFSET(struct write_console_output_reply, written) == 8 );
C_ASSERT( FIELD_OFFSET(struct write_console_output_reply, width) == 12 );
C_ASSERT( FIELD_OFFSET(struct write_console_output_reply, height) == 16 );
C_ASSERT( sizeof(struct write_console_output_reply) == 24 );
C_ASSERT( FIELD_OFFSET(struct fill_console_output_request, handle) == 12 );
C_ASSERT( FIELD_OFFSET(struct fill_console_output_request, x) == 16 );
C_ASSERT( FIELD_OFFSET(struct fill_console_output_request, y) == 20 );
C_ASSERT( FIELD_OFFSET(struct fill_console_output_request, mode) == 24 );
C_ASSERT( FIELD_OFFSET(struct fill_console_output_request, count) == 28 );
C_ASSERT( FIELD_OFFSET(struct fill_console_output_request, wrap) == 32 );
C_ASSERT( FIELD_OFFSET(struct fill_console_output_request, data) == 36 );
1262
C_ASSERT( sizeof(struct fill_console_output_request) == 40 );
1263 1264 1265 1266 1267 1268 1269
C_ASSERT( FIELD_OFFSET(struct fill_console_output_reply, written) == 8 );
C_ASSERT( sizeof(struct fill_console_output_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct read_console_output_request, handle) == 12 );
C_ASSERT( FIELD_OFFSET(struct read_console_output_request, x) == 16 );
C_ASSERT( FIELD_OFFSET(struct read_console_output_request, y) == 20 );
C_ASSERT( FIELD_OFFSET(struct read_console_output_request, mode) == 24 );
C_ASSERT( FIELD_OFFSET(struct read_console_output_request, wrap) == 28 );
1270
C_ASSERT( sizeof(struct read_console_output_request) == 32 );
1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290
C_ASSERT( FIELD_OFFSET(struct read_console_output_reply, width) == 8 );
C_ASSERT( FIELD_OFFSET(struct read_console_output_reply, height) == 12 );
C_ASSERT( sizeof(struct read_console_output_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct move_console_output_request, handle) == 12 );
C_ASSERT( FIELD_OFFSET(struct move_console_output_request, x_src) == 16 );
C_ASSERT( FIELD_OFFSET(struct move_console_output_request, y_src) == 18 );
C_ASSERT( FIELD_OFFSET(struct move_console_output_request, x_dst) == 20 );
C_ASSERT( FIELD_OFFSET(struct move_console_output_request, y_dst) == 22 );
C_ASSERT( FIELD_OFFSET(struct move_console_output_request, w) == 24 );
C_ASSERT( FIELD_OFFSET(struct move_console_output_request, h) == 26 );
C_ASSERT( sizeof(struct move_console_output_request) == 32 );
C_ASSERT( FIELD_OFFSET(struct send_console_signal_request, signal) == 12 );
C_ASSERT( FIELD_OFFSET(struct send_console_signal_request, group_id) == 16 );
C_ASSERT( sizeof(struct send_console_signal_request) == 24 );
C_ASSERT( FIELD_OFFSET(struct read_directory_changes_request, filter) == 12 );
C_ASSERT( FIELD_OFFSET(struct read_directory_changes_request, subtree) == 16 );
C_ASSERT( FIELD_OFFSET(struct read_directory_changes_request, want_data) == 20 );
C_ASSERT( FIELD_OFFSET(struct read_directory_changes_request, async) == 24 );
C_ASSERT( sizeof(struct read_directory_changes_request) == 64 );
C_ASSERT( FIELD_OFFSET(struct read_change_request, handle) == 12 );
1291
C_ASSERT( sizeof(struct read_change_request) == 16 );
1292
C_ASSERT( sizeof(struct read_change_reply) == 8 );
1293
C_ASSERT( FIELD_OFFSET(struct create_mapping_request, access) == 12 );
1294
C_ASSERT( FIELD_OFFSET(struct create_mapping_request, flags) == 16 );
1295
C_ASSERT( FIELD_OFFSET(struct create_mapping_request, file_access) == 20 );
1296 1297
C_ASSERT( FIELD_OFFSET(struct create_mapping_request, size) == 24 );
C_ASSERT( FIELD_OFFSET(struct create_mapping_request, file_handle) == 32 );
1298
C_ASSERT( sizeof(struct create_mapping_request) == 40 );
1299 1300 1301 1302 1303
C_ASSERT( FIELD_OFFSET(struct create_mapping_reply, handle) == 8 );
C_ASSERT( sizeof(struct create_mapping_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct open_mapping_request, access) == 12 );
C_ASSERT( FIELD_OFFSET(struct open_mapping_request, attributes) == 16 );
C_ASSERT( FIELD_OFFSET(struct open_mapping_request, rootdir) == 20 );
1304
C_ASSERT( sizeof(struct open_mapping_request) == 24 );
1305 1306 1307 1308
C_ASSERT( FIELD_OFFSET(struct open_mapping_reply, handle) == 8 );
C_ASSERT( sizeof(struct open_mapping_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct get_mapping_info_request, handle) == 12 );
C_ASSERT( FIELD_OFFSET(struct get_mapping_info_request, access) == 16 );
1309
C_ASSERT( sizeof(struct get_mapping_info_request) == 24 );
1310
C_ASSERT( FIELD_OFFSET(struct get_mapping_info_reply, size) == 8 );
1311
C_ASSERT( FIELD_OFFSET(struct get_mapping_info_reply, flags) == 16 );
1312 1313
C_ASSERT( FIELD_OFFSET(struct get_mapping_info_reply, shared_file) == 20 );
C_ASSERT( sizeof(struct get_mapping_info_reply) == 24 );
1314 1315 1316 1317 1318 1319 1320 1321
C_ASSERT( FIELD_OFFSET(struct map_view_request, mapping) == 12 );
C_ASSERT( FIELD_OFFSET(struct map_view_request, access) == 16 );
C_ASSERT( FIELD_OFFSET(struct map_view_request, base) == 24 );
C_ASSERT( FIELD_OFFSET(struct map_view_request, size) == 32 );
C_ASSERT( FIELD_OFFSET(struct map_view_request, start) == 40 );
C_ASSERT( sizeof(struct map_view_request) == 48 );
C_ASSERT( FIELD_OFFSET(struct unmap_view_request, base) == 16 );
C_ASSERT( sizeof(struct unmap_view_request) == 24 );
1322 1323 1324
C_ASSERT( FIELD_OFFSET(struct get_mapping_committed_range_request, base) == 16 );
C_ASSERT( FIELD_OFFSET(struct get_mapping_committed_range_request, offset) == 24 );
C_ASSERT( sizeof(struct get_mapping_committed_range_request) == 32 );
1325 1326 1327
C_ASSERT( FIELD_OFFSET(struct get_mapping_committed_range_reply, size) == 8 );
C_ASSERT( FIELD_OFFSET(struct get_mapping_committed_range_reply, committed) == 16 );
C_ASSERT( sizeof(struct get_mapping_committed_range_reply) == 24 );
1328 1329 1330 1331
C_ASSERT( FIELD_OFFSET(struct add_mapping_committed_range_request, base) == 16 );
C_ASSERT( FIELD_OFFSET(struct add_mapping_committed_range_request, offset) == 24 );
C_ASSERT( FIELD_OFFSET(struct add_mapping_committed_range_request, size) == 32 );
C_ASSERT( sizeof(struct add_mapping_committed_range_request) == 40 );
1332 1333 1334
C_ASSERT( FIELD_OFFSET(struct is_same_mapping_request, base1) == 16 );
C_ASSERT( FIELD_OFFSET(struct is_same_mapping_request, base2) == 24 );
C_ASSERT( sizeof(struct is_same_mapping_request) == 32 );
1335 1336
C_ASSERT( FIELD_OFFSET(struct create_snapshot_request, attributes) == 12 );
C_ASSERT( FIELD_OFFSET(struct create_snapshot_request, flags) == 16 );
1337
C_ASSERT( sizeof(struct create_snapshot_request) == 24 );
1338 1339 1340 1341
C_ASSERT( FIELD_OFFSET(struct create_snapshot_reply, handle) == 8 );
C_ASSERT( sizeof(struct create_snapshot_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct next_process_request, handle) == 12 );
C_ASSERT( FIELD_OFFSET(struct next_process_request, reset) == 16 );
1342
C_ASSERT( sizeof(struct next_process_request) == 24 );
1343 1344 1345 1346 1347 1348
C_ASSERT( FIELD_OFFSET(struct next_process_reply, count) == 8 );
C_ASSERT( FIELD_OFFSET(struct next_process_reply, pid) == 12 );
C_ASSERT( FIELD_OFFSET(struct next_process_reply, ppid) == 16 );
C_ASSERT( FIELD_OFFSET(struct next_process_reply, threads) == 20 );
C_ASSERT( FIELD_OFFSET(struct next_process_reply, priority) == 24 );
C_ASSERT( FIELD_OFFSET(struct next_process_reply, handles) == 28 );
1349 1350
C_ASSERT( FIELD_OFFSET(struct next_process_reply, unix_pid) == 32 );
C_ASSERT( sizeof(struct next_process_reply) == 40 );
1351 1352
C_ASSERT( FIELD_OFFSET(struct next_thread_request, handle) == 12 );
C_ASSERT( FIELD_OFFSET(struct next_thread_request, reset) == 16 );
1353
C_ASSERT( sizeof(struct next_thread_request) == 24 );
1354 1355 1356 1357 1358 1359 1360
C_ASSERT( FIELD_OFFSET(struct next_thread_reply, count) == 8 );
C_ASSERT( FIELD_OFFSET(struct next_thread_reply, pid) == 12 );
C_ASSERT( FIELD_OFFSET(struct next_thread_reply, tid) == 16 );
C_ASSERT( FIELD_OFFSET(struct next_thread_reply, base_pri) == 20 );
C_ASSERT( FIELD_OFFSET(struct next_thread_reply, delta_pri) == 24 );
C_ASSERT( sizeof(struct next_thread_reply) == 32 );
C_ASSERT( FIELD_OFFSET(struct wait_debug_event_request, get_handle) == 12 );
1361
C_ASSERT( sizeof(struct wait_debug_event_request) == 16 );
1362 1363 1364 1365 1366 1367 1368 1369 1370 1371
C_ASSERT( FIELD_OFFSET(struct wait_debug_event_reply, pid) == 8 );
C_ASSERT( FIELD_OFFSET(struct wait_debug_event_reply, tid) == 12 );
C_ASSERT( FIELD_OFFSET(struct wait_debug_event_reply, wait) == 16 );
C_ASSERT( sizeof(struct wait_debug_event_reply) == 24 );
C_ASSERT( FIELD_OFFSET(struct queue_exception_event_request, first) == 12 );
C_ASSERT( FIELD_OFFSET(struct queue_exception_event_request, code) == 16 );
C_ASSERT( FIELD_OFFSET(struct queue_exception_event_request, flags) == 20 );
C_ASSERT( FIELD_OFFSET(struct queue_exception_event_request, record) == 24 );
C_ASSERT( FIELD_OFFSET(struct queue_exception_event_request, address) == 32 );
C_ASSERT( FIELD_OFFSET(struct queue_exception_event_request, len) == 40 );
1372
C_ASSERT( sizeof(struct queue_exception_event_request) == 48 );
1373 1374 1375
C_ASSERT( FIELD_OFFSET(struct queue_exception_event_reply, handle) == 8 );
C_ASSERT( sizeof(struct queue_exception_event_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct get_exception_status_request, handle) == 12 );
1376
C_ASSERT( sizeof(struct get_exception_status_request) == 16 );
1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388
C_ASSERT( sizeof(struct get_exception_status_reply) == 8 );
C_ASSERT( FIELD_OFFSET(struct continue_debug_event_request, pid) == 12 );
C_ASSERT( FIELD_OFFSET(struct continue_debug_event_request, tid) == 16 );
C_ASSERT( FIELD_OFFSET(struct continue_debug_event_request, status) == 20 );
C_ASSERT( sizeof(struct continue_debug_event_request) == 24 );
C_ASSERT( FIELD_OFFSET(struct debug_process_request, pid) == 12 );
C_ASSERT( FIELD_OFFSET(struct debug_process_request, attach) == 16 );
C_ASSERT( sizeof(struct debug_process_request) == 24 );
C_ASSERT( FIELD_OFFSET(struct set_debugger_kill_on_exit_request, kill_on_exit) == 12 );
C_ASSERT( sizeof(struct set_debugger_kill_on_exit_request) == 16 );
C_ASSERT( FIELD_OFFSET(struct read_process_memory_request, handle) == 12 );
C_ASSERT( FIELD_OFFSET(struct read_process_memory_request, addr) == 16 );
1389
C_ASSERT( sizeof(struct read_process_memory_request) == 24 );
1390 1391 1392 1393
C_ASSERT( sizeof(struct read_process_memory_reply) == 8 );
C_ASSERT( FIELD_OFFSET(struct write_process_memory_request, handle) == 12 );
C_ASSERT( FIELD_OFFSET(struct write_process_memory_request, addr) == 16 );
C_ASSERT( sizeof(struct write_process_memory_request) == 24 );
1394 1395 1396
C_ASSERT( FIELD_OFFSET(struct create_key_request, access) == 12 );
C_ASSERT( FIELD_OFFSET(struct create_key_request, options) == 16 );
C_ASSERT( sizeof(struct create_key_request) == 24 );
1397 1398 1399 1400 1401 1402
C_ASSERT( FIELD_OFFSET(struct create_key_reply, hkey) == 8 );
C_ASSERT( FIELD_OFFSET(struct create_key_reply, created) == 12 );
C_ASSERT( sizeof(struct create_key_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct open_key_request, parent) == 12 );
C_ASSERT( FIELD_OFFSET(struct open_key_request, access) == 16 );
C_ASSERT( FIELD_OFFSET(struct open_key_request, attributes) == 20 );
1403
C_ASSERT( sizeof(struct open_key_request) == 24 );
1404 1405 1406 1407 1408 1409 1410 1411 1412
C_ASSERT( FIELD_OFFSET(struct open_key_reply, hkey) == 8 );
C_ASSERT( sizeof(struct open_key_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct delete_key_request, hkey) == 12 );
C_ASSERT( sizeof(struct delete_key_request) == 16 );
C_ASSERT( FIELD_OFFSET(struct flush_key_request, hkey) == 12 );
C_ASSERT( sizeof(struct flush_key_request) == 16 );
C_ASSERT( FIELD_OFFSET(struct enum_key_request, hkey) == 12 );
C_ASSERT( FIELD_OFFSET(struct enum_key_request, index) == 16 );
C_ASSERT( FIELD_OFFSET(struct enum_key_request, info_class) == 20 );
1413
C_ASSERT( sizeof(struct enum_key_request) == 24 );
1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428
C_ASSERT( FIELD_OFFSET(struct enum_key_reply, subkeys) == 8 );
C_ASSERT( FIELD_OFFSET(struct enum_key_reply, max_subkey) == 12 );
C_ASSERT( FIELD_OFFSET(struct enum_key_reply, max_class) == 16 );
C_ASSERT( FIELD_OFFSET(struct enum_key_reply, values) == 20 );
C_ASSERT( FIELD_OFFSET(struct enum_key_reply, max_value) == 24 );
C_ASSERT( FIELD_OFFSET(struct enum_key_reply, max_data) == 28 );
C_ASSERT( FIELD_OFFSET(struct enum_key_reply, modif) == 32 );
C_ASSERT( FIELD_OFFSET(struct enum_key_reply, total) == 40 );
C_ASSERT( FIELD_OFFSET(struct enum_key_reply, namelen) == 44 );
C_ASSERT( sizeof(struct enum_key_reply) == 48 );
C_ASSERT( FIELD_OFFSET(struct set_key_value_request, hkey) == 12 );
C_ASSERT( FIELD_OFFSET(struct set_key_value_request, type) == 16 );
C_ASSERT( FIELD_OFFSET(struct set_key_value_request, namelen) == 20 );
C_ASSERT( sizeof(struct set_key_value_request) == 24 );
C_ASSERT( FIELD_OFFSET(struct get_key_value_request, hkey) == 12 );
1429
C_ASSERT( sizeof(struct get_key_value_request) == 16 );
1430 1431 1432 1433 1434 1435
C_ASSERT( FIELD_OFFSET(struct get_key_value_reply, type) == 8 );
C_ASSERT( FIELD_OFFSET(struct get_key_value_reply, total) == 12 );
C_ASSERT( sizeof(struct get_key_value_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct enum_key_value_request, hkey) == 12 );
C_ASSERT( FIELD_OFFSET(struct enum_key_value_request, index) == 16 );
C_ASSERT( FIELD_OFFSET(struct enum_key_value_request, info_class) == 20 );
1436
C_ASSERT( sizeof(struct enum_key_value_request) == 24 );
1437 1438 1439 1440 1441 1442
C_ASSERT( FIELD_OFFSET(struct enum_key_value_reply, type) == 8 );
C_ASSERT( FIELD_OFFSET(struct enum_key_value_reply, total) == 12 );
C_ASSERT( FIELD_OFFSET(struct enum_key_value_reply, namelen) == 16 );
C_ASSERT( sizeof(struct enum_key_value_reply) == 24 );
C_ASSERT( FIELD_OFFSET(struct delete_key_value_request, hkey) == 12 );
C_ASSERT( sizeof(struct delete_key_value_request) == 16 );
1443 1444
C_ASSERT( FIELD_OFFSET(struct load_registry_request, file) == 12 );
C_ASSERT( sizeof(struct load_registry_request) == 16 );
1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455
C_ASSERT( FIELD_OFFSET(struct unload_registry_request, hkey) == 12 );
C_ASSERT( sizeof(struct unload_registry_request) == 16 );
C_ASSERT( FIELD_OFFSET(struct save_registry_request, hkey) == 12 );
C_ASSERT( FIELD_OFFSET(struct save_registry_request, file) == 16 );
C_ASSERT( sizeof(struct save_registry_request) == 24 );
C_ASSERT( FIELD_OFFSET(struct set_registry_notification_request, hkey) == 12 );
C_ASSERT( FIELD_OFFSET(struct set_registry_notification_request, event) == 16 );
C_ASSERT( FIELD_OFFSET(struct set_registry_notification_request, subtree) == 20 );
C_ASSERT( FIELD_OFFSET(struct set_registry_notification_request, filter) == 24 );
C_ASSERT( sizeof(struct set_registry_notification_request) == 32 );
C_ASSERT( FIELD_OFFSET(struct create_timer_request, access) == 12 );
1456 1457
C_ASSERT( FIELD_OFFSET(struct create_timer_request, manual) == 16 );
C_ASSERT( sizeof(struct create_timer_request) == 24 );
1458 1459 1460 1461 1462
C_ASSERT( FIELD_OFFSET(struct create_timer_reply, handle) == 8 );
C_ASSERT( sizeof(struct create_timer_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct open_timer_request, access) == 12 );
C_ASSERT( FIELD_OFFSET(struct open_timer_request, attributes) == 16 );
C_ASSERT( FIELD_OFFSET(struct open_timer_request, rootdir) == 20 );
1463
C_ASSERT( sizeof(struct open_timer_request) == 24 );
1464 1465 1466 1467 1468 1469 1470
C_ASSERT( FIELD_OFFSET(struct open_timer_reply, handle) == 8 );
C_ASSERT( sizeof(struct open_timer_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct set_timer_request, handle) == 12 );
C_ASSERT( FIELD_OFFSET(struct set_timer_request, expire) == 16 );
C_ASSERT( FIELD_OFFSET(struct set_timer_request, callback) == 24 );
C_ASSERT( FIELD_OFFSET(struct set_timer_request, arg) == 32 );
C_ASSERT( FIELD_OFFSET(struct set_timer_request, period) == 40 );
1471
C_ASSERT( sizeof(struct set_timer_request) == 48 );
1472 1473 1474
C_ASSERT( FIELD_OFFSET(struct set_timer_reply, signaled) == 8 );
C_ASSERT( sizeof(struct set_timer_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct cancel_timer_request, handle) == 12 );
1475
C_ASSERT( sizeof(struct cancel_timer_request) == 16 );
1476 1477 1478
C_ASSERT( FIELD_OFFSET(struct cancel_timer_reply, signaled) == 8 );
C_ASSERT( sizeof(struct cancel_timer_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct get_timer_info_request, handle) == 12 );
1479
C_ASSERT( sizeof(struct get_timer_info_request) == 16 );
1480 1481 1482 1483 1484 1485
C_ASSERT( FIELD_OFFSET(struct get_timer_info_reply, when) == 8 );
C_ASSERT( FIELD_OFFSET(struct get_timer_info_reply, signaled) == 16 );
C_ASSERT( sizeof(struct get_timer_info_reply) == 24 );
C_ASSERT( FIELD_OFFSET(struct get_thread_context_request, handle) == 12 );
C_ASSERT( FIELD_OFFSET(struct get_thread_context_request, flags) == 16 );
C_ASSERT( FIELD_OFFSET(struct get_thread_context_request, suspend) == 20 );
1486
C_ASSERT( sizeof(struct get_thread_context_request) == 24 );
1487 1488 1489
C_ASSERT( FIELD_OFFSET(struct get_thread_context_reply, self) == 8 );
C_ASSERT( sizeof(struct get_thread_context_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct set_thread_context_request, handle) == 12 );
1490
C_ASSERT( FIELD_OFFSET(struct set_thread_context_request, suspend) == 16 );
1491
C_ASSERT( sizeof(struct set_thread_context_request) == 24 );
1492 1493 1494 1495
C_ASSERT( FIELD_OFFSET(struct set_thread_context_reply, self) == 8 );
C_ASSERT( sizeof(struct set_thread_context_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct get_selector_entry_request, handle) == 12 );
C_ASSERT( FIELD_OFFSET(struct get_selector_entry_request, entry) == 16 );
1496
C_ASSERT( sizeof(struct get_selector_entry_request) == 24 );
1497 1498 1499 1500 1501
C_ASSERT( FIELD_OFFSET(struct get_selector_entry_reply, base) == 8 );
C_ASSERT( FIELD_OFFSET(struct get_selector_entry_reply, limit) == 12 );
C_ASSERT( FIELD_OFFSET(struct get_selector_entry_reply, flags) == 16 );
C_ASSERT( sizeof(struct get_selector_entry_reply) == 24 );
C_ASSERT( FIELD_OFFSET(struct add_atom_request, table) == 12 );
1502
C_ASSERT( sizeof(struct add_atom_request) == 16 );
1503 1504 1505 1506 1507 1508
C_ASSERT( FIELD_OFFSET(struct add_atom_reply, atom) == 8 );
C_ASSERT( sizeof(struct add_atom_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct delete_atom_request, table) == 12 );
C_ASSERT( FIELD_OFFSET(struct delete_atom_request, atom) == 16 );
C_ASSERT( sizeof(struct delete_atom_request) == 24 );
C_ASSERT( FIELD_OFFSET(struct find_atom_request, table) == 12 );
1509
C_ASSERT( sizeof(struct find_atom_request) == 16 );
1510 1511 1512 1513
C_ASSERT( FIELD_OFFSET(struct find_atom_reply, atom) == 8 );
C_ASSERT( sizeof(struct find_atom_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct get_atom_information_request, table) == 12 );
C_ASSERT( FIELD_OFFSET(struct get_atom_information_request, atom) == 16 );
1514
C_ASSERT( sizeof(struct get_atom_information_request) == 24 );
1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526
C_ASSERT( FIELD_OFFSET(struct get_atom_information_reply, count) == 8 );
C_ASSERT( FIELD_OFFSET(struct get_atom_information_reply, pinned) == 12 );
C_ASSERT( FIELD_OFFSET(struct get_atom_information_reply, total) == 16 );
C_ASSERT( sizeof(struct get_atom_information_reply) == 24 );
C_ASSERT( FIELD_OFFSET(struct set_atom_information_request, table) == 12 );
C_ASSERT( FIELD_OFFSET(struct set_atom_information_request, atom) == 16 );
C_ASSERT( FIELD_OFFSET(struct set_atom_information_request, pinned) == 20 );
C_ASSERT( sizeof(struct set_atom_information_request) == 24 );
C_ASSERT( FIELD_OFFSET(struct empty_atom_table_request, table) == 12 );
C_ASSERT( FIELD_OFFSET(struct empty_atom_table_request, if_pinned) == 16 );
C_ASSERT( sizeof(struct empty_atom_table_request) == 24 );
C_ASSERT( FIELD_OFFSET(struct init_atom_table_request, entries) == 12 );
1527
C_ASSERT( sizeof(struct init_atom_table_request) == 16 );
1528 1529
C_ASSERT( FIELD_OFFSET(struct init_atom_table_reply, table) == 8 );
C_ASSERT( sizeof(struct init_atom_table_reply) == 16 );
1530
C_ASSERT( sizeof(struct get_msg_queue_request) == 16 );
1531 1532 1533 1534 1535 1536 1537
C_ASSERT( FIELD_OFFSET(struct get_msg_queue_reply, handle) == 8 );
C_ASSERT( sizeof(struct get_msg_queue_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct set_queue_fd_request, handle) == 12 );
C_ASSERT( sizeof(struct set_queue_fd_request) == 16 );
C_ASSERT( FIELD_OFFSET(struct set_queue_mask_request, wake_mask) == 12 );
C_ASSERT( FIELD_OFFSET(struct set_queue_mask_request, changed_mask) == 16 );
C_ASSERT( FIELD_OFFSET(struct set_queue_mask_request, skip_wait) == 20 );
1538
C_ASSERT( sizeof(struct set_queue_mask_request) == 24 );
1539 1540 1541
C_ASSERT( FIELD_OFFSET(struct set_queue_mask_reply, wake_bits) == 8 );
C_ASSERT( FIELD_OFFSET(struct set_queue_mask_reply, changed_bits) == 12 );
C_ASSERT( sizeof(struct set_queue_mask_reply) == 16 );
1542
C_ASSERT( FIELD_OFFSET(struct get_queue_status_request, clear_bits) == 12 );
1543
C_ASSERT( sizeof(struct get_queue_status_request) == 16 );
1544 1545 1546 1547
C_ASSERT( FIELD_OFFSET(struct get_queue_status_reply, wake_bits) == 8 );
C_ASSERT( FIELD_OFFSET(struct get_queue_status_reply, changed_bits) == 12 );
C_ASSERT( sizeof(struct get_queue_status_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct get_process_idle_event_request, handle) == 12 );
1548
C_ASSERT( sizeof(struct get_process_idle_event_request) == 16 );
1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561
C_ASSERT( FIELD_OFFSET(struct get_process_idle_event_reply, event) == 8 );
C_ASSERT( sizeof(struct get_process_idle_event_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct send_message_request, id) == 12 );
C_ASSERT( FIELD_OFFSET(struct send_message_request, type) == 16 );
C_ASSERT( FIELD_OFFSET(struct send_message_request, flags) == 20 );
C_ASSERT( FIELD_OFFSET(struct send_message_request, win) == 24 );
C_ASSERT( FIELD_OFFSET(struct send_message_request, msg) == 28 );
C_ASSERT( FIELD_OFFSET(struct send_message_request, wparam) == 32 );
C_ASSERT( FIELD_OFFSET(struct send_message_request, lparam) == 40 );
C_ASSERT( FIELD_OFFSET(struct send_message_request, timeout) == 48 );
C_ASSERT( sizeof(struct send_message_request) == 56 );
C_ASSERT( FIELD_OFFSET(struct post_quit_message_request, exit_code) == 12 );
C_ASSERT( sizeof(struct post_quit_message_request) == 16 );
1562
C_ASSERT( FIELD_OFFSET(struct send_hardware_message_request, win) == 12 );
1563 1564
C_ASSERT( FIELD_OFFSET(struct send_hardware_message_request, input) == 16 );
C_ASSERT( FIELD_OFFSET(struct send_hardware_message_request, flags) == 48 );
1565
C_ASSERT( sizeof(struct send_hardware_message_request) == 56 );
1566
C_ASSERT( FIELD_OFFSET(struct send_hardware_message_reply, wait) == 8 );
1567 1568 1569 1570 1571
C_ASSERT( FIELD_OFFSET(struct send_hardware_message_reply, prev_x) == 12 );
C_ASSERT( FIELD_OFFSET(struct send_hardware_message_reply, prev_y) == 16 );
C_ASSERT( FIELD_OFFSET(struct send_hardware_message_reply, new_x) == 20 );
C_ASSERT( FIELD_OFFSET(struct send_hardware_message_reply, new_y) == 24 );
C_ASSERT( sizeof(struct send_hardware_message_reply) == 32 );
1572 1573 1574 1575 1576 1577 1578
C_ASSERT( FIELD_OFFSET(struct get_message_request, flags) == 12 );
C_ASSERT( FIELD_OFFSET(struct get_message_request, get_win) == 16 );
C_ASSERT( FIELD_OFFSET(struct get_message_request, get_first) == 20 );
C_ASSERT( FIELD_OFFSET(struct get_message_request, get_last) == 24 );
C_ASSERT( FIELD_OFFSET(struct get_message_request, hw_id) == 28 );
C_ASSERT( FIELD_OFFSET(struct get_message_request, wake_mask) == 32 );
C_ASSERT( FIELD_OFFSET(struct get_message_request, changed_mask) == 36 );
1579
C_ASSERT( sizeof(struct get_message_request) == 40 );
1580 1581 1582 1583 1584
C_ASSERT( FIELD_OFFSET(struct get_message_reply, win) == 8 );
C_ASSERT( FIELD_OFFSET(struct get_message_reply, msg) == 12 );
C_ASSERT( FIELD_OFFSET(struct get_message_reply, wparam) == 16 );
C_ASSERT( FIELD_OFFSET(struct get_message_reply, lparam) == 24 );
C_ASSERT( FIELD_OFFSET(struct get_message_reply, type) == 32 );
1585 1586 1587 1588 1589 1590
C_ASSERT( FIELD_OFFSET(struct get_message_reply, x) == 36 );
C_ASSERT( FIELD_OFFSET(struct get_message_reply, y) == 40 );
C_ASSERT( FIELD_OFFSET(struct get_message_reply, time) == 44 );
C_ASSERT( FIELD_OFFSET(struct get_message_reply, active_hooks) == 48 );
C_ASSERT( FIELD_OFFSET(struct get_message_reply, total) == 52 );
C_ASSERT( sizeof(struct get_message_reply) == 56 );
1591 1592 1593 1594 1595 1596 1597
C_ASSERT( FIELD_OFFSET(struct reply_message_request, remove) == 12 );
C_ASSERT( FIELD_OFFSET(struct reply_message_request, result) == 16 );
C_ASSERT( sizeof(struct reply_message_request) == 24 );
C_ASSERT( FIELD_OFFSET(struct accept_hardware_message_request, hw_id) == 12 );
C_ASSERT( FIELD_OFFSET(struct accept_hardware_message_request, remove) == 16 );
C_ASSERT( sizeof(struct accept_hardware_message_request) == 24 );
C_ASSERT( FIELD_OFFSET(struct get_message_reply_request, cancel) == 12 );
1598
C_ASSERT( sizeof(struct get_message_reply_request) == 16 );
1599 1600 1601 1602 1603 1604 1605
C_ASSERT( FIELD_OFFSET(struct get_message_reply_reply, result) == 8 );
C_ASSERT( sizeof(struct get_message_reply_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct set_win_timer_request, win) == 12 );
C_ASSERT( FIELD_OFFSET(struct set_win_timer_request, msg) == 16 );
C_ASSERT( FIELD_OFFSET(struct set_win_timer_request, rate) == 20 );
C_ASSERT( FIELD_OFFSET(struct set_win_timer_request, id) == 24 );
C_ASSERT( FIELD_OFFSET(struct set_win_timer_request, lparam) == 32 );
1606
C_ASSERT( sizeof(struct set_win_timer_request) == 40 );
1607 1608 1609 1610 1611 1612 1613
C_ASSERT( FIELD_OFFSET(struct set_win_timer_reply, id) == 8 );
C_ASSERT( sizeof(struct set_win_timer_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct kill_win_timer_request, win) == 12 );
C_ASSERT( FIELD_OFFSET(struct kill_win_timer_request, id) == 16 );
C_ASSERT( FIELD_OFFSET(struct kill_win_timer_request, msg) == 24 );
C_ASSERT( sizeof(struct kill_win_timer_request) == 32 );
C_ASSERT( FIELD_OFFSET(struct is_window_hung_request, win) == 12 );
1614
C_ASSERT( sizeof(struct is_window_hung_request) == 16 );
1615 1616 1617
C_ASSERT( FIELD_OFFSET(struct is_window_hung_reply, is_hung) == 8 );
C_ASSERT( sizeof(struct is_window_hung_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct get_serial_info_request, handle) == 12 );
1618 1619
C_ASSERT( FIELD_OFFSET(struct get_serial_info_request, flags) == 16 );
C_ASSERT( sizeof(struct get_serial_info_request) == 24 );
1620 1621 1622 1623
C_ASSERT( FIELD_OFFSET(struct get_serial_info_reply, eventmask) == 8 );
C_ASSERT( FIELD_OFFSET(struct get_serial_info_reply, cookie) == 12 );
C_ASSERT( FIELD_OFFSET(struct get_serial_info_reply, pending_write) == 16 );
C_ASSERT( sizeof(struct get_serial_info_reply) == 24 );
1624 1625
C_ASSERT( FIELD_OFFSET(struct set_serial_info_request, handle) == 12 );
C_ASSERT( FIELD_OFFSET(struct set_serial_info_request, flags) == 16 );
1626
C_ASSERT( sizeof(struct set_serial_info_request) == 24 );
1627 1628 1629 1630 1631
C_ASSERT( FIELD_OFFSET(struct register_async_request, type) == 12 );
C_ASSERT( FIELD_OFFSET(struct register_async_request, async) == 16 );
C_ASSERT( FIELD_OFFSET(struct register_async_request, count) == 56 );
C_ASSERT( sizeof(struct register_async_request) == 64 );
C_ASSERT( FIELD_OFFSET(struct cancel_async_request, handle) == 12 );
1632 1633 1634
C_ASSERT( FIELD_OFFSET(struct cancel_async_request, iosb) == 16 );
C_ASSERT( FIELD_OFFSET(struct cancel_async_request, only_thread) == 24 );
C_ASSERT( sizeof(struct cancel_async_request) == 32 );
1635 1636 1637 1638
C_ASSERT( FIELD_OFFSET(struct get_async_result_request, user_arg) == 16 );
C_ASSERT( sizeof(struct get_async_result_request) == 24 );
C_ASSERT( FIELD_OFFSET(struct get_async_result_reply, size) == 8 );
C_ASSERT( sizeof(struct get_async_result_reply) == 16 );
1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651
C_ASSERT( FIELD_OFFSET(struct read_request, async) == 16 );
C_ASSERT( FIELD_OFFSET(struct read_request, pos) == 56 );
C_ASSERT( sizeof(struct read_request) == 64 );
C_ASSERT( FIELD_OFFSET(struct read_reply, wait) == 8 );
C_ASSERT( FIELD_OFFSET(struct read_reply, options) == 12 );
C_ASSERT( sizeof(struct read_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct write_request, async) == 16 );
C_ASSERT( FIELD_OFFSET(struct write_request, pos) == 56 );
C_ASSERT( sizeof(struct write_request) == 64 );
C_ASSERT( FIELD_OFFSET(struct write_reply, wait) == 8 );
C_ASSERT( FIELD_OFFSET(struct write_reply, options) == 12 );
C_ASSERT( FIELD_OFFSET(struct write_reply, size) == 16 );
C_ASSERT( sizeof(struct write_reply) == 24 );
1652 1653
C_ASSERT( FIELD_OFFSET(struct ioctl_request, code) == 12 );
C_ASSERT( FIELD_OFFSET(struct ioctl_request, async) == 16 );
1654
C_ASSERT( sizeof(struct ioctl_request) == 56 );
1655 1656 1657
C_ASSERT( FIELD_OFFSET(struct ioctl_reply, wait) == 8 );
C_ASSERT( FIELD_OFFSET(struct ioctl_reply, options) == 12 );
C_ASSERT( sizeof(struct ioctl_reply) == 16 );
1658 1659 1660
C_ASSERT( FIELD_OFFSET(struct set_irp_result_request, handle) == 12 );
C_ASSERT( FIELD_OFFSET(struct set_irp_result_request, status) == 16 );
C_ASSERT( FIELD_OFFSET(struct set_irp_result_request, size) == 20 );
1661
C_ASSERT( sizeof(struct set_irp_result_request) == 24 );
1662
C_ASSERT( FIELD_OFFSET(struct create_named_pipe_request, access) == 12 );
1663 1664 1665 1666 1667
C_ASSERT( FIELD_OFFSET(struct create_named_pipe_request, options) == 16 );
C_ASSERT( FIELD_OFFSET(struct create_named_pipe_request, sharing) == 20 );
C_ASSERT( FIELD_OFFSET(struct create_named_pipe_request, maxinstances) == 24 );
C_ASSERT( FIELD_OFFSET(struct create_named_pipe_request, outsize) == 28 );
C_ASSERT( FIELD_OFFSET(struct create_named_pipe_request, insize) == 32 );
1668 1669 1670
C_ASSERT( FIELD_OFFSET(struct create_named_pipe_request, timeout) == 40 );
C_ASSERT( FIELD_OFFSET(struct create_named_pipe_request, flags) == 48 );
C_ASSERT( sizeof(struct create_named_pipe_request) == 56 );
1671 1672
C_ASSERT( FIELD_OFFSET(struct create_named_pipe_reply, handle) == 8 );
C_ASSERT( sizeof(struct create_named_pipe_reply) == 16 );
1673 1674 1675
C_ASSERT( FIELD_OFFSET(struct set_named_pipe_info_request, handle) == 12 );
C_ASSERT( FIELD_OFFSET(struct set_named_pipe_info_request, flags) == 16 );
C_ASSERT( sizeof(struct set_named_pipe_info_request) == 24 );
1676 1677 1678 1679
C_ASSERT( FIELD_OFFSET(struct create_window_request, parent) == 12 );
C_ASSERT( FIELD_OFFSET(struct create_window_request, owner) == 16 );
C_ASSERT( FIELD_OFFSET(struct create_window_request, atom) == 20 );
C_ASSERT( FIELD_OFFSET(struct create_window_request, instance) == 24 );
1680 1681
C_ASSERT( FIELD_OFFSET(struct create_window_request, dpi) == 32 );
C_ASSERT( FIELD_OFFSET(struct create_window_request, awareness) == 36 );
1682
C_ASSERT( sizeof(struct create_window_request) == 40 );
1683 1684 1685 1686 1687
C_ASSERT( FIELD_OFFSET(struct create_window_reply, handle) == 8 );
C_ASSERT( FIELD_OFFSET(struct create_window_reply, parent) == 12 );
C_ASSERT( FIELD_OFFSET(struct create_window_reply, owner) == 16 );
C_ASSERT( FIELD_OFFSET(struct create_window_reply, extra) == 20 );
C_ASSERT( FIELD_OFFSET(struct create_window_reply, class_ptr) == 24 );
1688 1689
C_ASSERT( FIELD_OFFSET(struct create_window_reply, dpi) == 32 );
C_ASSERT( FIELD_OFFSET(struct create_window_reply, awareness) == 36 );
1690
C_ASSERT( sizeof(struct create_window_reply) == 40 );
1691 1692 1693
C_ASSERT( FIELD_OFFSET(struct destroy_window_request, handle) == 12 );
C_ASSERT( sizeof(struct destroy_window_request) == 16 );
C_ASSERT( FIELD_OFFSET(struct get_desktop_window_request, force) == 12 );
1694
C_ASSERT( sizeof(struct get_desktop_window_request) == 16 );
1695 1696 1697 1698 1699
C_ASSERT( FIELD_OFFSET(struct get_desktop_window_reply, top_window) == 8 );
C_ASSERT( FIELD_OFFSET(struct get_desktop_window_reply, msg_window) == 12 );
C_ASSERT( sizeof(struct get_desktop_window_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct set_window_owner_request, handle) == 12 );
C_ASSERT( FIELD_OFFSET(struct set_window_owner_request, owner) == 16 );
1700
C_ASSERT( sizeof(struct set_window_owner_request) == 24 );
1701 1702 1703 1704
C_ASSERT( FIELD_OFFSET(struct set_window_owner_reply, full_owner) == 8 );
C_ASSERT( FIELD_OFFSET(struct set_window_owner_reply, prev_owner) == 12 );
C_ASSERT( sizeof(struct set_window_owner_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct get_window_info_request, handle) == 12 );
1705
C_ASSERT( sizeof(struct get_window_info_request) == 16 );
1706 1707 1708 1709 1710 1711
C_ASSERT( FIELD_OFFSET(struct get_window_info_reply, full_handle) == 8 );
C_ASSERT( FIELD_OFFSET(struct get_window_info_reply, last_active) == 12 );
C_ASSERT( FIELD_OFFSET(struct get_window_info_reply, pid) == 16 );
C_ASSERT( FIELD_OFFSET(struct get_window_info_reply, tid) == 20 );
C_ASSERT( FIELD_OFFSET(struct get_window_info_reply, atom) == 24 );
C_ASSERT( FIELD_OFFSET(struct get_window_info_reply, is_unicode) == 28 );
1712 1713
C_ASSERT( FIELD_OFFSET(struct get_window_info_reply, dpi) == 32 );
C_ASSERT( FIELD_OFFSET(struct get_window_info_reply, awareness) == 36 );
1714
C_ASSERT( sizeof(struct get_window_info_reply) == 40 );
1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725
C_ASSERT( FIELD_OFFSET(struct set_window_info_request, flags) == 12 );
C_ASSERT( FIELD_OFFSET(struct set_window_info_request, is_unicode) == 14 );
C_ASSERT( FIELD_OFFSET(struct set_window_info_request, handle) == 16 );
C_ASSERT( FIELD_OFFSET(struct set_window_info_request, style) == 20 );
C_ASSERT( FIELD_OFFSET(struct set_window_info_request, ex_style) == 24 );
C_ASSERT( FIELD_OFFSET(struct set_window_info_request, id) == 28 );
C_ASSERT( FIELD_OFFSET(struct set_window_info_request, instance) == 32 );
C_ASSERT( FIELD_OFFSET(struct set_window_info_request, user_data) == 40 );
C_ASSERT( FIELD_OFFSET(struct set_window_info_request, extra_offset) == 48 );
C_ASSERT( FIELD_OFFSET(struct set_window_info_request, extra_size) == 52 );
C_ASSERT( FIELD_OFFSET(struct set_window_info_request, extra_value) == 56 );
1726
C_ASSERT( sizeof(struct set_window_info_request) == 64 );
1727 1728 1729 1730 1731 1732 1733 1734 1735
C_ASSERT( FIELD_OFFSET(struct set_window_info_reply, old_style) == 8 );
C_ASSERT( FIELD_OFFSET(struct set_window_info_reply, old_ex_style) == 12 );
C_ASSERT( FIELD_OFFSET(struct set_window_info_reply, old_instance) == 16 );
C_ASSERT( FIELD_OFFSET(struct set_window_info_reply, old_user_data) == 24 );
C_ASSERT( FIELD_OFFSET(struct set_window_info_reply, old_extra_value) == 32 );
C_ASSERT( FIELD_OFFSET(struct set_window_info_reply, old_id) == 40 );
C_ASSERT( sizeof(struct set_window_info_reply) == 48 );
C_ASSERT( FIELD_OFFSET(struct set_parent_request, handle) == 12 );
C_ASSERT( FIELD_OFFSET(struct set_parent_request, parent) == 16 );
1736
C_ASSERT( sizeof(struct set_parent_request) == 24 );
1737 1738
C_ASSERT( FIELD_OFFSET(struct set_parent_reply, old_parent) == 8 );
C_ASSERT( FIELD_OFFSET(struct set_parent_reply, full_parent) == 12 );
1739 1740
C_ASSERT( FIELD_OFFSET(struct set_parent_reply, dpi) == 16 );
C_ASSERT( FIELD_OFFSET(struct set_parent_reply, awareness) == 20 );
1741
C_ASSERT( sizeof(struct set_parent_reply) == 24 );
1742
C_ASSERT( FIELD_OFFSET(struct get_window_parents_request, handle) == 12 );
1743
C_ASSERT( sizeof(struct get_window_parents_request) == 16 );
1744 1745 1746 1747 1748 1749
C_ASSERT( FIELD_OFFSET(struct get_window_parents_reply, count) == 8 );
C_ASSERT( sizeof(struct get_window_parents_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct get_window_children_request, desktop) == 12 );
C_ASSERT( FIELD_OFFSET(struct get_window_children_request, parent) == 16 );
C_ASSERT( FIELD_OFFSET(struct get_window_children_request, atom) == 20 );
C_ASSERT( FIELD_OFFSET(struct get_window_children_request, tid) == 24 );
1750
C_ASSERT( sizeof(struct get_window_children_request) == 32 );
1751 1752 1753 1754 1755
C_ASSERT( FIELD_OFFSET(struct get_window_children_reply, count) == 8 );
C_ASSERT( sizeof(struct get_window_children_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct get_window_children_from_point_request, parent) == 12 );
C_ASSERT( FIELD_OFFSET(struct get_window_children_from_point_request, x) == 16 );
C_ASSERT( FIELD_OFFSET(struct get_window_children_from_point_request, y) == 20 );
1756 1757
C_ASSERT( FIELD_OFFSET(struct get_window_children_from_point_request, dpi) == 24 );
C_ASSERT( sizeof(struct get_window_children_from_point_request) == 32 );
1758 1759 1760
C_ASSERT( FIELD_OFFSET(struct get_window_children_from_point_reply, count) == 8 );
C_ASSERT( sizeof(struct get_window_children_from_point_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct get_window_tree_request, handle) == 12 );
1761
C_ASSERT( sizeof(struct get_window_tree_request) == 16 );
1762 1763 1764 1765 1766 1767 1768 1769 1770
C_ASSERT( FIELD_OFFSET(struct get_window_tree_reply, parent) == 8 );
C_ASSERT( FIELD_OFFSET(struct get_window_tree_reply, owner) == 12 );
C_ASSERT( FIELD_OFFSET(struct get_window_tree_reply, next_sibling) == 16 );
C_ASSERT( FIELD_OFFSET(struct get_window_tree_reply, prev_sibling) == 20 );
C_ASSERT( FIELD_OFFSET(struct get_window_tree_reply, first_sibling) == 24 );
C_ASSERT( FIELD_OFFSET(struct get_window_tree_reply, last_sibling) == 28 );
C_ASSERT( FIELD_OFFSET(struct get_window_tree_reply, first_child) == 32 );
C_ASSERT( FIELD_OFFSET(struct get_window_tree_reply, last_child) == 36 );
C_ASSERT( sizeof(struct get_window_tree_reply) == 40 );
1771 1772
C_ASSERT( FIELD_OFFSET(struct set_window_pos_request, swp_flags) == 12 );
C_ASSERT( FIELD_OFFSET(struct set_window_pos_request, paint_flags) == 14 );
1773 1774 1775 1776
C_ASSERT( FIELD_OFFSET(struct set_window_pos_request, handle) == 16 );
C_ASSERT( FIELD_OFFSET(struct set_window_pos_request, previous) == 20 );
C_ASSERT( FIELD_OFFSET(struct set_window_pos_request, window) == 24 );
C_ASSERT( FIELD_OFFSET(struct set_window_pos_request, client) == 40 );
1777
C_ASSERT( sizeof(struct set_window_pos_request) == 56 );
1778 1779
C_ASSERT( FIELD_OFFSET(struct set_window_pos_reply, new_style) == 8 );
C_ASSERT( FIELD_OFFSET(struct set_window_pos_reply, new_ex_style) == 12 );
1780
C_ASSERT( FIELD_OFFSET(struct set_window_pos_reply, surface_win) == 16 );
1781
C_ASSERT( FIELD_OFFSET(struct set_window_pos_reply, needs_update) == 20 );
1782
C_ASSERT( sizeof(struct set_window_pos_reply) == 24 );
1783
C_ASSERT( FIELD_OFFSET(struct get_window_rectangles_request, handle) == 12 );
1784
C_ASSERT( FIELD_OFFSET(struct get_window_rectangles_request, relative) == 16 );
1785
C_ASSERT( FIELD_OFFSET(struct get_window_rectangles_request, dpi) == 20 );
1786
C_ASSERT( sizeof(struct get_window_rectangles_request) == 24 );
1787
C_ASSERT( FIELD_OFFSET(struct get_window_rectangles_reply, window) == 8 );
1788 1789
C_ASSERT( FIELD_OFFSET(struct get_window_rectangles_reply, client) == 24 );
C_ASSERT( sizeof(struct get_window_rectangles_reply) == 40 );
1790
C_ASSERT( FIELD_OFFSET(struct get_window_text_request, handle) == 12 );
1791
C_ASSERT( sizeof(struct get_window_text_request) == 16 );
1792 1793
C_ASSERT( FIELD_OFFSET(struct get_window_text_reply, length) == 8 );
C_ASSERT( sizeof(struct get_window_text_reply) == 16 );
1794 1795 1796 1797
C_ASSERT( FIELD_OFFSET(struct set_window_text_request, handle) == 12 );
C_ASSERT( sizeof(struct set_window_text_request) == 16 );
C_ASSERT( FIELD_OFFSET(struct get_windows_offset_request, from) == 12 );
C_ASSERT( FIELD_OFFSET(struct get_windows_offset_request, to) == 16 );
1798
C_ASSERT( FIELD_OFFSET(struct get_windows_offset_request, dpi) == 20 );
1799
C_ASSERT( sizeof(struct get_windows_offset_request) == 24 );
1800 1801
C_ASSERT( FIELD_OFFSET(struct get_windows_offset_reply, x) == 8 );
C_ASSERT( FIELD_OFFSET(struct get_windows_offset_reply, y) == 12 );
1802 1803
C_ASSERT( FIELD_OFFSET(struct get_windows_offset_reply, mirror) == 16 );
C_ASSERT( sizeof(struct get_windows_offset_reply) == 24 );
1804 1805
C_ASSERT( FIELD_OFFSET(struct get_visible_region_request, window) == 12 );
C_ASSERT( FIELD_OFFSET(struct get_visible_region_request, flags) == 16 );
1806
C_ASSERT( sizeof(struct get_visible_region_request) == 24 );
1807 1808 1809
C_ASSERT( FIELD_OFFSET(struct get_visible_region_reply, top_win) == 8 );
C_ASSERT( FIELD_OFFSET(struct get_visible_region_reply, top_rect) == 12 );
C_ASSERT( FIELD_OFFSET(struct get_visible_region_reply, win_rect) == 28 );
1810 1811 1812
C_ASSERT( FIELD_OFFSET(struct get_visible_region_reply, paint_flags) == 44 );
C_ASSERT( FIELD_OFFSET(struct get_visible_region_reply, total_size) == 48 );
C_ASSERT( sizeof(struct get_visible_region_reply) == 56 );
1813 1814 1815 1816 1817
C_ASSERT( FIELD_OFFSET(struct get_surface_region_request, window) == 12 );
C_ASSERT( sizeof(struct get_surface_region_request) == 16 );
C_ASSERT( FIELD_OFFSET(struct get_surface_region_reply, visible_rect) == 8 );
C_ASSERT( FIELD_OFFSET(struct get_surface_region_reply, total_size) == 24 );
C_ASSERT( sizeof(struct get_surface_region_reply) == 32 );
1818
C_ASSERT( FIELD_OFFSET(struct get_window_region_request, window) == 12 );
1819
C_ASSERT( sizeof(struct get_window_region_request) == 16 );
1820 1821 1822 1823 1824 1825 1826 1827
C_ASSERT( FIELD_OFFSET(struct get_window_region_reply, total_size) == 8 );
C_ASSERT( sizeof(struct get_window_region_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct set_window_region_request, window) == 12 );
C_ASSERT( FIELD_OFFSET(struct set_window_region_request, redraw) == 16 );
C_ASSERT( sizeof(struct set_window_region_request) == 24 );
C_ASSERT( FIELD_OFFSET(struct get_update_region_request, window) == 12 );
C_ASSERT( FIELD_OFFSET(struct get_update_region_request, from_child) == 16 );
C_ASSERT( FIELD_OFFSET(struct get_update_region_request, flags) == 20 );
1828
C_ASSERT( sizeof(struct get_update_region_request) == 24 );
1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844
C_ASSERT( FIELD_OFFSET(struct get_update_region_reply, child) == 8 );
C_ASSERT( FIELD_OFFSET(struct get_update_region_reply, flags) == 12 );
C_ASSERT( FIELD_OFFSET(struct get_update_region_reply, total_size) == 16 );
C_ASSERT( sizeof(struct get_update_region_reply) == 24 );
C_ASSERT( FIELD_OFFSET(struct update_window_zorder_request, window) == 12 );
C_ASSERT( FIELD_OFFSET(struct update_window_zorder_request, rect) == 16 );
C_ASSERT( sizeof(struct update_window_zorder_request) == 32 );
C_ASSERT( FIELD_OFFSET(struct redraw_window_request, window) == 12 );
C_ASSERT( FIELD_OFFSET(struct redraw_window_request, flags) == 16 );
C_ASSERT( sizeof(struct redraw_window_request) == 24 );
C_ASSERT( FIELD_OFFSET(struct set_window_property_request, window) == 12 );
C_ASSERT( FIELD_OFFSET(struct set_window_property_request, data) == 16 );
C_ASSERT( FIELD_OFFSET(struct set_window_property_request, atom) == 24 );
C_ASSERT( sizeof(struct set_window_property_request) == 32 );
C_ASSERT( FIELD_OFFSET(struct remove_window_property_request, window) == 12 );
C_ASSERT( FIELD_OFFSET(struct remove_window_property_request, atom) == 16 );
1845
C_ASSERT( sizeof(struct remove_window_property_request) == 24 );
1846 1847 1848 1849
C_ASSERT( FIELD_OFFSET(struct remove_window_property_reply, data) == 8 );
C_ASSERT( sizeof(struct remove_window_property_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct get_window_property_request, window) == 12 );
C_ASSERT( FIELD_OFFSET(struct get_window_property_request, atom) == 16 );
1850
C_ASSERT( sizeof(struct get_window_property_request) == 24 );
1851 1852 1853
C_ASSERT( FIELD_OFFSET(struct get_window_property_reply, data) == 8 );
C_ASSERT( sizeof(struct get_window_property_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct get_window_properties_request, window) == 12 );
1854
C_ASSERT( sizeof(struct get_window_properties_request) == 16 );
1855 1856 1857 1858 1859
C_ASSERT( FIELD_OFFSET(struct get_window_properties_reply, total) == 8 );
C_ASSERT( sizeof(struct get_window_properties_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct create_winstation_request, flags) == 12 );
C_ASSERT( FIELD_OFFSET(struct create_winstation_request, access) == 16 );
C_ASSERT( FIELD_OFFSET(struct create_winstation_request, attributes) == 20 );
1860 1861
C_ASSERT( FIELD_OFFSET(struct create_winstation_request, rootdir) == 24 );
C_ASSERT( sizeof(struct create_winstation_request) == 32 );
1862 1863 1864 1865
C_ASSERT( FIELD_OFFSET(struct create_winstation_reply, handle) == 8 );
C_ASSERT( sizeof(struct create_winstation_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct open_winstation_request, access) == 12 );
C_ASSERT( FIELD_OFFSET(struct open_winstation_request, attributes) == 16 );
1866
C_ASSERT( FIELD_OFFSET(struct open_winstation_request, rootdir) == 20 );
1867
C_ASSERT( sizeof(struct open_winstation_request) == 24 );
1868 1869 1870 1871
C_ASSERT( FIELD_OFFSET(struct open_winstation_reply, handle) == 8 );
C_ASSERT( sizeof(struct open_winstation_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct close_winstation_request, handle) == 12 );
C_ASSERT( sizeof(struct close_winstation_request) == 16 );
1872
C_ASSERT( sizeof(struct get_process_winstation_request) == 16 );
1873 1874 1875 1876 1877
C_ASSERT( FIELD_OFFSET(struct get_process_winstation_reply, handle) == 8 );
C_ASSERT( sizeof(struct get_process_winstation_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct set_process_winstation_request, handle) == 12 );
C_ASSERT( sizeof(struct set_process_winstation_request) == 16 );
C_ASSERT( FIELD_OFFSET(struct enum_winstation_request, index) == 12 );
1878
C_ASSERT( sizeof(struct enum_winstation_request) == 16 );
1879 1880 1881 1882 1883
C_ASSERT( FIELD_OFFSET(struct enum_winstation_reply, next) == 8 );
C_ASSERT( sizeof(struct enum_winstation_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct create_desktop_request, flags) == 12 );
C_ASSERT( FIELD_OFFSET(struct create_desktop_request, access) == 16 );
C_ASSERT( FIELD_OFFSET(struct create_desktop_request, attributes) == 20 );
1884
C_ASSERT( sizeof(struct create_desktop_request) == 24 );
1885 1886 1887 1888 1889 1890
C_ASSERT( FIELD_OFFSET(struct create_desktop_reply, handle) == 8 );
C_ASSERT( sizeof(struct create_desktop_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct open_desktop_request, winsta) == 12 );
C_ASSERT( FIELD_OFFSET(struct open_desktop_request, flags) == 16 );
C_ASSERT( FIELD_OFFSET(struct open_desktop_request, access) == 20 );
C_ASSERT( FIELD_OFFSET(struct open_desktop_request, attributes) == 24 );
1891
C_ASSERT( sizeof(struct open_desktop_request) == 32 );
1892 1893
C_ASSERT( FIELD_OFFSET(struct open_desktop_reply, handle) == 8 );
C_ASSERT( sizeof(struct open_desktop_reply) == 16 );
1894 1895 1896 1897 1898 1899
C_ASSERT( FIELD_OFFSET(struct open_input_desktop_request, flags) == 12 );
C_ASSERT( FIELD_OFFSET(struct open_input_desktop_request, access) == 16 );
C_ASSERT( FIELD_OFFSET(struct open_input_desktop_request, attributes) == 20 );
C_ASSERT( sizeof(struct open_input_desktop_request) == 24 );
C_ASSERT( FIELD_OFFSET(struct open_input_desktop_reply, handle) == 8 );
C_ASSERT( sizeof(struct open_input_desktop_reply) == 16 );
1900 1901 1902
C_ASSERT( FIELD_OFFSET(struct close_desktop_request, handle) == 12 );
C_ASSERT( sizeof(struct close_desktop_request) == 16 );
C_ASSERT( FIELD_OFFSET(struct get_thread_desktop_request, tid) == 12 );
1903
C_ASSERT( sizeof(struct get_thread_desktop_request) == 16 );
1904 1905 1906 1907 1908 1909
C_ASSERT( FIELD_OFFSET(struct get_thread_desktop_reply, handle) == 8 );
C_ASSERT( sizeof(struct get_thread_desktop_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct set_thread_desktop_request, handle) == 12 );
C_ASSERT( sizeof(struct set_thread_desktop_request) == 16 );
C_ASSERT( FIELD_OFFSET(struct enum_desktop_request, winstation) == 12 );
C_ASSERT( FIELD_OFFSET(struct enum_desktop_request, index) == 16 );
1910
C_ASSERT( sizeof(struct enum_desktop_request) == 24 );
1911 1912 1913 1914 1915
C_ASSERT( FIELD_OFFSET(struct enum_desktop_reply, next) == 8 );
C_ASSERT( sizeof(struct enum_desktop_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct set_user_object_info_request, handle) == 12 );
C_ASSERT( FIELD_OFFSET(struct set_user_object_info_request, flags) == 16 );
C_ASSERT( FIELD_OFFSET(struct set_user_object_info_request, obj_flags) == 20 );
1916
C_ASSERT( sizeof(struct set_user_object_info_request) == 24 );
1917 1918 1919
C_ASSERT( FIELD_OFFSET(struct set_user_object_info_reply, is_desktop) == 8 );
C_ASSERT( FIELD_OFFSET(struct set_user_object_info_reply, old_obj_flags) == 12 );
C_ASSERT( sizeof(struct set_user_object_info_reply) == 16 );
1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934
C_ASSERT( FIELD_OFFSET(struct register_hotkey_request, window) == 12 );
C_ASSERT( FIELD_OFFSET(struct register_hotkey_request, id) == 16 );
C_ASSERT( FIELD_OFFSET(struct register_hotkey_request, flags) == 20 );
C_ASSERT( FIELD_OFFSET(struct register_hotkey_request, vkey) == 24 );
C_ASSERT( sizeof(struct register_hotkey_request) == 32 );
C_ASSERT( FIELD_OFFSET(struct register_hotkey_reply, replaced) == 8 );
C_ASSERT( FIELD_OFFSET(struct register_hotkey_reply, flags) == 12 );
C_ASSERT( FIELD_OFFSET(struct register_hotkey_reply, vkey) == 16 );
C_ASSERT( sizeof(struct register_hotkey_reply) == 24 );
C_ASSERT( FIELD_OFFSET(struct unregister_hotkey_request, window) == 12 );
C_ASSERT( FIELD_OFFSET(struct unregister_hotkey_request, id) == 16 );
C_ASSERT( sizeof(struct unregister_hotkey_request) == 24 );
C_ASSERT( FIELD_OFFSET(struct unregister_hotkey_reply, flags) == 8 );
C_ASSERT( FIELD_OFFSET(struct unregister_hotkey_reply, vkey) == 12 );
C_ASSERT( sizeof(struct unregister_hotkey_reply) == 16 );
1935 1936 1937 1938 1939
C_ASSERT( FIELD_OFFSET(struct attach_thread_input_request, tid_from) == 12 );
C_ASSERT( FIELD_OFFSET(struct attach_thread_input_request, tid_to) == 16 );
C_ASSERT( FIELD_OFFSET(struct attach_thread_input_request, attach) == 20 );
C_ASSERT( sizeof(struct attach_thread_input_request) == 24 );
C_ASSERT( FIELD_OFFSET(struct get_thread_input_request, tid) == 12 );
1940
C_ASSERT( sizeof(struct get_thread_input_request) == 16 );
1941 1942 1943 1944 1945 1946 1947
C_ASSERT( FIELD_OFFSET(struct get_thread_input_reply, focus) == 8 );
C_ASSERT( FIELD_OFFSET(struct get_thread_input_reply, capture) == 12 );
C_ASSERT( FIELD_OFFSET(struct get_thread_input_reply, active) == 16 );
C_ASSERT( FIELD_OFFSET(struct get_thread_input_reply, foreground) == 20 );
C_ASSERT( FIELD_OFFSET(struct get_thread_input_reply, menu_owner) == 24 );
C_ASSERT( FIELD_OFFSET(struct get_thread_input_reply, move_size) == 28 );
C_ASSERT( FIELD_OFFSET(struct get_thread_input_reply, caret) == 32 );
1948 1949 1950 1951
C_ASSERT( FIELD_OFFSET(struct get_thread_input_reply, cursor) == 36 );
C_ASSERT( FIELD_OFFSET(struct get_thread_input_reply, show_count) == 40 );
C_ASSERT( FIELD_OFFSET(struct get_thread_input_reply, rect) == 44 );
C_ASSERT( sizeof(struct get_thread_input_reply) == 64 );
1952
C_ASSERT( sizeof(struct get_last_input_time_request) == 16 );
1953 1954 1955 1956
C_ASSERT( FIELD_OFFSET(struct get_last_input_time_reply, time) == 8 );
C_ASSERT( sizeof(struct get_last_input_time_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct get_key_state_request, tid) == 12 );
C_ASSERT( FIELD_OFFSET(struct get_key_state_request, key) == 16 );
1957
C_ASSERT( sizeof(struct get_key_state_request) == 24 );
1958 1959 1960
C_ASSERT( FIELD_OFFSET(struct get_key_state_reply, state) == 8 );
C_ASSERT( sizeof(struct get_key_state_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct set_key_state_request, tid) == 12 );
1961 1962
C_ASSERT( FIELD_OFFSET(struct set_key_state_request, async) == 16 );
C_ASSERT( sizeof(struct set_key_state_request) == 24 );
1963
C_ASSERT( FIELD_OFFSET(struct set_foreground_window_request, handle) == 12 );
1964
C_ASSERT( sizeof(struct set_foreground_window_request) == 16 );
1965 1966 1967 1968 1969
C_ASSERT( FIELD_OFFSET(struct set_foreground_window_reply, previous) == 8 );
C_ASSERT( FIELD_OFFSET(struct set_foreground_window_reply, send_msg_old) == 12 );
C_ASSERT( FIELD_OFFSET(struct set_foreground_window_reply, send_msg_new) == 16 );
C_ASSERT( sizeof(struct set_foreground_window_reply) == 24 );
C_ASSERT( FIELD_OFFSET(struct set_focus_window_request, handle) == 12 );
1970
C_ASSERT( sizeof(struct set_focus_window_request) == 16 );
1971 1972 1973
C_ASSERT( FIELD_OFFSET(struct set_focus_window_reply, previous) == 8 );
C_ASSERT( sizeof(struct set_focus_window_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct set_active_window_request, handle) == 12 );
1974
C_ASSERT( sizeof(struct set_active_window_request) == 16 );
1975 1976 1977 1978
C_ASSERT( FIELD_OFFSET(struct set_active_window_reply, previous) == 8 );
C_ASSERT( sizeof(struct set_active_window_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct set_capture_window_request, handle) == 12 );
C_ASSERT( FIELD_OFFSET(struct set_capture_window_request, flags) == 16 );
1979
C_ASSERT( sizeof(struct set_capture_window_request) == 24 );
1980 1981 1982 1983 1984 1985
C_ASSERT( FIELD_OFFSET(struct set_capture_window_reply, previous) == 8 );
C_ASSERT( FIELD_OFFSET(struct set_capture_window_reply, full_handle) == 12 );
C_ASSERT( sizeof(struct set_capture_window_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct set_caret_window_request, handle) == 12 );
C_ASSERT( FIELD_OFFSET(struct set_caret_window_request, width) == 16 );
C_ASSERT( FIELD_OFFSET(struct set_caret_window_request, height) == 20 );
1986
C_ASSERT( sizeof(struct set_caret_window_request) == 24 );
1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997
C_ASSERT( FIELD_OFFSET(struct set_caret_window_reply, previous) == 8 );
C_ASSERT( FIELD_OFFSET(struct set_caret_window_reply, old_rect) == 12 );
C_ASSERT( FIELD_OFFSET(struct set_caret_window_reply, old_hide) == 28 );
C_ASSERT( FIELD_OFFSET(struct set_caret_window_reply, old_state) == 32 );
C_ASSERT( sizeof(struct set_caret_window_reply) == 40 );
C_ASSERT( FIELD_OFFSET(struct set_caret_info_request, flags) == 12 );
C_ASSERT( FIELD_OFFSET(struct set_caret_info_request, handle) == 16 );
C_ASSERT( FIELD_OFFSET(struct set_caret_info_request, x) == 20 );
C_ASSERT( FIELD_OFFSET(struct set_caret_info_request, y) == 24 );
C_ASSERT( FIELD_OFFSET(struct set_caret_info_request, hide) == 28 );
C_ASSERT( FIELD_OFFSET(struct set_caret_info_request, state) == 32 );
1998
C_ASSERT( sizeof(struct set_caret_info_request) == 40 );
1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011
C_ASSERT( FIELD_OFFSET(struct set_caret_info_reply, full_handle) == 8 );
C_ASSERT( FIELD_OFFSET(struct set_caret_info_reply, old_rect) == 12 );
C_ASSERT( FIELD_OFFSET(struct set_caret_info_reply, old_hide) == 28 );
C_ASSERT( FIELD_OFFSET(struct set_caret_info_reply, old_state) == 32 );
C_ASSERT( sizeof(struct set_caret_info_reply) == 40 );
C_ASSERT( FIELD_OFFSET(struct set_hook_request, id) == 12 );
C_ASSERT( FIELD_OFFSET(struct set_hook_request, pid) == 16 );
C_ASSERT( FIELD_OFFSET(struct set_hook_request, tid) == 20 );
C_ASSERT( FIELD_OFFSET(struct set_hook_request, event_min) == 24 );
C_ASSERT( FIELD_OFFSET(struct set_hook_request, event_max) == 28 );
C_ASSERT( FIELD_OFFSET(struct set_hook_request, proc) == 32 );
C_ASSERT( FIELD_OFFSET(struct set_hook_request, flags) == 40 );
C_ASSERT( FIELD_OFFSET(struct set_hook_request, unicode) == 44 );
2012
C_ASSERT( sizeof(struct set_hook_request) == 48 );
2013 2014 2015 2016 2017 2018
C_ASSERT( FIELD_OFFSET(struct set_hook_reply, handle) == 8 );
C_ASSERT( FIELD_OFFSET(struct set_hook_reply, active_hooks) == 12 );
C_ASSERT( sizeof(struct set_hook_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct remove_hook_request, handle) == 12 );
C_ASSERT( FIELD_OFFSET(struct remove_hook_request, proc) == 16 );
C_ASSERT( FIELD_OFFSET(struct remove_hook_request, id) == 24 );
2019
C_ASSERT( sizeof(struct remove_hook_request) == 32 );
2020 2021 2022 2023 2024 2025 2026
C_ASSERT( FIELD_OFFSET(struct remove_hook_reply, active_hooks) == 8 );
C_ASSERT( sizeof(struct remove_hook_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct start_hook_chain_request, id) == 12 );
C_ASSERT( FIELD_OFFSET(struct start_hook_chain_request, event) == 16 );
C_ASSERT( FIELD_OFFSET(struct start_hook_chain_request, window) == 20 );
C_ASSERT( FIELD_OFFSET(struct start_hook_chain_request, object_id) == 24 );
C_ASSERT( FIELD_OFFSET(struct start_hook_chain_request, child_id) == 28 );
2027
C_ASSERT( sizeof(struct start_hook_chain_request) == 32 );
2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042
C_ASSERT( FIELD_OFFSET(struct start_hook_chain_reply, handle) == 8 );
C_ASSERT( FIELD_OFFSET(struct start_hook_chain_reply, pid) == 12 );
C_ASSERT( FIELD_OFFSET(struct start_hook_chain_reply, tid) == 16 );
C_ASSERT( FIELD_OFFSET(struct start_hook_chain_reply, unicode) == 20 );
C_ASSERT( FIELD_OFFSET(struct start_hook_chain_reply, proc) == 24 );
C_ASSERT( FIELD_OFFSET(struct start_hook_chain_reply, active_hooks) == 32 );
C_ASSERT( sizeof(struct start_hook_chain_reply) == 40 );
C_ASSERT( FIELD_OFFSET(struct finish_hook_chain_request, id) == 12 );
C_ASSERT( sizeof(struct finish_hook_chain_request) == 16 );
C_ASSERT( FIELD_OFFSET(struct get_hook_info_request, handle) == 12 );
C_ASSERT( FIELD_OFFSET(struct get_hook_info_request, get_next) == 16 );
C_ASSERT( FIELD_OFFSET(struct get_hook_info_request, event) == 20 );
C_ASSERT( FIELD_OFFSET(struct get_hook_info_request, window) == 24 );
C_ASSERT( FIELD_OFFSET(struct get_hook_info_request, object_id) == 28 );
C_ASSERT( FIELD_OFFSET(struct get_hook_info_request, child_id) == 32 );
2043
C_ASSERT( sizeof(struct get_hook_info_request) == 40 );
2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057
C_ASSERT( FIELD_OFFSET(struct get_hook_info_reply, handle) == 8 );
C_ASSERT( FIELD_OFFSET(struct get_hook_info_reply, id) == 12 );
C_ASSERT( FIELD_OFFSET(struct get_hook_info_reply, pid) == 16 );
C_ASSERT( FIELD_OFFSET(struct get_hook_info_reply, tid) == 20 );
C_ASSERT( FIELD_OFFSET(struct get_hook_info_reply, proc) == 24 );
C_ASSERT( FIELD_OFFSET(struct get_hook_info_reply, unicode) == 32 );
C_ASSERT( sizeof(struct get_hook_info_reply) == 40 );
C_ASSERT( FIELD_OFFSET(struct create_class_request, local) == 12 );
C_ASSERT( FIELD_OFFSET(struct create_class_request, atom) == 16 );
C_ASSERT( FIELD_OFFSET(struct create_class_request, style) == 20 );
C_ASSERT( FIELD_OFFSET(struct create_class_request, instance) == 24 );
C_ASSERT( FIELD_OFFSET(struct create_class_request, extra) == 32 );
C_ASSERT( FIELD_OFFSET(struct create_class_request, win_extra) == 36 );
C_ASSERT( FIELD_OFFSET(struct create_class_request, client_ptr) == 40 );
2058 2059
C_ASSERT( FIELD_OFFSET(struct create_class_request, name_offset) == 48 );
C_ASSERT( sizeof(struct create_class_request) == 56 );
2060 2061 2062 2063
C_ASSERT( FIELD_OFFSET(struct create_class_reply, atom) == 8 );
C_ASSERT( sizeof(struct create_class_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct destroy_class_request, atom) == 12 );
C_ASSERT( FIELD_OFFSET(struct destroy_class_request, instance) == 16 );
2064
C_ASSERT( sizeof(struct destroy_class_request) == 24 );
2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075
C_ASSERT( FIELD_OFFSET(struct destroy_class_reply, client_ptr) == 8 );
C_ASSERT( sizeof(struct destroy_class_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct set_class_info_request, window) == 12 );
C_ASSERT( FIELD_OFFSET(struct set_class_info_request, flags) == 16 );
C_ASSERT( FIELD_OFFSET(struct set_class_info_request, atom) == 20 );
C_ASSERT( FIELD_OFFSET(struct set_class_info_request, style) == 24 );
C_ASSERT( FIELD_OFFSET(struct set_class_info_request, win_extra) == 28 );
C_ASSERT( FIELD_OFFSET(struct set_class_info_request, instance) == 32 );
C_ASSERT( FIELD_OFFSET(struct set_class_info_request, extra_offset) == 40 );
C_ASSERT( FIELD_OFFSET(struct set_class_info_request, extra_size) == 44 );
C_ASSERT( FIELD_OFFSET(struct set_class_info_request, extra_value) == 48 );
2076
C_ASSERT( sizeof(struct set_class_info_request) == 56 );
2077
C_ASSERT( FIELD_OFFSET(struct set_class_info_reply, old_atom) == 8 );
2078 2079 2080 2081 2082 2083 2084
C_ASSERT( FIELD_OFFSET(struct set_class_info_reply, base_atom) == 12 );
C_ASSERT( FIELD_OFFSET(struct set_class_info_reply, old_instance) == 16 );
C_ASSERT( FIELD_OFFSET(struct set_class_info_reply, old_extra_value) == 24 );
C_ASSERT( FIELD_OFFSET(struct set_class_info_reply, old_style) == 32 );
C_ASSERT( FIELD_OFFSET(struct set_class_info_reply, old_extra) == 36 );
C_ASSERT( FIELD_OFFSET(struct set_class_info_reply, old_win_extra) == 40 );
C_ASSERT( sizeof(struct set_class_info_reply) == 48 );
2085 2086 2087 2088 2089 2090 2091 2092
C_ASSERT( FIELD_OFFSET(struct open_clipboard_request, window) == 12 );
C_ASSERT( sizeof(struct open_clipboard_request) == 16 );
C_ASSERT( FIELD_OFFSET(struct open_clipboard_reply, owner) == 8 );
C_ASSERT( sizeof(struct open_clipboard_reply) == 16 );
C_ASSERT( sizeof(struct close_clipboard_request) == 16 );
C_ASSERT( FIELD_OFFSET(struct close_clipboard_reply, viewer) == 8 );
C_ASSERT( FIELD_OFFSET(struct close_clipboard_reply, owner) == 12 );
C_ASSERT( sizeof(struct close_clipboard_reply) == 16 );
2093
C_ASSERT( sizeof(struct empty_clipboard_request) == 16 );
2094
C_ASSERT( FIELD_OFFSET(struct set_clipboard_data_request, format) == 12 );
2095 2096
C_ASSERT( FIELD_OFFSET(struct set_clipboard_data_request, lcid) == 16 );
C_ASSERT( sizeof(struct set_clipboard_data_request) == 24 );
2097 2098
C_ASSERT( FIELD_OFFSET(struct set_clipboard_data_reply, seqno) == 8 );
C_ASSERT( sizeof(struct set_clipboard_data_reply) == 16 );
2099
C_ASSERT( FIELD_OFFSET(struct get_clipboard_data_request, format) == 12 );
2100 2101 2102 2103
C_ASSERT( FIELD_OFFSET(struct get_clipboard_data_request, render) == 16 );
C_ASSERT( FIELD_OFFSET(struct get_clipboard_data_request, cached) == 20 );
C_ASSERT( FIELD_OFFSET(struct get_clipboard_data_request, seqno) == 24 );
C_ASSERT( sizeof(struct get_clipboard_data_request) == 32 );
2104 2105
C_ASSERT( FIELD_OFFSET(struct get_clipboard_data_reply, from) == 8 );
C_ASSERT( FIELD_OFFSET(struct get_clipboard_data_reply, owner) == 12 );
2106 2107
C_ASSERT( FIELD_OFFSET(struct get_clipboard_data_reply, seqno) == 16 );
C_ASSERT( FIELD_OFFSET(struct get_clipboard_data_reply, total) == 20 );
2108
C_ASSERT( sizeof(struct get_clipboard_data_reply) == 24 );
2109 2110 2111 2112 2113 2114 2115 2116
C_ASSERT( FIELD_OFFSET(struct get_clipboard_formats_request, format) == 12 );
C_ASSERT( sizeof(struct get_clipboard_formats_request) == 16 );
C_ASSERT( FIELD_OFFSET(struct get_clipboard_formats_reply, count) == 8 );
C_ASSERT( sizeof(struct get_clipboard_formats_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct enum_clipboard_formats_request, previous) == 12 );
C_ASSERT( sizeof(struct enum_clipboard_formats_request) == 16 );
C_ASSERT( FIELD_OFFSET(struct enum_clipboard_formats_reply, format) == 8 );
C_ASSERT( sizeof(struct enum_clipboard_formats_reply) == 16 );
2117 2118 2119
C_ASSERT( FIELD_OFFSET(struct release_clipboard_request, owner) == 12 );
C_ASSERT( sizeof(struct release_clipboard_request) == 16 );
C_ASSERT( FIELD_OFFSET(struct release_clipboard_reply, viewer) == 8 );
2120
C_ASSERT( FIELD_OFFSET(struct release_clipboard_reply, owner) == 12 );
2121
C_ASSERT( sizeof(struct release_clipboard_reply) == 16 );
2122 2123 2124 2125 2126 2127
C_ASSERT( sizeof(struct get_clipboard_info_request) == 16 );
C_ASSERT( FIELD_OFFSET(struct get_clipboard_info_reply, window) == 8 );
C_ASSERT( FIELD_OFFSET(struct get_clipboard_info_reply, owner) == 12 );
C_ASSERT( FIELD_OFFSET(struct get_clipboard_info_reply, viewer) == 16 );
C_ASSERT( FIELD_OFFSET(struct get_clipboard_info_reply, seqno) == 20 );
C_ASSERT( sizeof(struct get_clipboard_info_reply) == 24 );
2128 2129 2130 2131 2132 2133
C_ASSERT( FIELD_OFFSET(struct set_clipboard_viewer_request, viewer) == 12 );
C_ASSERT( FIELD_OFFSET(struct set_clipboard_viewer_request, previous) == 16 );
C_ASSERT( sizeof(struct set_clipboard_viewer_request) == 24 );
C_ASSERT( FIELD_OFFSET(struct set_clipboard_viewer_reply, old_viewer) == 8 );
C_ASSERT( FIELD_OFFSET(struct set_clipboard_viewer_reply, owner) == 12 );
C_ASSERT( sizeof(struct set_clipboard_viewer_reply) == 16 );
2134 2135 2136 2137
C_ASSERT( FIELD_OFFSET(struct add_clipboard_listener_request, window) == 12 );
C_ASSERT( sizeof(struct add_clipboard_listener_request) == 16 );
C_ASSERT( FIELD_OFFSET(struct remove_clipboard_listener_request, window) == 12 );
C_ASSERT( sizeof(struct remove_clipboard_listener_request) == 16 );
2138 2139 2140 2141
C_ASSERT( FIELD_OFFSET(struct open_token_request, handle) == 12 );
C_ASSERT( FIELD_OFFSET(struct open_token_request, access) == 16 );
C_ASSERT( FIELD_OFFSET(struct open_token_request, attributes) == 20 );
C_ASSERT( FIELD_OFFSET(struct open_token_request, flags) == 24 );
2142
C_ASSERT( sizeof(struct open_token_request) == 32 );
2143 2144 2145 2146 2147 2148 2149
C_ASSERT( FIELD_OFFSET(struct open_token_reply, token) == 8 );
C_ASSERT( sizeof(struct open_token_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct set_global_windows_request, flags) == 12 );
C_ASSERT( FIELD_OFFSET(struct set_global_windows_request, shell_window) == 16 );
C_ASSERT( FIELD_OFFSET(struct set_global_windows_request, shell_listview) == 20 );
C_ASSERT( FIELD_OFFSET(struct set_global_windows_request, progman_window) == 24 );
C_ASSERT( FIELD_OFFSET(struct set_global_windows_request, taskman_window) == 28 );
2150
C_ASSERT( sizeof(struct set_global_windows_request) == 32 );
2151 2152 2153 2154 2155 2156 2157 2158
C_ASSERT( FIELD_OFFSET(struct set_global_windows_reply, old_shell_window) == 8 );
C_ASSERT( FIELD_OFFSET(struct set_global_windows_reply, old_shell_listview) == 12 );
C_ASSERT( FIELD_OFFSET(struct set_global_windows_reply, old_progman_window) == 16 );
C_ASSERT( FIELD_OFFSET(struct set_global_windows_reply, old_taskman_window) == 20 );
C_ASSERT( sizeof(struct set_global_windows_reply) == 24 );
C_ASSERT( FIELD_OFFSET(struct adjust_token_privileges_request, handle) == 12 );
C_ASSERT( FIELD_OFFSET(struct adjust_token_privileges_request, disable_all) == 16 );
C_ASSERT( FIELD_OFFSET(struct adjust_token_privileges_request, get_modified_state) == 20 );
2159
C_ASSERT( sizeof(struct adjust_token_privileges_request) == 24 );
2160 2161 2162
C_ASSERT( FIELD_OFFSET(struct adjust_token_privileges_reply, len) == 8 );
C_ASSERT( sizeof(struct adjust_token_privileges_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct get_token_privileges_request, handle) == 12 );
2163
C_ASSERT( sizeof(struct get_token_privileges_request) == 16 );
2164 2165 2166 2167
C_ASSERT( FIELD_OFFSET(struct get_token_privileges_reply, len) == 8 );
C_ASSERT( sizeof(struct get_token_privileges_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct check_token_privileges_request, handle) == 12 );
C_ASSERT( FIELD_OFFSET(struct check_token_privileges_request, all_required) == 16 );
2168
C_ASSERT( sizeof(struct check_token_privileges_request) == 24 );
2169 2170 2171 2172
C_ASSERT( FIELD_OFFSET(struct check_token_privileges_reply, has_privileges) == 8 );
C_ASSERT( sizeof(struct check_token_privileges_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct duplicate_token_request, handle) == 12 );
C_ASSERT( FIELD_OFFSET(struct duplicate_token_request, access) == 16 );
2173 2174
C_ASSERT( FIELD_OFFSET(struct duplicate_token_request, primary) == 20 );
C_ASSERT( FIELD_OFFSET(struct duplicate_token_request, impersonation_level) == 24 );
2175
C_ASSERT( sizeof(struct duplicate_token_request) == 32 );
2176 2177 2178 2179 2180 2181 2182 2183
C_ASSERT( FIELD_OFFSET(struct duplicate_token_reply, new_handle) == 8 );
C_ASSERT( sizeof(struct duplicate_token_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct access_check_request, handle) == 12 );
C_ASSERT( FIELD_OFFSET(struct access_check_request, desired_access) == 16 );
C_ASSERT( FIELD_OFFSET(struct access_check_request, mapping_read) == 20 );
C_ASSERT( FIELD_OFFSET(struct access_check_request, mapping_write) == 24 );
C_ASSERT( FIELD_OFFSET(struct access_check_request, mapping_execute) == 28 );
C_ASSERT( FIELD_OFFSET(struct access_check_request, mapping_all) == 32 );
2184
C_ASSERT( sizeof(struct access_check_request) == 40 );
2185 2186 2187 2188
C_ASSERT( FIELD_OFFSET(struct access_check_reply, access_granted) == 8 );
C_ASSERT( FIELD_OFFSET(struct access_check_reply, access_status) == 12 );
C_ASSERT( FIELD_OFFSET(struct access_check_reply, privileges_len) == 16 );
C_ASSERT( sizeof(struct access_check_reply) == 24 );
2189 2190
C_ASSERT( FIELD_OFFSET(struct get_token_sid_request, handle) == 12 );
C_ASSERT( FIELD_OFFSET(struct get_token_sid_request, which_sid) == 16 );
2191
C_ASSERT( sizeof(struct get_token_sid_request) == 24 );
2192 2193
C_ASSERT( FIELD_OFFSET(struct get_token_sid_reply, sid_len) == 8 );
C_ASSERT( sizeof(struct get_token_sid_reply) == 16 );
2194
C_ASSERT( FIELD_OFFSET(struct get_token_groups_request, handle) == 12 );
2195
C_ASSERT( sizeof(struct get_token_groups_request) == 16 );
2196 2197
C_ASSERT( FIELD_OFFSET(struct get_token_groups_reply, user_len) == 8 );
C_ASSERT( sizeof(struct get_token_groups_reply) == 16 );
2198
C_ASSERT( FIELD_OFFSET(struct get_token_default_dacl_request, handle) == 12 );
2199
C_ASSERT( sizeof(struct get_token_default_dacl_request) == 16 );
2200 2201 2202 2203
C_ASSERT( FIELD_OFFSET(struct get_token_default_dacl_reply, acl_len) == 8 );
C_ASSERT( sizeof(struct get_token_default_dacl_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct set_token_default_dacl_request, handle) == 12 );
C_ASSERT( sizeof(struct set_token_default_dacl_request) == 16 );
2204 2205 2206 2207 2208
C_ASSERT( FIELD_OFFSET(struct set_security_object_request, handle) == 12 );
C_ASSERT( FIELD_OFFSET(struct set_security_object_request, security_info) == 16 );
C_ASSERT( sizeof(struct set_security_object_request) == 24 );
C_ASSERT( FIELD_OFFSET(struct get_security_object_request, handle) == 12 );
C_ASSERT( FIELD_OFFSET(struct get_security_object_request, security_info) == 16 );
2209
C_ASSERT( sizeof(struct get_security_object_request) == 24 );
2210 2211
C_ASSERT( FIELD_OFFSET(struct get_security_object_reply, sd_len) == 8 );
C_ASSERT( sizeof(struct get_security_object_reply) == 16 );
2212 2213 2214
C_ASSERT( sizeof(struct get_system_handles_request) == 16 );
C_ASSERT( FIELD_OFFSET(struct get_system_handles_reply, count) == 8 );
C_ASSERT( sizeof(struct get_system_handles_reply) == 16 );
2215
C_ASSERT( FIELD_OFFSET(struct create_mailslot_request, access) == 12 );
2216 2217 2218
C_ASSERT( FIELD_OFFSET(struct create_mailslot_request, read_timeout) == 16 );
C_ASSERT( FIELD_OFFSET(struct create_mailslot_request, max_msgsize) == 24 );
C_ASSERT( sizeof(struct create_mailslot_request) == 32 );
2219 2220 2221 2222 2223
C_ASSERT( FIELD_OFFSET(struct create_mailslot_reply, handle) == 8 );
C_ASSERT( sizeof(struct create_mailslot_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct set_mailslot_info_request, handle) == 12 );
C_ASSERT( FIELD_OFFSET(struct set_mailslot_info_request, read_timeout) == 16 );
C_ASSERT( FIELD_OFFSET(struct set_mailslot_info_request, flags) == 24 );
2224
C_ASSERT( sizeof(struct set_mailslot_info_request) == 32 );
2225 2226 2227 2228
C_ASSERT( FIELD_OFFSET(struct set_mailslot_info_reply, read_timeout) == 8 );
C_ASSERT( FIELD_OFFSET(struct set_mailslot_info_reply, max_msgsize) == 16 );
C_ASSERT( sizeof(struct set_mailslot_info_reply) == 24 );
C_ASSERT( FIELD_OFFSET(struct create_directory_request, access) == 12 );
2229
C_ASSERT( sizeof(struct create_directory_request) == 16 );
2230 2231 2232 2233 2234
C_ASSERT( FIELD_OFFSET(struct create_directory_reply, handle) == 8 );
C_ASSERT( sizeof(struct create_directory_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct open_directory_request, access) == 12 );
C_ASSERT( FIELD_OFFSET(struct open_directory_request, attributes) == 16 );
C_ASSERT( FIELD_OFFSET(struct open_directory_request, rootdir) == 20 );
2235
C_ASSERT( sizeof(struct open_directory_request) == 24 );
2236 2237 2238 2239
C_ASSERT( FIELD_OFFSET(struct open_directory_reply, handle) == 8 );
C_ASSERT( sizeof(struct open_directory_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct get_directory_entry_request, handle) == 12 );
C_ASSERT( FIELD_OFFSET(struct get_directory_entry_request, index) == 16 );
2240
C_ASSERT( sizeof(struct get_directory_entry_request) == 24 );
2241 2242 2243
C_ASSERT( FIELD_OFFSET(struct get_directory_entry_reply, name_len) == 8 );
C_ASSERT( sizeof(struct get_directory_entry_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct create_symlink_request, access) == 12 );
2244
C_ASSERT( sizeof(struct create_symlink_request) == 16 );
2245 2246 2247 2248 2249
C_ASSERT( FIELD_OFFSET(struct create_symlink_reply, handle) == 8 );
C_ASSERT( sizeof(struct create_symlink_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct open_symlink_request, access) == 12 );
C_ASSERT( FIELD_OFFSET(struct open_symlink_request, attributes) == 16 );
C_ASSERT( FIELD_OFFSET(struct open_symlink_request, rootdir) == 20 );
2250
C_ASSERT( sizeof(struct open_symlink_request) == 24 );
2251 2252 2253
C_ASSERT( FIELD_OFFSET(struct open_symlink_reply, handle) == 8 );
C_ASSERT( sizeof(struct open_symlink_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct query_symlink_request, handle) == 12 );
2254
C_ASSERT( sizeof(struct query_symlink_request) == 16 );
2255 2256
C_ASSERT( FIELD_OFFSET(struct query_symlink_reply, total) == 8 );
C_ASSERT( sizeof(struct query_symlink_reply) == 16 );
2257
C_ASSERT( FIELD_OFFSET(struct get_object_info_request, handle) == 12 );
2258
C_ASSERT( sizeof(struct get_object_info_request) == 16 );
2259 2260
C_ASSERT( FIELD_OFFSET(struct get_object_info_reply, access) == 8 );
C_ASSERT( FIELD_OFFSET(struct get_object_info_reply, ref_count) == 12 );
2261 2262
C_ASSERT( FIELD_OFFSET(struct get_object_info_reply, handle_count) == 16 );
C_ASSERT( FIELD_OFFSET(struct get_object_info_reply, total) == 20 );
2263
C_ASSERT( sizeof(struct get_object_info_reply) == 24 );
2264 2265 2266 2267
C_ASSERT( FIELD_OFFSET(struct get_object_type_request, handle) == 12 );
C_ASSERT( sizeof(struct get_object_type_request) == 16 );
C_ASSERT( FIELD_OFFSET(struct get_object_type_reply, total) == 8 );
C_ASSERT( sizeof(struct get_object_type_reply) == 16 );
2268 2269 2270
C_ASSERT( FIELD_OFFSET(struct unlink_object_request, handle) == 12 );
C_ASSERT( sizeof(struct unlink_object_request) == 16 );
C_ASSERT( FIELD_OFFSET(struct get_token_impersonation_level_request, handle) == 12 );
2271
C_ASSERT( sizeof(struct get_token_impersonation_level_request) == 16 );
2272 2273
C_ASSERT( FIELD_OFFSET(struct get_token_impersonation_level_reply, impersonation_level) == 8 );
C_ASSERT( sizeof(struct get_token_impersonation_level_reply) == 16 );
2274
C_ASSERT( sizeof(struct allocate_locally_unique_id_request) == 16 );
2275 2276 2277 2278
C_ASSERT( FIELD_OFFSET(struct allocate_locally_unique_id_reply, luid) == 8 );
C_ASSERT( sizeof(struct allocate_locally_unique_id_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct create_device_manager_request, access) == 12 );
C_ASSERT( FIELD_OFFSET(struct create_device_manager_request, attributes) == 16 );
2279
C_ASSERT( sizeof(struct create_device_manager_request) == 24 );
2280 2281
C_ASSERT( FIELD_OFFSET(struct create_device_manager_reply, handle) == 8 );
C_ASSERT( sizeof(struct create_device_manager_reply) == 16 );
2282 2283 2284 2285 2286 2287 2288
C_ASSERT( FIELD_OFFSET(struct create_device_request, rootdir) == 12 );
C_ASSERT( FIELD_OFFSET(struct create_device_request, user_ptr) == 16 );
C_ASSERT( FIELD_OFFSET(struct create_device_request, manager) == 24 );
C_ASSERT( sizeof(struct create_device_request) == 32 );
C_ASSERT( FIELD_OFFSET(struct delete_device_request, manager) == 12 );
C_ASSERT( FIELD_OFFSET(struct delete_device_request, device) == 16 );
C_ASSERT( sizeof(struct delete_device_request) == 24 );
2289 2290 2291
C_ASSERT( FIELD_OFFSET(struct get_next_device_request_request, manager) == 12 );
C_ASSERT( FIELD_OFFSET(struct get_next_device_request_request, prev) == 16 );
C_ASSERT( FIELD_OFFSET(struct get_next_device_request_request, status) == 20 );
2292 2293
C_ASSERT( FIELD_OFFSET(struct get_next_device_request_request, user_ptr) == 24 );
C_ASSERT( sizeof(struct get_next_device_request_request) == 32 );
2294
C_ASSERT( FIELD_OFFSET(struct get_next_device_request_reply, params) == 8 );
2295 2296 2297 2298 2299
C_ASSERT( FIELD_OFFSET(struct get_next_device_request_reply, next) == 40 );
C_ASSERT( FIELD_OFFSET(struct get_next_device_request_reply, client_tid) == 44 );
C_ASSERT( FIELD_OFFSET(struct get_next_device_request_reply, client_thread) == 48 );
C_ASSERT( FIELD_OFFSET(struct get_next_device_request_reply, in_size) == 56 );
C_ASSERT( sizeof(struct get_next_device_request_reply) == 64 );
2300 2301 2302 2303 2304 2305 2306 2307 2308
C_ASSERT( FIELD_OFFSET(struct get_kernel_object_ptr_request, manager) == 12 );
C_ASSERT( FIELD_OFFSET(struct get_kernel_object_ptr_request, handle) == 16 );
C_ASSERT( sizeof(struct get_kernel_object_ptr_request) == 24 );
C_ASSERT( FIELD_OFFSET(struct get_kernel_object_ptr_reply, user_ptr) == 8 );
C_ASSERT( sizeof(struct get_kernel_object_ptr_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct set_kernel_object_ptr_request, manager) == 12 );
C_ASSERT( FIELD_OFFSET(struct set_kernel_object_ptr_request, handle) == 16 );
C_ASSERT( FIELD_OFFSET(struct set_kernel_object_ptr_request, user_ptr) == 24 );
C_ASSERT( sizeof(struct set_kernel_object_ptr_request) == 32 );
2309 2310 2311 2312 2313 2314
C_ASSERT( FIELD_OFFSET(struct grab_kernel_object_request, manager) == 12 );
C_ASSERT( FIELD_OFFSET(struct grab_kernel_object_request, user_ptr) == 16 );
C_ASSERT( sizeof(struct grab_kernel_object_request) == 24 );
C_ASSERT( FIELD_OFFSET(struct release_kernel_object_request, manager) == 12 );
C_ASSERT( FIELD_OFFSET(struct release_kernel_object_request, user_ptr) == 16 );
C_ASSERT( sizeof(struct release_kernel_object_request) == 24 );
2315 2316 2317 2318 2319 2320
C_ASSERT( FIELD_OFFSET(struct get_kernel_object_handle_request, manager) == 12 );
C_ASSERT( FIELD_OFFSET(struct get_kernel_object_handle_request, user_ptr) == 16 );
C_ASSERT( FIELD_OFFSET(struct get_kernel_object_handle_request, access) == 24 );
C_ASSERT( sizeof(struct get_kernel_object_handle_request) == 32 );
C_ASSERT( FIELD_OFFSET(struct get_kernel_object_handle_reply, handle) == 8 );
C_ASSERT( sizeof(struct get_kernel_object_handle_reply) == 16 );
2321
C_ASSERT( sizeof(struct make_process_system_request) == 16 );
2322 2323 2324
C_ASSERT( FIELD_OFFSET(struct make_process_system_reply, event) == 8 );
C_ASSERT( sizeof(struct make_process_system_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct get_token_statistics_request, handle) == 12 );
2325
C_ASSERT( sizeof(struct get_token_statistics_request) == 16 );
2326 2327 2328 2329 2330 2331 2332 2333
C_ASSERT( FIELD_OFFSET(struct get_token_statistics_reply, token_id) == 8 );
C_ASSERT( FIELD_OFFSET(struct get_token_statistics_reply, modified_id) == 16 );
C_ASSERT( FIELD_OFFSET(struct get_token_statistics_reply, primary) == 24 );
C_ASSERT( FIELD_OFFSET(struct get_token_statistics_reply, impersonation_level) == 28 );
C_ASSERT( FIELD_OFFSET(struct get_token_statistics_reply, group_count) == 32 );
C_ASSERT( FIELD_OFFSET(struct get_token_statistics_reply, privilege_count) == 36 );
C_ASSERT( sizeof(struct get_token_statistics_reply) == 40 );
C_ASSERT( FIELD_OFFSET(struct create_completion_request, access) == 12 );
2334 2335
C_ASSERT( FIELD_OFFSET(struct create_completion_request, concurrent) == 16 );
C_ASSERT( sizeof(struct create_completion_request) == 24 );
2336 2337 2338 2339 2340
C_ASSERT( FIELD_OFFSET(struct create_completion_reply, handle) == 8 );
C_ASSERT( sizeof(struct create_completion_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct open_completion_request, access) == 12 );
C_ASSERT( FIELD_OFFSET(struct open_completion_request, attributes) == 16 );
C_ASSERT( FIELD_OFFSET(struct open_completion_request, rootdir) == 20 );
2341
C_ASSERT( sizeof(struct open_completion_request) == 24 );
2342 2343 2344 2345 2346 2347
C_ASSERT( FIELD_OFFSET(struct open_completion_reply, handle) == 8 );
C_ASSERT( sizeof(struct open_completion_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct add_completion_request, handle) == 12 );
C_ASSERT( FIELD_OFFSET(struct add_completion_request, ckey) == 16 );
C_ASSERT( FIELD_OFFSET(struct add_completion_request, cvalue) == 24 );
C_ASSERT( FIELD_OFFSET(struct add_completion_request, information) == 32 );
2348 2349
C_ASSERT( FIELD_OFFSET(struct add_completion_request, status) == 40 );
C_ASSERT( sizeof(struct add_completion_request) == 48 );
2350
C_ASSERT( FIELD_OFFSET(struct remove_completion_request, handle) == 12 );
2351
C_ASSERT( sizeof(struct remove_completion_request) == 16 );
2352 2353 2354
C_ASSERT( FIELD_OFFSET(struct remove_completion_reply, ckey) == 8 );
C_ASSERT( FIELD_OFFSET(struct remove_completion_reply, cvalue) == 16 );
C_ASSERT( FIELD_OFFSET(struct remove_completion_reply, information) == 24 );
2355 2356
C_ASSERT( FIELD_OFFSET(struct remove_completion_reply, status) == 32 );
C_ASSERT( sizeof(struct remove_completion_reply) == 40 );
2357
C_ASSERT( FIELD_OFFSET(struct query_completion_request, handle) == 12 );
2358
C_ASSERT( sizeof(struct query_completion_request) == 16 );
2359 2360 2361 2362 2363 2364 2365 2366
C_ASSERT( FIELD_OFFSET(struct query_completion_reply, depth) == 8 );
C_ASSERT( sizeof(struct query_completion_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct set_completion_info_request, handle) == 12 );
C_ASSERT( FIELD_OFFSET(struct set_completion_info_request, ckey) == 16 );
C_ASSERT( FIELD_OFFSET(struct set_completion_info_request, chandle) == 24 );
C_ASSERT( sizeof(struct set_completion_info_request) == 32 );
C_ASSERT( FIELD_OFFSET(struct add_fd_completion_request, handle) == 12 );
C_ASSERT( FIELD_OFFSET(struct add_fd_completion_request, cvalue) == 16 );
2367 2368
C_ASSERT( FIELD_OFFSET(struct add_fd_completion_request, information) == 24 );
C_ASSERT( FIELD_OFFSET(struct add_fd_completion_request, status) == 32 );
2369
C_ASSERT( FIELD_OFFSET(struct add_fd_completion_request, async) == 36 );
2370
C_ASSERT( sizeof(struct add_fd_completion_request) == 40 );
2371 2372 2373
C_ASSERT( FIELD_OFFSET(struct set_fd_completion_mode_request, handle) == 12 );
C_ASSERT( FIELD_OFFSET(struct set_fd_completion_mode_request, flags) == 16 );
C_ASSERT( sizeof(struct set_fd_completion_mode_request) == 24 );
2374 2375 2376 2377 2378
C_ASSERT( FIELD_OFFSET(struct set_fd_disp_info_request, handle) == 12 );
C_ASSERT( FIELD_OFFSET(struct set_fd_disp_info_request, unlink) == 16 );
C_ASSERT( sizeof(struct set_fd_disp_info_request) == 24 );
C_ASSERT( FIELD_OFFSET(struct set_fd_name_info_request, handle) == 12 );
C_ASSERT( FIELD_OFFSET(struct set_fd_name_info_request, rootdir) == 16 );
2379
C_ASSERT( FIELD_OFFSET(struct set_fd_name_info_request, link) == 20 );
2380
C_ASSERT( sizeof(struct set_fd_name_info_request) == 24 );
2381
C_ASSERT( FIELD_OFFSET(struct get_window_layered_info_request, handle) == 12 );
2382
C_ASSERT( sizeof(struct get_window_layered_info_request) == 16 );
2383 2384 2385 2386 2387 2388 2389 2390 2391
C_ASSERT( FIELD_OFFSET(struct get_window_layered_info_reply, color_key) == 8 );
C_ASSERT( FIELD_OFFSET(struct get_window_layered_info_reply, alpha) == 12 );
C_ASSERT( FIELD_OFFSET(struct get_window_layered_info_reply, flags) == 16 );
C_ASSERT( sizeof(struct get_window_layered_info_reply) == 24 );
C_ASSERT( FIELD_OFFSET(struct set_window_layered_info_request, handle) == 12 );
C_ASSERT( FIELD_OFFSET(struct set_window_layered_info_request, color_key) == 16 );
C_ASSERT( FIELD_OFFSET(struct set_window_layered_info_request, alpha) == 20 );
C_ASSERT( FIELD_OFFSET(struct set_window_layered_info_request, flags) == 24 );
C_ASSERT( sizeof(struct set_window_layered_info_request) == 32 );
2392
C_ASSERT( sizeof(struct alloc_user_handle_request) == 16 );
2393 2394 2395 2396
C_ASSERT( FIELD_OFFSET(struct alloc_user_handle_reply, handle) == 8 );
C_ASSERT( sizeof(struct alloc_user_handle_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct free_user_handle_request, handle) == 12 );
C_ASSERT( sizeof(struct free_user_handle_request) == 16 );
2397 2398 2399
C_ASSERT( FIELD_OFFSET(struct set_cursor_request, flags) == 12 );
C_ASSERT( FIELD_OFFSET(struct set_cursor_request, handle) == 16 );
C_ASSERT( FIELD_OFFSET(struct set_cursor_request, show_count) == 20 );
2400 2401
C_ASSERT( FIELD_OFFSET(struct set_cursor_request, x) == 24 );
C_ASSERT( FIELD_OFFSET(struct set_cursor_request, y) == 28 );
2402
C_ASSERT( FIELD_OFFSET(struct set_cursor_request, clip) == 32 );
2403 2404
C_ASSERT( FIELD_OFFSET(struct set_cursor_request, clip_msg) == 48 );
C_ASSERT( sizeof(struct set_cursor_request) == 56 );
2405 2406
C_ASSERT( FIELD_OFFSET(struct set_cursor_reply, prev_handle) == 8 );
C_ASSERT( FIELD_OFFSET(struct set_cursor_reply, prev_count) == 12 );
2407 2408 2409 2410 2411 2412 2413
C_ASSERT( FIELD_OFFSET(struct set_cursor_reply, prev_x) == 16 );
C_ASSERT( FIELD_OFFSET(struct set_cursor_reply, prev_y) == 20 );
C_ASSERT( FIELD_OFFSET(struct set_cursor_reply, new_x) == 24 );
C_ASSERT( FIELD_OFFSET(struct set_cursor_reply, new_y) == 28 );
C_ASSERT( FIELD_OFFSET(struct set_cursor_reply, new_clip) == 32 );
C_ASSERT( FIELD_OFFSET(struct set_cursor_reply, last_change) == 48 );
C_ASSERT( sizeof(struct set_cursor_reply) == 56 );
2414
C_ASSERT( sizeof(struct update_rawinput_devices_request) == 16 );
2415 2416 2417
C_ASSERT( sizeof(struct get_suspend_context_request) == 16 );
C_ASSERT( sizeof(struct get_suspend_context_reply) == 8 );
C_ASSERT( sizeof(struct set_suspend_context_request) == 16 );
2418
C_ASSERT( FIELD_OFFSET(struct create_job_request, access) == 12 );
2419
C_ASSERT( sizeof(struct create_job_request) == 16 );
2420 2421
C_ASSERT( FIELD_OFFSET(struct create_job_reply, handle) == 8 );
C_ASSERT( sizeof(struct create_job_reply) == 16 );
2422 2423 2424 2425 2426 2427
C_ASSERT( FIELD_OFFSET(struct open_job_request, access) == 12 );
C_ASSERT( FIELD_OFFSET(struct open_job_request, attributes) == 16 );
C_ASSERT( FIELD_OFFSET(struct open_job_request, rootdir) == 20 );
C_ASSERT( sizeof(struct open_job_request) == 24 );
C_ASSERT( FIELD_OFFSET(struct open_job_reply, handle) == 8 );
C_ASSERT( sizeof(struct open_job_reply) == 16 );
2428 2429 2430
C_ASSERT( FIELD_OFFSET(struct assign_job_request, job) == 12 );
C_ASSERT( FIELD_OFFSET(struct assign_job_request, process) == 16 );
C_ASSERT( sizeof(struct assign_job_request) == 24 );
2431 2432 2433
C_ASSERT( FIELD_OFFSET(struct process_in_job_request, job) == 12 );
C_ASSERT( FIELD_OFFSET(struct process_in_job_request, process) == 16 );
C_ASSERT( sizeof(struct process_in_job_request) == 24 );
2434 2435 2436
C_ASSERT( FIELD_OFFSET(struct set_job_limits_request, handle) == 12 );
C_ASSERT( FIELD_OFFSET(struct set_job_limits_request, limit_flags) == 16 );
C_ASSERT( sizeof(struct set_job_limits_request) == 24 );
2437 2438 2439 2440
C_ASSERT( FIELD_OFFSET(struct set_job_completion_port_request, job) == 12 );
C_ASSERT( FIELD_OFFSET(struct set_job_completion_port_request, port) == 16 );
C_ASSERT( FIELD_OFFSET(struct set_job_completion_port_request, key) == 24 );
C_ASSERT( sizeof(struct set_job_completion_port_request) == 32 );
2441 2442 2443
C_ASSERT( FIELD_OFFSET(struct terminate_job_request, handle) == 12 );
C_ASSERT( FIELD_OFFSET(struct terminate_job_request, status) == 16 );
C_ASSERT( sizeof(struct terminate_job_request) == 24 );
2444 2445 2446 2447
C_ASSERT( FIELD_OFFSET(struct suspend_process_request, handle) == 12 );
C_ASSERT( sizeof(struct suspend_process_request) == 16 );
C_ASSERT( FIELD_OFFSET(struct resume_process_request, handle) == 12 );
C_ASSERT( sizeof(struct resume_process_request) == 16 );
2448

Alexandre Julliard's avatar
Alexandre Julliard committed
2449 2450
#endif  /* WANT_REQUEST_HANDLERS */

2451 2452 2453
/* ### make_requests end ### */
/* Everything above this line is generated automatically by tools/make_requests */

Alexandre Julliard's avatar
Alexandre Julliard committed
2454
#endif  /* __WINE_SERVER_REQUEST_H */