request.h 136 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 int server_dir_fd, config_dir_fd;
64

65 66
extern void trace_request(void);
extern void trace_reply( enum request req, const union generic_reply *reply );
Alexandre Julliard's avatar
Alexandre Julliard committed
67

68
/* get the request vararg data */
69
static inline const void *get_req_data(void)
70
{
71
    return current->req_data;
72 73
}

74
/* get the request vararg size */
75
static inline data_size_t get_req_data_size(void)
76 77 78 79
{
    return current->req.request_header.request_size;
}

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

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

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

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


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

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

405 406
#ifdef WANT_REQUEST_HANDLERS

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

701
C_ASSERT( sizeof(affinity_t) == 8 );
702 703 704 705 706 707 708 709
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 );
C_ASSERT( sizeof(client_ptr_t) == 8 );
710
C_ASSERT( sizeof(cpu_type_t) == 4 );
711 712
C_ASSERT( sizeof(data_size_t) == 4 );
C_ASSERT( sizeof(file_pos_t) == 8 );
713
C_ASSERT( sizeof(hw_input_t) == 32 );
714 715
C_ASSERT( sizeof(int) == 4 );
C_ASSERT( sizeof(ioctl_code_t) == 4 );
716
C_ASSERT( sizeof(irp_params_t) == 24 );
717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734
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 );
C_ASSERT( FIELD_OFFSET(struct new_process_request, inherit_all) == 12 );
C_ASSERT( FIELD_OFFSET(struct new_process_request, create_flags) == 16 );
C_ASSERT( FIELD_OFFSET(struct new_process_request, socket_fd) == 20 );
C_ASSERT( FIELD_OFFSET(struct new_process_request, exe_file) == 24 );
735 736 737 738
C_ASSERT( FIELD_OFFSET(struct new_process_request, process_access) == 28 );
C_ASSERT( FIELD_OFFSET(struct new_process_request, process_attr) == 32 );
C_ASSERT( FIELD_OFFSET(struct new_process_request, thread_access) == 36 );
C_ASSERT( FIELD_OFFSET(struct new_process_request, thread_attr) == 40 );
739 740 741
C_ASSERT( FIELD_OFFSET(struct new_process_request, cpu) == 44 );
C_ASSERT( FIELD_OFFSET(struct new_process_request, info_size) == 48 );
C_ASSERT( sizeof(struct new_process_request) == 56 );
742 743 744 745 746 747 748
C_ASSERT( FIELD_OFFSET(struct new_process_reply, info) == 8 );
C_ASSERT( FIELD_OFFSET(struct new_process_reply, pid) == 12 );
C_ASSERT( FIELD_OFFSET(struct new_process_reply, phandle) == 16 );
C_ASSERT( FIELD_OFFSET(struct new_process_reply, tid) == 20 );
C_ASSERT( FIELD_OFFSET(struct new_process_reply, thandle) == 24 );
C_ASSERT( sizeof(struct new_process_reply) == 32 );
C_ASSERT( FIELD_OFFSET(struct get_new_process_info_request, info) == 12 );
749
C_ASSERT( sizeof(struct get_new_process_info_request) == 16 );
750 751 752 753 754 755 756
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 );
C_ASSERT( FIELD_OFFSET(struct new_thread_request, access) == 12 );
C_ASSERT( FIELD_OFFSET(struct new_thread_request, attributes) == 16 );
C_ASSERT( FIELD_OFFSET(struct new_thread_request, suspend) == 20 );
C_ASSERT( FIELD_OFFSET(struct new_thread_request, request_fd) == 24 );
757
C_ASSERT( sizeof(struct new_thread_request) == 32 );
758 759 760
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 );
761
C_ASSERT( sizeof(struct get_startup_info_request) == 16 );
762
C_ASSERT( FIELD_OFFSET(struct get_startup_info_reply, exe_file) == 8 );
763 764
C_ASSERT( FIELD_OFFSET(struct get_startup_info_reply, info_size) == 12 );
C_ASSERT( sizeof(struct get_startup_info_reply) == 16 );
765 766 767 768 769
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 );
770 771
C_ASSERT( FIELD_OFFSET(struct init_process_done_reply, suspend) == 8 );
C_ASSERT( sizeof(struct init_process_done_reply) == 16 );
772 773 774 775 776 777 778
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 );
779
C_ASSERT( FIELD_OFFSET(struct init_thread_request, cpu) == 48 );
780
C_ASSERT( sizeof(struct init_thread_request) == 56 );
781 782 783 784 785
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 );
786
C_ASSERT( FIELD_OFFSET(struct init_thread_reply, all_cpus) == 32 );
787
C_ASSERT( FIELD_OFFSET(struct init_thread_reply, suspend) == 36 );
788
C_ASSERT( sizeof(struct init_thread_reply) == 40 );
789 790
C_ASSERT( FIELD_OFFSET(struct terminate_process_request, handle) == 12 );
C_ASSERT( FIELD_OFFSET(struct terminate_process_request, exit_code) == 16 );
791
C_ASSERT( sizeof(struct terminate_process_request) == 24 );
792 793 794 795
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 );
796
C_ASSERT( sizeof(struct terminate_thread_request) == 24 );
797 798 799 800
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 );
801
C_ASSERT( sizeof(struct get_process_info_request) == 16 );
802 803
C_ASSERT( FIELD_OFFSET(struct get_process_info_reply, pid) == 8 );
C_ASSERT( FIELD_OFFSET(struct get_process_info_reply, ppid) == 12 );
804
C_ASSERT( FIELD_OFFSET(struct get_process_info_reply, affinity) == 16 );
805 806 807 808
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 );
809
C_ASSERT( FIELD_OFFSET(struct get_process_info_reply, priority) == 52 );
810
C_ASSERT( FIELD_OFFSET(struct get_process_info_reply, cpu) == 56 );
811
C_ASSERT( FIELD_OFFSET(struct get_process_info_reply, debugger_present) == 60 );
812
C_ASSERT( FIELD_OFFSET(struct get_process_info_reply, debug_children) == 62 );
813
C_ASSERT( sizeof(struct get_process_info_reply) == 64 );
814 815 816 817 818 819 820 821 822
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 );
823 824 825 826 827 828 829
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 );
830
C_ASSERT( sizeof(struct get_thread_info_request) == 24 );
831 832 833
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 );
834 835 836 837 838 839
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 );
C_ASSERT( sizeof(struct get_thread_info_reply) == 56 );
840 841 842 843 844
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 );
845 846 847 848
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 );
849 850 851
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 );
852 853
C_ASSERT( FIELD_OFFSET(struct get_dll_info_request, handle) == 12 );
C_ASSERT( FIELD_OFFSET(struct get_dll_info_request, base_address) == 16 );
854
C_ASSERT( sizeof(struct get_dll_info_request) == 24 );
855
C_ASSERT( FIELD_OFFSET(struct get_dll_info_reply, entry_point) == 8 );
856
C_ASSERT( FIELD_OFFSET(struct get_dll_info_reply, filename_len) == 16 );
857 858
C_ASSERT( sizeof(struct get_dll_info_reply) == 24 );
C_ASSERT( FIELD_OFFSET(struct suspend_thread_request, handle) == 12 );
859
C_ASSERT( sizeof(struct suspend_thread_request) == 16 );
860 861 862
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 );
863
C_ASSERT( sizeof(struct resume_thread_request) == 16 );
864 865
C_ASSERT( FIELD_OFFSET(struct resume_thread_reply, count) == 8 );
C_ASSERT( sizeof(struct resume_thread_reply) == 16 );
866
C_ASSERT( FIELD_OFFSET(struct load_dll_request, dbg_offset) == 12 );
867 868
C_ASSERT( FIELD_OFFSET(struct load_dll_request, base) == 16 );
C_ASSERT( FIELD_OFFSET(struct load_dll_request, name) == 24 );
869 870
C_ASSERT( FIELD_OFFSET(struct load_dll_request, dbg_size) == 32 );
C_ASSERT( sizeof(struct load_dll_request) == 40 );
871 872 873 874
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 );
875
C_ASSERT( sizeof(struct queue_apc_request) == 56 );
876 877 878 879
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 );
880
C_ASSERT( sizeof(struct get_apc_result_request) == 16 );
881 882 883 884 885 886 887
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 );
888
C_ASSERT( sizeof(struct set_handle_info_request) == 24 );
889 890 891 892 893 894 895 896
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 );
897
C_ASSERT( sizeof(struct dup_handle_request) == 40 );
898 899 900 901 902 903 904
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 );
905
C_ASSERT( sizeof(struct open_process_request) == 24 );
906 907 908 909 910
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 );
911
C_ASSERT( sizeof(struct open_thread_request) == 24 );
912 913 914 915
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 );
916 917
C_ASSERT( FIELD_OFFSET(struct select_request, timeout) == 24 );
C_ASSERT( FIELD_OFFSET(struct select_request, prev_apc) == 32 );
918
C_ASSERT( sizeof(struct select_request) == 40 );
919 920 921 922 923
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 );
924 925 926
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 );
927 928 929 930 931
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 );
932 933 934 935 936
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 );
937 938 939
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 );
940
C_ASSERT( sizeof(struct open_event_request) == 24 );
941 942
C_ASSERT( FIELD_OFFSET(struct open_event_reply, handle) == 8 );
C_ASSERT( sizeof(struct open_event_reply) == 16 );
943
C_ASSERT( FIELD_OFFSET(struct create_keyed_event_request, access) == 12 );
944
C_ASSERT( sizeof(struct create_keyed_event_request) == 16 );
945 946 947 948 949 950 951 952
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 );
953
C_ASSERT( FIELD_OFFSET(struct create_mutex_request, access) == 12 );
954
C_ASSERT( FIELD_OFFSET(struct create_mutex_request, owned) == 16 );
955
C_ASSERT( sizeof(struct create_mutex_request) == 24 );
956 957 958
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 );
959
C_ASSERT( sizeof(struct release_mutex_request) == 16 );
960 961 962 963 964
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 );
965
C_ASSERT( sizeof(struct open_mutex_request) == 24 );
966 967
C_ASSERT( FIELD_OFFSET(struct open_mutex_reply, handle) == 8 );
C_ASSERT( sizeof(struct open_mutex_reply) == 16 );
968 969 970 971 972 973
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 );
974
C_ASSERT( FIELD_OFFSET(struct create_semaphore_request, access) == 12 );
975 976 977
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 );
978 979 980 981
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 );
982
C_ASSERT( sizeof(struct release_semaphore_request) == 24 );
983 984
C_ASSERT( FIELD_OFFSET(struct release_semaphore_reply, prev_count) == 8 );
C_ASSERT( sizeof(struct release_semaphore_reply) == 16 );
985 986 987 988 989
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 );
990 991 992
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 );
993
C_ASSERT( sizeof(struct open_semaphore_request) == 24 );
994 995 996
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 );
997 998 999 1000 1001
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 );
1002 1003 1004 1005 1006 1007 1008
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 );
1009
C_ASSERT( sizeof(struct open_file_object_request) == 32 );
1010 1011 1012 1013 1014
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 );
1015
C_ASSERT( sizeof(struct alloc_file_handle_request) == 24 );
1016 1017
C_ASSERT( FIELD_OFFSET(struct alloc_file_handle_reply, handle) == 8 );
C_ASSERT( sizeof(struct alloc_file_handle_reply) == 16 );
1018
C_ASSERT( FIELD_OFFSET(struct get_handle_unix_name_request, handle) == 12 );
1019
C_ASSERT( sizeof(struct get_handle_unix_name_request) == 16 );
1020 1021
C_ASSERT( FIELD_OFFSET(struct get_handle_unix_name_reply, name_len) == 8 );
C_ASSERT( sizeof(struct get_handle_unix_name_reply) == 16 );
1022
C_ASSERT( FIELD_OFFSET(struct get_handle_fd_request, handle) == 12 );
1023
C_ASSERT( sizeof(struct get_handle_fd_request) == 16 );
1024
C_ASSERT( FIELD_OFFSET(struct get_handle_fd_reply, type) == 8 );
1025
C_ASSERT( FIELD_OFFSET(struct get_handle_fd_reply, cacheable) == 12 );
1026 1027 1028
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 );
1029 1030 1031 1032
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 );
1033 1034 1035 1036
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 );
1037 1038 1039 1040
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 );
1041 1042 1043 1044
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 );
1045 1046 1047 1048 1049
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 );
1050
C_ASSERT( sizeof(struct lock_file_request) == 40 );
1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063
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 );
1064
C_ASSERT( sizeof(struct create_socket_request) == 40 );
1065 1066 1067 1068 1069
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 );
1070
C_ASSERT( sizeof(struct accept_socket_request) == 24 );
1071 1072
C_ASSERT( FIELD_OFFSET(struct accept_socket_reply, handle) == 8 );
C_ASSERT( sizeof(struct accept_socket_reply) == 16 );
1073 1074 1075
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 );
1076 1077 1078 1079 1080 1081 1082 1083 1084
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 );
1085
C_ASSERT( sizeof(struct get_socket_event_request) == 24 );
1086 1087 1088 1089
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 );
1090 1091 1092 1093 1094 1095
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 );
1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106
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 );
1107 1108
C_ASSERT( FIELD_OFFSET(struct alloc_console_request, input_fd) == 24 );
C_ASSERT( sizeof(struct alloc_console_request) == 32 );
1109 1110 1111 1112 1113
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 );
1114
C_ASSERT( sizeof(struct get_console_renderer_events_request) == 16 );
1115 1116 1117 1118 1119
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 );
1120
C_ASSERT( sizeof(struct open_console_request) == 32 );
1121 1122
C_ASSERT( FIELD_OFFSET(struct open_console_reply, handle) == 8 );
C_ASSERT( sizeof(struct open_console_reply) == 16 );
1123
C_ASSERT( sizeof(struct get_console_wait_event_request) == 16 );
1124 1125 1126
C_ASSERT( FIELD_OFFSET(struct get_console_wait_event_reply, handle) == 8 );
C_ASSERT( sizeof(struct get_console_wait_event_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct get_console_mode_request, handle) == 12 );
1127
C_ASSERT( sizeof(struct get_console_mode_request) == 16 );
1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143
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 );
1144
C_ASSERT( sizeof(struct get_console_input_info_request) == 16 );
1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156
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 );
1157
C_ASSERT( sizeof(struct get_console_input_history_request) == 24 );
1158 1159 1160 1161 1162 1163
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 );
1164
C_ASSERT( FIELD_OFFSET(struct create_console_output_request, fd) == 28 );
1165
C_ASSERT( sizeof(struct create_console_output_request) == 32 );
1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176
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 );
1177 1178 1179 1180 1181 1182 1183 1184 1185
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 );
1186
C_ASSERT( sizeof(struct set_console_output_info_request) == 56 );
1187
C_ASSERT( FIELD_OFFSET(struct get_console_output_info_request, handle) == 12 );
1188
C_ASSERT( sizeof(struct get_console_output_info_request) == 16 );
1189 1190 1191 1192 1193 1194 1195
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 );
1196 1197 1198 1199 1200 1201 1202 1203 1204
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 );
1205 1206
C_ASSERT( sizeof(struct get_console_output_info_reply) == 40 );
C_ASSERT( FIELD_OFFSET(struct write_console_input_request, handle) == 12 );
1207
C_ASSERT( sizeof(struct write_console_input_request) == 16 );
1208 1209 1210 1211
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 );
1212
C_ASSERT( sizeof(struct read_console_input_request) == 24 );
1213 1214 1215 1216 1217 1218 1219
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 );
1220
C_ASSERT( sizeof(struct write_console_output_request) == 32 );
1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231
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 );
1232
C_ASSERT( sizeof(struct fill_console_output_request) == 40 );
1233 1234 1235 1236 1237 1238 1239
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 );
1240
C_ASSERT( sizeof(struct read_console_output_request) == 32 );
1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260
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 );
1261
C_ASSERT( sizeof(struct read_change_request) == 16 );
1262
C_ASSERT( sizeof(struct read_change_reply) == 8 );
1263
C_ASSERT( FIELD_OFFSET(struct create_mapping_request, access) == 12 );
1264
C_ASSERT( FIELD_OFFSET(struct create_mapping_request, flags) == 16 );
1265
C_ASSERT( FIELD_OFFSET(struct create_mapping_request, file_access) == 20 );
1266 1267
C_ASSERT( FIELD_OFFSET(struct create_mapping_request, size) == 24 );
C_ASSERT( FIELD_OFFSET(struct create_mapping_request, file_handle) == 32 );
1268
C_ASSERT( sizeof(struct create_mapping_request) == 40 );
1269 1270 1271 1272 1273
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 );
1274
C_ASSERT( sizeof(struct open_mapping_request) == 24 );
1275 1276 1277 1278
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 );
1279
C_ASSERT( sizeof(struct get_mapping_info_request) == 24 );
1280
C_ASSERT( FIELD_OFFSET(struct get_mapping_info_reply, size) == 8 );
1281
C_ASSERT( FIELD_OFFSET(struct get_mapping_info_reply, flags) == 16 );
1282 1283
C_ASSERT( FIELD_OFFSET(struct get_mapping_info_reply, shared_file) == 20 );
C_ASSERT( sizeof(struct get_mapping_info_reply) == 24 );
1284 1285 1286 1287 1288 1289 1290 1291
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 );
1292 1293 1294
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 );
1295 1296 1297
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 );
1298 1299 1300 1301
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 );
1302 1303 1304
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 );
1305 1306
C_ASSERT( FIELD_OFFSET(struct create_snapshot_request, attributes) == 12 );
C_ASSERT( FIELD_OFFSET(struct create_snapshot_request, flags) == 16 );
1307
C_ASSERT( sizeof(struct create_snapshot_request) == 24 );
1308 1309 1310 1311
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 );
1312
C_ASSERT( sizeof(struct next_process_request) == 24 );
1313 1314 1315 1316 1317 1318
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 );
1319 1320
C_ASSERT( FIELD_OFFSET(struct next_process_reply, unix_pid) == 32 );
C_ASSERT( sizeof(struct next_process_reply) == 40 );
1321 1322
C_ASSERT( FIELD_OFFSET(struct next_thread_request, handle) == 12 );
C_ASSERT( FIELD_OFFSET(struct next_thread_request, reset) == 16 );
1323
C_ASSERT( sizeof(struct next_thread_request) == 24 );
1324 1325 1326 1327 1328 1329 1330
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 );
1331
C_ASSERT( sizeof(struct wait_debug_event_request) == 16 );
1332 1333 1334 1335 1336 1337 1338 1339 1340 1341
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 );
1342
C_ASSERT( sizeof(struct queue_exception_event_request) == 48 );
1343 1344 1345
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 );
1346
C_ASSERT( sizeof(struct get_exception_status_request) == 16 );
1347 1348 1349 1350 1351 1352 1353 1354 1355
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 debug_break_request, handle) == 12 );
1356
C_ASSERT( sizeof(struct debug_break_request) == 16 );
1357 1358 1359 1360 1361 1362
C_ASSERT( FIELD_OFFSET(struct debug_break_reply, self) == 8 );
C_ASSERT( sizeof(struct debug_break_reply) == 16 );
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 );
1363
C_ASSERT( sizeof(struct read_process_memory_request) == 24 );
1364 1365 1366 1367
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 );
1368 1369 1370
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 );
1371 1372 1373 1374 1375 1376
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 );
1377
C_ASSERT( sizeof(struct open_key_request) == 24 );
1378 1379 1380 1381 1382 1383 1384 1385 1386
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 );
1387
C_ASSERT( sizeof(struct enum_key_request) == 24 );
1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402
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 );
1403
C_ASSERT( sizeof(struct get_key_value_request) == 16 );
1404 1405 1406 1407 1408 1409
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 );
1410
C_ASSERT( sizeof(struct enum_key_value_request) == 24 );
1411 1412 1413 1414 1415 1416
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 );
1417 1418
C_ASSERT( FIELD_OFFSET(struct load_registry_request, file) == 12 );
C_ASSERT( sizeof(struct load_registry_request) == 16 );
1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429
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 );
1430 1431
C_ASSERT( FIELD_OFFSET(struct create_timer_request, manual) == 16 );
C_ASSERT( sizeof(struct create_timer_request) == 24 );
1432 1433 1434 1435 1436
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 );
1437
C_ASSERT( sizeof(struct open_timer_request) == 24 );
1438 1439 1440 1441 1442 1443 1444
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 );
1445
C_ASSERT( sizeof(struct set_timer_request) == 48 );
1446 1447 1448
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 );
1449
C_ASSERT( sizeof(struct cancel_timer_request) == 16 );
1450 1451 1452
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 );
1453
C_ASSERT( sizeof(struct get_timer_info_request) == 16 );
1454 1455 1456 1457 1458 1459
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 );
1460
C_ASSERT( sizeof(struct get_thread_context_request) == 24 );
1461 1462 1463
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 );
1464
C_ASSERT( FIELD_OFFSET(struct set_thread_context_request, suspend) == 16 );
1465
C_ASSERT( sizeof(struct set_thread_context_request) == 24 );
1466 1467 1468 1469
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 );
1470
C_ASSERT( sizeof(struct get_selector_entry_request) == 24 );
1471 1472 1473 1474 1475
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 );
1476
C_ASSERT( sizeof(struct add_atom_request) == 16 );
1477 1478 1479 1480 1481 1482
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 );
1483
C_ASSERT( sizeof(struct find_atom_request) == 16 );
1484 1485 1486 1487
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 );
1488
C_ASSERT( sizeof(struct get_atom_information_request) == 24 );
1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500
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 );
1501
C_ASSERT( sizeof(struct init_atom_table_request) == 16 );
1502 1503
C_ASSERT( FIELD_OFFSET(struct init_atom_table_reply, table) == 8 );
C_ASSERT( sizeof(struct init_atom_table_reply) == 16 );
1504
C_ASSERT( sizeof(struct get_msg_queue_request) == 16 );
1505 1506 1507 1508 1509 1510 1511
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 );
1512
C_ASSERT( sizeof(struct set_queue_mask_request) == 24 );
1513 1514 1515
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 );
1516
C_ASSERT( FIELD_OFFSET(struct get_queue_status_request, clear_bits) == 12 );
1517
C_ASSERT( sizeof(struct get_queue_status_request) == 16 );
1518 1519 1520 1521
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 );
1522
C_ASSERT( sizeof(struct get_process_idle_event_request) == 16 );
1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535
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 );
1536
C_ASSERT( FIELD_OFFSET(struct send_hardware_message_request, win) == 12 );
1537 1538
C_ASSERT( FIELD_OFFSET(struct send_hardware_message_request, input) == 16 );
C_ASSERT( FIELD_OFFSET(struct send_hardware_message_request, flags) == 48 );
1539
C_ASSERT( sizeof(struct send_hardware_message_request) == 56 );
1540
C_ASSERT( FIELD_OFFSET(struct send_hardware_message_reply, wait) == 8 );
1541 1542 1543 1544 1545
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 );
1546 1547 1548 1549 1550 1551 1552
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 );
1553
C_ASSERT( sizeof(struct get_message_request) == 40 );
1554 1555 1556 1557 1558
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 );
1559 1560 1561 1562 1563 1564
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 );
1565 1566 1567 1568 1569 1570 1571
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 );
1572
C_ASSERT( sizeof(struct get_message_reply_request) == 16 );
1573 1574 1575 1576 1577 1578 1579
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 );
1580
C_ASSERT( sizeof(struct set_win_timer_request) == 40 );
1581 1582 1583 1584 1585 1586 1587
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 );
1588
C_ASSERT( sizeof(struct is_window_hung_request) == 16 );
1589 1590 1591
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 );
1592 1593
C_ASSERT( FIELD_OFFSET(struct get_serial_info_request, flags) == 16 );
C_ASSERT( sizeof(struct get_serial_info_request) == 24 );
1594 1595 1596 1597
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 );
1598 1599
C_ASSERT( FIELD_OFFSET(struct set_serial_info_request, handle) == 12 );
C_ASSERT( FIELD_OFFSET(struct set_serial_info_request, flags) == 16 );
1600
C_ASSERT( sizeof(struct set_serial_info_request) == 24 );
1601 1602 1603 1604 1605
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 );
1606 1607 1608
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 );
1609 1610 1611 1612
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 );
1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625
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 );
1626 1627
C_ASSERT( FIELD_OFFSET(struct ioctl_request, code) == 12 );
C_ASSERT( FIELD_OFFSET(struct ioctl_request, async) == 16 );
1628
C_ASSERT( sizeof(struct ioctl_request) == 56 );
1629 1630 1631
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 );
1632 1633 1634
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 );
1635
C_ASSERT( FIELD_OFFSET(struct set_irp_result_request, file_ptr) == 24 );
1636
C_ASSERT( sizeof(struct set_irp_result_request) == 32 );
1637
C_ASSERT( FIELD_OFFSET(struct create_named_pipe_request, access) == 12 );
1638 1639 1640 1641 1642
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 );
1643 1644 1645
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 );
1646 1647 1648
C_ASSERT( FIELD_OFFSET(struct create_named_pipe_reply, handle) == 8 );
C_ASSERT( sizeof(struct create_named_pipe_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct get_named_pipe_info_request, handle) == 12 );
1649
C_ASSERT( sizeof(struct get_named_pipe_info_request) == 16 );
1650
C_ASSERT( FIELD_OFFSET(struct get_named_pipe_info_reply, flags) == 8 );
1651 1652 1653 1654 1655
C_ASSERT( FIELD_OFFSET(struct get_named_pipe_info_reply, sharing) == 12 );
C_ASSERT( FIELD_OFFSET(struct get_named_pipe_info_reply, maxinstances) == 16 );
C_ASSERT( FIELD_OFFSET(struct get_named_pipe_info_reply, instances) == 20 );
C_ASSERT( FIELD_OFFSET(struct get_named_pipe_info_reply, outsize) == 24 );
C_ASSERT( FIELD_OFFSET(struct get_named_pipe_info_reply, insize) == 28 );
1656
C_ASSERT( sizeof(struct get_named_pipe_info_reply) == 32 );
1657 1658 1659
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 );
1660 1661 1662 1663
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 );
1664 1665
C_ASSERT( FIELD_OFFSET(struct create_window_request, dpi) == 32 );
C_ASSERT( FIELD_OFFSET(struct create_window_request, awareness) == 36 );
1666
C_ASSERT( sizeof(struct create_window_request) == 40 );
1667 1668 1669 1670 1671
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 );
1672 1673
C_ASSERT( FIELD_OFFSET(struct create_window_reply, dpi) == 32 );
C_ASSERT( FIELD_OFFSET(struct create_window_reply, awareness) == 36 );
1674
C_ASSERT( sizeof(struct create_window_reply) == 40 );
1675 1676 1677
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 );
1678
C_ASSERT( sizeof(struct get_desktop_window_request) == 16 );
1679 1680 1681 1682 1683
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 );
1684
C_ASSERT( sizeof(struct set_window_owner_request) == 24 );
1685 1686 1687 1688
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 );
1689
C_ASSERT( sizeof(struct get_window_info_request) == 16 );
1690 1691 1692 1693 1694 1695
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 );
1696 1697
C_ASSERT( FIELD_OFFSET(struct get_window_info_reply, dpi) == 32 );
C_ASSERT( FIELD_OFFSET(struct get_window_info_reply, awareness) == 36 );
1698
C_ASSERT( sizeof(struct get_window_info_reply) == 40 );
1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709
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 );
1710
C_ASSERT( sizeof(struct set_window_info_request) == 64 );
1711 1712 1713 1714 1715 1716 1717 1718 1719
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 );
1720
C_ASSERT( sizeof(struct set_parent_request) == 24 );
1721 1722
C_ASSERT( FIELD_OFFSET(struct set_parent_reply, old_parent) == 8 );
C_ASSERT( FIELD_OFFSET(struct set_parent_reply, full_parent) == 12 );
1723 1724
C_ASSERT( FIELD_OFFSET(struct set_parent_reply, dpi) == 16 );
C_ASSERT( FIELD_OFFSET(struct set_parent_reply, awareness) == 20 );
1725
C_ASSERT( sizeof(struct set_parent_reply) == 24 );
1726
C_ASSERT( FIELD_OFFSET(struct get_window_parents_request, handle) == 12 );
1727
C_ASSERT( sizeof(struct get_window_parents_request) == 16 );
1728 1729 1730 1731 1732 1733
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 );
1734
C_ASSERT( sizeof(struct get_window_children_request) == 32 );
1735 1736 1737 1738 1739
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 );
1740
C_ASSERT( sizeof(struct get_window_children_from_point_request) == 24 );
1741 1742 1743
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 );
1744
C_ASSERT( sizeof(struct get_window_tree_request) == 16 );
1745 1746 1747 1748 1749 1750 1751 1752 1753
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 );
1754 1755
C_ASSERT( FIELD_OFFSET(struct set_window_pos_request, swp_flags) == 12 );
C_ASSERT( FIELD_OFFSET(struct set_window_pos_request, paint_flags) == 14 );
1756 1757 1758 1759
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 );
1760
C_ASSERT( sizeof(struct set_window_pos_request) == 56 );
1761 1762
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 );
1763
C_ASSERT( FIELD_OFFSET(struct set_window_pos_reply, surface_win) == 16 );
1764
C_ASSERT( FIELD_OFFSET(struct set_window_pos_reply, needs_update) == 20 );
1765
C_ASSERT( sizeof(struct set_window_pos_reply) == 24 );
1766
C_ASSERT( FIELD_OFFSET(struct get_window_rectangles_request, handle) == 12 );
1767 1768
C_ASSERT( FIELD_OFFSET(struct get_window_rectangles_request, relative) == 16 );
C_ASSERT( sizeof(struct get_window_rectangles_request) == 24 );
1769
C_ASSERT( FIELD_OFFSET(struct get_window_rectangles_reply, window) == 8 );
1770 1771
C_ASSERT( FIELD_OFFSET(struct get_window_rectangles_reply, client) == 24 );
C_ASSERT( sizeof(struct get_window_rectangles_reply) == 40 );
1772
C_ASSERT( FIELD_OFFSET(struct get_window_text_request, handle) == 12 );
1773
C_ASSERT( sizeof(struct get_window_text_request) == 16 );
1774 1775
C_ASSERT( FIELD_OFFSET(struct get_window_text_reply, length) == 8 );
C_ASSERT( sizeof(struct get_window_text_reply) == 16 );
1776 1777 1778 1779
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 );
1780
C_ASSERT( sizeof(struct get_windows_offset_request) == 24 );
1781 1782
C_ASSERT( FIELD_OFFSET(struct get_windows_offset_reply, x) == 8 );
C_ASSERT( FIELD_OFFSET(struct get_windows_offset_reply, y) == 12 );
1783 1784
C_ASSERT( FIELD_OFFSET(struct get_windows_offset_reply, mirror) == 16 );
C_ASSERT( sizeof(struct get_windows_offset_reply) == 24 );
1785 1786
C_ASSERT( FIELD_OFFSET(struct get_visible_region_request, window) == 12 );
C_ASSERT( FIELD_OFFSET(struct get_visible_region_request, flags) == 16 );
1787
C_ASSERT( sizeof(struct get_visible_region_request) == 24 );
1788 1789 1790
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 );
1791 1792 1793
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 );
1794 1795 1796 1797 1798
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 );
1799
C_ASSERT( FIELD_OFFSET(struct get_window_region_request, window) == 12 );
1800
C_ASSERT( sizeof(struct get_window_region_request) == 16 );
1801 1802 1803 1804 1805 1806 1807 1808
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 );
1809
C_ASSERT( sizeof(struct get_update_region_request) == 24 );
1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825
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 );
1826
C_ASSERT( sizeof(struct remove_window_property_request) == 24 );
1827 1828 1829 1830
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 );
1831
C_ASSERT( sizeof(struct get_window_property_request) == 24 );
1832 1833 1834
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 );
1835
C_ASSERT( sizeof(struct get_window_properties_request) == 16 );
1836 1837 1838 1839 1840
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 );
1841 1842
C_ASSERT( FIELD_OFFSET(struct create_winstation_request, rootdir) == 24 );
C_ASSERT( sizeof(struct create_winstation_request) == 32 );
1843 1844 1845 1846
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 );
1847
C_ASSERT( FIELD_OFFSET(struct open_winstation_request, rootdir) == 20 );
1848
C_ASSERT( sizeof(struct open_winstation_request) == 24 );
1849 1850 1851 1852
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 );
1853
C_ASSERT( sizeof(struct get_process_winstation_request) == 16 );
1854 1855 1856 1857 1858
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 );
1859
C_ASSERT( sizeof(struct enum_winstation_request) == 16 );
1860 1861 1862 1863 1864
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 );
1865
C_ASSERT( sizeof(struct create_desktop_request) == 24 );
1866 1867 1868 1869 1870 1871
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 );
1872
C_ASSERT( sizeof(struct open_desktop_request) == 32 );
1873 1874
C_ASSERT( FIELD_OFFSET(struct open_desktop_reply, handle) == 8 );
C_ASSERT( sizeof(struct open_desktop_reply) == 16 );
1875 1876 1877 1878 1879 1880
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 );
1881 1882 1883
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 );
1884
C_ASSERT( sizeof(struct get_thread_desktop_request) == 16 );
1885 1886 1887 1888 1889 1890
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 );
1891
C_ASSERT( sizeof(struct enum_desktop_request) == 24 );
1892 1893 1894 1895 1896
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 );
1897
C_ASSERT( sizeof(struct set_user_object_info_request) == 24 );
1898 1899 1900
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 );
1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915
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 );
1916 1917 1918 1919 1920
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 );
1921
C_ASSERT( sizeof(struct get_thread_input_request) == 16 );
1922 1923 1924 1925 1926 1927 1928
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 );
1929 1930 1931 1932
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 );
1933
C_ASSERT( sizeof(struct get_last_input_time_request) == 16 );
1934 1935 1936 1937
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 );
1938
C_ASSERT( sizeof(struct get_key_state_request) == 24 );
1939 1940 1941
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 );
1942 1943
C_ASSERT( FIELD_OFFSET(struct set_key_state_request, async) == 16 );
C_ASSERT( sizeof(struct set_key_state_request) == 24 );
1944
C_ASSERT( FIELD_OFFSET(struct set_foreground_window_request, handle) == 12 );
1945
C_ASSERT( sizeof(struct set_foreground_window_request) == 16 );
1946 1947 1948 1949 1950
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 );
1951
C_ASSERT( sizeof(struct set_focus_window_request) == 16 );
1952 1953 1954
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 );
1955
C_ASSERT( sizeof(struct set_active_window_request) == 16 );
1956 1957 1958 1959
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 );
1960
C_ASSERT( sizeof(struct set_capture_window_request) == 24 );
1961 1962 1963 1964 1965 1966
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 );
1967
C_ASSERT( sizeof(struct set_caret_window_request) == 24 );
1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978
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 );
1979
C_ASSERT( sizeof(struct set_caret_info_request) == 40 );
1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992
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 );
1993
C_ASSERT( sizeof(struct set_hook_request) == 48 );
1994 1995 1996 1997 1998 1999
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 );
2000
C_ASSERT( sizeof(struct remove_hook_request) == 32 );
2001 2002 2003 2004 2005 2006 2007
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 );
2008
C_ASSERT( sizeof(struct start_hook_chain_request) == 32 );
2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023
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 );
2024
C_ASSERT( sizeof(struct get_hook_info_request) == 40 );
2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038
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 );
2039
C_ASSERT( sizeof(struct create_class_request) == 48 );
2040 2041 2042 2043
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 );
2044
C_ASSERT( sizeof(struct destroy_class_request) == 24 );
2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055
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 );
2056
C_ASSERT( sizeof(struct set_class_info_request) == 56 );
2057 2058 2059 2060 2061 2062 2063
C_ASSERT( FIELD_OFFSET(struct set_class_info_reply, old_atom) == 8 );
C_ASSERT( FIELD_OFFSET(struct set_class_info_reply, old_style) == 12 );
C_ASSERT( FIELD_OFFSET(struct set_class_info_reply, old_extra) == 16 );
C_ASSERT( FIELD_OFFSET(struct set_class_info_reply, old_win_extra) == 20 );
C_ASSERT( FIELD_OFFSET(struct set_class_info_reply, old_instance) == 24 );
C_ASSERT( FIELD_OFFSET(struct set_class_info_reply, old_extra_value) == 32 );
C_ASSERT( sizeof(struct set_class_info_reply) == 40 );
2064 2065 2066 2067 2068 2069 2070 2071
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 );
2072
C_ASSERT( sizeof(struct empty_clipboard_request) == 16 );
2073
C_ASSERT( FIELD_OFFSET(struct set_clipboard_data_request, format) == 12 );
2074 2075
C_ASSERT( FIELD_OFFSET(struct set_clipboard_data_request, lcid) == 16 );
C_ASSERT( sizeof(struct set_clipboard_data_request) == 24 );
2076 2077
C_ASSERT( FIELD_OFFSET(struct set_clipboard_data_reply, seqno) == 8 );
C_ASSERT( sizeof(struct set_clipboard_data_reply) == 16 );
2078
C_ASSERT( FIELD_OFFSET(struct get_clipboard_data_request, format) == 12 );
2079 2080 2081 2082
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 );
2083 2084
C_ASSERT( FIELD_OFFSET(struct get_clipboard_data_reply, from) == 8 );
C_ASSERT( FIELD_OFFSET(struct get_clipboard_data_reply, owner) == 12 );
2085 2086
C_ASSERT( FIELD_OFFSET(struct get_clipboard_data_reply, seqno) == 16 );
C_ASSERT( FIELD_OFFSET(struct get_clipboard_data_reply, total) == 20 );
2087
C_ASSERT( sizeof(struct get_clipboard_data_reply) == 24 );
2088 2089 2090 2091 2092 2093 2094 2095
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 );
2096 2097 2098
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 );
2099
C_ASSERT( FIELD_OFFSET(struct release_clipboard_reply, owner) == 12 );
2100
C_ASSERT( sizeof(struct release_clipboard_reply) == 16 );
2101 2102 2103 2104 2105 2106
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 );
2107 2108 2109 2110 2111 2112
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 );
2113 2114 2115 2116
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 );
2117 2118 2119 2120
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 );
2121
C_ASSERT( sizeof(struct open_token_request) == 32 );
2122 2123 2124 2125 2126 2127 2128
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 );
2129
C_ASSERT( sizeof(struct set_global_windows_request) == 32 );
2130 2131 2132 2133 2134 2135 2136 2137
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 );
2138
C_ASSERT( sizeof(struct adjust_token_privileges_request) == 24 );
2139 2140 2141
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 );
2142
C_ASSERT( sizeof(struct get_token_privileges_request) == 16 );
2143 2144 2145 2146
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 );
2147
C_ASSERT( sizeof(struct check_token_privileges_request) == 24 );
2148 2149 2150 2151
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 );
2152 2153
C_ASSERT( FIELD_OFFSET(struct duplicate_token_request, primary) == 20 );
C_ASSERT( FIELD_OFFSET(struct duplicate_token_request, impersonation_level) == 24 );
2154
C_ASSERT( sizeof(struct duplicate_token_request) == 32 );
2155 2156 2157 2158 2159 2160 2161 2162
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 );
2163
C_ASSERT( sizeof(struct access_check_request) == 40 );
2164 2165 2166 2167
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 );
2168 2169
C_ASSERT( FIELD_OFFSET(struct get_token_sid_request, handle) == 12 );
C_ASSERT( FIELD_OFFSET(struct get_token_sid_request, which_sid) == 16 );
2170
C_ASSERT( sizeof(struct get_token_sid_request) == 24 );
2171 2172
C_ASSERT( FIELD_OFFSET(struct get_token_sid_reply, sid_len) == 8 );
C_ASSERT( sizeof(struct get_token_sid_reply) == 16 );
2173
C_ASSERT( FIELD_OFFSET(struct get_token_groups_request, handle) == 12 );
2174
C_ASSERT( sizeof(struct get_token_groups_request) == 16 );
2175 2176
C_ASSERT( FIELD_OFFSET(struct get_token_groups_reply, user_len) == 8 );
C_ASSERT( sizeof(struct get_token_groups_reply) == 16 );
2177
C_ASSERT( FIELD_OFFSET(struct get_token_default_dacl_request, handle) == 12 );
2178
C_ASSERT( sizeof(struct get_token_default_dacl_request) == 16 );
2179 2180 2181 2182
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 );
2183 2184 2185 2186 2187
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 );
2188
C_ASSERT( sizeof(struct get_security_object_request) == 24 );
2189 2190
C_ASSERT( FIELD_OFFSET(struct get_security_object_reply, sd_len) == 8 );
C_ASSERT( sizeof(struct get_security_object_reply) == 16 );
2191 2192 2193
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 );
2194
C_ASSERT( FIELD_OFFSET(struct create_mailslot_request, access) == 12 );
2195 2196 2197
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 );
2198 2199 2200 2201 2202
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 );
2203
C_ASSERT( sizeof(struct set_mailslot_info_request) == 32 );
2204 2205 2206 2207
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 );
2208
C_ASSERT( sizeof(struct create_directory_request) == 16 );
2209 2210 2211 2212 2213
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 );
2214
C_ASSERT( sizeof(struct open_directory_request) == 24 );
2215 2216 2217 2218
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 );
2219
C_ASSERT( sizeof(struct get_directory_entry_request) == 24 );
2220 2221 2222
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 );
2223
C_ASSERT( sizeof(struct create_symlink_request) == 16 );
2224 2225 2226 2227 2228
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 );
2229
C_ASSERT( sizeof(struct open_symlink_request) == 24 );
2230 2231 2232
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 );
2233
C_ASSERT( sizeof(struct query_symlink_request) == 16 );
2234 2235
C_ASSERT( FIELD_OFFSET(struct query_symlink_reply, total) == 8 );
C_ASSERT( sizeof(struct query_symlink_reply) == 16 );
2236
C_ASSERT( FIELD_OFFSET(struct get_object_info_request, handle) == 12 );
2237
C_ASSERT( sizeof(struct get_object_info_request) == 16 );
2238 2239
C_ASSERT( FIELD_OFFSET(struct get_object_info_reply, access) == 8 );
C_ASSERT( FIELD_OFFSET(struct get_object_info_reply, ref_count) == 12 );
2240 2241
C_ASSERT( FIELD_OFFSET(struct get_object_info_reply, handle_count) == 16 );
C_ASSERT( FIELD_OFFSET(struct get_object_info_reply, total) == 20 );
2242
C_ASSERT( sizeof(struct get_object_info_reply) == 24 );
2243 2244 2245 2246
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 );
2247 2248 2249
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 );
2250
C_ASSERT( sizeof(struct get_token_impersonation_level_request) == 16 );
2251 2252
C_ASSERT( FIELD_OFFSET(struct get_token_impersonation_level_reply, impersonation_level) == 8 );
C_ASSERT( sizeof(struct get_token_impersonation_level_reply) == 16 );
2253
C_ASSERT( sizeof(struct allocate_locally_unique_id_request) == 16 );
2254 2255 2256 2257
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 );
2258
C_ASSERT( sizeof(struct create_device_manager_request) == 24 );
2259 2260 2261 2262 2263 2264 2265
C_ASSERT( FIELD_OFFSET(struct create_device_manager_reply, handle) == 8 );
C_ASSERT( sizeof(struct create_device_manager_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct create_device_request, access) == 12 );
C_ASSERT( FIELD_OFFSET(struct create_device_request, attributes) == 16 );
C_ASSERT( FIELD_OFFSET(struct create_device_request, rootdir) == 20 );
C_ASSERT( FIELD_OFFSET(struct create_device_request, user_ptr) == 24 );
C_ASSERT( FIELD_OFFSET(struct create_device_request, manager) == 32 );
2266
C_ASSERT( sizeof(struct create_device_request) == 40 );
2267 2268 2269 2270 2271 2272 2273
C_ASSERT( FIELD_OFFSET(struct create_device_reply, handle) == 8 );
C_ASSERT( sizeof(struct create_device_reply) == 16 );
C_ASSERT( FIELD_OFFSET(struct delete_device_request, handle) == 12 );
C_ASSERT( sizeof(struct delete_device_request) == 16 );
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 );
2274
C_ASSERT( sizeof(struct get_next_device_request_request) == 24 );
2275
C_ASSERT( FIELD_OFFSET(struct get_next_device_request_reply, params) == 8 );
2276 2277 2278 2279 2280 2281
C_ASSERT( FIELD_OFFSET(struct get_next_device_request_reply, next) == 32 );
C_ASSERT( FIELD_OFFSET(struct get_next_device_request_reply, client_pid) == 36 );
C_ASSERT( FIELD_OFFSET(struct get_next_device_request_reply, client_tid) == 40 );
C_ASSERT( FIELD_OFFSET(struct get_next_device_request_reply, in_size) == 44 );
C_ASSERT( FIELD_OFFSET(struct get_next_device_request_reply, out_size) == 48 );
C_ASSERT( sizeof(struct get_next_device_request_reply) == 56 );
2282
C_ASSERT( sizeof(struct make_process_system_request) == 16 );
2283 2284 2285
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 );
2286
C_ASSERT( sizeof(struct get_token_statistics_request) == 16 );
2287 2288 2289 2290 2291 2292 2293 2294
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 );
2295 2296
C_ASSERT( FIELD_OFFSET(struct create_completion_request, concurrent) == 16 );
C_ASSERT( sizeof(struct create_completion_request) == 24 );
2297 2298 2299 2300 2301
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 );
2302
C_ASSERT( sizeof(struct open_completion_request) == 24 );
2303 2304 2305 2306 2307 2308
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 );
2309 2310
C_ASSERT( FIELD_OFFSET(struct add_completion_request, status) == 40 );
C_ASSERT( sizeof(struct add_completion_request) == 48 );
2311
C_ASSERT( FIELD_OFFSET(struct remove_completion_request, handle) == 12 );
2312
C_ASSERT( sizeof(struct remove_completion_request) == 16 );
2313 2314 2315
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 );
2316 2317
C_ASSERT( FIELD_OFFSET(struct remove_completion_reply, status) == 32 );
C_ASSERT( sizeof(struct remove_completion_reply) == 40 );
2318
C_ASSERT( FIELD_OFFSET(struct query_completion_request, handle) == 12 );
2319
C_ASSERT( sizeof(struct query_completion_request) == 16 );
2320 2321 2322 2323 2324 2325 2326 2327
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 );
2328 2329 2330
C_ASSERT( FIELD_OFFSET(struct add_fd_completion_request, information) == 24 );
C_ASSERT( FIELD_OFFSET(struct add_fd_completion_request, status) == 32 );
C_ASSERT( sizeof(struct add_fd_completion_request) == 40 );
2331 2332 2333 2334 2335
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 );
2336
C_ASSERT( FIELD_OFFSET(struct set_fd_name_info_request, link) == 20 );
2337
C_ASSERT( sizeof(struct set_fd_name_info_request) == 24 );
2338
C_ASSERT( FIELD_OFFSET(struct get_window_layered_info_request, handle) == 12 );
2339
C_ASSERT( sizeof(struct get_window_layered_info_request) == 16 );
2340 2341 2342 2343 2344 2345 2346 2347 2348
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 );
2349
C_ASSERT( sizeof(struct alloc_user_handle_request) == 16 );
2350 2351 2352 2353
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 );
2354 2355 2356
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 );
2357 2358
C_ASSERT( FIELD_OFFSET(struct set_cursor_request, x) == 24 );
C_ASSERT( FIELD_OFFSET(struct set_cursor_request, y) == 28 );
2359
C_ASSERT( FIELD_OFFSET(struct set_cursor_request, clip) == 32 );
2360 2361
C_ASSERT( FIELD_OFFSET(struct set_cursor_request, clip_msg) == 48 );
C_ASSERT( sizeof(struct set_cursor_request) == 56 );
2362 2363
C_ASSERT( FIELD_OFFSET(struct set_cursor_reply, prev_handle) == 8 );
C_ASSERT( FIELD_OFFSET(struct set_cursor_reply, prev_count) == 12 );
2364 2365 2366 2367 2368 2369 2370
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 );
2371
C_ASSERT( sizeof(struct update_rawinput_devices_request) == 16 );
2372 2373 2374
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 );
2375
C_ASSERT( FIELD_OFFSET(struct create_job_request, access) == 12 );
2376
C_ASSERT( sizeof(struct create_job_request) == 16 );
2377 2378
C_ASSERT( FIELD_OFFSET(struct create_job_reply, handle) == 8 );
C_ASSERT( sizeof(struct create_job_reply) == 16 );
2379 2380 2381 2382 2383 2384
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 );
2385 2386 2387
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 );
2388 2389 2390
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 );
2391 2392 2393
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 );
2394 2395 2396 2397
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 );
2398 2399 2400
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 );
2401

Alexandre Julliard's avatar
Alexandre Julliard committed
2402 2403
#endif  /* WANT_REQUEST_HANDLERS */

2404 2405 2406
/* ### make_requests end ### */
/* Everything above this line is generated automatically by tools/make_requests */

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