mirror of
git://source.winehq.org/git/wine.git
synced 2024-09-02 11:33:38 +00:00
![Zebediah Figura](/assets/img/avatar_default.png)
Although there is arguably an advantage to saving a server request, the impetus for this patch is make it easier for the server to process the IRP return status before (or at the same time as) it processes the IOSB status. This allows simpler handling of the case where the IRP handler returns STATUS_PENDING but completes the IRP before returning. Signed-off-by: Zebediah Figura <zfigura@codeweavers.com> Signed-off-by: Alexandre Julliard <julliard@winehq.org>
2252 lines
126 KiB
C
2252 lines
126 KiB
C
/*
|
|
* Wine server requests
|
|
*
|
|
* Copyright (C) 1999 Alexandre Julliard
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
|
|
*/
|
|
|
|
#ifndef __WINE_SERVER_REQUEST_H
|
|
#define __WINE_SERVER_REQUEST_H
|
|
|
|
#include <assert.h>
|
|
|
|
#include "thread.h"
|
|
#include "wine/server_protocol.h"
|
|
|
|
/* max request length */
|
|
#define MAX_REQUEST_LENGTH 8192
|
|
|
|
/* request handler definition */
|
|
#define DECL_HANDLER(name) \
|
|
void req_##name( const struct name##_request *req, struct name##_reply *reply )
|
|
|
|
/* request functions */
|
|
|
|
#ifdef __GNUC__
|
|
extern void fatal_protocol_error( struct thread *thread,
|
|
const char *err, ... ) __attribute__((format (printf,2,3)));
|
|
extern void fatal_error( const char *err, ... ) __attribute__((noreturn,format(printf,1,2)));
|
|
#else
|
|
extern void fatal_protocol_error( struct thread *thread, const char *err, ... );
|
|
extern void fatal_error( const char *err, ... );
|
|
#endif
|
|
|
|
extern const char *get_config_dir(void);
|
|
extern void *set_reply_data_size( data_size_t size );
|
|
extern const struct object_attributes *get_req_object_attributes( const struct security_descriptor **sd,
|
|
struct unicode_str *name,
|
|
struct object **root );
|
|
extern const void *get_req_data_after_objattr( const struct object_attributes *attr, data_size_t *len );
|
|
extern int receive_fd( struct process *process );
|
|
extern int send_client_fd( struct process *process, int fd, obj_handle_t handle );
|
|
extern void read_request( struct thread *thread );
|
|
extern void write_reply( struct thread *thread );
|
|
extern timeout_t monotonic_counter(void);
|
|
extern void open_master_socket(void);
|
|
extern void close_master_socket( timeout_t timeout );
|
|
extern void shutdown_master_socket(void);
|
|
extern int wait_for_lock(void);
|
|
extern int kill_lock_owner( int sig );
|
|
extern char *server_dir;
|
|
extern int server_dir_fd, config_dir_fd;
|
|
|
|
extern void trace_request(void);
|
|
extern void trace_reply( enum request req, const union generic_reply *reply );
|
|
|
|
/* get current tick count to return to client */
|
|
static inline unsigned int get_tick_count(void)
|
|
{
|
|
return monotonic_counter() / 10000;
|
|
}
|
|
|
|
/* get the request vararg data */
|
|
static inline const void *get_req_data(void)
|
|
{
|
|
return current->req_data;
|
|
}
|
|
|
|
/* get the request vararg size */
|
|
static inline data_size_t get_req_data_size(void)
|
|
{
|
|
return current->req.request_header.request_size;
|
|
}
|
|
|
|
/* get the request vararg as unicode string */
|
|
static inline struct unicode_str get_req_unicode_str(void)
|
|
{
|
|
struct unicode_str ret;
|
|
ret.str = get_req_data();
|
|
ret.len = (get_req_data_size() / sizeof(WCHAR)) * sizeof(WCHAR);
|
|
return ret;
|
|
}
|
|
|
|
/* get the reply maximum vararg size */
|
|
static inline data_size_t get_reply_max_size(void)
|
|
{
|
|
return current->req.request_header.reply_size;
|
|
}
|
|
|
|
/* allocate and fill the reply data */
|
|
static inline void *set_reply_data( const void *data, data_size_t size )
|
|
{
|
|
void *ret = set_reply_data_size( size );
|
|
if (ret) memcpy( ret, data, size );
|
|
return ret;
|
|
}
|
|
|
|
/* set the reply data pointer directly (will be freed by request code) */
|
|
static inline void set_reply_data_ptr( void *data, data_size_t size )
|
|
{
|
|
assert( size <= get_reply_max_size() );
|
|
current->reply_size = size;
|
|
current->reply_data = data;
|
|
}
|
|
|
|
|
|
/* Everything below this line is generated automatically by tools/make_requests */
|
|
/* ### make_requests begin ### */
|
|
|
|
DECL_HANDLER(new_process);
|
|
DECL_HANDLER(get_new_process_info);
|
|
DECL_HANDLER(new_thread);
|
|
DECL_HANDLER(get_startup_info);
|
|
DECL_HANDLER(init_process_done);
|
|
DECL_HANDLER(init_first_thread);
|
|
DECL_HANDLER(init_thread);
|
|
DECL_HANDLER(terminate_process);
|
|
DECL_HANDLER(terminate_thread);
|
|
DECL_HANDLER(get_process_info);
|
|
DECL_HANDLER(get_process_debug_info);
|
|
DECL_HANDLER(get_process_image_name);
|
|
DECL_HANDLER(get_process_vm_counters);
|
|
DECL_HANDLER(set_process_info);
|
|
DECL_HANDLER(get_thread_info);
|
|
DECL_HANDLER(get_thread_times);
|
|
DECL_HANDLER(set_thread_info);
|
|
DECL_HANDLER(suspend_thread);
|
|
DECL_HANDLER(resume_thread);
|
|
DECL_HANDLER(queue_apc);
|
|
DECL_HANDLER(get_apc_result);
|
|
DECL_HANDLER(close_handle);
|
|
DECL_HANDLER(set_handle_info);
|
|
DECL_HANDLER(dup_handle);
|
|
DECL_HANDLER(make_temporary);
|
|
DECL_HANDLER(open_process);
|
|
DECL_HANDLER(open_thread);
|
|
DECL_HANDLER(select);
|
|
DECL_HANDLER(create_event);
|
|
DECL_HANDLER(event_op);
|
|
DECL_HANDLER(query_event);
|
|
DECL_HANDLER(open_event);
|
|
DECL_HANDLER(create_keyed_event);
|
|
DECL_HANDLER(open_keyed_event);
|
|
DECL_HANDLER(create_mutex);
|
|
DECL_HANDLER(release_mutex);
|
|
DECL_HANDLER(open_mutex);
|
|
DECL_HANDLER(query_mutex);
|
|
DECL_HANDLER(create_semaphore);
|
|
DECL_HANDLER(release_semaphore);
|
|
DECL_HANDLER(query_semaphore);
|
|
DECL_HANDLER(open_semaphore);
|
|
DECL_HANDLER(create_file);
|
|
DECL_HANDLER(open_file_object);
|
|
DECL_HANDLER(alloc_file_handle);
|
|
DECL_HANDLER(get_handle_unix_name);
|
|
DECL_HANDLER(get_handle_fd);
|
|
DECL_HANDLER(get_directory_cache_entry);
|
|
DECL_HANDLER(flush);
|
|
DECL_HANDLER(get_file_info);
|
|
DECL_HANDLER(get_volume_info);
|
|
DECL_HANDLER(lock_file);
|
|
DECL_HANDLER(unlock_file);
|
|
DECL_HANDLER(recv_socket);
|
|
DECL_HANDLER(poll_socket);
|
|
DECL_HANDLER(send_socket);
|
|
DECL_HANDLER(get_next_console_request);
|
|
DECL_HANDLER(read_directory_changes);
|
|
DECL_HANDLER(read_change);
|
|
DECL_HANDLER(create_mapping);
|
|
DECL_HANDLER(open_mapping);
|
|
DECL_HANDLER(get_mapping_info);
|
|
DECL_HANDLER(map_view);
|
|
DECL_HANDLER(unmap_view);
|
|
DECL_HANDLER(get_mapping_committed_range);
|
|
DECL_HANDLER(add_mapping_committed_range);
|
|
DECL_HANDLER(is_same_mapping);
|
|
DECL_HANDLER(get_mapping_filename);
|
|
DECL_HANDLER(list_processes);
|
|
DECL_HANDLER(create_debug_obj);
|
|
DECL_HANDLER(wait_debug_event);
|
|
DECL_HANDLER(queue_exception_event);
|
|
DECL_HANDLER(get_exception_status);
|
|
DECL_HANDLER(continue_debug_event);
|
|
DECL_HANDLER(debug_process);
|
|
DECL_HANDLER(set_debug_obj_info);
|
|
DECL_HANDLER(read_process_memory);
|
|
DECL_HANDLER(write_process_memory);
|
|
DECL_HANDLER(create_key);
|
|
DECL_HANDLER(open_key);
|
|
DECL_HANDLER(delete_key);
|
|
DECL_HANDLER(flush_key);
|
|
DECL_HANDLER(enum_key);
|
|
DECL_HANDLER(set_key_value);
|
|
DECL_HANDLER(get_key_value);
|
|
DECL_HANDLER(enum_key_value);
|
|
DECL_HANDLER(delete_key_value);
|
|
DECL_HANDLER(load_registry);
|
|
DECL_HANDLER(unload_registry);
|
|
DECL_HANDLER(save_registry);
|
|
DECL_HANDLER(set_registry_notification);
|
|
DECL_HANDLER(create_timer);
|
|
DECL_HANDLER(open_timer);
|
|
DECL_HANDLER(set_timer);
|
|
DECL_HANDLER(cancel_timer);
|
|
DECL_HANDLER(get_timer_info);
|
|
DECL_HANDLER(get_thread_context);
|
|
DECL_HANDLER(set_thread_context);
|
|
DECL_HANDLER(get_selector_entry);
|
|
DECL_HANDLER(add_atom);
|
|
DECL_HANDLER(delete_atom);
|
|
DECL_HANDLER(find_atom);
|
|
DECL_HANDLER(get_atom_information);
|
|
DECL_HANDLER(get_msg_queue);
|
|
DECL_HANDLER(set_queue_fd);
|
|
DECL_HANDLER(set_queue_mask);
|
|
DECL_HANDLER(get_queue_status);
|
|
DECL_HANDLER(get_process_idle_event);
|
|
DECL_HANDLER(send_message);
|
|
DECL_HANDLER(post_quit_message);
|
|
DECL_HANDLER(send_hardware_message);
|
|
DECL_HANDLER(get_message);
|
|
DECL_HANDLER(reply_message);
|
|
DECL_HANDLER(accept_hardware_message);
|
|
DECL_HANDLER(get_message_reply);
|
|
DECL_HANDLER(set_win_timer);
|
|
DECL_HANDLER(kill_win_timer);
|
|
DECL_HANDLER(is_window_hung);
|
|
DECL_HANDLER(get_serial_info);
|
|
DECL_HANDLER(set_serial_info);
|
|
DECL_HANDLER(register_async);
|
|
DECL_HANDLER(cancel_async);
|
|
DECL_HANDLER(get_async_result);
|
|
DECL_HANDLER(read);
|
|
DECL_HANDLER(write);
|
|
DECL_HANDLER(ioctl);
|
|
DECL_HANDLER(set_irp_result);
|
|
DECL_HANDLER(create_named_pipe);
|
|
DECL_HANDLER(set_named_pipe_info);
|
|
DECL_HANDLER(create_window);
|
|
DECL_HANDLER(destroy_window);
|
|
DECL_HANDLER(get_desktop_window);
|
|
DECL_HANDLER(set_window_owner);
|
|
DECL_HANDLER(get_window_info);
|
|
DECL_HANDLER(set_window_info);
|
|
DECL_HANDLER(set_parent);
|
|
DECL_HANDLER(get_window_parents);
|
|
DECL_HANDLER(get_window_children);
|
|
DECL_HANDLER(get_window_children_from_point);
|
|
DECL_HANDLER(get_window_tree);
|
|
DECL_HANDLER(set_window_pos);
|
|
DECL_HANDLER(get_window_rectangles);
|
|
DECL_HANDLER(get_window_text);
|
|
DECL_HANDLER(set_window_text);
|
|
DECL_HANDLER(get_windows_offset);
|
|
DECL_HANDLER(get_visible_region);
|
|
DECL_HANDLER(get_surface_region);
|
|
DECL_HANDLER(get_window_region);
|
|
DECL_HANDLER(set_window_region);
|
|
DECL_HANDLER(get_update_region);
|
|
DECL_HANDLER(update_window_zorder);
|
|
DECL_HANDLER(redraw_window);
|
|
DECL_HANDLER(set_window_property);
|
|
DECL_HANDLER(remove_window_property);
|
|
DECL_HANDLER(get_window_property);
|
|
DECL_HANDLER(get_window_properties);
|
|
DECL_HANDLER(create_winstation);
|
|
DECL_HANDLER(open_winstation);
|
|
DECL_HANDLER(close_winstation);
|
|
DECL_HANDLER(get_process_winstation);
|
|
DECL_HANDLER(set_process_winstation);
|
|
DECL_HANDLER(enum_winstation);
|
|
DECL_HANDLER(create_desktop);
|
|
DECL_HANDLER(open_desktop);
|
|
DECL_HANDLER(open_input_desktop);
|
|
DECL_HANDLER(close_desktop);
|
|
DECL_HANDLER(get_thread_desktop);
|
|
DECL_HANDLER(set_thread_desktop);
|
|
DECL_HANDLER(enum_desktop);
|
|
DECL_HANDLER(set_user_object_info);
|
|
DECL_HANDLER(register_hotkey);
|
|
DECL_HANDLER(unregister_hotkey);
|
|
DECL_HANDLER(attach_thread_input);
|
|
DECL_HANDLER(get_thread_input);
|
|
DECL_HANDLER(get_last_input_time);
|
|
DECL_HANDLER(get_key_state);
|
|
DECL_HANDLER(set_key_state);
|
|
DECL_HANDLER(set_foreground_window);
|
|
DECL_HANDLER(set_focus_window);
|
|
DECL_HANDLER(set_active_window);
|
|
DECL_HANDLER(set_capture_window);
|
|
DECL_HANDLER(set_caret_window);
|
|
DECL_HANDLER(set_caret_info);
|
|
DECL_HANDLER(set_hook);
|
|
DECL_HANDLER(remove_hook);
|
|
DECL_HANDLER(start_hook_chain);
|
|
DECL_HANDLER(finish_hook_chain);
|
|
DECL_HANDLER(get_hook_info);
|
|
DECL_HANDLER(create_class);
|
|
DECL_HANDLER(destroy_class);
|
|
DECL_HANDLER(set_class_info);
|
|
DECL_HANDLER(open_clipboard);
|
|
DECL_HANDLER(close_clipboard);
|
|
DECL_HANDLER(empty_clipboard);
|
|
DECL_HANDLER(set_clipboard_data);
|
|
DECL_HANDLER(get_clipboard_data);
|
|
DECL_HANDLER(get_clipboard_formats);
|
|
DECL_HANDLER(enum_clipboard_formats);
|
|
DECL_HANDLER(release_clipboard);
|
|
DECL_HANDLER(get_clipboard_info);
|
|
DECL_HANDLER(set_clipboard_viewer);
|
|
DECL_HANDLER(add_clipboard_listener);
|
|
DECL_HANDLER(remove_clipboard_listener);
|
|
DECL_HANDLER(open_token);
|
|
DECL_HANDLER(set_global_windows);
|
|
DECL_HANDLER(adjust_token_privileges);
|
|
DECL_HANDLER(get_token_privileges);
|
|
DECL_HANDLER(check_token_privileges);
|
|
DECL_HANDLER(duplicate_token);
|
|
DECL_HANDLER(filter_token);
|
|
DECL_HANDLER(access_check);
|
|
DECL_HANDLER(get_token_sid);
|
|
DECL_HANDLER(get_token_groups);
|
|
DECL_HANDLER(get_token_default_dacl);
|
|
DECL_HANDLER(set_token_default_dacl);
|
|
DECL_HANDLER(set_security_object);
|
|
DECL_HANDLER(get_security_object);
|
|
DECL_HANDLER(get_system_handles);
|
|
DECL_HANDLER(create_mailslot);
|
|
DECL_HANDLER(set_mailslot_info);
|
|
DECL_HANDLER(create_directory);
|
|
DECL_HANDLER(open_directory);
|
|
DECL_HANDLER(get_directory_entry);
|
|
DECL_HANDLER(create_symlink);
|
|
DECL_HANDLER(open_symlink);
|
|
DECL_HANDLER(query_symlink);
|
|
DECL_HANDLER(get_object_info);
|
|
DECL_HANDLER(get_object_name);
|
|
DECL_HANDLER(get_object_type);
|
|
DECL_HANDLER(get_object_types);
|
|
DECL_HANDLER(allocate_locally_unique_id);
|
|
DECL_HANDLER(create_device_manager);
|
|
DECL_HANDLER(create_device);
|
|
DECL_HANDLER(delete_device);
|
|
DECL_HANDLER(get_next_device_request);
|
|
DECL_HANDLER(get_kernel_object_ptr);
|
|
DECL_HANDLER(set_kernel_object_ptr);
|
|
DECL_HANDLER(grab_kernel_object);
|
|
DECL_HANDLER(release_kernel_object);
|
|
DECL_HANDLER(get_kernel_object_handle);
|
|
DECL_HANDLER(make_process_system);
|
|
DECL_HANDLER(get_token_info);
|
|
DECL_HANDLER(create_linked_token);
|
|
DECL_HANDLER(create_completion);
|
|
DECL_HANDLER(open_completion);
|
|
DECL_HANDLER(add_completion);
|
|
DECL_HANDLER(remove_completion);
|
|
DECL_HANDLER(query_completion);
|
|
DECL_HANDLER(set_completion_info);
|
|
DECL_HANDLER(add_fd_completion);
|
|
DECL_HANDLER(set_fd_completion_mode);
|
|
DECL_HANDLER(set_fd_disp_info);
|
|
DECL_HANDLER(set_fd_name_info);
|
|
DECL_HANDLER(set_fd_eof_info);
|
|
DECL_HANDLER(get_window_layered_info);
|
|
DECL_HANDLER(set_window_layered_info);
|
|
DECL_HANDLER(alloc_user_handle);
|
|
DECL_HANDLER(free_user_handle);
|
|
DECL_HANDLER(set_cursor);
|
|
DECL_HANDLER(get_cursor_history);
|
|
DECL_HANDLER(get_rawinput_buffer);
|
|
DECL_HANDLER(update_rawinput_devices);
|
|
DECL_HANDLER(get_rawinput_devices);
|
|
DECL_HANDLER(create_job);
|
|
DECL_HANDLER(open_job);
|
|
DECL_HANDLER(assign_job);
|
|
DECL_HANDLER(process_in_job);
|
|
DECL_HANDLER(set_job_limits);
|
|
DECL_HANDLER(set_job_completion_port);
|
|
DECL_HANDLER(get_job_info);
|
|
DECL_HANDLER(terminate_job);
|
|
DECL_HANDLER(suspend_process);
|
|
DECL_HANDLER(resume_process);
|
|
DECL_HANDLER(get_next_thread);
|
|
|
|
#ifdef WANT_REQUEST_HANDLERS
|
|
|
|
typedef void (*req_handler)( const void *req, void *reply );
|
|
static const req_handler req_handlers[REQ_NB_REQUESTS] =
|
|
{
|
|
(req_handler)req_new_process,
|
|
(req_handler)req_get_new_process_info,
|
|
(req_handler)req_new_thread,
|
|
(req_handler)req_get_startup_info,
|
|
(req_handler)req_init_process_done,
|
|
(req_handler)req_init_first_thread,
|
|
(req_handler)req_init_thread,
|
|
(req_handler)req_terminate_process,
|
|
(req_handler)req_terminate_thread,
|
|
(req_handler)req_get_process_info,
|
|
(req_handler)req_get_process_debug_info,
|
|
(req_handler)req_get_process_image_name,
|
|
(req_handler)req_get_process_vm_counters,
|
|
(req_handler)req_set_process_info,
|
|
(req_handler)req_get_thread_info,
|
|
(req_handler)req_get_thread_times,
|
|
(req_handler)req_set_thread_info,
|
|
(req_handler)req_suspend_thread,
|
|
(req_handler)req_resume_thread,
|
|
(req_handler)req_queue_apc,
|
|
(req_handler)req_get_apc_result,
|
|
(req_handler)req_close_handle,
|
|
(req_handler)req_set_handle_info,
|
|
(req_handler)req_dup_handle,
|
|
(req_handler)req_make_temporary,
|
|
(req_handler)req_open_process,
|
|
(req_handler)req_open_thread,
|
|
(req_handler)req_select,
|
|
(req_handler)req_create_event,
|
|
(req_handler)req_event_op,
|
|
(req_handler)req_query_event,
|
|
(req_handler)req_open_event,
|
|
(req_handler)req_create_keyed_event,
|
|
(req_handler)req_open_keyed_event,
|
|
(req_handler)req_create_mutex,
|
|
(req_handler)req_release_mutex,
|
|
(req_handler)req_open_mutex,
|
|
(req_handler)req_query_mutex,
|
|
(req_handler)req_create_semaphore,
|
|
(req_handler)req_release_semaphore,
|
|
(req_handler)req_query_semaphore,
|
|
(req_handler)req_open_semaphore,
|
|
(req_handler)req_create_file,
|
|
(req_handler)req_open_file_object,
|
|
(req_handler)req_alloc_file_handle,
|
|
(req_handler)req_get_handle_unix_name,
|
|
(req_handler)req_get_handle_fd,
|
|
(req_handler)req_get_directory_cache_entry,
|
|
(req_handler)req_flush,
|
|
(req_handler)req_get_file_info,
|
|
(req_handler)req_get_volume_info,
|
|
(req_handler)req_lock_file,
|
|
(req_handler)req_unlock_file,
|
|
(req_handler)req_recv_socket,
|
|
(req_handler)req_poll_socket,
|
|
(req_handler)req_send_socket,
|
|
(req_handler)req_get_next_console_request,
|
|
(req_handler)req_read_directory_changes,
|
|
(req_handler)req_read_change,
|
|
(req_handler)req_create_mapping,
|
|
(req_handler)req_open_mapping,
|
|
(req_handler)req_get_mapping_info,
|
|
(req_handler)req_map_view,
|
|
(req_handler)req_unmap_view,
|
|
(req_handler)req_get_mapping_committed_range,
|
|
(req_handler)req_add_mapping_committed_range,
|
|
(req_handler)req_is_same_mapping,
|
|
(req_handler)req_get_mapping_filename,
|
|
(req_handler)req_list_processes,
|
|
(req_handler)req_create_debug_obj,
|
|
(req_handler)req_wait_debug_event,
|
|
(req_handler)req_queue_exception_event,
|
|
(req_handler)req_get_exception_status,
|
|
(req_handler)req_continue_debug_event,
|
|
(req_handler)req_debug_process,
|
|
(req_handler)req_set_debug_obj_info,
|
|
(req_handler)req_read_process_memory,
|
|
(req_handler)req_write_process_memory,
|
|
(req_handler)req_create_key,
|
|
(req_handler)req_open_key,
|
|
(req_handler)req_delete_key,
|
|
(req_handler)req_flush_key,
|
|
(req_handler)req_enum_key,
|
|
(req_handler)req_set_key_value,
|
|
(req_handler)req_get_key_value,
|
|
(req_handler)req_enum_key_value,
|
|
(req_handler)req_delete_key_value,
|
|
(req_handler)req_load_registry,
|
|
(req_handler)req_unload_registry,
|
|
(req_handler)req_save_registry,
|
|
(req_handler)req_set_registry_notification,
|
|
(req_handler)req_create_timer,
|
|
(req_handler)req_open_timer,
|
|
(req_handler)req_set_timer,
|
|
(req_handler)req_cancel_timer,
|
|
(req_handler)req_get_timer_info,
|
|
(req_handler)req_get_thread_context,
|
|
(req_handler)req_set_thread_context,
|
|
(req_handler)req_get_selector_entry,
|
|
(req_handler)req_add_atom,
|
|
(req_handler)req_delete_atom,
|
|
(req_handler)req_find_atom,
|
|
(req_handler)req_get_atom_information,
|
|
(req_handler)req_get_msg_queue,
|
|
(req_handler)req_set_queue_fd,
|
|
(req_handler)req_set_queue_mask,
|
|
(req_handler)req_get_queue_status,
|
|
(req_handler)req_get_process_idle_event,
|
|
(req_handler)req_send_message,
|
|
(req_handler)req_post_quit_message,
|
|
(req_handler)req_send_hardware_message,
|
|
(req_handler)req_get_message,
|
|
(req_handler)req_reply_message,
|
|
(req_handler)req_accept_hardware_message,
|
|
(req_handler)req_get_message_reply,
|
|
(req_handler)req_set_win_timer,
|
|
(req_handler)req_kill_win_timer,
|
|
(req_handler)req_is_window_hung,
|
|
(req_handler)req_get_serial_info,
|
|
(req_handler)req_set_serial_info,
|
|
(req_handler)req_register_async,
|
|
(req_handler)req_cancel_async,
|
|
(req_handler)req_get_async_result,
|
|
(req_handler)req_read,
|
|
(req_handler)req_write,
|
|
(req_handler)req_ioctl,
|
|
(req_handler)req_set_irp_result,
|
|
(req_handler)req_create_named_pipe,
|
|
(req_handler)req_set_named_pipe_info,
|
|
(req_handler)req_create_window,
|
|
(req_handler)req_destroy_window,
|
|
(req_handler)req_get_desktop_window,
|
|
(req_handler)req_set_window_owner,
|
|
(req_handler)req_get_window_info,
|
|
(req_handler)req_set_window_info,
|
|
(req_handler)req_set_parent,
|
|
(req_handler)req_get_window_parents,
|
|
(req_handler)req_get_window_children,
|
|
(req_handler)req_get_window_children_from_point,
|
|
(req_handler)req_get_window_tree,
|
|
(req_handler)req_set_window_pos,
|
|
(req_handler)req_get_window_rectangles,
|
|
(req_handler)req_get_window_text,
|
|
(req_handler)req_set_window_text,
|
|
(req_handler)req_get_windows_offset,
|
|
(req_handler)req_get_visible_region,
|
|
(req_handler)req_get_surface_region,
|
|
(req_handler)req_get_window_region,
|
|
(req_handler)req_set_window_region,
|
|
(req_handler)req_get_update_region,
|
|
(req_handler)req_update_window_zorder,
|
|
(req_handler)req_redraw_window,
|
|
(req_handler)req_set_window_property,
|
|
(req_handler)req_remove_window_property,
|
|
(req_handler)req_get_window_property,
|
|
(req_handler)req_get_window_properties,
|
|
(req_handler)req_create_winstation,
|
|
(req_handler)req_open_winstation,
|
|
(req_handler)req_close_winstation,
|
|
(req_handler)req_get_process_winstation,
|
|
(req_handler)req_set_process_winstation,
|
|
(req_handler)req_enum_winstation,
|
|
(req_handler)req_create_desktop,
|
|
(req_handler)req_open_desktop,
|
|
(req_handler)req_open_input_desktop,
|
|
(req_handler)req_close_desktop,
|
|
(req_handler)req_get_thread_desktop,
|
|
(req_handler)req_set_thread_desktop,
|
|
(req_handler)req_enum_desktop,
|
|
(req_handler)req_set_user_object_info,
|
|
(req_handler)req_register_hotkey,
|
|
(req_handler)req_unregister_hotkey,
|
|
(req_handler)req_attach_thread_input,
|
|
(req_handler)req_get_thread_input,
|
|
(req_handler)req_get_last_input_time,
|
|
(req_handler)req_get_key_state,
|
|
(req_handler)req_set_key_state,
|
|
(req_handler)req_set_foreground_window,
|
|
(req_handler)req_set_focus_window,
|
|
(req_handler)req_set_active_window,
|
|
(req_handler)req_set_capture_window,
|
|
(req_handler)req_set_caret_window,
|
|
(req_handler)req_set_caret_info,
|
|
(req_handler)req_set_hook,
|
|
(req_handler)req_remove_hook,
|
|
(req_handler)req_start_hook_chain,
|
|
(req_handler)req_finish_hook_chain,
|
|
(req_handler)req_get_hook_info,
|
|
(req_handler)req_create_class,
|
|
(req_handler)req_destroy_class,
|
|
(req_handler)req_set_class_info,
|
|
(req_handler)req_open_clipboard,
|
|
(req_handler)req_close_clipboard,
|
|
(req_handler)req_empty_clipboard,
|
|
(req_handler)req_set_clipboard_data,
|
|
(req_handler)req_get_clipboard_data,
|
|
(req_handler)req_get_clipboard_formats,
|
|
(req_handler)req_enum_clipboard_formats,
|
|
(req_handler)req_release_clipboard,
|
|
(req_handler)req_get_clipboard_info,
|
|
(req_handler)req_set_clipboard_viewer,
|
|
(req_handler)req_add_clipboard_listener,
|
|
(req_handler)req_remove_clipboard_listener,
|
|
(req_handler)req_open_token,
|
|
(req_handler)req_set_global_windows,
|
|
(req_handler)req_adjust_token_privileges,
|
|
(req_handler)req_get_token_privileges,
|
|
(req_handler)req_check_token_privileges,
|
|
(req_handler)req_duplicate_token,
|
|
(req_handler)req_filter_token,
|
|
(req_handler)req_access_check,
|
|
(req_handler)req_get_token_sid,
|
|
(req_handler)req_get_token_groups,
|
|
(req_handler)req_get_token_default_dacl,
|
|
(req_handler)req_set_token_default_dacl,
|
|
(req_handler)req_set_security_object,
|
|
(req_handler)req_get_security_object,
|
|
(req_handler)req_get_system_handles,
|
|
(req_handler)req_create_mailslot,
|
|
(req_handler)req_set_mailslot_info,
|
|
(req_handler)req_create_directory,
|
|
(req_handler)req_open_directory,
|
|
(req_handler)req_get_directory_entry,
|
|
(req_handler)req_create_symlink,
|
|
(req_handler)req_open_symlink,
|
|
(req_handler)req_query_symlink,
|
|
(req_handler)req_get_object_info,
|
|
(req_handler)req_get_object_name,
|
|
(req_handler)req_get_object_type,
|
|
(req_handler)req_get_object_types,
|
|
(req_handler)req_allocate_locally_unique_id,
|
|
(req_handler)req_create_device_manager,
|
|
(req_handler)req_create_device,
|
|
(req_handler)req_delete_device,
|
|
(req_handler)req_get_next_device_request,
|
|
(req_handler)req_get_kernel_object_ptr,
|
|
(req_handler)req_set_kernel_object_ptr,
|
|
(req_handler)req_grab_kernel_object,
|
|
(req_handler)req_release_kernel_object,
|
|
(req_handler)req_get_kernel_object_handle,
|
|
(req_handler)req_make_process_system,
|
|
(req_handler)req_get_token_info,
|
|
(req_handler)req_create_linked_token,
|
|
(req_handler)req_create_completion,
|
|
(req_handler)req_open_completion,
|
|
(req_handler)req_add_completion,
|
|
(req_handler)req_remove_completion,
|
|
(req_handler)req_query_completion,
|
|
(req_handler)req_set_completion_info,
|
|
(req_handler)req_add_fd_completion,
|
|
(req_handler)req_set_fd_completion_mode,
|
|
(req_handler)req_set_fd_disp_info,
|
|
(req_handler)req_set_fd_name_info,
|
|
(req_handler)req_set_fd_eof_info,
|
|
(req_handler)req_get_window_layered_info,
|
|
(req_handler)req_set_window_layered_info,
|
|
(req_handler)req_alloc_user_handle,
|
|
(req_handler)req_free_user_handle,
|
|
(req_handler)req_set_cursor,
|
|
(req_handler)req_get_cursor_history,
|
|
(req_handler)req_get_rawinput_buffer,
|
|
(req_handler)req_update_rawinput_devices,
|
|
(req_handler)req_get_rawinput_devices,
|
|
(req_handler)req_create_job,
|
|
(req_handler)req_open_job,
|
|
(req_handler)req_assign_job,
|
|
(req_handler)req_process_in_job,
|
|
(req_handler)req_set_job_limits,
|
|
(req_handler)req_set_job_completion_port,
|
|
(req_handler)req_get_job_info,
|
|
(req_handler)req_terminate_job,
|
|
(req_handler)req_suspend_process,
|
|
(req_handler)req_resume_process,
|
|
(req_handler)req_get_next_thread,
|
|
};
|
|
|
|
C_ASSERT( sizeof(abstime_t) == 8 );
|
|
C_ASSERT( sizeof(affinity_t) == 8 );
|
|
C_ASSERT( sizeof(apc_call_t) == 48 );
|
|
C_ASSERT( sizeof(apc_param_t) == 8 );
|
|
C_ASSERT( sizeof(apc_result_t) == 40 );
|
|
C_ASSERT( sizeof(async_data_t) == 40 );
|
|
C_ASSERT( sizeof(atom_t) == 4 );
|
|
C_ASSERT( sizeof(char) == 1 );
|
|
C_ASSERT( sizeof(client_ptr_t) == 8 );
|
|
C_ASSERT( sizeof(data_size_t) == 4 );
|
|
C_ASSERT( sizeof(file_pos_t) == 8 );
|
|
C_ASSERT( sizeof(generic_map_t) == 16 );
|
|
C_ASSERT( sizeof(hw_input_t) == 40 );
|
|
C_ASSERT( sizeof(int) == 4 );
|
|
C_ASSERT( sizeof(ioctl_code_t) == 4 );
|
|
C_ASSERT( sizeof(irp_params_t) == 32 );
|
|
C_ASSERT( sizeof(lparam_t) == 8 );
|
|
C_ASSERT( sizeof(luid_t) == 8 );
|
|
C_ASSERT( sizeof(mem_size_t) == 8 );
|
|
C_ASSERT( sizeof(mod_handle_t) == 8 );
|
|
C_ASSERT( sizeof(obj_handle_t) == 4 );
|
|
C_ASSERT( sizeof(process_id_t) == 4 );
|
|
C_ASSERT( sizeof(rectangle_t) == 16 );
|
|
C_ASSERT( sizeof(short int) == 2 );
|
|
C_ASSERT( sizeof(thread_id_t) == 4 );
|
|
C_ASSERT( sizeof(timeout_t) == 8 );
|
|
C_ASSERT( sizeof(unsigned char) == 1 );
|
|
C_ASSERT( sizeof(unsigned int) == 4 );
|
|
C_ASSERT( sizeof(unsigned short) == 2 );
|
|
C_ASSERT( sizeof(user_handle_t) == 4 );
|
|
C_ASSERT( FIELD_OFFSET(struct new_process_request, token) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct new_process_request, debug) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct new_process_request, parent_process) == 20 );
|
|
C_ASSERT( FIELD_OFFSET(struct new_process_request, flags) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct new_process_request, socket_fd) == 28 );
|
|
C_ASSERT( FIELD_OFFSET(struct new_process_request, access) == 32 );
|
|
C_ASSERT( FIELD_OFFSET(struct new_process_request, machine) == 36 );
|
|
C_ASSERT( FIELD_OFFSET(struct new_process_request, info_size) == 40 );
|
|
C_ASSERT( FIELD_OFFSET(struct new_process_request, handles_size) == 44 );
|
|
C_ASSERT( FIELD_OFFSET(struct new_process_request, jobs_size) == 48 );
|
|
C_ASSERT( sizeof(struct new_process_request) == 56 );
|
|
C_ASSERT( FIELD_OFFSET(struct new_process_reply, info) == 8 );
|
|
C_ASSERT( FIELD_OFFSET(struct new_process_reply, pid) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct new_process_reply, handle) == 16 );
|
|
C_ASSERT( sizeof(struct new_process_reply) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_new_process_info_request, info) == 12 );
|
|
C_ASSERT( sizeof(struct get_new_process_info_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_new_process_info_reply, success) == 8 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_new_process_info_reply, exit_code) == 12 );
|
|
C_ASSERT( sizeof(struct get_new_process_info_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct new_thread_request, process) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct new_thread_request, access) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct new_thread_request, suspend) == 20 );
|
|
C_ASSERT( FIELD_OFFSET(struct new_thread_request, request_fd) == 24 );
|
|
C_ASSERT( sizeof(struct new_thread_request) == 32 );
|
|
C_ASSERT( FIELD_OFFSET(struct new_thread_reply, tid) == 8 );
|
|
C_ASSERT( FIELD_OFFSET(struct new_thread_reply, handle) == 12 );
|
|
C_ASSERT( sizeof(struct new_thread_reply) == 16 );
|
|
C_ASSERT( sizeof(struct get_startup_info_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_startup_info_reply, info_size) == 8 );
|
|
C_ASSERT( sizeof(struct get_startup_info_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct init_process_done_request, teb) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct init_process_done_request, peb) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct init_process_done_request, ldt_copy) == 32 );
|
|
C_ASSERT( sizeof(struct init_process_done_request) == 40 );
|
|
C_ASSERT( FIELD_OFFSET(struct init_process_done_reply, entry) == 8 );
|
|
C_ASSERT( FIELD_OFFSET(struct init_process_done_reply, suspend) == 16 );
|
|
C_ASSERT( sizeof(struct init_process_done_reply) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct init_first_thread_request, unix_pid) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct init_first_thread_request, unix_tid) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct init_first_thread_request, debug_level) == 20 );
|
|
C_ASSERT( FIELD_OFFSET(struct init_first_thread_request, reply_fd) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct init_first_thread_request, wait_fd) == 28 );
|
|
C_ASSERT( sizeof(struct init_first_thread_request) == 32 );
|
|
C_ASSERT( FIELD_OFFSET(struct init_first_thread_reply, pid) == 8 );
|
|
C_ASSERT( FIELD_OFFSET(struct init_first_thread_reply, tid) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct init_first_thread_reply, server_start) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct init_first_thread_reply, session_id) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct init_first_thread_reply, info_size) == 28 );
|
|
C_ASSERT( sizeof(struct init_first_thread_reply) == 32 );
|
|
C_ASSERT( FIELD_OFFSET(struct init_thread_request, unix_tid) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct init_thread_request, reply_fd) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct init_thread_request, wait_fd) == 20 );
|
|
C_ASSERT( FIELD_OFFSET(struct init_thread_request, teb) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct init_thread_request, entry) == 32 );
|
|
C_ASSERT( sizeof(struct init_thread_request) == 40 );
|
|
C_ASSERT( FIELD_OFFSET(struct init_thread_reply, suspend) == 8 );
|
|
C_ASSERT( sizeof(struct init_thread_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct terminate_process_request, handle) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct terminate_process_request, exit_code) == 16 );
|
|
C_ASSERT( sizeof(struct terminate_process_request) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct terminate_process_reply, self) == 8 );
|
|
C_ASSERT( sizeof(struct terminate_process_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct terminate_thread_request, handle) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct terminate_thread_request, exit_code) == 16 );
|
|
C_ASSERT( sizeof(struct terminate_thread_request) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct terminate_thread_reply, self) == 8 );
|
|
C_ASSERT( sizeof(struct terminate_thread_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_process_info_request, handle) == 12 );
|
|
C_ASSERT( sizeof(struct get_process_info_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_process_info_reply, pid) == 8 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_process_info_reply, ppid) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_process_info_reply, affinity) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_process_info_reply, peb) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_process_info_reply, start_time) == 32 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_process_info_reply, end_time) == 40 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_process_info_reply, session_id) == 48 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_process_info_reply, exit_code) == 52 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_process_info_reply, priority) == 56 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_process_info_reply, machine) == 60 );
|
|
C_ASSERT( sizeof(struct get_process_info_reply) == 64 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_process_debug_info_request, handle) == 12 );
|
|
C_ASSERT( sizeof(struct get_process_debug_info_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_process_debug_info_reply, debug) == 8 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_process_debug_info_reply, debug_children) == 12 );
|
|
C_ASSERT( sizeof(struct get_process_debug_info_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_process_image_name_request, handle) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_process_image_name_request, win32) == 16 );
|
|
C_ASSERT( sizeof(struct get_process_image_name_request) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_process_image_name_reply, len) == 8 );
|
|
C_ASSERT( sizeof(struct get_process_image_name_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_process_vm_counters_request, handle) == 12 );
|
|
C_ASSERT( sizeof(struct get_process_vm_counters_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_process_vm_counters_reply, peak_virtual_size) == 8 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_process_vm_counters_reply, virtual_size) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_process_vm_counters_reply, peak_working_set_size) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_process_vm_counters_reply, working_set_size) == 32 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_process_vm_counters_reply, pagefile_usage) == 40 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_process_vm_counters_reply, peak_pagefile_usage) == 48 );
|
|
C_ASSERT( sizeof(struct get_process_vm_counters_reply) == 56 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_process_info_request, handle) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_process_info_request, mask) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_process_info_request, priority) == 20 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_process_info_request, affinity) == 24 );
|
|
C_ASSERT( sizeof(struct set_process_info_request) == 32 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_thread_info_request, handle) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_thread_info_request, access) == 16 );
|
|
C_ASSERT( sizeof(struct get_thread_info_request) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_thread_info_reply, pid) == 8 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_thread_info_reply, tid) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_thread_info_reply, teb) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_thread_info_reply, entry_point) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_thread_info_reply, affinity) == 32 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_thread_info_reply, exit_code) == 40 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_thread_info_reply, priority) == 44 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_thread_info_reply, last) == 48 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_thread_info_reply, suspend_count) == 52 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_thread_info_reply, dbg_hidden) == 56 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_thread_info_reply, desc_len) == 60 );
|
|
C_ASSERT( sizeof(struct get_thread_info_reply) == 64 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_thread_times_request, handle) == 12 );
|
|
C_ASSERT( sizeof(struct get_thread_times_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_thread_times_reply, creation_time) == 8 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_thread_times_reply, exit_time) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_thread_times_reply, unix_pid) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_thread_times_reply, unix_tid) == 28 );
|
|
C_ASSERT( sizeof(struct get_thread_times_reply) == 32 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_thread_info_request, handle) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_thread_info_request, mask) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_thread_info_request, priority) == 20 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_thread_info_request, affinity) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_thread_info_request, entry_point) == 32 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_thread_info_request, token) == 40 );
|
|
C_ASSERT( sizeof(struct set_thread_info_request) == 48 );
|
|
C_ASSERT( FIELD_OFFSET(struct suspend_thread_request, handle) == 12 );
|
|
C_ASSERT( sizeof(struct suspend_thread_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct suspend_thread_reply, count) == 8 );
|
|
C_ASSERT( sizeof(struct suspend_thread_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct resume_thread_request, handle) == 12 );
|
|
C_ASSERT( sizeof(struct resume_thread_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct resume_thread_reply, count) == 8 );
|
|
C_ASSERT( sizeof(struct resume_thread_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct queue_apc_request, handle) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct queue_apc_request, call) == 16 );
|
|
C_ASSERT( sizeof(struct queue_apc_request) == 64 );
|
|
C_ASSERT( FIELD_OFFSET(struct queue_apc_reply, handle) == 8 );
|
|
C_ASSERT( FIELD_OFFSET(struct queue_apc_reply, self) == 12 );
|
|
C_ASSERT( sizeof(struct queue_apc_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_apc_result_request, handle) == 12 );
|
|
C_ASSERT( sizeof(struct get_apc_result_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_apc_result_reply, result) == 8 );
|
|
C_ASSERT( sizeof(struct get_apc_result_reply) == 48 );
|
|
C_ASSERT( FIELD_OFFSET(struct close_handle_request, handle) == 12 );
|
|
C_ASSERT( sizeof(struct close_handle_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_handle_info_request, handle) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_handle_info_request, flags) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_handle_info_request, mask) == 20 );
|
|
C_ASSERT( sizeof(struct set_handle_info_request) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_handle_info_reply, old_flags) == 8 );
|
|
C_ASSERT( sizeof(struct set_handle_info_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct dup_handle_request, src_process) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct dup_handle_request, src_handle) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct dup_handle_request, dst_process) == 20 );
|
|
C_ASSERT( FIELD_OFFSET(struct dup_handle_request, access) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct dup_handle_request, attributes) == 28 );
|
|
C_ASSERT( FIELD_OFFSET(struct dup_handle_request, options) == 32 );
|
|
C_ASSERT( sizeof(struct dup_handle_request) == 40 );
|
|
C_ASSERT( FIELD_OFFSET(struct dup_handle_reply, handle) == 8 );
|
|
C_ASSERT( sizeof(struct dup_handle_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct make_temporary_request, handle) == 12 );
|
|
C_ASSERT( sizeof(struct make_temporary_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct open_process_request, pid) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct open_process_request, access) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct open_process_request, attributes) == 20 );
|
|
C_ASSERT( sizeof(struct open_process_request) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct open_process_reply, handle) == 8 );
|
|
C_ASSERT( sizeof(struct open_process_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct open_thread_request, tid) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct open_thread_request, access) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct open_thread_request, attributes) == 20 );
|
|
C_ASSERT( sizeof(struct open_thread_request) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct open_thread_reply, handle) == 8 );
|
|
C_ASSERT( sizeof(struct open_thread_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct select_request, flags) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct select_request, cookie) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct select_request, timeout) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct select_request, size) == 32 );
|
|
C_ASSERT( FIELD_OFFSET(struct select_request, prev_apc) == 36 );
|
|
C_ASSERT( sizeof(struct select_request) == 40 );
|
|
C_ASSERT( FIELD_OFFSET(struct select_reply, call) == 8 );
|
|
C_ASSERT( FIELD_OFFSET(struct select_reply, apc_handle) == 56 );
|
|
C_ASSERT( FIELD_OFFSET(struct select_reply, signaled) == 60 );
|
|
C_ASSERT( sizeof(struct select_reply) == 64 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_event_request, access) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_event_request, manual_reset) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_event_request, initial_state) == 20 );
|
|
C_ASSERT( sizeof(struct create_event_request) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_event_reply, handle) == 8 );
|
|
C_ASSERT( sizeof(struct create_event_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct event_op_request, handle) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct event_op_request, op) == 16 );
|
|
C_ASSERT( sizeof(struct event_op_request) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct event_op_reply, state) == 8 );
|
|
C_ASSERT( sizeof(struct event_op_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct query_event_request, handle) == 12 );
|
|
C_ASSERT( sizeof(struct query_event_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct query_event_reply, manual_reset) == 8 );
|
|
C_ASSERT( FIELD_OFFSET(struct query_event_reply, state) == 12 );
|
|
C_ASSERT( sizeof(struct query_event_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct open_event_request, access) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct open_event_request, attributes) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct open_event_request, rootdir) == 20 );
|
|
C_ASSERT( sizeof(struct open_event_request) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct open_event_reply, handle) == 8 );
|
|
C_ASSERT( sizeof(struct open_event_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_keyed_event_request, access) == 12 );
|
|
C_ASSERT( sizeof(struct create_keyed_event_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_keyed_event_reply, handle) == 8 );
|
|
C_ASSERT( sizeof(struct create_keyed_event_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct open_keyed_event_request, access) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct open_keyed_event_request, attributes) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct open_keyed_event_request, rootdir) == 20 );
|
|
C_ASSERT( sizeof(struct open_keyed_event_request) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct open_keyed_event_reply, handle) == 8 );
|
|
C_ASSERT( sizeof(struct open_keyed_event_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_mutex_request, access) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_mutex_request, owned) == 16 );
|
|
C_ASSERT( sizeof(struct create_mutex_request) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_mutex_reply, handle) == 8 );
|
|
C_ASSERT( sizeof(struct create_mutex_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct release_mutex_request, handle) == 12 );
|
|
C_ASSERT( sizeof(struct release_mutex_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct release_mutex_reply, prev_count) == 8 );
|
|
C_ASSERT( sizeof(struct release_mutex_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct open_mutex_request, access) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct open_mutex_request, attributes) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct open_mutex_request, rootdir) == 20 );
|
|
C_ASSERT( sizeof(struct open_mutex_request) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct open_mutex_reply, handle) == 8 );
|
|
C_ASSERT( sizeof(struct open_mutex_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct query_mutex_request, handle) == 12 );
|
|
C_ASSERT( sizeof(struct query_mutex_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct query_mutex_reply, count) == 8 );
|
|
C_ASSERT( FIELD_OFFSET(struct query_mutex_reply, owned) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct query_mutex_reply, abandoned) == 16 );
|
|
C_ASSERT( sizeof(struct query_mutex_reply) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_semaphore_request, access) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_semaphore_request, initial) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_semaphore_request, max) == 20 );
|
|
C_ASSERT( sizeof(struct create_semaphore_request) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_semaphore_reply, handle) == 8 );
|
|
C_ASSERT( sizeof(struct create_semaphore_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct release_semaphore_request, handle) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct release_semaphore_request, count) == 16 );
|
|
C_ASSERT( sizeof(struct release_semaphore_request) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct release_semaphore_reply, prev_count) == 8 );
|
|
C_ASSERT( sizeof(struct release_semaphore_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct query_semaphore_request, handle) == 12 );
|
|
C_ASSERT( sizeof(struct query_semaphore_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct query_semaphore_reply, current) == 8 );
|
|
C_ASSERT( FIELD_OFFSET(struct query_semaphore_reply, max) == 12 );
|
|
C_ASSERT( sizeof(struct query_semaphore_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct open_semaphore_request, access) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct open_semaphore_request, attributes) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct open_semaphore_request, rootdir) == 20 );
|
|
C_ASSERT( sizeof(struct open_semaphore_request) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct open_semaphore_reply, handle) == 8 );
|
|
C_ASSERT( sizeof(struct open_semaphore_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_file_request, access) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_file_request, sharing) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_file_request, create) == 20 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_file_request, options) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_file_request, attrs) == 28 );
|
|
C_ASSERT( sizeof(struct create_file_request) == 32 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_file_reply, handle) == 8 );
|
|
C_ASSERT( sizeof(struct create_file_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct open_file_object_request, access) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct open_file_object_request, attributes) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct open_file_object_request, rootdir) == 20 );
|
|
C_ASSERT( FIELD_OFFSET(struct open_file_object_request, sharing) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct open_file_object_request, options) == 28 );
|
|
C_ASSERT( sizeof(struct open_file_object_request) == 32 );
|
|
C_ASSERT( FIELD_OFFSET(struct open_file_object_reply, handle) == 8 );
|
|
C_ASSERT( sizeof(struct open_file_object_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct alloc_file_handle_request, access) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct alloc_file_handle_request, attributes) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct alloc_file_handle_request, fd) == 20 );
|
|
C_ASSERT( sizeof(struct alloc_file_handle_request) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct alloc_file_handle_reply, handle) == 8 );
|
|
C_ASSERT( sizeof(struct alloc_file_handle_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_handle_unix_name_request, handle) == 12 );
|
|
C_ASSERT( sizeof(struct get_handle_unix_name_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_handle_unix_name_reply, name_len) == 8 );
|
|
C_ASSERT( sizeof(struct get_handle_unix_name_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_handle_fd_request, handle) == 12 );
|
|
C_ASSERT( sizeof(struct get_handle_fd_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_handle_fd_reply, type) == 8 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_handle_fd_reply, cacheable) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_handle_fd_reply, access) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_handle_fd_reply, options) == 20 );
|
|
C_ASSERT( sizeof(struct get_handle_fd_reply) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_directory_cache_entry_request, handle) == 12 );
|
|
C_ASSERT( sizeof(struct get_directory_cache_entry_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_directory_cache_entry_reply, entry) == 8 );
|
|
C_ASSERT( sizeof(struct get_directory_cache_entry_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct flush_request, async) == 16 );
|
|
C_ASSERT( sizeof(struct flush_request) == 56 );
|
|
C_ASSERT( FIELD_OFFSET(struct flush_reply, event) == 8 );
|
|
C_ASSERT( sizeof(struct flush_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_file_info_request, handle) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_file_info_request, info_class) == 16 );
|
|
C_ASSERT( sizeof(struct get_file_info_request) == 24 );
|
|
C_ASSERT( sizeof(struct get_file_info_reply) == 8 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_volume_info_request, handle) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_volume_info_request, async) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_volume_info_request, info_class) == 56 );
|
|
C_ASSERT( sizeof(struct get_volume_info_request) == 64 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_volume_info_reply, wait) == 8 );
|
|
C_ASSERT( sizeof(struct get_volume_info_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct lock_file_request, handle) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct lock_file_request, offset) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct lock_file_request, count) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct lock_file_request, shared) == 32 );
|
|
C_ASSERT( FIELD_OFFSET(struct lock_file_request, wait) == 36 );
|
|
C_ASSERT( sizeof(struct lock_file_request) == 40 );
|
|
C_ASSERT( FIELD_OFFSET(struct lock_file_reply, handle) == 8 );
|
|
C_ASSERT( FIELD_OFFSET(struct lock_file_reply, overlapped) == 12 );
|
|
C_ASSERT( sizeof(struct lock_file_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct unlock_file_request, handle) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct unlock_file_request, offset) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct unlock_file_request, count) == 24 );
|
|
C_ASSERT( sizeof(struct unlock_file_request) == 32 );
|
|
C_ASSERT( FIELD_OFFSET(struct recv_socket_request, oob) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct recv_socket_request, async) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct recv_socket_request, status) == 56 );
|
|
C_ASSERT( FIELD_OFFSET(struct recv_socket_request, total) == 60 );
|
|
C_ASSERT( sizeof(struct recv_socket_request) == 64 );
|
|
C_ASSERT( FIELD_OFFSET(struct recv_socket_reply, wait) == 8 );
|
|
C_ASSERT( FIELD_OFFSET(struct recv_socket_reply, options) == 12 );
|
|
C_ASSERT( sizeof(struct recv_socket_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct poll_socket_request, async) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct poll_socket_request, timeout) == 56 );
|
|
C_ASSERT( sizeof(struct poll_socket_request) == 64 );
|
|
C_ASSERT( FIELD_OFFSET(struct poll_socket_reply, wait) == 8 );
|
|
C_ASSERT( FIELD_OFFSET(struct poll_socket_reply, options) == 12 );
|
|
C_ASSERT( sizeof(struct poll_socket_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct send_socket_request, async) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct send_socket_request, status) == 56 );
|
|
C_ASSERT( FIELD_OFFSET(struct send_socket_request, total) == 60 );
|
|
C_ASSERT( sizeof(struct send_socket_request) == 64 );
|
|
C_ASSERT( FIELD_OFFSET(struct send_socket_reply, wait) == 8 );
|
|
C_ASSERT( FIELD_OFFSET(struct send_socket_reply, options) == 12 );
|
|
C_ASSERT( sizeof(struct send_socket_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_next_console_request_request, handle) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_next_console_request_request, signal) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_next_console_request_request, read) == 20 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_next_console_request_request, status) == 24 );
|
|
C_ASSERT( sizeof(struct get_next_console_request_request) == 32 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_next_console_request_reply, code) == 8 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_next_console_request_reply, output) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_next_console_request_reply, out_size) == 16 );
|
|
C_ASSERT( sizeof(struct get_next_console_request_reply) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct read_directory_changes_request, filter) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct read_directory_changes_request, subtree) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct read_directory_changes_request, want_data) == 20 );
|
|
C_ASSERT( FIELD_OFFSET(struct read_directory_changes_request, async) == 24 );
|
|
C_ASSERT( sizeof(struct read_directory_changes_request) == 64 );
|
|
C_ASSERT( FIELD_OFFSET(struct read_change_request, handle) == 12 );
|
|
C_ASSERT( sizeof(struct read_change_request) == 16 );
|
|
C_ASSERT( sizeof(struct read_change_reply) == 8 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_mapping_request, access) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_mapping_request, flags) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_mapping_request, file_access) == 20 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_mapping_request, size) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_mapping_request, file_handle) == 32 );
|
|
C_ASSERT( sizeof(struct create_mapping_request) == 40 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_mapping_reply, handle) == 8 );
|
|
C_ASSERT( sizeof(struct create_mapping_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct open_mapping_request, access) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct open_mapping_request, attributes) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct open_mapping_request, rootdir) == 20 );
|
|
C_ASSERT( sizeof(struct open_mapping_request) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct open_mapping_reply, handle) == 8 );
|
|
C_ASSERT( sizeof(struct open_mapping_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_mapping_info_request, handle) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_mapping_info_request, access) == 16 );
|
|
C_ASSERT( sizeof(struct get_mapping_info_request) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_mapping_info_reply, size) == 8 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_mapping_info_reply, flags) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_mapping_info_reply, shared_file) == 20 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_mapping_info_reply, total) == 24 );
|
|
C_ASSERT( sizeof(struct get_mapping_info_reply) == 32 );
|
|
C_ASSERT( FIELD_OFFSET(struct map_view_request, mapping) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct map_view_request, access) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct map_view_request, base) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct map_view_request, size) == 32 );
|
|
C_ASSERT( FIELD_OFFSET(struct map_view_request, start) == 40 );
|
|
C_ASSERT( sizeof(struct map_view_request) == 48 );
|
|
C_ASSERT( FIELD_OFFSET(struct unmap_view_request, base) == 16 );
|
|
C_ASSERT( sizeof(struct unmap_view_request) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_mapping_committed_range_request, base) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_mapping_committed_range_request, offset) == 24 );
|
|
C_ASSERT( sizeof(struct get_mapping_committed_range_request) == 32 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_mapping_committed_range_reply, size) == 8 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_mapping_committed_range_reply, committed) == 16 );
|
|
C_ASSERT( sizeof(struct get_mapping_committed_range_reply) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct add_mapping_committed_range_request, base) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct add_mapping_committed_range_request, offset) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct add_mapping_committed_range_request, size) == 32 );
|
|
C_ASSERT( sizeof(struct add_mapping_committed_range_request) == 40 );
|
|
C_ASSERT( FIELD_OFFSET(struct is_same_mapping_request, base1) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct is_same_mapping_request, base2) == 24 );
|
|
C_ASSERT( sizeof(struct is_same_mapping_request) == 32 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_mapping_filename_request, process) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_mapping_filename_request, addr) == 16 );
|
|
C_ASSERT( sizeof(struct get_mapping_filename_request) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_mapping_filename_reply, len) == 8 );
|
|
C_ASSERT( sizeof(struct get_mapping_filename_reply) == 16 );
|
|
C_ASSERT( sizeof(struct list_processes_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct list_processes_reply, info_size) == 8 );
|
|
C_ASSERT( FIELD_OFFSET(struct list_processes_reply, process_count) == 12 );
|
|
C_ASSERT( sizeof(struct list_processes_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_debug_obj_request, access) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_debug_obj_request, flags) == 16 );
|
|
C_ASSERT( sizeof(struct create_debug_obj_request) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_debug_obj_reply, handle) == 8 );
|
|
C_ASSERT( sizeof(struct create_debug_obj_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct wait_debug_event_request, debug) == 12 );
|
|
C_ASSERT( sizeof(struct wait_debug_event_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct wait_debug_event_reply, pid) == 8 );
|
|
C_ASSERT( FIELD_OFFSET(struct wait_debug_event_reply, tid) == 12 );
|
|
C_ASSERT( sizeof(struct wait_debug_event_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct queue_exception_event_request, first) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct queue_exception_event_request, code) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct queue_exception_event_request, flags) == 20 );
|
|
C_ASSERT( FIELD_OFFSET(struct queue_exception_event_request, record) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct queue_exception_event_request, address) == 32 );
|
|
C_ASSERT( FIELD_OFFSET(struct queue_exception_event_request, len) == 40 );
|
|
C_ASSERT( sizeof(struct queue_exception_event_request) == 48 );
|
|
C_ASSERT( FIELD_OFFSET(struct queue_exception_event_reply, handle) == 8 );
|
|
C_ASSERT( sizeof(struct queue_exception_event_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_exception_status_request, handle) == 12 );
|
|
C_ASSERT( sizeof(struct get_exception_status_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct continue_debug_event_request, debug) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct continue_debug_event_request, pid) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct continue_debug_event_request, tid) == 20 );
|
|
C_ASSERT( FIELD_OFFSET(struct continue_debug_event_request, status) == 24 );
|
|
C_ASSERT( sizeof(struct continue_debug_event_request) == 32 );
|
|
C_ASSERT( FIELD_OFFSET(struct debug_process_request, handle) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct debug_process_request, debug) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct debug_process_request, attach) == 20 );
|
|
C_ASSERT( sizeof(struct debug_process_request) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_debug_obj_info_request, debug) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_debug_obj_info_request, flags) == 16 );
|
|
C_ASSERT( sizeof(struct set_debug_obj_info_request) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct read_process_memory_request, handle) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct read_process_memory_request, addr) == 16 );
|
|
C_ASSERT( sizeof(struct read_process_memory_request) == 24 );
|
|
C_ASSERT( sizeof(struct read_process_memory_reply) == 8 );
|
|
C_ASSERT( FIELD_OFFSET(struct write_process_memory_request, handle) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct write_process_memory_request, addr) == 16 );
|
|
C_ASSERT( sizeof(struct write_process_memory_request) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_key_request, access) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_key_request, options) == 16 );
|
|
C_ASSERT( sizeof(struct create_key_request) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_key_reply, hkey) == 8 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_key_reply, created) == 12 );
|
|
C_ASSERT( sizeof(struct create_key_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct open_key_request, parent) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct open_key_request, access) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct open_key_request, attributes) == 20 );
|
|
C_ASSERT( sizeof(struct open_key_request) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct open_key_reply, hkey) == 8 );
|
|
C_ASSERT( sizeof(struct open_key_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct delete_key_request, hkey) == 12 );
|
|
C_ASSERT( sizeof(struct delete_key_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct flush_key_request, hkey) == 12 );
|
|
C_ASSERT( sizeof(struct flush_key_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct enum_key_request, hkey) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct enum_key_request, index) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct enum_key_request, info_class) == 20 );
|
|
C_ASSERT( sizeof(struct enum_key_request) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct enum_key_reply, subkeys) == 8 );
|
|
C_ASSERT( FIELD_OFFSET(struct enum_key_reply, max_subkey) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct enum_key_reply, max_class) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct enum_key_reply, values) == 20 );
|
|
C_ASSERT( FIELD_OFFSET(struct enum_key_reply, max_value) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct enum_key_reply, max_data) == 28 );
|
|
C_ASSERT( FIELD_OFFSET(struct enum_key_reply, modif) == 32 );
|
|
C_ASSERT( FIELD_OFFSET(struct enum_key_reply, total) == 40 );
|
|
C_ASSERT( FIELD_OFFSET(struct enum_key_reply, namelen) == 44 );
|
|
C_ASSERT( sizeof(struct enum_key_reply) == 48 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_key_value_request, hkey) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_key_value_request, type) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_key_value_request, namelen) == 20 );
|
|
C_ASSERT( sizeof(struct set_key_value_request) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_key_value_request, hkey) == 12 );
|
|
C_ASSERT( sizeof(struct get_key_value_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_key_value_reply, type) == 8 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_key_value_reply, total) == 12 );
|
|
C_ASSERT( sizeof(struct get_key_value_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct enum_key_value_request, hkey) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct enum_key_value_request, index) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct enum_key_value_request, info_class) == 20 );
|
|
C_ASSERT( sizeof(struct enum_key_value_request) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct enum_key_value_reply, type) == 8 );
|
|
C_ASSERT( FIELD_OFFSET(struct enum_key_value_reply, total) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct enum_key_value_reply, namelen) == 16 );
|
|
C_ASSERT( sizeof(struct enum_key_value_reply) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct delete_key_value_request, hkey) == 12 );
|
|
C_ASSERT( sizeof(struct delete_key_value_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct load_registry_request, file) == 12 );
|
|
C_ASSERT( sizeof(struct load_registry_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct unload_registry_request, parent) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct unload_registry_request, attributes) == 16 );
|
|
C_ASSERT( sizeof(struct unload_registry_request) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct save_registry_request, hkey) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct save_registry_request, file) == 16 );
|
|
C_ASSERT( sizeof(struct save_registry_request) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_registry_notification_request, hkey) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_registry_notification_request, event) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_registry_notification_request, subtree) == 20 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_registry_notification_request, filter) == 24 );
|
|
C_ASSERT( sizeof(struct set_registry_notification_request) == 32 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_timer_request, access) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_timer_request, manual) == 16 );
|
|
C_ASSERT( sizeof(struct create_timer_request) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_timer_reply, handle) == 8 );
|
|
C_ASSERT( sizeof(struct create_timer_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct open_timer_request, access) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct open_timer_request, attributes) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct open_timer_request, rootdir) == 20 );
|
|
C_ASSERT( sizeof(struct open_timer_request) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct open_timer_reply, handle) == 8 );
|
|
C_ASSERT( sizeof(struct open_timer_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_timer_request, handle) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_timer_request, expire) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_timer_request, callback) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_timer_request, arg) == 32 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_timer_request, period) == 40 );
|
|
C_ASSERT( sizeof(struct set_timer_request) == 48 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_timer_reply, signaled) == 8 );
|
|
C_ASSERT( sizeof(struct set_timer_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct cancel_timer_request, handle) == 12 );
|
|
C_ASSERT( sizeof(struct cancel_timer_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct cancel_timer_reply, signaled) == 8 );
|
|
C_ASSERT( sizeof(struct cancel_timer_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_timer_info_request, handle) == 12 );
|
|
C_ASSERT( sizeof(struct get_timer_info_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_timer_info_reply, when) == 8 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_timer_info_reply, signaled) == 16 );
|
|
C_ASSERT( sizeof(struct get_timer_info_reply) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_thread_context_request, handle) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_thread_context_request, context) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_thread_context_request, flags) == 20 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_thread_context_request, machine) == 24 );
|
|
C_ASSERT( sizeof(struct get_thread_context_request) == 32 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_thread_context_reply, self) == 8 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_thread_context_reply, handle) == 12 );
|
|
C_ASSERT( sizeof(struct get_thread_context_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_thread_context_request, handle) == 12 );
|
|
C_ASSERT( sizeof(struct set_thread_context_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_thread_context_reply, self) == 8 );
|
|
C_ASSERT( sizeof(struct set_thread_context_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_selector_entry_request, handle) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_selector_entry_request, entry) == 16 );
|
|
C_ASSERT( sizeof(struct get_selector_entry_request) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_selector_entry_reply, base) == 8 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_selector_entry_reply, limit) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_selector_entry_reply, flags) == 16 );
|
|
C_ASSERT( sizeof(struct get_selector_entry_reply) == 24 );
|
|
C_ASSERT( sizeof(struct add_atom_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct add_atom_reply, atom) == 8 );
|
|
C_ASSERT( sizeof(struct add_atom_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct delete_atom_request, atom) == 12 );
|
|
C_ASSERT( sizeof(struct delete_atom_request) == 16 );
|
|
C_ASSERT( sizeof(struct find_atom_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct find_atom_reply, atom) == 8 );
|
|
C_ASSERT( sizeof(struct find_atom_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_atom_information_request, atom) == 12 );
|
|
C_ASSERT( sizeof(struct get_atom_information_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_atom_information_reply, count) == 8 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_atom_information_reply, pinned) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_atom_information_reply, total) == 16 );
|
|
C_ASSERT( sizeof(struct get_atom_information_reply) == 24 );
|
|
C_ASSERT( sizeof(struct get_msg_queue_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_msg_queue_reply, handle) == 8 );
|
|
C_ASSERT( sizeof(struct get_msg_queue_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_queue_fd_request, handle) == 12 );
|
|
C_ASSERT( sizeof(struct set_queue_fd_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_queue_mask_request, wake_mask) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_queue_mask_request, changed_mask) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_queue_mask_request, skip_wait) == 20 );
|
|
C_ASSERT( sizeof(struct set_queue_mask_request) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_queue_mask_reply, wake_bits) == 8 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_queue_mask_reply, changed_bits) == 12 );
|
|
C_ASSERT( sizeof(struct set_queue_mask_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_queue_status_request, clear_bits) == 12 );
|
|
C_ASSERT( sizeof(struct get_queue_status_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_queue_status_reply, wake_bits) == 8 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_queue_status_reply, changed_bits) == 12 );
|
|
C_ASSERT( sizeof(struct get_queue_status_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_process_idle_event_request, handle) == 12 );
|
|
C_ASSERT( sizeof(struct get_process_idle_event_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_process_idle_event_reply, event) == 8 );
|
|
C_ASSERT( sizeof(struct get_process_idle_event_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct send_message_request, id) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct send_message_request, type) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct send_message_request, flags) == 20 );
|
|
C_ASSERT( FIELD_OFFSET(struct send_message_request, win) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct send_message_request, msg) == 28 );
|
|
C_ASSERT( FIELD_OFFSET(struct send_message_request, wparam) == 32 );
|
|
C_ASSERT( FIELD_OFFSET(struct send_message_request, lparam) == 40 );
|
|
C_ASSERT( FIELD_OFFSET(struct send_message_request, timeout) == 48 );
|
|
C_ASSERT( sizeof(struct send_message_request) == 56 );
|
|
C_ASSERT( FIELD_OFFSET(struct post_quit_message_request, exit_code) == 12 );
|
|
C_ASSERT( sizeof(struct post_quit_message_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct send_hardware_message_request, win) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct send_hardware_message_request, input) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct send_hardware_message_request, flags) == 56 );
|
|
C_ASSERT( sizeof(struct send_hardware_message_request) == 64 );
|
|
C_ASSERT( FIELD_OFFSET(struct send_hardware_message_reply, wait) == 8 );
|
|
C_ASSERT( FIELD_OFFSET(struct send_hardware_message_reply, prev_x) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct send_hardware_message_reply, prev_y) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct send_hardware_message_reply, new_x) == 20 );
|
|
C_ASSERT( FIELD_OFFSET(struct send_hardware_message_reply, new_y) == 24 );
|
|
C_ASSERT( sizeof(struct send_hardware_message_reply) == 32 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_message_request, flags) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_message_request, get_win) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_message_request, get_first) == 20 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_message_request, get_last) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_message_request, hw_id) == 28 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_message_request, wake_mask) == 32 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_message_request, changed_mask) == 36 );
|
|
C_ASSERT( sizeof(struct get_message_request) == 40 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_message_reply, win) == 8 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_message_reply, msg) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_message_reply, wparam) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_message_reply, lparam) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_message_reply, type) == 32 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_message_reply, x) == 36 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_message_reply, y) == 40 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_message_reply, time) == 44 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_message_reply, active_hooks) == 48 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_message_reply, total) == 52 );
|
|
C_ASSERT( sizeof(struct get_message_reply) == 56 );
|
|
C_ASSERT( FIELD_OFFSET(struct reply_message_request, remove) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct reply_message_request, result) == 16 );
|
|
C_ASSERT( sizeof(struct reply_message_request) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct accept_hardware_message_request, hw_id) == 12 );
|
|
C_ASSERT( sizeof(struct accept_hardware_message_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_message_reply_request, cancel) == 12 );
|
|
C_ASSERT( sizeof(struct get_message_reply_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_message_reply_reply, result) == 8 );
|
|
C_ASSERT( sizeof(struct get_message_reply_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_win_timer_request, win) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_win_timer_request, msg) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_win_timer_request, rate) == 20 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_win_timer_request, id) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_win_timer_request, lparam) == 32 );
|
|
C_ASSERT( sizeof(struct set_win_timer_request) == 40 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_win_timer_reply, id) == 8 );
|
|
C_ASSERT( sizeof(struct set_win_timer_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct kill_win_timer_request, win) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct kill_win_timer_request, id) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct kill_win_timer_request, msg) == 24 );
|
|
C_ASSERT( sizeof(struct kill_win_timer_request) == 32 );
|
|
C_ASSERT( FIELD_OFFSET(struct is_window_hung_request, win) == 12 );
|
|
C_ASSERT( sizeof(struct is_window_hung_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct is_window_hung_reply, is_hung) == 8 );
|
|
C_ASSERT( sizeof(struct is_window_hung_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_serial_info_request, handle) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_serial_info_request, flags) == 16 );
|
|
C_ASSERT( sizeof(struct get_serial_info_request) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_serial_info_reply, eventmask) == 8 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_serial_info_reply, cookie) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_serial_info_reply, pending_write) == 16 );
|
|
C_ASSERT( sizeof(struct get_serial_info_reply) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_serial_info_request, handle) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_serial_info_request, flags) == 16 );
|
|
C_ASSERT( sizeof(struct set_serial_info_request) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct register_async_request, type) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct register_async_request, async) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct register_async_request, count) == 56 );
|
|
C_ASSERT( sizeof(struct register_async_request) == 64 );
|
|
C_ASSERT( FIELD_OFFSET(struct cancel_async_request, handle) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct cancel_async_request, iosb) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct cancel_async_request, only_thread) == 24 );
|
|
C_ASSERT( sizeof(struct cancel_async_request) == 32 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_async_result_request, user_arg) == 16 );
|
|
C_ASSERT( sizeof(struct get_async_result_request) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_async_result_reply, size) == 8 );
|
|
C_ASSERT( sizeof(struct get_async_result_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct read_request, async) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct read_request, pos) == 56 );
|
|
C_ASSERT( sizeof(struct read_request) == 64 );
|
|
C_ASSERT( FIELD_OFFSET(struct read_reply, wait) == 8 );
|
|
C_ASSERT( FIELD_OFFSET(struct read_reply, options) == 12 );
|
|
C_ASSERT( sizeof(struct read_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct write_request, async) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct write_request, pos) == 56 );
|
|
C_ASSERT( sizeof(struct write_request) == 64 );
|
|
C_ASSERT( FIELD_OFFSET(struct write_reply, wait) == 8 );
|
|
C_ASSERT( FIELD_OFFSET(struct write_reply, options) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct write_reply, size) == 16 );
|
|
C_ASSERT( sizeof(struct write_reply) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct ioctl_request, code) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct ioctl_request, async) == 16 );
|
|
C_ASSERT( sizeof(struct ioctl_request) == 56 );
|
|
C_ASSERT( FIELD_OFFSET(struct ioctl_reply, wait) == 8 );
|
|
C_ASSERT( FIELD_OFFSET(struct ioctl_reply, options) == 12 );
|
|
C_ASSERT( sizeof(struct ioctl_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_irp_result_request, handle) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_irp_result_request, status) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_irp_result_request, size) == 20 );
|
|
C_ASSERT( sizeof(struct set_irp_result_request) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_named_pipe_request, access) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_named_pipe_request, options) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_named_pipe_request, sharing) == 20 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_named_pipe_request, maxinstances) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_named_pipe_request, outsize) == 28 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_named_pipe_request, insize) == 32 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_named_pipe_request, timeout) == 40 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_named_pipe_request, flags) == 48 );
|
|
C_ASSERT( sizeof(struct create_named_pipe_request) == 56 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_named_pipe_reply, handle) == 8 );
|
|
C_ASSERT( sizeof(struct create_named_pipe_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_named_pipe_info_request, handle) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_named_pipe_info_request, flags) == 16 );
|
|
C_ASSERT( sizeof(struct set_named_pipe_info_request) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_window_request, parent) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_window_request, owner) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_window_request, atom) == 20 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_window_request, instance) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_window_request, dpi) == 32 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_window_request, awareness) == 36 );
|
|
C_ASSERT( sizeof(struct create_window_request) == 40 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_window_reply, handle) == 8 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_window_reply, parent) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_window_reply, owner) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_window_reply, extra) == 20 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_window_reply, class_ptr) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_window_reply, dpi) == 32 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_window_reply, awareness) == 36 );
|
|
C_ASSERT( sizeof(struct create_window_reply) == 40 );
|
|
C_ASSERT( FIELD_OFFSET(struct destroy_window_request, handle) == 12 );
|
|
C_ASSERT( sizeof(struct destroy_window_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_desktop_window_request, force) == 12 );
|
|
C_ASSERT( sizeof(struct get_desktop_window_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_desktop_window_reply, top_window) == 8 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_desktop_window_reply, msg_window) == 12 );
|
|
C_ASSERT( sizeof(struct get_desktop_window_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_window_owner_request, handle) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_window_owner_request, owner) == 16 );
|
|
C_ASSERT( sizeof(struct set_window_owner_request) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_window_owner_reply, full_owner) == 8 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_window_owner_reply, prev_owner) == 12 );
|
|
C_ASSERT( sizeof(struct set_window_owner_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_window_info_request, handle) == 12 );
|
|
C_ASSERT( sizeof(struct get_window_info_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_window_info_reply, full_handle) == 8 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_window_info_reply, last_active) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_window_info_reply, pid) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_window_info_reply, tid) == 20 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_window_info_reply, atom) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_window_info_reply, is_unicode) == 28 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_window_info_reply, dpi) == 32 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_window_info_reply, awareness) == 36 );
|
|
C_ASSERT( sizeof(struct get_window_info_reply) == 40 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_window_info_request, flags) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_window_info_request, is_unicode) == 14 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_window_info_request, handle) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_window_info_request, style) == 20 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_window_info_request, ex_style) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_window_info_request, id) == 28 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_window_info_request, instance) == 32 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_window_info_request, user_data) == 40 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_window_info_request, extra_offset) == 48 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_window_info_request, extra_size) == 52 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_window_info_request, extra_value) == 56 );
|
|
C_ASSERT( sizeof(struct set_window_info_request) == 64 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_window_info_reply, old_style) == 8 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_window_info_reply, old_ex_style) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_window_info_reply, old_instance) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_window_info_reply, old_user_data) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_window_info_reply, old_extra_value) == 32 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_window_info_reply, old_id) == 40 );
|
|
C_ASSERT( sizeof(struct set_window_info_reply) == 48 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_parent_request, handle) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_parent_request, parent) == 16 );
|
|
C_ASSERT( sizeof(struct set_parent_request) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_parent_reply, old_parent) == 8 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_parent_reply, full_parent) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_parent_reply, dpi) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_parent_reply, awareness) == 20 );
|
|
C_ASSERT( sizeof(struct set_parent_reply) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_window_parents_request, handle) == 12 );
|
|
C_ASSERT( sizeof(struct get_window_parents_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_window_parents_reply, count) == 8 );
|
|
C_ASSERT( sizeof(struct get_window_parents_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_window_children_request, desktop) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_window_children_request, parent) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_window_children_request, atom) == 20 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_window_children_request, tid) == 24 );
|
|
C_ASSERT( sizeof(struct get_window_children_request) == 32 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_window_children_reply, count) == 8 );
|
|
C_ASSERT( sizeof(struct get_window_children_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_window_children_from_point_request, parent) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_window_children_from_point_request, x) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_window_children_from_point_request, y) == 20 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_window_children_from_point_request, dpi) == 24 );
|
|
C_ASSERT( sizeof(struct get_window_children_from_point_request) == 32 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_window_children_from_point_reply, count) == 8 );
|
|
C_ASSERT( sizeof(struct get_window_children_from_point_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_window_tree_request, handle) == 12 );
|
|
C_ASSERT( sizeof(struct get_window_tree_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_window_tree_reply, parent) == 8 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_window_tree_reply, owner) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_window_tree_reply, next_sibling) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_window_tree_reply, prev_sibling) == 20 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_window_tree_reply, first_sibling) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_window_tree_reply, last_sibling) == 28 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_window_tree_reply, first_child) == 32 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_window_tree_reply, last_child) == 36 );
|
|
C_ASSERT( sizeof(struct get_window_tree_reply) == 40 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_window_pos_request, swp_flags) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_window_pos_request, paint_flags) == 14 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_window_pos_request, handle) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_window_pos_request, previous) == 20 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_window_pos_request, window) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_window_pos_request, client) == 40 );
|
|
C_ASSERT( sizeof(struct set_window_pos_request) == 56 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_window_pos_reply, new_style) == 8 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_window_pos_reply, new_ex_style) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_window_pos_reply, surface_win) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_window_pos_reply, needs_update) == 20 );
|
|
C_ASSERT( sizeof(struct set_window_pos_reply) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_window_rectangles_request, handle) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_window_rectangles_request, relative) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_window_rectangles_request, dpi) == 20 );
|
|
C_ASSERT( sizeof(struct get_window_rectangles_request) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_window_rectangles_reply, window) == 8 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_window_rectangles_reply, client) == 24 );
|
|
C_ASSERT( sizeof(struct get_window_rectangles_reply) == 40 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_window_text_request, handle) == 12 );
|
|
C_ASSERT( sizeof(struct get_window_text_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_window_text_reply, length) == 8 );
|
|
C_ASSERT( sizeof(struct get_window_text_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_window_text_request, handle) == 12 );
|
|
C_ASSERT( sizeof(struct set_window_text_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_windows_offset_request, from) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_windows_offset_request, to) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_windows_offset_request, dpi) == 20 );
|
|
C_ASSERT( sizeof(struct get_windows_offset_request) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_windows_offset_reply, x) == 8 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_windows_offset_reply, y) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_windows_offset_reply, mirror) == 16 );
|
|
C_ASSERT( sizeof(struct get_windows_offset_reply) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_visible_region_request, window) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_visible_region_request, flags) == 16 );
|
|
C_ASSERT( sizeof(struct get_visible_region_request) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_visible_region_reply, top_win) == 8 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_visible_region_reply, top_rect) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_visible_region_reply, win_rect) == 28 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_visible_region_reply, paint_flags) == 44 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_visible_region_reply, total_size) == 48 );
|
|
C_ASSERT( sizeof(struct get_visible_region_reply) == 56 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_surface_region_request, window) == 12 );
|
|
C_ASSERT( sizeof(struct get_surface_region_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_surface_region_reply, visible_rect) == 8 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_surface_region_reply, total_size) == 24 );
|
|
C_ASSERT( sizeof(struct get_surface_region_reply) == 32 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_window_region_request, window) == 12 );
|
|
C_ASSERT( sizeof(struct get_window_region_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_window_region_reply, total_size) == 8 );
|
|
C_ASSERT( sizeof(struct get_window_region_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_window_region_request, window) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_window_region_request, redraw) == 16 );
|
|
C_ASSERT( sizeof(struct set_window_region_request) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_update_region_request, window) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_update_region_request, from_child) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_update_region_request, flags) == 20 );
|
|
C_ASSERT( sizeof(struct get_update_region_request) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_update_region_reply, child) == 8 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_update_region_reply, flags) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_update_region_reply, total_size) == 16 );
|
|
C_ASSERT( sizeof(struct get_update_region_reply) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct update_window_zorder_request, window) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct update_window_zorder_request, rect) == 16 );
|
|
C_ASSERT( sizeof(struct update_window_zorder_request) == 32 );
|
|
C_ASSERT( FIELD_OFFSET(struct redraw_window_request, window) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct redraw_window_request, flags) == 16 );
|
|
C_ASSERT( sizeof(struct redraw_window_request) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_window_property_request, window) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_window_property_request, data) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_window_property_request, atom) == 24 );
|
|
C_ASSERT( sizeof(struct set_window_property_request) == 32 );
|
|
C_ASSERT( FIELD_OFFSET(struct remove_window_property_request, window) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct remove_window_property_request, atom) == 16 );
|
|
C_ASSERT( sizeof(struct remove_window_property_request) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct remove_window_property_reply, data) == 8 );
|
|
C_ASSERT( sizeof(struct remove_window_property_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_window_property_request, window) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_window_property_request, atom) == 16 );
|
|
C_ASSERT( sizeof(struct get_window_property_request) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_window_property_reply, data) == 8 );
|
|
C_ASSERT( sizeof(struct get_window_property_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_window_properties_request, window) == 12 );
|
|
C_ASSERT( sizeof(struct get_window_properties_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_window_properties_reply, total) == 8 );
|
|
C_ASSERT( sizeof(struct get_window_properties_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_winstation_request, flags) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_winstation_request, access) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_winstation_request, attributes) == 20 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_winstation_request, rootdir) == 24 );
|
|
C_ASSERT( sizeof(struct create_winstation_request) == 32 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_winstation_reply, handle) == 8 );
|
|
C_ASSERT( sizeof(struct create_winstation_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct open_winstation_request, access) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct open_winstation_request, attributes) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct open_winstation_request, rootdir) == 20 );
|
|
C_ASSERT( sizeof(struct open_winstation_request) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct open_winstation_reply, handle) == 8 );
|
|
C_ASSERT( sizeof(struct open_winstation_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct close_winstation_request, handle) == 12 );
|
|
C_ASSERT( sizeof(struct close_winstation_request) == 16 );
|
|
C_ASSERT( sizeof(struct get_process_winstation_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_process_winstation_reply, handle) == 8 );
|
|
C_ASSERT( sizeof(struct get_process_winstation_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_process_winstation_request, handle) == 12 );
|
|
C_ASSERT( sizeof(struct set_process_winstation_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct enum_winstation_request, index) == 12 );
|
|
C_ASSERT( sizeof(struct enum_winstation_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct enum_winstation_reply, next) == 8 );
|
|
C_ASSERT( sizeof(struct enum_winstation_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_desktop_request, flags) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_desktop_request, access) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_desktop_request, attributes) == 20 );
|
|
C_ASSERT( sizeof(struct create_desktop_request) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_desktop_reply, handle) == 8 );
|
|
C_ASSERT( sizeof(struct create_desktop_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct open_desktop_request, winsta) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct open_desktop_request, flags) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct open_desktop_request, access) == 20 );
|
|
C_ASSERT( FIELD_OFFSET(struct open_desktop_request, attributes) == 24 );
|
|
C_ASSERT( sizeof(struct open_desktop_request) == 32 );
|
|
C_ASSERT( FIELD_OFFSET(struct open_desktop_reply, handle) == 8 );
|
|
C_ASSERT( sizeof(struct open_desktop_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct open_input_desktop_request, flags) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct open_input_desktop_request, access) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct open_input_desktop_request, attributes) == 20 );
|
|
C_ASSERT( sizeof(struct open_input_desktop_request) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct open_input_desktop_reply, handle) == 8 );
|
|
C_ASSERT( sizeof(struct open_input_desktop_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct close_desktop_request, handle) == 12 );
|
|
C_ASSERT( sizeof(struct close_desktop_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_thread_desktop_request, tid) == 12 );
|
|
C_ASSERT( sizeof(struct get_thread_desktop_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_thread_desktop_reply, handle) == 8 );
|
|
C_ASSERT( sizeof(struct get_thread_desktop_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_thread_desktop_request, handle) == 12 );
|
|
C_ASSERT( sizeof(struct set_thread_desktop_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct enum_desktop_request, winstation) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct enum_desktop_request, index) == 16 );
|
|
C_ASSERT( sizeof(struct enum_desktop_request) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct enum_desktop_reply, next) == 8 );
|
|
C_ASSERT( sizeof(struct enum_desktop_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_user_object_info_request, handle) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_user_object_info_request, flags) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_user_object_info_request, obj_flags) == 20 );
|
|
C_ASSERT( sizeof(struct set_user_object_info_request) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_user_object_info_reply, is_desktop) == 8 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_user_object_info_reply, old_obj_flags) == 12 );
|
|
C_ASSERT( sizeof(struct set_user_object_info_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct register_hotkey_request, window) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct register_hotkey_request, id) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct register_hotkey_request, flags) == 20 );
|
|
C_ASSERT( FIELD_OFFSET(struct register_hotkey_request, vkey) == 24 );
|
|
C_ASSERT( sizeof(struct register_hotkey_request) == 32 );
|
|
C_ASSERT( FIELD_OFFSET(struct register_hotkey_reply, replaced) == 8 );
|
|
C_ASSERT( FIELD_OFFSET(struct register_hotkey_reply, flags) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct register_hotkey_reply, vkey) == 16 );
|
|
C_ASSERT( sizeof(struct register_hotkey_reply) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct unregister_hotkey_request, window) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct unregister_hotkey_request, id) == 16 );
|
|
C_ASSERT( sizeof(struct unregister_hotkey_request) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct unregister_hotkey_reply, flags) == 8 );
|
|
C_ASSERT( FIELD_OFFSET(struct unregister_hotkey_reply, vkey) == 12 );
|
|
C_ASSERT( sizeof(struct unregister_hotkey_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct attach_thread_input_request, tid_from) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct attach_thread_input_request, tid_to) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct attach_thread_input_request, attach) == 20 );
|
|
C_ASSERT( sizeof(struct attach_thread_input_request) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_thread_input_request, tid) == 12 );
|
|
C_ASSERT( sizeof(struct get_thread_input_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_thread_input_reply, focus) == 8 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_thread_input_reply, capture) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_thread_input_reply, active) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_thread_input_reply, foreground) == 20 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_thread_input_reply, menu_owner) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_thread_input_reply, move_size) == 28 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_thread_input_reply, caret) == 32 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_thread_input_reply, cursor) == 36 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_thread_input_reply, show_count) == 40 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_thread_input_reply, rect) == 44 );
|
|
C_ASSERT( sizeof(struct get_thread_input_reply) == 64 );
|
|
C_ASSERT( sizeof(struct get_last_input_time_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_last_input_time_reply, time) == 8 );
|
|
C_ASSERT( sizeof(struct get_last_input_time_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_key_state_request, async) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_key_state_request, key) == 16 );
|
|
C_ASSERT( sizeof(struct get_key_state_request) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_key_state_reply, state) == 8 );
|
|
C_ASSERT( sizeof(struct get_key_state_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_key_state_request, async) == 12 );
|
|
C_ASSERT( sizeof(struct set_key_state_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_foreground_window_request, handle) == 12 );
|
|
C_ASSERT( sizeof(struct set_foreground_window_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_foreground_window_reply, previous) == 8 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_foreground_window_reply, send_msg_old) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_foreground_window_reply, send_msg_new) == 16 );
|
|
C_ASSERT( sizeof(struct set_foreground_window_reply) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_focus_window_request, handle) == 12 );
|
|
C_ASSERT( sizeof(struct set_focus_window_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_focus_window_reply, previous) == 8 );
|
|
C_ASSERT( sizeof(struct set_focus_window_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_active_window_request, handle) == 12 );
|
|
C_ASSERT( sizeof(struct set_active_window_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_active_window_reply, previous) == 8 );
|
|
C_ASSERT( sizeof(struct set_active_window_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_capture_window_request, handle) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_capture_window_request, flags) == 16 );
|
|
C_ASSERT( sizeof(struct set_capture_window_request) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_capture_window_reply, previous) == 8 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_capture_window_reply, full_handle) == 12 );
|
|
C_ASSERT( sizeof(struct set_capture_window_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_caret_window_request, handle) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_caret_window_request, width) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_caret_window_request, height) == 20 );
|
|
C_ASSERT( sizeof(struct set_caret_window_request) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_caret_window_reply, previous) == 8 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_caret_window_reply, old_rect) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_caret_window_reply, old_hide) == 28 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_caret_window_reply, old_state) == 32 );
|
|
C_ASSERT( sizeof(struct set_caret_window_reply) == 40 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_caret_info_request, flags) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_caret_info_request, handle) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_caret_info_request, x) == 20 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_caret_info_request, y) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_caret_info_request, hide) == 28 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_caret_info_request, state) == 32 );
|
|
C_ASSERT( sizeof(struct set_caret_info_request) == 40 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_caret_info_reply, full_handle) == 8 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_caret_info_reply, old_rect) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_caret_info_reply, old_hide) == 28 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_caret_info_reply, old_state) == 32 );
|
|
C_ASSERT( sizeof(struct set_caret_info_reply) == 40 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_hook_request, id) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_hook_request, pid) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_hook_request, tid) == 20 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_hook_request, event_min) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_hook_request, event_max) == 28 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_hook_request, proc) == 32 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_hook_request, flags) == 40 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_hook_request, unicode) == 44 );
|
|
C_ASSERT( sizeof(struct set_hook_request) == 48 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_hook_reply, handle) == 8 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_hook_reply, active_hooks) == 12 );
|
|
C_ASSERT( sizeof(struct set_hook_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct remove_hook_request, handle) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct remove_hook_request, proc) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct remove_hook_request, id) == 24 );
|
|
C_ASSERT( sizeof(struct remove_hook_request) == 32 );
|
|
C_ASSERT( FIELD_OFFSET(struct remove_hook_reply, active_hooks) == 8 );
|
|
C_ASSERT( sizeof(struct remove_hook_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct start_hook_chain_request, id) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct start_hook_chain_request, event) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct start_hook_chain_request, window) == 20 );
|
|
C_ASSERT( FIELD_OFFSET(struct start_hook_chain_request, object_id) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct start_hook_chain_request, child_id) == 28 );
|
|
C_ASSERT( sizeof(struct start_hook_chain_request) == 32 );
|
|
C_ASSERT( FIELD_OFFSET(struct start_hook_chain_reply, handle) == 8 );
|
|
C_ASSERT( FIELD_OFFSET(struct start_hook_chain_reply, pid) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct start_hook_chain_reply, tid) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct start_hook_chain_reply, unicode) == 20 );
|
|
C_ASSERT( FIELD_OFFSET(struct start_hook_chain_reply, proc) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct start_hook_chain_reply, active_hooks) == 32 );
|
|
C_ASSERT( sizeof(struct start_hook_chain_reply) == 40 );
|
|
C_ASSERT( FIELD_OFFSET(struct finish_hook_chain_request, id) == 12 );
|
|
C_ASSERT( sizeof(struct finish_hook_chain_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_hook_info_request, handle) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_hook_info_request, get_next) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_hook_info_request, event) == 20 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_hook_info_request, window) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_hook_info_request, object_id) == 28 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_hook_info_request, child_id) == 32 );
|
|
C_ASSERT( sizeof(struct get_hook_info_request) == 40 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_hook_info_reply, handle) == 8 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_hook_info_reply, id) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_hook_info_reply, pid) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_hook_info_reply, tid) == 20 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_hook_info_reply, proc) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_hook_info_reply, unicode) == 32 );
|
|
C_ASSERT( sizeof(struct get_hook_info_reply) == 40 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_class_request, local) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_class_request, atom) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_class_request, style) == 20 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_class_request, instance) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_class_request, extra) == 32 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_class_request, win_extra) == 36 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_class_request, client_ptr) == 40 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_class_request, name_offset) == 48 );
|
|
C_ASSERT( sizeof(struct create_class_request) == 56 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_class_reply, atom) == 8 );
|
|
C_ASSERT( sizeof(struct create_class_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct destroy_class_request, atom) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct destroy_class_request, instance) == 16 );
|
|
C_ASSERT( sizeof(struct destroy_class_request) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct destroy_class_reply, client_ptr) == 8 );
|
|
C_ASSERT( sizeof(struct destroy_class_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_class_info_request, window) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_class_info_request, flags) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_class_info_request, atom) == 20 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_class_info_request, style) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_class_info_request, win_extra) == 28 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_class_info_request, instance) == 32 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_class_info_request, extra_offset) == 40 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_class_info_request, extra_size) == 44 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_class_info_request, extra_value) == 48 );
|
|
C_ASSERT( sizeof(struct set_class_info_request) == 56 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_class_info_reply, old_atom) == 8 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_class_info_reply, base_atom) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_class_info_reply, old_instance) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_class_info_reply, old_extra_value) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_class_info_reply, old_style) == 32 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_class_info_reply, old_extra) == 36 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_class_info_reply, old_win_extra) == 40 );
|
|
C_ASSERT( sizeof(struct set_class_info_reply) == 48 );
|
|
C_ASSERT( FIELD_OFFSET(struct open_clipboard_request, window) == 12 );
|
|
C_ASSERT( sizeof(struct open_clipboard_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct open_clipboard_reply, owner) == 8 );
|
|
C_ASSERT( sizeof(struct open_clipboard_reply) == 16 );
|
|
C_ASSERT( sizeof(struct close_clipboard_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct close_clipboard_reply, viewer) == 8 );
|
|
C_ASSERT( FIELD_OFFSET(struct close_clipboard_reply, owner) == 12 );
|
|
C_ASSERT( sizeof(struct close_clipboard_reply) == 16 );
|
|
C_ASSERT( sizeof(struct empty_clipboard_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_clipboard_data_request, format) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_clipboard_data_request, lcid) == 16 );
|
|
C_ASSERT( sizeof(struct set_clipboard_data_request) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_clipboard_data_reply, seqno) == 8 );
|
|
C_ASSERT( sizeof(struct set_clipboard_data_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_clipboard_data_request, format) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_clipboard_data_request, render) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_clipboard_data_request, cached) == 20 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_clipboard_data_request, seqno) == 24 );
|
|
C_ASSERT( sizeof(struct get_clipboard_data_request) == 32 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_clipboard_data_reply, from) == 8 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_clipboard_data_reply, owner) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_clipboard_data_reply, seqno) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_clipboard_data_reply, total) == 20 );
|
|
C_ASSERT( sizeof(struct get_clipboard_data_reply) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_clipboard_formats_request, format) == 12 );
|
|
C_ASSERT( sizeof(struct get_clipboard_formats_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_clipboard_formats_reply, count) == 8 );
|
|
C_ASSERT( sizeof(struct get_clipboard_formats_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct enum_clipboard_formats_request, previous) == 12 );
|
|
C_ASSERT( sizeof(struct enum_clipboard_formats_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct enum_clipboard_formats_reply, format) == 8 );
|
|
C_ASSERT( sizeof(struct enum_clipboard_formats_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct release_clipboard_request, owner) == 12 );
|
|
C_ASSERT( sizeof(struct release_clipboard_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct release_clipboard_reply, viewer) == 8 );
|
|
C_ASSERT( FIELD_OFFSET(struct release_clipboard_reply, owner) == 12 );
|
|
C_ASSERT( sizeof(struct release_clipboard_reply) == 16 );
|
|
C_ASSERT( sizeof(struct get_clipboard_info_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_clipboard_info_reply, window) == 8 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_clipboard_info_reply, owner) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_clipboard_info_reply, viewer) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_clipboard_info_reply, seqno) == 20 );
|
|
C_ASSERT( sizeof(struct get_clipboard_info_reply) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_clipboard_viewer_request, viewer) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_clipboard_viewer_request, previous) == 16 );
|
|
C_ASSERT( sizeof(struct set_clipboard_viewer_request) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_clipboard_viewer_reply, old_viewer) == 8 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_clipboard_viewer_reply, owner) == 12 );
|
|
C_ASSERT( sizeof(struct set_clipboard_viewer_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct add_clipboard_listener_request, window) == 12 );
|
|
C_ASSERT( sizeof(struct add_clipboard_listener_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct remove_clipboard_listener_request, window) == 12 );
|
|
C_ASSERT( sizeof(struct remove_clipboard_listener_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct open_token_request, handle) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct open_token_request, access) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct open_token_request, attributes) == 20 );
|
|
C_ASSERT( FIELD_OFFSET(struct open_token_request, flags) == 24 );
|
|
C_ASSERT( sizeof(struct open_token_request) == 32 );
|
|
C_ASSERT( FIELD_OFFSET(struct open_token_reply, token) == 8 );
|
|
C_ASSERT( sizeof(struct open_token_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_global_windows_request, flags) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_global_windows_request, shell_window) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_global_windows_request, shell_listview) == 20 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_global_windows_request, progman_window) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_global_windows_request, taskman_window) == 28 );
|
|
C_ASSERT( sizeof(struct set_global_windows_request) == 32 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_global_windows_reply, old_shell_window) == 8 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_global_windows_reply, old_shell_listview) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_global_windows_reply, old_progman_window) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_global_windows_reply, old_taskman_window) == 20 );
|
|
C_ASSERT( sizeof(struct set_global_windows_reply) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct adjust_token_privileges_request, handle) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct adjust_token_privileges_request, disable_all) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct adjust_token_privileges_request, get_modified_state) == 20 );
|
|
C_ASSERT( sizeof(struct adjust_token_privileges_request) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct adjust_token_privileges_reply, len) == 8 );
|
|
C_ASSERT( sizeof(struct adjust_token_privileges_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_token_privileges_request, handle) == 12 );
|
|
C_ASSERT( sizeof(struct get_token_privileges_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_token_privileges_reply, len) == 8 );
|
|
C_ASSERT( sizeof(struct get_token_privileges_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct check_token_privileges_request, handle) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct check_token_privileges_request, all_required) == 16 );
|
|
C_ASSERT( sizeof(struct check_token_privileges_request) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct check_token_privileges_reply, has_privileges) == 8 );
|
|
C_ASSERT( sizeof(struct check_token_privileges_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct duplicate_token_request, handle) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct duplicate_token_request, access) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct duplicate_token_request, primary) == 20 );
|
|
C_ASSERT( FIELD_OFFSET(struct duplicate_token_request, impersonation_level) == 24 );
|
|
C_ASSERT( sizeof(struct duplicate_token_request) == 32 );
|
|
C_ASSERT( FIELD_OFFSET(struct duplicate_token_reply, new_handle) == 8 );
|
|
C_ASSERT( sizeof(struct duplicate_token_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct filter_token_request, handle) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct filter_token_request, flags) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct filter_token_request, privileges_size) == 20 );
|
|
C_ASSERT( sizeof(struct filter_token_request) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct filter_token_reply, new_handle) == 8 );
|
|
C_ASSERT( sizeof(struct filter_token_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct access_check_request, handle) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct access_check_request, desired_access) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct access_check_request, mapping) == 20 );
|
|
C_ASSERT( sizeof(struct access_check_request) == 40 );
|
|
C_ASSERT( FIELD_OFFSET(struct access_check_reply, access_granted) == 8 );
|
|
C_ASSERT( FIELD_OFFSET(struct access_check_reply, access_status) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct access_check_reply, privileges_len) == 16 );
|
|
C_ASSERT( sizeof(struct access_check_reply) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_token_sid_request, handle) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_token_sid_request, which_sid) == 16 );
|
|
C_ASSERT( sizeof(struct get_token_sid_request) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_token_sid_reply, sid_len) == 8 );
|
|
C_ASSERT( sizeof(struct get_token_sid_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_token_groups_request, handle) == 12 );
|
|
C_ASSERT( sizeof(struct get_token_groups_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_token_groups_reply, user_len) == 8 );
|
|
C_ASSERT( sizeof(struct get_token_groups_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_token_default_dacl_request, handle) == 12 );
|
|
C_ASSERT( sizeof(struct get_token_default_dacl_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_token_default_dacl_reply, acl_len) == 8 );
|
|
C_ASSERT( sizeof(struct get_token_default_dacl_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_token_default_dacl_request, handle) == 12 );
|
|
C_ASSERT( sizeof(struct set_token_default_dacl_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_security_object_request, handle) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_security_object_request, security_info) == 16 );
|
|
C_ASSERT( sizeof(struct set_security_object_request) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_security_object_request, handle) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_security_object_request, security_info) == 16 );
|
|
C_ASSERT( sizeof(struct get_security_object_request) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_security_object_reply, sd_len) == 8 );
|
|
C_ASSERT( sizeof(struct get_security_object_reply) == 16 );
|
|
C_ASSERT( sizeof(struct get_system_handles_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_system_handles_reply, count) == 8 );
|
|
C_ASSERT( sizeof(struct get_system_handles_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_mailslot_request, access) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_mailslot_request, read_timeout) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_mailslot_request, max_msgsize) == 24 );
|
|
C_ASSERT( sizeof(struct create_mailslot_request) == 32 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_mailslot_reply, handle) == 8 );
|
|
C_ASSERT( sizeof(struct create_mailslot_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_mailslot_info_request, handle) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_mailslot_info_request, read_timeout) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_mailslot_info_request, flags) == 24 );
|
|
C_ASSERT( sizeof(struct set_mailslot_info_request) == 32 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_mailslot_info_reply, read_timeout) == 8 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_mailslot_info_reply, max_msgsize) == 16 );
|
|
C_ASSERT( sizeof(struct set_mailslot_info_reply) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_directory_request, access) == 12 );
|
|
C_ASSERT( sizeof(struct create_directory_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_directory_reply, handle) == 8 );
|
|
C_ASSERT( sizeof(struct create_directory_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct open_directory_request, access) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct open_directory_request, attributes) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct open_directory_request, rootdir) == 20 );
|
|
C_ASSERT( sizeof(struct open_directory_request) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct open_directory_reply, handle) == 8 );
|
|
C_ASSERT( sizeof(struct open_directory_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_directory_entry_request, handle) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_directory_entry_request, index) == 16 );
|
|
C_ASSERT( sizeof(struct get_directory_entry_request) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_directory_entry_reply, name_len) == 8 );
|
|
C_ASSERT( sizeof(struct get_directory_entry_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_symlink_request, access) == 12 );
|
|
C_ASSERT( sizeof(struct create_symlink_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_symlink_reply, handle) == 8 );
|
|
C_ASSERT( sizeof(struct create_symlink_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct open_symlink_request, access) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct open_symlink_request, attributes) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct open_symlink_request, rootdir) == 20 );
|
|
C_ASSERT( sizeof(struct open_symlink_request) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct open_symlink_reply, handle) == 8 );
|
|
C_ASSERT( sizeof(struct open_symlink_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct query_symlink_request, handle) == 12 );
|
|
C_ASSERT( sizeof(struct query_symlink_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct query_symlink_reply, total) == 8 );
|
|
C_ASSERT( sizeof(struct query_symlink_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_object_info_request, handle) == 12 );
|
|
C_ASSERT( sizeof(struct get_object_info_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_object_info_reply, access) == 8 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_object_info_reply, ref_count) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_object_info_reply, handle_count) == 16 );
|
|
C_ASSERT( sizeof(struct get_object_info_reply) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_object_name_request, handle) == 12 );
|
|
C_ASSERT( sizeof(struct get_object_name_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_object_name_reply, total) == 8 );
|
|
C_ASSERT( sizeof(struct get_object_name_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_object_type_request, handle) == 12 );
|
|
C_ASSERT( sizeof(struct get_object_type_request) == 16 );
|
|
C_ASSERT( sizeof(struct get_object_type_reply) == 8 );
|
|
C_ASSERT( sizeof(struct get_object_types_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_object_types_reply, count) == 8 );
|
|
C_ASSERT( sizeof(struct get_object_types_reply) == 16 );
|
|
C_ASSERT( sizeof(struct allocate_locally_unique_id_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct allocate_locally_unique_id_reply, luid) == 8 );
|
|
C_ASSERT( sizeof(struct allocate_locally_unique_id_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_device_manager_request, access) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_device_manager_request, attributes) == 16 );
|
|
C_ASSERT( sizeof(struct create_device_manager_request) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_device_manager_reply, handle) == 8 );
|
|
C_ASSERT( sizeof(struct create_device_manager_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_device_request, rootdir) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_device_request, user_ptr) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_device_request, manager) == 24 );
|
|
C_ASSERT( sizeof(struct create_device_request) == 32 );
|
|
C_ASSERT( FIELD_OFFSET(struct delete_device_request, manager) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct delete_device_request, device) == 16 );
|
|
C_ASSERT( sizeof(struct delete_device_request) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_next_device_request_request, manager) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_next_device_request_request, prev) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_next_device_request_request, status) == 20 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_next_device_request_request, user_ptr) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_next_device_request_request, result) == 32 );
|
|
C_ASSERT( sizeof(struct get_next_device_request_request) == 40 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_next_device_request_reply, params) == 8 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_next_device_request_reply, next) == 40 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_next_device_request_reply, client_tid) == 44 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_next_device_request_reply, client_thread) == 48 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_next_device_request_reply, in_size) == 56 );
|
|
C_ASSERT( sizeof(struct get_next_device_request_reply) == 64 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_kernel_object_ptr_request, manager) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_kernel_object_ptr_request, handle) == 16 );
|
|
C_ASSERT( sizeof(struct get_kernel_object_ptr_request) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_kernel_object_ptr_reply, user_ptr) == 8 );
|
|
C_ASSERT( sizeof(struct get_kernel_object_ptr_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_kernel_object_ptr_request, manager) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_kernel_object_ptr_request, handle) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_kernel_object_ptr_request, user_ptr) == 24 );
|
|
C_ASSERT( sizeof(struct set_kernel_object_ptr_request) == 32 );
|
|
C_ASSERT( FIELD_OFFSET(struct grab_kernel_object_request, manager) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct grab_kernel_object_request, user_ptr) == 16 );
|
|
C_ASSERT( sizeof(struct grab_kernel_object_request) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct release_kernel_object_request, manager) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct release_kernel_object_request, user_ptr) == 16 );
|
|
C_ASSERT( sizeof(struct release_kernel_object_request) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_kernel_object_handle_request, manager) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_kernel_object_handle_request, user_ptr) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_kernel_object_handle_request, access) == 24 );
|
|
C_ASSERT( sizeof(struct get_kernel_object_handle_request) == 32 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_kernel_object_handle_reply, handle) == 8 );
|
|
C_ASSERT( sizeof(struct get_kernel_object_handle_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct make_process_system_request, handle) == 12 );
|
|
C_ASSERT( sizeof(struct make_process_system_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct make_process_system_reply, event) == 8 );
|
|
C_ASSERT( sizeof(struct make_process_system_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_token_info_request, handle) == 12 );
|
|
C_ASSERT( sizeof(struct get_token_info_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_token_info_reply, token_id) == 8 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_token_info_reply, modified_id) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_token_info_reply, session_id) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_token_info_reply, primary) == 28 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_token_info_reply, impersonation_level) == 32 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_token_info_reply, elevation) == 36 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_token_info_reply, group_count) == 40 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_token_info_reply, privilege_count) == 44 );
|
|
C_ASSERT( sizeof(struct get_token_info_reply) == 48 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_linked_token_request, handle) == 12 );
|
|
C_ASSERT( sizeof(struct create_linked_token_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_linked_token_reply, linked) == 8 );
|
|
C_ASSERT( sizeof(struct create_linked_token_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_completion_request, access) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_completion_request, concurrent) == 16 );
|
|
C_ASSERT( sizeof(struct create_completion_request) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_completion_reply, handle) == 8 );
|
|
C_ASSERT( sizeof(struct create_completion_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct open_completion_request, access) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct open_completion_request, attributes) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct open_completion_request, rootdir) == 20 );
|
|
C_ASSERT( sizeof(struct open_completion_request) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct open_completion_reply, handle) == 8 );
|
|
C_ASSERT( sizeof(struct open_completion_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct add_completion_request, handle) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct add_completion_request, ckey) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct add_completion_request, cvalue) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct add_completion_request, information) == 32 );
|
|
C_ASSERT( FIELD_OFFSET(struct add_completion_request, status) == 40 );
|
|
C_ASSERT( sizeof(struct add_completion_request) == 48 );
|
|
C_ASSERT( FIELD_OFFSET(struct remove_completion_request, handle) == 12 );
|
|
C_ASSERT( sizeof(struct remove_completion_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct remove_completion_reply, ckey) == 8 );
|
|
C_ASSERT( FIELD_OFFSET(struct remove_completion_reply, cvalue) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct remove_completion_reply, information) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct remove_completion_reply, status) == 32 );
|
|
C_ASSERT( sizeof(struct remove_completion_reply) == 40 );
|
|
C_ASSERT( FIELD_OFFSET(struct query_completion_request, handle) == 12 );
|
|
C_ASSERT( sizeof(struct query_completion_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct query_completion_reply, depth) == 8 );
|
|
C_ASSERT( sizeof(struct query_completion_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_completion_info_request, handle) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_completion_info_request, ckey) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_completion_info_request, chandle) == 24 );
|
|
C_ASSERT( sizeof(struct set_completion_info_request) == 32 );
|
|
C_ASSERT( FIELD_OFFSET(struct add_fd_completion_request, handle) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct add_fd_completion_request, cvalue) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct add_fd_completion_request, information) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct add_fd_completion_request, status) == 32 );
|
|
C_ASSERT( FIELD_OFFSET(struct add_fd_completion_request, async) == 36 );
|
|
C_ASSERT( sizeof(struct add_fd_completion_request) == 40 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_fd_completion_mode_request, handle) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_fd_completion_mode_request, flags) == 16 );
|
|
C_ASSERT( sizeof(struct set_fd_completion_mode_request) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_fd_disp_info_request, handle) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_fd_disp_info_request, unlink) == 16 );
|
|
C_ASSERT( sizeof(struct set_fd_disp_info_request) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_fd_name_info_request, handle) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_fd_name_info_request, rootdir) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_fd_name_info_request, namelen) == 20 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_fd_name_info_request, link) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_fd_name_info_request, replace) == 28 );
|
|
C_ASSERT( sizeof(struct set_fd_name_info_request) == 32 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_fd_eof_info_request, handle) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_fd_eof_info_request, eof) == 16 );
|
|
C_ASSERT( sizeof(struct set_fd_eof_info_request) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_window_layered_info_request, handle) == 12 );
|
|
C_ASSERT( sizeof(struct get_window_layered_info_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_window_layered_info_reply, color_key) == 8 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_window_layered_info_reply, alpha) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_window_layered_info_reply, flags) == 16 );
|
|
C_ASSERT( sizeof(struct get_window_layered_info_reply) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_window_layered_info_request, handle) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_window_layered_info_request, color_key) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_window_layered_info_request, alpha) == 20 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_window_layered_info_request, flags) == 24 );
|
|
C_ASSERT( sizeof(struct set_window_layered_info_request) == 32 );
|
|
C_ASSERT( sizeof(struct alloc_user_handle_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct alloc_user_handle_reply, handle) == 8 );
|
|
C_ASSERT( sizeof(struct alloc_user_handle_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct free_user_handle_request, handle) == 12 );
|
|
C_ASSERT( sizeof(struct free_user_handle_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_cursor_request, flags) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_cursor_request, handle) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_cursor_request, show_count) == 20 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_cursor_request, x) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_cursor_request, y) == 28 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_cursor_request, clip) == 32 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_cursor_request, clip_msg) == 48 );
|
|
C_ASSERT( sizeof(struct set_cursor_request) == 56 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_cursor_reply, prev_handle) == 8 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_cursor_reply, prev_count) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_cursor_reply, prev_x) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_cursor_reply, prev_y) == 20 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_cursor_reply, new_x) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_cursor_reply, new_y) == 28 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_cursor_reply, new_clip) == 32 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_cursor_reply, last_change) == 48 );
|
|
C_ASSERT( sizeof(struct set_cursor_reply) == 56 );
|
|
C_ASSERT( sizeof(struct get_cursor_history_request) == 16 );
|
|
C_ASSERT( sizeof(struct get_cursor_history_reply) == 8 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_rawinput_buffer_request, rawinput_size) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_rawinput_buffer_request, buffer_size) == 16 );
|
|
C_ASSERT( sizeof(struct get_rawinput_buffer_request) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_rawinput_buffer_reply, next_size) == 8 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_rawinput_buffer_reply, count) == 12 );
|
|
C_ASSERT( sizeof(struct get_rawinput_buffer_reply) == 16 );
|
|
C_ASSERT( sizeof(struct update_rawinput_devices_request) == 16 );
|
|
C_ASSERT( sizeof(struct get_rawinput_devices_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_rawinput_devices_reply, device_count) == 8 );
|
|
C_ASSERT( sizeof(struct get_rawinput_devices_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_job_request, access) == 12 );
|
|
C_ASSERT( sizeof(struct create_job_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct create_job_reply, handle) == 8 );
|
|
C_ASSERT( sizeof(struct create_job_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct open_job_request, access) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct open_job_request, attributes) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct open_job_request, rootdir) == 20 );
|
|
C_ASSERT( sizeof(struct open_job_request) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct open_job_reply, handle) == 8 );
|
|
C_ASSERT( sizeof(struct open_job_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct assign_job_request, job) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct assign_job_request, process) == 16 );
|
|
C_ASSERT( sizeof(struct assign_job_request) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct process_in_job_request, job) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct process_in_job_request, process) == 16 );
|
|
C_ASSERT( sizeof(struct process_in_job_request) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_job_limits_request, handle) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_job_limits_request, limit_flags) == 16 );
|
|
C_ASSERT( sizeof(struct set_job_limits_request) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_job_completion_port_request, job) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_job_completion_port_request, port) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct set_job_completion_port_request, key) == 24 );
|
|
C_ASSERT( sizeof(struct set_job_completion_port_request) == 32 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_job_info_request, handle) == 12 );
|
|
C_ASSERT( sizeof(struct get_job_info_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_job_info_reply, total_processes) == 8 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_job_info_reply, active_processes) == 12 );
|
|
C_ASSERT( sizeof(struct get_job_info_reply) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct terminate_job_request, handle) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct terminate_job_request, status) == 16 );
|
|
C_ASSERT( sizeof(struct terminate_job_request) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct suspend_process_request, handle) == 12 );
|
|
C_ASSERT( sizeof(struct suspend_process_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct resume_process_request, handle) == 12 );
|
|
C_ASSERT( sizeof(struct resume_process_request) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_next_thread_request, process) == 12 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_next_thread_request, last) == 16 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_next_thread_request, access) == 20 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_next_thread_request, attributes) == 24 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_next_thread_request, flags) == 28 );
|
|
C_ASSERT( sizeof(struct get_next_thread_request) == 32 );
|
|
C_ASSERT( FIELD_OFFSET(struct get_next_thread_reply, handle) == 8 );
|
|
C_ASSERT( sizeof(struct get_next_thread_reply) == 16 );
|
|
|
|
#endif /* WANT_REQUEST_HANDLERS */
|
|
|
|
/* ### make_requests end ### */
|
|
/* Everything above this line is generated automatically by tools/make_requests */
|
|
|
|
#endif /* __WINE_SERVER_REQUEST_H */
|