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