diff options
Diffstat (limited to 'src')
28 files changed, 5313 insertions, 243 deletions
diff --git a/src/emu/x86int3.c b/src/emu/x86int3.c index 917b0b02..aa869dae 100755 --- a/src/emu/x86int3.c +++ b/src/emu/x86int3.c @@ -310,7 +310,7 @@ void x86Int3(x64emu_t* emu, uintptr_t* addr) } else if(!strcmp(s, "vsscanf")) { snprintf(buff, 255, "%04d|%p: Calling %s(\"%s\", \"%s\", ...)", tid, from_ptrv(*(ptr_t*)from_ptr(R_ESP)), s, from_ptrv(*(ptr_t*)from_ptr(R_ESP+4)), from_ptrv(*(ptr_t*)from_ptr(R_ESP+8))); } else if(strstr(s, "XCreateWindow")==s) { - snprintf(buff, 255, "%04d|%p: Calling %s(%p, %p, %d, %d, %u, %u, %u, %d, %u, %p, %u, %p)", tid, from_ptrv(*(ptr_t*)from_ptr(R_ESP)), s, from_ptrv(*(ptr_t*)from_ptr(R_ESP+4)), from_ptrv(*(ptr_t*)from_ptr(R_ESP+8)), *(int*)from_ptr(R_ESP+12), *(int*)from_ptr(R_ESP+16), *(uint32_t*)from_ptr(R_ESP+20), *(uint32_t*)from_ptr(R_ESP+24), *(uint32_t*)from_ptr(R_ESP+28), *(int32_t*)from_ptr(R_ESP+32), *(uint32_t*)from_ptr(R_ESP+36), *(void**)from_ptr(R_ESP+40), *(uint32_t*)from_ptr(R_ESP+44), *(void**)from_ptr(R_ESP+48)); + snprintf(buff, 255, "%04d|%p: Calling %s(%p, %p, %d, %d, %u, %u, %u, %d, %u, %p, 0x%x, %p)", tid, from_ptrv(*(ptr_t*)from_ptr(R_ESP)), s, from_ptrv(*(ptr_t*)from_ptr(R_ESP+4)), from_ptrv(*(ptr_t*)from_ptr(R_ESP+8)), *(int*)from_ptr(R_ESP+12), *(int*)from_ptr(R_ESP+16), *(uint32_t*)from_ptr(R_ESP+20), *(uint32_t*)from_ptr(R_ESP+24), *(uint32_t*)from_ptr(R_ESP+28), *(int32_t*)from_ptr(R_ESP+32), *(uint32_t*)from_ptr(R_ESP+36), from_ptrv(*(ptr_t*)from_ptr(R_ESP+40)), *(uint32_t*)from_ptr(R_ESP+44), from_ptrv(*(ptr_t*)from_ptr(R_ESP+48))); } else if(strstr(s, "XLoadQueryFont")==s) { snprintf(buff, 255, "%04d|%p: Calling %s(%p, \"%s\")", tid, from_ptrv(*(ptr_t*)from_ptr(R_ESP)), s, from_ptrv(*(ptr_t*)from_ptr(R_ESP+4)), from_ptrv(*(ptr_t*)from_ptr(R_ESP+8))); } else if(strstr(s, "pthread_mutex_lock")==s || strstr(s, "pthread_mutex_unlock")==s) { diff --git a/src/include/box32.h b/src/include/box32.h index b4d7cf06..cbf97767 100644 --- a/src/include/box32.h +++ b/src/include/box32.h @@ -58,7 +58,7 @@ static inline long_t to_long(long l) { } static inline ulong_t to_ulong(unsigned long l) { if(l!=0xffffffffffffffffLL && (l>>32)) - printf_log(LOG_NONE, "Warning, ulong 0x%p is not a 32bits value\n", (void*)l); + printf_log(LOG_NONE, "Warning, ulong %p is not a 32bits value\n", (void*)l); return (ulong_t)l; } #else //TEST32 diff --git a/src/library_list_32.h b/src/library_list_32.h index 50b0698d..1a52430e 100644 --- a/src/library_list_32.h +++ b/src/library_list_32.h @@ -15,5 +15,6 @@ GO("libGLU.so.1", libglu) GO("libSDL-1.2.so.0", sdl1) GO("libasound.so.2", libasound) GO("libasound.so", libasound) +GO("libX11.so.6", libx11) GO("crashhandler.so", crashhandler) diff --git a/src/libtools/my_x11_defs.h b/src/libtools/my_x11_defs.h new file mode 100644 index 00000000..b0a1cdc2 --- /dev/null +++ b/src/libtools/my_x11_defs.h @@ -0,0 +1,741 @@ +#ifndef MY_X11_DEFS +#define MY_X11_DEFS +#include <stdint.h> + +typedef unsigned long XID; + +typedef struct XImageSave_s { + int anyEmu; + void* create; + void* destroy; + void* get; + void* put; + void* sub; + void* add; +} XImageSave_t; + +typedef struct ximage_s { + void*(*create_image)( + void* /* display */, + void* /* visual */, + uint32_t /* depth */, + int32_t /* format */, + int32_t /* offset */, + void* /* data */, + uint32_t /* width */, + uint32_t /* height */, + int32_t /* bitmap_pad */, + int32_t /* bytes_per_line */); + int32_t (*destroy_image) (void*); + uintptr_t (*get_pixel) (void*, int32_t, int32_t); + int32_t (*put_pixel) (void*, int32_t, int32_t, uintptr_t); + void*(*sub_image) (void*, int32_t, int32_t, uint32_t, uint32_t); //sub_image return a new XImage that need bridging => custom wrapper + int32_t (*add_pixel) (void*, intptr_t); +} ximage_t; + +typedef struct _XImage { + int32_t width, height; /* size of image */ + int32_t xoffset; /* number of pixels offset in X direction */ + int32_t format; /* XYBitmap, XYPixmap, ZPixmap */ + void* data; /* pointer to image data */ + int32_t byte_order; /* data byte order, LSBFirst, MSBFirst */ + int32_t bitmap_unit; /* quant. of scanline 8, 16, 32 */ + int32_t bitmap_bit_order; /* LSBFirst, MSBFirst */ + int32_t bitmap_pad; /* 8, 16, 32 either XY or ZPixmap */ + int32_t depth; /* depth of image */ + int32_t bytes_per_line; /* accelarator to next line */ + int32_t bits_per_pixel; /* bits per pixel (ZPixmap) */ + uintptr_t red_mask; /* bits in z arrangment */ + uintptr_t green_mask; + uintptr_t blue_mask; + void* obdata; /* hook for the object routines to hang on */ + ximage_t f; + +} XImage; + +struct my_XFreeFuncs { + void* atoms; + void* modifiermap; + void* key_bindings; + void* context_db; + void* defaultCCCs; + void* clientCmaps; + void* intensityMaps; + void* im_filters; + void* xkb; +}; + +struct my_XExten { + struct my_XExten *next; + void* codes; // XExtCodes + void* create_GC; // CreateGCType + void* copy_GC; // CopyGCType + void* flush_GC; // FlushGCType + void* free_GC; // FreeGCType + void* create_Font; // CreateFontType + void* free_Font; // FreeFontType + void* close_display; // CloseDisplayType + void* error; // ErrorType + void* error_string; // ErrorStringType + char *name; + void* error_values; // PrintErrorType + void* before_flush; // BeforeFlushType + struct my_XExten *next_flush; +}; + +struct my_XInternalAsync { + struct my_XInternalAsync *next; + int (*handler)(void*, void*, char*, int, void*); + void* data; +}; + +struct my_XLockPtrs { + void (*lock_display)(void* dpy); + void (*unlock_display)(void *dpy); +}; + +struct my_XConnectionInfo { + int fd; + void* read_callback; // _XInternalConnectionProc + void* call_data; + void* *watch_data; + struct my_XConnectionInfo *next; +}; + +struct my_XConnWatchInfo { + void* fn; // XConnectionWatchProc + void* client_data; + struct _XConnWatchInfo *next; +}; + +typedef struct my_Screen_s { + void* ext_data; //XExtData * + struct my_XDisplay_s *display; + XID root; + int width, height; + int mwidth, mheight; + int ndepths; + void* depths; //Depth * + int root_depth; /* bits per pixel */ + void* root_visual; //Visual * + void* default_gc; //GC == struct _XGC* + XID cmap; + unsigned long white_pixel; + unsigned long black_pixel; + int max_maps, min_maps; + int backing_store; + int save_unders; + long root_input_mask; +} my_Screen_t; + +typedef struct my_XDisplay_s +{ + void *ext_data; + struct my_XFreeFuncs *free_funcs; + int fd; + int conn_checker; + int proto_major_version; + int proto_minor_version; + char *vendor; + XID resource_base; + XID resource_mask; + XID resource_id; + int resource_shift; + XID (*resource_alloc)(void*); + int byte_order; + int bitmap_unit; + int bitmap_pad; + int bitmap_bit_order; + int nformats; + void *pixmap_format; + int vnumber; + int release; + void *head, *tail; + int qlen; + unsigned long last_request_read; + unsigned long request; + char *last_req; + char *buffer; + char *bufptr; + char *bufmax; + unsigned max_request_size; + void* *db; + int (*synchandler)(void*); + char *display_name; + int default_screen; + int nscreens; + my_Screen_t *screens; + unsigned long motion_buffer; + volatile unsigned long flags; + int min_keycode; + int max_keycode; + void *keysyms; + void *modifiermap; + int keysyms_per_keycode; + char *xdefaults; + char *scratch_buffer; + unsigned long scratch_length; + int ext_number; + struct my_XExten *ext_procs; + int (*event_vec[128])(void *, void *, void *); + int (*wire_vec[128])(void *, void *, void *); + XID lock_meaning; + void* lock; + struct my_XInternalAsync *async_handlers; + unsigned long bigreq_size; + struct my_XLockPtrs *lock_fns; + void (*idlist_alloc)(void *, void *, int); + void* key_bindings; + XID cursor_font; + void* *atoms; + unsigned int mode_switch; + unsigned int num_lock; + void* context_db; + int (**error_vec)(void*, void*, void*); + struct { + void* defaultCCCs; + void* clientCmaps; + void* perVisualIntensityMaps; + } cms; + void* im_filters; + void* qfree; + unsigned long next_event_serial_num; + struct my_XExten *flushes; + struct my_XConnectionInfo *im_fd_info; + int im_fd_length; + struct my_XConnWatchInfo *conn_watchers; + int watcher_count; + void* filedes; + int (*savedsynchandler)(void *); + XID resource_max; + int xcmisc_opcode; + void* *xkb_info; + void* *trans_conn; + void* *xcb; + unsigned int next_cookie; + int (*generic_event_vec[128])(void*, void*, void*); + int (*generic_event_copy_vec[128])(void*, void*, void*); + void *cookiejar; + unsigned long last_request_read_upper32bit; // 64bits only + unsigned long request_upper32bit; // 64bits only + void* error_threads; + void* exit_handler; + void* exit_handler_data; +} my_XDisplay_t; + +typedef struct my_XSetWindowAttributes_s { + XID background_pixmap; + unsigned long background_pixel; + XID border_pixmap; + unsigned long border_pixel; + int bit_gravity; + int win_gravity; + int backing_store; + unsigned long backing_planes; + unsigned long backing_pixel; + int save_under; + long event_mask; + long do_not_propagate_mask; + int override_redirect; + XID colormap; + XID cursor; +} my_XSetWindowAttributes_t; + +typedef struct my_XKeyEvent_s +{ + int type; + unsigned long serial; + int send_event; + my_XDisplay_t *display; + XID window; + XID root; + XID subwindow; + unsigned long time; + int x, y; + int x_root, y_root; + unsigned int state; + unsigned int keycode; + int same_screen; +} my_XKeyEvent_t; +typedef my_XKeyEvent_t my_XKeyPressedEvent_t; +typedef my_XKeyEvent_t my_XKeyReleasedEvent_t; + +typedef struct my_XButtonEvent_s +{ + int type; + unsigned long serial; + int send_event; + my_XDisplay_t *display; + XID window; + XID root; + XID subwindow; + unsigned long time; + int x, y; + int x_root, y_root; + unsigned int state; + unsigned int button; + int same_screen; +} my_XButtonEvent_t; +typedef my_XButtonEvent_t my_XButtonPressedEvent_t; +typedef my_XButtonEvent_t my_XButtonReleasedEvent_t; + +typedef struct my_XMotionEvent_s +{ + int type; + unsigned long serial; + int send_event; + my_XDisplay_t *display; + XID window; + XID root; + XID subwindow; + unsigned long time; + int x, y; + int x_root, y_root; + unsigned int state; + char is_hint; + int same_screen; +} my_XMotionEvent_t; +typedef my_XMotionEvent_t my_XPointerMovedEvent_t; + +typedef struct my_XCrossingEvent_s +{ + int type; + unsigned long serial; + int send_event; + my_XDisplay_t *display; + XID window; + XID root; + XID subwindow; + unsigned long time; + int x, y; + int x_root, y_root; + int mode; + int detail; + int same_screen; + int focus; + unsigned int state; +} my_XCrossingEvent_t; + +typedef my_XCrossingEvent_t my_XEnterWindowEvent_t; +typedef my_XCrossingEvent_t my_XLeaveWindowEvent_t; + +typedef struct my_XFocusChangeEvent_s +{ + int type; + unsigned long serial; + int send_event; + my_XDisplay_t *display; + XID window; + int mode; + int detail; +} my_XFocusChangeEvent_t; +typedef my_XFocusChangeEvent_t my_XFocusInEvent_t; +typedef my_XFocusChangeEvent_t my_XFocusOutEvent_t; + +typedef struct my_XKeymapEvent_s +{ + int type; + unsigned long serial; + int send_event; + my_XDisplay_t *display; + XID window; + char key_vector[32]; +} my_XKeymapEvent_t; + +typedef struct my_XExposeEvent_s +{ + int type; + unsigned long serial; + int send_event; + my_XDisplay_t *display; + XID window; + int x, y; + int width, height; + int count; +} my_XExposeEvent_t; + +typedef struct my_XGraphicsExposeEvent_s +{ + int type; + unsigned long serial; + int send_event; + my_XDisplay_t *display; + XID drawable; + int x, y; + int width, height; + int count; + int major_code; + int minor_code; +} my_XGraphicsExposeEvent_t; + +typedef struct my_XNoExposeEvent_s +{ + int type; + unsigned long serial; + int send_event; + my_XDisplay_t *display; + XID drawable; + int major_code; + int minor_code; +} my_XNoExposeEvent_t; + +typedef struct my_XVisibilityEvent_s +{ + int type; + unsigned long serial; + int send_event; + my_XDisplay_t *display; + XID window; + int state; +} my_XVisibilityEvent_t; + +typedef struct my_XCreateWindowEvent_s +{ + int type; + unsigned long serial; + int send_event; + my_XDisplay_t *display; + XID parent; + XID window; + int x, y; + int width, height; + int border_width; + int override_redirect; +} my_XCreateWindowEvent_t; + +typedef struct my_XDestroyWindowEvent_s +{ + int type; + unsigned long serial; + int send_event; + my_XDisplay_t *display; + XID event; + XID window; +} my_XDestroyWindowEvent_t; + +typedef struct my_XUnmapEvent_s +{ + int type; + unsigned long serial; + int send_event; + my_XDisplay_t *display; + XID event; + XID window; + int from_configure; +} my_XUnmapEvent_t; + +typedef struct my_XMapEvent_s +{ + int type; + unsigned long serial; + int send_event; + my_XDisplay_t *display; + XID event; + XID window; + int override_redirect; +} my_XMapEvent_t; + +typedef struct my_XMapRequestEvent_s +{ + int type; + unsigned long serial; + int send_event; + my_XDisplay_t *display; + XID parent; + XID window; +} my_XMapRequestEvent_t; + +typedef struct my_XReparentEvent_s +{ + int type; + unsigned long serial; + int send_event; + my_XDisplay_t *display; + XID event; + XID window; + XID parent; + int x, y; + int override_redirect; +} my_XReparentEvent_t; + +typedef struct my_XConfigureEvent_s +{ + int type; + unsigned long serial; + int send_event; + my_XDisplay_t *display; + XID event; + XID window; + int x, y; + int width, height; + int border_width; + XID above; + int override_redirect; +} my_XConfigureEvent_t; + +typedef struct my_XGravityEvent_s +{ + int type; + unsigned long serial; + int send_event; + my_XDisplay_t *display; + XID event; + XID window; + int x, y; +} my_XGravityEvent_t; + +typedef struct my_XResizeRequestEvent_s +{ + int type; + unsigned long serial; + int send_event; + my_XDisplay_t *display; + XID window; + int width, height; +} my_XResizeRequestEvent_t; + +typedef struct my_XConfigureRequestEvent_s +{ + int type; + unsigned long serial; + int send_event; + my_XDisplay_t *display; + XID parent; + XID window; + int x, y; + int width, height; + int border_width; + XID above; + int detail; + unsigned long value_mask; +} my_XConfigureRequestEvent_t; + +typedef struct my_XCirculateEvent_s +{ + int type; + unsigned long serial; + int send_event; + my_XDisplay_t *display; + XID event; + XID window; + int place; +} my_XCirculateEvent_t; + +typedef struct my_XCirculateRequestEvent_s +{ + int type; + unsigned long serial; + int send_event; + my_XDisplay_t *display; + XID parent; + XID window; + int place; +} my_XCirculateRequestEvent_t; + +typedef struct my_XPropertyEvent_s +{ + int type; + unsigned long serial; + int send_event; + my_XDisplay_t *display; + XID window; + XID atom; + unsigned long time; + int state; +} my_XPropertyEvent_t; + +typedef struct my_XSelectionClearEvent_s +{ + int type; + unsigned long serial; + int send_event; + my_XDisplay_t *display; + XID window; + XID selection; + unsigned long time; +} my_XSelectionClearEvent_t; + +typedef struct my_XSelectionRequestEvent_s +{ + int type; + unsigned long serial; + int send_event; + my_XDisplay_t *display; + XID owner; + XID requestor; + XID selection; + XID target; + XID property; + unsigned long time; +} my_XSelectionRequestEvent_t; + +typedef struct my_XSelectionEvent_s +{ + int type; + unsigned long serial; + int send_event; + my_XDisplay_t *display; + XID requestor; + XID selection; + XID target; + XID property; + unsigned long time; +} my_XSelectionEvent_t; + +typedef struct my_XColormapEvent_s +{ + int type; + unsigned long serial; + int send_event; + my_XDisplay_t *display; + XID window; + XID colormap; + int c_new; + int state; +} my_XColormapEvent_t; + +typedef struct my_XClientMessageEvent_s +{ + int type; + unsigned long serial; + int send_event; + my_XDisplay_t *display; + XID window; + XID message_type; + int format; + union { + char b[20]; + short s[10]; + long l[5]; + } data; +} my_XClientMessageEvent_t; + +typedef struct my_XMappingEvent_s +{ + int type; + unsigned long serial; + int send_event; + my_XDisplay_t *display; + XID window; + int request; + int first_keycode; + int count; +} my_XMappingEvent_t; + +typedef struct my_XErrorEvent_s +{ + int type; + my_XDisplay_t *display; + XID resourceid; + unsigned long serial; + unsigned char error_code; + unsigned char request_code; + unsigned char minor_code; +} my_XErrorEvent_t; + +typedef struct my_XAnyEvent_s +{ + int type; + unsigned long serial; + int send_event; + my_XDisplay_t *display; + XID window; +} my_XAnyEvent_t; + +typedef struct my_XGenericEvent_s +{ + int type; + unsigned long serial; + int send_event; + my_XDisplay_t *display; + int extension; + int evtype; +} my_XGenericEvent_t; + +typedef struct my_XGenericEventCookie_s +{ + int type; + unsigned long serial; + int send_event; + my_XDisplay_t *display; + int extension; + int evtype; + unsigned int cookie; + void *data; +} my_XGenericEventCookie_t; + +typedef union my_XEvent_s { + int type; + my_XAnyEvent_t xany; + my_XKeyEvent_t xkey; + my_XButtonEvent_t xbutton; + my_XMotionEvent_t xmotion; + my_XCrossingEvent_t xcrossing; + my_XFocusChangeEvent_t xfocus; + my_XExposeEvent_t xexpose; + my_XGraphicsExposeEvent_t xgraphicsexpose; + my_XNoExposeEvent_t xnoexpose; + my_XVisibilityEvent_t xvisibility; + my_XCreateWindowEvent_t xcreatewindow; + my_XDestroyWindowEvent_t xdestroywindow; + my_XUnmapEvent_t xunmap; + my_XMapEvent_t xmap; + my_XMapRequestEvent_t xmaprequest; + my_XReparentEvent_t xreparent; + my_XConfigureEvent_t xconfigure; + my_XGravityEvent_t xgravity; + my_XResizeRequestEvent_t xresizerequest; + my_XConfigureRequestEvent_t xconfigurerequest; + my_XCirculateEvent_t xcirculate; + my_XCirculateRequestEvent_t xcirculaterequest; + my_XPropertyEvent_t xproperty; + my_XSelectionClearEvent_t xselectionclear; + my_XSelectionRequestEvent_t xselectionrequest; + my_XSelectionEvent_t xselection; + my_XColormapEvent_t xcolormap; + my_XClientMessageEvent_t xclient; + my_XMappingEvent_t xmapping; + my_XErrorEvent_t xerror; + my_XKeymapEvent_t xkeymap; + my_XGenericEvent_t xgeneric; + my_XGenericEventCookie_t xcookie; + long pad[24]; +} my_XEvent_t; + +#define XEVT_KeyPress 2 +#define XEVT_KeyRelease 3 +#define XEVT_ButtonPress 4 +#define XEVT_ButtonRelease 5 +#define XEVT_MotionNotify 6 +#define XEVT_EnterNotify 7 +#define XEVT_LeaveNotify 8 +#define XEVT_FocusIn 9 +#define XEVT_FocusOut 10 +#define XEVT_KeymapNotify 11 +#define XEVT_Expose 12 +#define XEVT_GraphicsExpose 13 +#define XEVT_NoExpose 14 +#define XEVT_VisibilityNotify 15 +#define XEVT_CreateNotify 16 +#define XEVT_DestroyNotify 17 +#define XEVT_UnmapNotify 18 +#define XEVT_MapNotify 19 +#define XEVT_MapRequest 20 +#define XEVT_ReparentNotify 21 +#define XEVT_ConfigureNotify 22 +#define XEVT_ConfigureRequest 23 +#define XEVT_GravityNotify 24 +#define XEVT_ResizeRequest 25 +#define XEVT_CirculateNotify 26 +#define XEVT_CirculateRequest 27 +#define XEVT_PropertyNotify 28 +#define XEVT_SelectionClear 29 +#define XEVT_SelectionRequest 30 +#define XEVT_SelectionNotify 31 +#define XEVT_ColormapNotify 32 +#define XEVT_ClientMessage 33 +#define XEVT_MappingNotify 34 +#define XEVT_GenericEvent 35 + + +#endif//MY_X11_DEFS \ No newline at end of file diff --git a/src/libtools/my_x11_defs_32.h b/src/libtools/my_x11_defs_32.h new file mode 100644 index 00000000..ec08bd91 --- /dev/null +++ b/src/libtools/my_x11_defs_32.h @@ -0,0 +1,685 @@ +#ifndef MY_X11_DEFS_32 +#define MY_X11_DEFS_32 +#include <stdint.h> +#include "box32.h" + +typedef ulong_t XID_32; + +typedef struct ximage_32_s { + ptr_t create_image; + ptr_t destroy_image; + ptr_t get_pixel; + ptr_t put_pixel; + ptr_t sub_image; + ptr_t add_pixel; +} ximage_32_t; + +typedef struct _XImage_32 { + int32_t width, height; + int32_t xoffset; + int32_t format; + ptr_t data; + int byte_order; + int bitmap_unit; + int bitmap_bit_order; + int bitmap_pad; + int depth; + int bytes_per_line; + int bits_per_pixel; + ulong_t red_mask; + ulong_t green_mask; + ulong_t blue_mask; + ptr_t obdata; + ximage_32_t f; +} XImage_32; + +struct my_XFreeFuncs_32 { + ptr_t atoms; // void* + ptr_t modifiermap; // void* + ptr_t key_bindings; // void* + ptr_t context_db; // void* + ptr_t defaultCCCs; // void* + ptr_t clientCmaps; // void* + ptr_t intensityMaps; // void* + ptr_t im_filters; // void* + ptr_t xkb; // void* +}; + +struct my_XExten_32 { + ptr_t next; //struct my_XExten * + ptr_t codes; // XExtCodes + ptr_t create_GC; // CreateGCType + ptr_t copy_GC; // CopyGCType + ptr_t flush_GC; // FlushGCType + ptr_t free_GC; // FreeGCType + ptr_t create_Font; // CreateFontType + ptr_t free_Font; // FreeFontType + ptr_t close_display; // CloseDisplayType + ptr_t error; // ErrorType + ptr_t error_string; // ErrorStringType + ptr_t name; //char* + ptr_t error_values; // PrintErrorType + ptr_t before_flush; // BeforeFlushType + ptr_t next_flush; //struct my_XExten * +}; + +struct my_XInternalAsync_32 { + ptr_t next; //struct my_XInternalAsync_32 * + ptr_t handler; //int (*handler)(void*, void*, char*, int, void*); + ptr_t data; //void* +}; + +struct my_XLockPtrs_32 { + ptr_t lock_display;// void (*lock_display)(void* dpy); + ptr_t unlock_display;// void (*unlock_display)(void *dpy); +}; + +struct my_XConnectionInfo_32 { + int fd; + ptr_t read_callback; // _XInternalConnectionProc + ptr_t call_data; + ptr_t watch_data; // void** + struct my_XConnectionInfo *next; +}; + +struct my_XConnWatchInfo_32 { + ptr_t fn; // XConnectionWatchProc + ptr_t client_data; + ptr_t next; //struct _XConnWatchInfo * +}; + +typedef struct my_Screen_32_s { + ptr_t ext_data; //XExtData * + ptr_t display; //struct my_XDisplay_s * + XID_32 root; + int width, height; + int mwidth, mheight; + int ndepths; + ptr_t depths; //Depth * + int root_depth; /* bits per pixel */ + ptr_t root_visual; //Visual * + ptr_t default_gc; //GC == struct _XGC* + XID_32 cmap; + ulong_t white_pixel; + ulong_t black_pixel; + int max_maps, min_maps; + int backing_store; + int save_unders; + long_t root_input_mask; +} my_Screen_32_t; + +typedef struct my_XDisplay_32_s +{ + ptr_t ext_data; //void * //offset = 0x00 + ptr_t free_funcs; //struct my_XFreeFuncs_32 * + int fd; + int conn_checker; + int proto_major_version; //offset = 0x10 + int proto_minor_version; + ptr_t vendor; //char * + XID_32 resource_base; + XID_32 resource_mask; // offset = 0x20 + XID_32 resource_id; + int resource_shift; + ptr_t resource_alloc;//XID_32 (*resource_alloc)(void*); + int byte_order; // offset = 0x30 + int bitmap_unit; + int bitmap_pad; + int bitmap_bit_order; + int nformats; //offset = 0x40 + ptr_t pixmap_format; //void * + int vnumber; + int release; + ptr_t head, tail; //ofsset = 0x50 + int qlen; + ulong_t last_request_read; + ulong_t request; //offset = 0x60 + ptr_t last_req; //char * + ptr_t buffer; //char * + ptr_t bufptr; //char * + ptr_t bufmax; //char * //offset = 0x70 + unsigned max_request_size; + ptr_t db; //void* * + ptr_t synchandler; //int (*synchandler)(void*); + ptr_t display_name;//char * //offset = 0x80 + int default_screen; + int nscreens; + ptr_t screens;//void * + ulong_t motion_buffer; //offset = 0x90 + volatile ulong_t flags; + int min_keycode; + int max_keycode; + ptr_t keysyms; //void * + ptr_t modifiermap; //void * + int keysyms_per_keycode; + ptr_t xdefaults; //char * + ptr_t scratch_buffer; //char * + ulong_t scratch_length; + int ext_number; + ptr_t ext_procs; //struct my_XExten * + ptr_t event_vec; //int (*event_vec[128])(void *, void *, void *); + ptr_t wire_vec; //int (*wire_vec[128])(void *, void *, void *); + XID_32 lock_meaning; + ptr_t lock; //void* + ptr_t async_handlers; //struct my_XInternalAsync * + ulong_t bigreq_size; + ptr_t lock_fns; //struct my_XLockPtrs * + ptr_t idlist_alloc; //void (*idlist_alloc)(void *, void *, int); + ptr_t key_bindings; //void* + XID_32 cursor_font; + ptr_t atoms; //void* * + unsigned int mode_switch; + unsigned int num_lock; + ptr_t context_db; //void* + ptr_t error_vec; //int (**error_vec)(void*, void*, void*); + struct { + ptr_t defaultCCCs; //void* + ptr_t clientCmaps; //void* + ptr_t perVisualIntensityMaps; //void* + } cms; + ptr_t im_filters; //void* + ptr_t qfree; //void* + ulong_t next_event_32_serial_num; + ptr_t flushes; //struct my_XExten * + ptr_t im_fd_info; //struct my_XConnectionInfo * + int im_fd_length; + ptr_t conn_watchers; //struct my_XConnWatchInfo * + int watcher_count; + ptr_t filedes; //void* + ptr_t savedsynchandler; //int (*savedsynchandler)(void *); + XID_32 resource_max; + int xcmisc_opcode; + ptr_t xkb_info; //void* * + ptr_t trans_conn; //void* * + ptr_t xcb; //void* * + unsigned int next_cookie; + ptr_t generic_event_vec[128]; //int (*generic_event_vec[128])(void*, void*, void*); + ptr_t generic_event_copy_vec[128]; //int (*generic_event_copy_vec[128])(void*, void*, void*); + ptr_t cookiejar; //void * + ptr_t error_threads; //void * + ptr_t exit_handler; //void * + ptr_t exit_handler_data; //void * +} my_XDisplay_32_t; + +typedef struct my_XSetWindowAttributes_32_s { + XID_32 background_pixmap; + ulong_t background_pixel; + XID_32 border_pixmap; + ulong_t border_pixel; + int bit_gravity; + int win_gravity; + int backing_store; + ulong_t backing_planes; + ulong_t backing_pixel; + int save_under; + long_t event_mask; + long_t do_not_propagate_mask; + int override_redirect; + XID_32 colormap; + XID_32 cursor; +} my_XSetWindowAttributes_32_t; + +// Events + +typedef struct my_XKeyEvent_32_s +{ + int type; + ulong_t serial; + int send_event; + ptr_t display; //Display* + XID_32 window; + XID_32 root; + XID_32 subwindow; + ulong_t time; + int x, y; + int x_root, y_root; + unsigned int state; + unsigned int keycode; + int same_screen; +} my_XKeyEvent_32_t; +typedef my_XKeyEvent_32_t my_XKeyPressedEvent_32_t; +typedef my_XKeyEvent_32_t my_XKeyReleasedEvent_32_t; + +typedef struct my_XButtonEvent_32_s +{ + int type; + ulong_t serial; + int send_event; + ptr_t display; //Display* + XID_32 window; + XID_32 root; + XID_32 subwindow; + ulong_t time; + int x, y; + int x_root, y_root; + unsigned int state; + unsigned int button; + int same_screen; +} my_XButtonEvent_32_t; +typedef my_XButtonEvent_32_t my_XButtonPressedEvent_32_t; +typedef my_XButtonEvent_32_t my_XButtonReleasedEvent_32_t; + +typedef struct my_XMotionEvent_32_s +{ + int type; + ulong_t serial; + int send_event; + ptr_t display; //Display* + XID_32 window; + XID_32 root; + XID_32 subwindow; + ulong_t time; + int x, y; + int x_root, y_root; + unsigned int state; + char is_hint; + int same_screen; +} my_XMotionEvent_32_t; +typedef my_XMotionEvent_32_t my_XPointerMovedEvent_32_t; + +typedef struct my_XCrossingEvent_32_s +{ + int type; + ulong_t serial; + int send_event; + ptr_t display; //Display* + XID_32 window; + XID_32 root; + XID_32 subwindow; + ulong_t time; + int x, y; + int x_root, y_root; + int mode; + int detail; + int same_screen; + int focus; + unsigned int state; +} my_XCrossingEvent_32_t; + +typedef my_XCrossingEvent_32_t my_XEnterWindowEvent_32_t; +typedef my_XCrossingEvent_32_t my_XLeaveWindowEvent_32_t; + +typedef struct my_XFocusChangeEvent_32_s +{ + int type; + ulong_t serial; + int send_event; + ptr_t display; //Display* + XID_32 window; + int mode; + int detail; +} my_XFocusChangeEvent_32_t; +typedef my_XFocusChangeEvent_32_t my_XFocusInEvent_32_t; +typedef my_XFocusChangeEvent_32_t my_XFocusOutEvent_32_t; + +typedef struct my_XKeymapEvent_32_s +{ + int type; + ulong_t serial; + int send_event; + ptr_t display; //Display* + XID_32 window; + char key_vector[32]; +} my_XKeymapEvent_32_t; + +typedef struct my_XExposeEvent_32_s +{ + int type; + ulong_t serial; + int send_event; + ptr_t display; //Display* + XID_32 window; + int x, y; + int width, height; + int count; +} my_XExposeEvent_32_t; + +typedef struct my_XGraphicsExposeEvent_32_s +{ + int type; + ulong_t serial; + int send_event; + ptr_t display; //Display* + XID_32 drawable; + int x, y; + int width, height; + int count; + int major_code; + int minor_code; +} my_XGraphicsExposeEvent_32_t; + +typedef struct my_XNoExposeEvent_32_s +{ + int type; + ulong_t serial; + int send_event; + ptr_t display; //Display* + XID_32 drawable; + int major_code; + int minor_code; +} my_XNoExposeEvent_32_t; + +typedef struct my_XVisibilityEvent_32_s +{ + int type; + ulong_t serial; + int send_event; + ptr_t display; //Display* + XID_32 window; + int state; +} my_XVisibilityEvent_32_t; + +typedef struct my_XCreateWindowEvent_32_s +{ + int type; + ulong_t serial; + int send_event; + ptr_t display; //Display* + XID_32 parent; + XID_32 window; + int x, y; + int width, height; + int border_width; + int override_redirect; +} my_XCreateWindowEvent_32_t; + +typedef struct my_XDestroyWindowEvent_32_s +{ + int type; + ulong_t serial; + int send_event; + ptr_t display; //Display* + XID_32 event; + XID_32 window; +} my_XDestroyWindowEvent_32_t; + +typedef struct my_XUnmapEvent_32_s +{ + int type; + ulong_t serial; + int send_event; + ptr_t display; //Display* + XID_32 event; + XID_32 window; + int from_configure; +} my_XUnmapEvent_32_t; + +typedef struct my_XMapEvent_32_s +{ + int type; + ulong_t serial; + int send_event; + ptr_t display; //Display* + XID_32 event; + XID_32 window; + int override_redirect; +} my_XMapEvent_32_t; + +typedef struct my_XMapRequestEvent_32_s +{ + int type; + ulong_t serial; + int send_event; + ptr_t display; //Display* + XID_32 parent; + XID_32 window; +} my_XMapRequestEvent_32_t; + +typedef struct my_XReparentEvent_32_s +{ + int type; + ulong_t serial; + int send_event; + ptr_t display; //Display* + XID_32 event; + XID_32 window; + XID_32 parent; + int x, y; + int override_redirect; +} my_XReparentEvent_32_t; + +typedef struct my_XConfigureEvent_32_s +{ + int type; + ulong_t serial; + int send_event; + ptr_t display; //Display* + XID_32 event; + XID_32 window; + int x, y; + int width, height; + int border_width; + XID_32 above; + int override_redirect; +} my_XConfigureEvent_32_t; + +typedef struct my_XGravityEvent_32_s +{ + int type; + ulong_t serial; + int send_event; + ptr_t display; //Display* + XID_32 event; + XID_32 window; + int x, y; +} my_XGravityEvent_32_t; + +typedef struct my_XResizeRequestEvent_32_s +{ + int type; + ulong_t serial; + int send_event; + ptr_t display; //Display* + XID_32 window; + int width, height; +} my_XResizeRequestEvent_32_t; + +typedef struct my_XConfigureRequestEvent_32_s +{ + int type; + ulong_t serial; + int send_event; + ptr_t display; //Display* + XID_32 parent; + XID_32 window; + int x, y; + int width, height; + int border_width; + XID_32 above; + int detail; + ulong_t value_mask; +} my_XConfigureRequestEvent_32_t; + +typedef struct my_XCirculateEvent_32_s +{ + int type; + ulong_t serial; + int send_event; + ptr_t display; //Display* + XID_32 event; + XID_32 window; + int place; +} my_XCirculateEvent_32_t; + +typedef struct my_XCirculateRequestEvent_32_s +{ + int type; + ulong_t serial; + int send_event; + ptr_t display; //Display* + XID_32 parent; + XID_32 window; + int place; +} my_XCirculateRequestEvent_32_t; + +typedef struct my_XPropertyEvent_32_s +{ + int type; + ulong_t serial; + int send_event; + ptr_t display; //Display* + XID_32 window; + XID_32 atom; + ulong_t time; + int state; +} my_XPropertyEvent_32_t; + +typedef struct my_XSelectionClearEvent_32_s +{ + int type; + ulong_t serial; + int send_event; + ptr_t display; //Display* + XID_32 window; + XID_32 selection; + ulong_t time; +} my_XSelectionClearEvent_32_t; + +typedef struct my_XSelectionRequestEvent_32_s +{ + int type; + ulong_t serial; + int send_event; + ptr_t display; //Display* + XID_32 owner; + XID_32 requestor; + XID_32 selection; + XID_32 target; + XID_32 property; + ulong_t time; +} my_XSelectionRequestEvent_32_t; + +typedef struct my_XSelectionEvent_32_s +{ + int type; + ulong_t serial; + int send_event; + ptr_t display; //Display* + XID_32 requestor; + XID_32 selection; + XID_32 target; + XID_32 property; + ulong_t time; +} my_XSelectionEvent_32_t; + +typedef struct my_XColormapEvent_32_s +{ + int type; + ulong_t serial; + int send_event; + ptr_t display; //Display* + XID_32 window; + XID_32 colormap; + int c_new; + int state; +} my_XColormapEvent_32_t; + +typedef struct my_XClientMessageEvent_32_s +{ + int type; + ulong_t serial; + int send_event; + ptr_t display; //Display* + XID_32 window; + XID_32 message_type; + int format; + union { + char b[20]; + short s[10]; + long_t l[5]; + } data; +} my_XClientMessageEvent_32_t; + +typedef struct my_XMappingEvent_32_s +{ + int type; + ulong_t serial; + int send_event; + ptr_t display; //Display* + XID_32 window; + int request; + int first_keycode; + int count; +} my_XMappingEvent_32_t; + +typedef struct my_XErrorEvent_32_s +{ + int type; + ptr_t display; //Display* + XID_32 resourceid; + ulong_t serial; + unsigned char error_code; + unsigned char request_code; + unsigned char minor_code; +} my_XErrorEvent_32_t; + +typedef struct my_XAnyEvent_32_s +{ + int type; + ulong_t serial; + int send_event; + ptr_t display; //Display* + XID_32 window; +} my_XAnyEvent_32_t; + +typedef struct my_XGenericEvent_32_s +{ + int type; + ulong_t serial; + int send_event; + ptr_t display; //Display* + int extension; + int evtype; +} my_XGenericEvent_32_t; + +typedef struct my_XGenericEventCookie_32_s +{ + int type; + ulong_t serial; + int send_event; + ptr_t display; //Display* + int extension; + int evtype; + unsigned int cookie; + void *data; +} my_XGenericEventCookie_32_t; + +typedef union my_XEvent_32_s { + int type; + my_XAnyEvent_32_t xany; + my_XKeyEvent_32_t xkey; + my_XButtonEvent_32_t xbutton; + my_XMotionEvent_32_t xmotion; + my_XCrossingEvent_32_t xcrossing; + my_XFocusChangeEvent_32_t xfocus; + my_XExposeEvent_32_t xexpose; + my_XGraphicsExposeEvent_32_t xgraphicsexpose; + my_XNoExposeEvent_32_t xnoexpose; + my_XVisibilityEvent_32_t xvisibility; + my_XCreateWindowEvent_32_t xcreatewindow; + my_XDestroyWindowEvent_32_t xdestroywindow; + my_XUnmapEvent_32_t xunmap; + my_XMapEvent_32_t xmap; + my_XMapRequestEvent_32_t xmaprequest; + my_XReparentEvent_32_t xreparent; + my_XConfigureEvent_32_t xconfigure; + my_XGravityEvent_32_t xgravity; + my_XResizeRequestEvent_32_t xresizerequest; + my_XConfigureRequestEvent_32_t xconfigurerequest; + my_XCirculateEvent_32_t xcirculate; + my_XCirculateRequestEvent_32_t xcirculaterequest; + my_XPropertyEvent_32_t xproperty; + my_XSelectionClearEvent_32_t xselectionclear; + my_XSelectionRequestEvent_32_t xselectionrequest; + my_XSelectionEvent_32_t xselection; + my_XColormapEvent_32_t xcolormap; + my_XClientMessageEvent_32_t xclient; + my_XMappingEvent_32_t xmapping; + my_XErrorEvent_32_t xerror; + my_XKeymapEvent_32_t xkeymap; + my_XGenericEvent_32_t xgeneric; + my_XGenericEventCookie_32_t xcookie; + long_t pad[24]; +} my_XEvent_32_t; + +#endif//MY_X11_DEFS_32 \ No newline at end of file diff --git a/src/wrapped/generated/functions_list.txt b/src/wrapped/generated/functions_list.txt index 4df39143..5dafe43a 100644 --- a/src/wrapped/generated/functions_list.txt +++ b/src/wrapped/generated/functions_list.txt @@ -5007,6 +5007,8 @@ wrappedlibvdpau: - vdp_device_create_x11 wrappedlibvorbis: wrappedlibx11: +- vFp: + - XcmsFreeCCC - iFp: - XDestroyImage - XInitImage diff --git a/src/wrapped/generated/wrappedlibx11types.h b/src/wrapped/generated/wrappedlibx11types.h index 1651619f..15ab5a8d 100644 --- a/src/wrapped/generated/wrappedlibx11types.h +++ b/src/wrapped/generated/wrappedlibx11types.h @@ -11,6 +11,7 @@ #define ADDED_FUNCTIONS() #endif +typedef void (*vFp_t)(void*); typedef int32_t (*iFp_t)(void*); typedef void* (*pFp_t)(void*); typedef void (*vFpp_t)(void*, void*); @@ -31,6 +32,7 @@ typedef void* (*pFppuiipuuii_t)(void*, void*, uint32_t, int32_t, int32_t, void*, typedef void* (*pFpLiiuuLipii_t)(void*, uintptr_t, int32_t, int32_t, uint32_t, uint32_t, uintptr_t, int32_t, void*, int32_t, int32_t); #define SUPER() ADDED_FUNCTIONS() \ + GO(XcmsFreeCCC, vFp_t) \ GO(XDestroyImage, iFp_t) \ GO(XInitImage, iFp_t) \ GO(_XInitImageFuncPtrs, iFp_t) \ diff --git a/src/wrapped/wrappedlibx11_private.h b/src/wrapped/wrappedlibx11_private.h index 867c0e5d..e4fc4876 100644 --- a/src/wrapped/wrappedlibx11_private.h +++ b/src/wrapped/wrappedlibx11_private.h @@ -128,7 +128,7 @@ DATA(_XcmsDIColorSpacesInit, 6*sizeof(void*)) //GOM(XcmsDisplayOfCCC, pFEp) //GO(_XcmsEqualWhitePts, GO(XcmsFormatOfPrefix, LFp) -//GOM(XcmsFreeCCC, vFEp) +GOM(XcmsFreeCCC, vFp) //GO(_XcmsFreeIntensityMaps, //GO(_XcmsFreePointerArray, //GO(_XcmsGetElement, diff --git a/src/wrapped32/generated/converter32.c b/src/wrapped32/generated/converter32.c index 19b09648..840b683e 100644 --- a/src/wrapped32/generated/converter32.c +++ b/src/wrapped32/generated/converter32.c @@ -113,3 +113,18 @@ void to_struct_up(ptr_t d, const struct_up_t *src) { *(uint32_t*)dest = src->u0; dest += 4; *(ptr_t*)dest = to_ptrv(src->p1); dest += 4; } +void from_struct_hWcc(struct_hWcc_t *dest, ptr_t s) { + uint8_t* src = (uint8_t*)from_ptrv(s); + dest->L0 = from_hash(*(uint32_t*)src); src += 4; + dest->W1 = *(uint16_t*)src; src += 2; + dest->c2 = *(char*)src; src += 1; + dest->c3 = *(char*)src; src += 1; +} +void to_struct_hWcc(ptr_t d, const struct_hWcc_t *src) { + if (!src) return; + uint8_t* dest = (uint8_t*)from_ptrv(d); + *(uint32_t*)dest = to_hash(src->L0); dest += 4; + *(uint16_t*)dest = src->W1; dest += 2; + *(char*)dest = src->c2; dest += 1; + *(char*)dest = src->c3; dest += 1; +} diff --git a/src/wrapped32/generated/converter32.h b/src/wrapped32/generated/converter32.h index 41981b42..b63c9621 100644 --- a/src/wrapped32/generated/converter32.h +++ b/src/wrapped32/generated/converter32.h @@ -60,5 +60,13 @@ typedef struct struct_up_s { } struct_up_t; void from_struct_up(struct_up_t *dest, ptr_t src); void to_struct_up(ptr_t dest, const struct_up_t *src); +typedef struct struct_hWcc_s { + unsigned long L0; + unsigned short W1; + char c2; + char c3; +} struct_hWcc_t; +void from_struct_hWcc(struct_hWcc_t *dest, ptr_t src); +void to_struct_hWcc(ptr_t dest, const struct_hWcc_t *src); #endif // __CONVERTER_H_ diff --git a/src/wrapped32/generated/functions_list.txt b/src/wrapped32/generated/functions_list.txt index d615e4b8..7456d7a9 100644 --- a/src/wrapped32/generated/functions_list.txt +++ b/src/wrapped32/generated/functions_list.txt @@ -12,6 +12,7 @@ #() vFp -> vFp #() vFA -> vFA #() vFS -> vFS +#() vFX -> vFX #() iFv -> iFv #() iFi -> iFi #() iFI -> iFI @@ -22,6 +23,7 @@ #() iFp -> iFp #() iFh -> iFh #() iFS -> iFS +#() iFX -> iFX #() IFf -> IFf #() IFd -> IFd #() IFp -> IFp @@ -56,11 +58,13 @@ #() pFu -> pFu #() pFL -> pFL #() pFp -> pFp +#() pFX -> pFX #() hFv -> hFv #() aFa -> aFa #() tFi -> tFi #() tFu -> tFu #() tFp -> tFp +#() iFBp_ -> iFB #() LFrL_ -> LFB #() pFrL_ -> pFB #() LFriiiiiiiiilt_ -> LFB @@ -98,9 +102,11 @@ #() vFlp -> vFlp #() vFpC -> vFpC #() vFpu -> vFpu +#() vFpl -> vFpl #() vFpL -> vFpL #() vFpp -> vFpp #() vFSp -> vFSp +#() vFXp -> vFXp #() wFpi -> wFpi #() iFEv -> iFEv #() iFEi -> iFEi @@ -120,6 +126,7 @@ #() iFli -> iFli #() iFpi -> iFpi #() iFpu -> iFpu +#() iFpl -> iFpl #() iFpL -> iFpL #() iFpp -> iFpp #() iFpV -> iFpV @@ -127,6 +134,9 @@ #() iFhi -> iFhi #() iFhp -> iFhp #() iFhh -> iFhh +#() iFXi -> iFXi +#() iFXL -> iFXL +#() iFXp -> iFXp #() IFII -> IFII #() CFip -> CFip #() CFCi -> CFCi @@ -161,6 +171,7 @@ #() lFpl -> lFpl #() LFpL -> LFpL #() LFpp -> LFpp +#() LFXi -> LFXi #() pFEv -> pFEv #() pFEu -> pFEu #() pFEp -> pFEp @@ -173,6 +184,7 @@ #() pFpu -> pFpu #() pFpL -> pFpL #() pFpp -> pFpp +#() pFXi -> pFXi #() SFip -> SFip #() SFpp -> SFpp #() tFip -> tFip @@ -255,6 +267,7 @@ #() vFppi -> vFppi #() vFppu -> vFppu #() vFppp -> vFppp +#() vFXpi -> vFXpi #() iFEip -> iFEip #() iFEpi -> iFEpi #() iFEpL -> iFEpL @@ -262,6 +275,7 @@ #() iFEpV -> iFEpV #() iFEhi -> iFEhi #() iFESp -> iFESp +#() iFEXp -> iFEXp #() iFiii -> iFiii #() iFiiI -> iFiiI #() iFiiu -> iFiiu @@ -280,12 +294,12 @@ #() iFuup -> iFuup #() iFuLp -> iFuLp #() iFfff -> iFfff +#() iFpii -> iFpii #() iFpiu -> iFpiu #() iFpip -> iFpip #() iFpuC -> iFpuC #() iFpuu -> iFpuu #() iFpuU -> iFpuU -#() iFpup -> iFpup #() iFpLi -> iFpLi #() iFppi -> iFppi #() iFppu -> iFppu @@ -298,6 +312,12 @@ #() iFhpp -> iFhpp #() iFSIi -> iFSIi #() iFSli -> iFSli +#() iFXip -> iFXip +#() iFXuu -> iFXuu +#() iFXLL -> iFXLL +#() iFXLp -> iFXLp +#() iFXpu -> iFXpu +#() iFXpp -> iFXpp #() IFiIi -> IFiIi #() CFipp -> CFipp #() CFuUu -> CFuUu @@ -317,9 +337,12 @@ #() dFddp -> dFddp #() lFipL -> lFipL #() lFlpi -> lFlpi +#() lFpLL -> lFpLL #() lFppL -> lFppL +#() LFpii -> LFpii #() LFpip -> LFpip #() LFppL -> LFppL +#() LFXCi -> LFXCi #() pFEip -> pFEip #() pFEpi -> pFEpi #() pFEpp -> pFEpp @@ -327,7 +350,6 @@ #() pFulu -> pFulu #() pFpii -> pFpii #() pFpiL -> pFpiL -#() pFpip -> pFpip #() pFpiS -> pFpiS #() pFpuL -> pFpuL #() pFpup -> pFpup @@ -335,6 +357,7 @@ #() pFppL -> pFppL #() pFppp -> pFppp #() pFpOM -> pFpOM +#() pFXip -> pFXip #() aFipa -> aFipa #() SFEpp -> SFEpp #() SFppS -> SFppS @@ -343,12 +366,14 @@ #() iFpBp_i -> iFpBi #() iFpbL_p -> iFpBp #() iFBp_LL -> iFBLL +#() iFBp_pi -> iFBpi #() IFpBp_i -> IFpBi #() UFpBp_i -> UFpBi #() dFpBp_i -> dFpBi #() dFpBp_a -> dFpBa #() lFpBp_i -> lFpBi #() LFpBp_i -> LFpBi +#() iFXLbhWcc_ -> iFXLB #() pFppriiiiiiiiilt_ -> pFppB #() vFEipp -> vFEipp #() vFEipV -> vFEipV @@ -426,13 +451,14 @@ #() vFffff -> vFffff #() vFdddd -> vFdddd #() vFllii -> vFllii -#() vFpiii -> vFpiii #() vFpipp -> vFpipp #() vFpdii -> vFpdii #() vFpddd -> vFpddd #() vFplpp -> vFplpp #() vFppip -> vFppip #() vFpppp -> vFpppp +#() vFXiiL -> vFXiiL +#() vFXpip -> vFXpip #() iFEiip -> iFEiip #() iFEiiN -> iFEiiN #() iFEipp -> iFEipp @@ -457,9 +483,8 @@ #() iFippi -> iFippi #() iFuiup -> iFuiup #() iFuupi -> iFuupi -#() iFpiip -> iFpiip +#() iFpiiL -> iFpiiL #() iFpipp -> iFpipp -#() iFpuup -> iFpuup #() iFpupp -> iFpupp #() iFppii -> iFppii #() iFppiU -> iFppiU @@ -469,34 +494,41 @@ #() iFpppi -> iFpppi #() iFpppp -> iFpppp #() iFhpiL -> iFhpiL +#() iFXipp -> iFXipp +#() iFXppp -> iFXppp #() CFuuff -> CFuuff #() uFuuuu -> uFuuuu #() lFEipi -> lFEipi #() lFiipL -> lFiipL #() lFipLi -> lFipLi #() lFpuip -> lFpuip +#() LFEXii -> LFEXii #() LFpLLS -> LFpLLS #() LFppLp -> LFppLp #() LFppLa -> LFppLa +#() LFXLpi -> LFXLpi #() pFEppi -> pFEppi #() pFEppp -> pFEppp #() pFiiiu -> pFiiiu #() pFillu -> pFillu #() pFullu -> pFullu #() pFlfff -> pFlfff -#() pFpiii -> pFpiii #() pFpiLL -> pFpiLL -#() pFpipp -> pFpipp #() pFppLL -> pFppLL -#() pFpppi -> pFpppi #() pFpppp -> pFpppp +#() pFXiii -> pFXiii +#() pFXLLp -> pFXLLp +#() pFXppi -> pFXppi +#() iFppbp_p -> iFppBp #() iFBp_pui -> iFBpui #() IFpBp_ii -> IFpBii #() UFpBp_ii -> UFpBii #() lFiibp_L -> lFiiBL #() LFpbp_Lp -> LFpBLp #() iFEpprLL_ -> iFEppB +#() iFXLpBhWcc_ -> iFXLpB #() LFpLpriiiiiiiiilt_ -> LFpLpB +#() vFEuipp -> vFEuipp #() vFEpLLp -> vFEpLLp #() vFiiiii -> vFiiiii #() vFiiiiu -> vFiiiiu @@ -601,23 +633,23 @@ #() iFiiipp -> iFiiipp #() iFiLLLL -> iFiLLLL #() iFipLLi -> iFipLLi -#() iFpiiip -> iFpiiip -#() iFpippp -> iFpippp -#() iFppipi -> iFppipi +#() iFpLuLi -> iFpLuLi #() iFpppip -> iFpppip #() iFpppup -> iFpppup #() iFppppp -> iFppppp -#() IFppIII -> IFppIII +#() iFXiiip -> iFXiiip +#() iFXpppp -> iFXpppp +#() IFXpIII -> IFXpIII #() uFpLLLS -> uFpLLLS #() UFuiCiu -> UFuiCiu #() lFpuipC -> lFpuipC #() LFpLppa -> LFpLppa +#() LFXLuuu -> LFXLuuu #() pFuiupp -> pFuiupp +#() pFpiiuu -> pFpiiuu #() pFpippp -> pFpippp -#() pFppipi -> pFppipi #() pFppuup -> pFppuup #() pFppupp -> pFppupp -#() pFpppip -> pFpppip #() iFEBh_ppp -> iFEBppp #() LFpbp_LLp -> LFpBLLp #() LFpBp_LLp -> LFpBLLp @@ -686,18 +718,17 @@ #() vFdddddd -> vFdddddd #() vFpipipV -> vFpipipV #() vFpdddii -> vFpdddii -#() vFppiiii -> vFppiiii #() vFppupii -> vFppupii #() iFuiiuup -> iFuiiuup -#() iFpiiipp -> iFpiiipp #() iFpiippp -> iFpiippp #() iFppiiii -> iFppiiii -#() iFppIppp -> iFppIppp +#() iFXLiiiL -> iFXLiiiL +#() iFXpIppp -> iFXpIppp #() uFupuufp -> uFupuufp #() lFipLipu -> lFipLipu #() lFipLipp -> lFipLipp +#() pFEpiiuu -> pFEpiiuu #() pFEpLLiN -> pFEpLLiN -#() pFpippip -> pFpippip #() vFiiiiiip -> vFiiiiiip #() vFiiiiuup -> vFiiiiuup #() vFiiuilil -> vFiiuilil @@ -752,7 +783,9 @@ #() iFEpLiipV -> iFEpLiipV #() iFuiiiuup -> iFuiiiuup #() iFpupLpLi -> iFpupLpLi +#() iFXiuLiii -> iFXiuLiii #() uFuippppp -> uFuippppp +#() LFXLLppuu -> LFXLLppuu #() pFEpLiiii -> pFEpLiiii #() pFEpLiiiI -> pFEpLiiiI #() vFiiiiuuip -> vFiiiiuuip @@ -784,11 +817,12 @@ #() vFffffffff -> vFffffffff #() iFEpippppp -> iFEpippppp #() iFuiiiiuup -> iFuiiiiuup -#() iFppIIIppp -> iFppIIIppp +#() iFXpIIIppp -> iFXpIIIppp #() CFuiifpppp -> CFuiifpppp #() uFuipppppp -> uFuipppppp #() uFuupuuiuf -> uFuupuuiuf #() uFulpppppp -> uFulpppppp +#() LFXLpuuLLu -> LFXLpuuLLu #() vFiiiiiiiii -> vFiiiiiiiii #() vFiiiiiiill -> vFiiiiiiill #() vFiiiiillli -> vFiiiiillli @@ -816,7 +850,9 @@ #() iFuiiuuiiip -> iFuiiuuiiip #() iFuiiupiiup -> iFuiiupiiup #() iFdddpppppp -> iFdddpppppp +#() iFXLiuiiLLL -> iFXLiuiiLLL #() uFuulpiuiuf -> uFuulpiuiuf +#() pFEXLiiuuLi -> pFEXLiiuuLi #() vFiiiiiiiiii -> vFiiiiiiiiii #() vFiiiiiiiiui -> vFiiiiiiiiui #() vFiiiiiiiiuu -> vFiiiiiiiiuu @@ -836,6 +872,8 @@ #() vFuddiiddiip -> vFuddiiddiip #() vFffffffffff -> vFffffffffff #() iFuiiiuuiiip -> iFuiiiuuiiip +#() iFXuuLiuiiLL -> iFXuuLiuiiLL +#() pFXpuiipuuii -> pFXpuiipuuii #() vFiiiiillliip -> vFiiiiillliip #() vFiiiiilllilp -> vFiiiiilllilp #() vFuiiiiiiiuip -> vFuiiiiiiiuip @@ -851,7 +889,9 @@ #() vFuffffffffff -> vFuffffffffff #() vFUufffffffff -> vFUufffffffff #() vFpipipiipiiu -> vFpipipiipiiu +#() iFEXLppiiiiuu -> iFEXLppiiiiuu #() iFuiiiiuuiiip -> iFuiiiiuuiiip +#() pFEXpuiipuuii -> pFEXpuiipuuii #() vFuiiiiiiiiuUC -> vFuiiiiiiiiuUC #() vFuiiiiiiiuuip -> vFuiiiiiiiuuip #() vFuuiiiiiiiiuu -> vFuuiiiiiiiiuu @@ -859,19 +899,20 @@ #() vFuuiiiiiiiuup -> vFuuiiiiiiiuup #() vFuuuuuuuuuuuu -> vFuuuuuuuuuuuu #() vFffffffffffff -> vFffffffffffff +#() pFEXLiiuuLipii -> pFEXLiiuuLipii #() vFuiiiiiiiiiuup -> vFuiiiiiiiiiuup #() vFuuuuuuuuuuuuu -> vFuuuuuuuuuuuuu #() vFuUuuuuuuuuuuu -> vFuUuuuuuuuuuuu #() vFuffffffffffff -> vFuffffffffffff #() iFddddpppddpppp -> iFddddpppddpppp #() uFippuuuulllipp -> uFippuuuulllipp +#() LFEXLiiuuuiupLp -> LFEXLiiuuuiupLp #() vFuffiiffiiffiip -> vFuffiiffiiffiip #() vFuddiiddiiddiip -> vFuddiiddiiddiip #() vFuiiiiiuiiiiilll -> vFuiiiiiuiiiiilll #() vFuuiiiiuuiiiiiii -> vFuuiiiiuuiiiiiii #() vFfffffffffffffff -> vFfffffffffffffff #() vFuuuuiiiiuuiiiiiii -> vFuuuuiiiiuuiiiiiii -#() vFppuiiiiipuiiiiiiii -> vFppuiiiiipuiiiiiiii #() uFippuuuuiiiiuuiiiiiiiipp -> uFippuuuuiiiiuuiiiiiiiipp #defined(ANDROID) vFEpppp -> vFEpppp #defined(HAVE_LD80BITS) DFD -> DFD @@ -898,6 +939,8 @@ wrappedldlinux: - pFp: - __tls_get_addr wrappedlibasound: +- iFpppp: + - snd_pcm_mmap_begin wrappedlibc: - vFv: - vFp: @@ -1061,10 +1104,12 @@ wrappedlibgl: - eglDebugMessageControlKHR - vFipp: - glProgramCallbackMESA -- vFppi: - - glXSwapIntervalEXT - vFppp: - eglSetBlobCacheFuncsANDROID +- vFXpi: + - glXSwapIntervalEXT +- vFuipp: + - glShaderSource wrappedlibglu: - vFpup: - gluNurbsCallback @@ -1173,6 +1218,11 @@ wrappedlibpthread: - pthread_rwlock_destroy - pthread_rwlock_unlock - pthread_rwlock_wrlock + - sem_close + - sem_destroy + - sem_post + - sem_trywait + - sem_wait - iFh: - pthread_detach - vFpi: @@ -1211,13 +1261,18 @@ wrappedlibpthread: - pthread_mutex_timedlock - pthread_once - pthread_rwlock_init + - sem_getvalue - iFhi: - pthread_kill@GLIBC_2.0 - vFppp: - _pthread_cleanup_push - _pthread_cleanup_push_defer +- iFpiu: + - sem_init - iFpup: - pthread_attr_setaffinity_np +- iFpLL: + - sem_timedwait - iFppL: - pthread_attr_setstack - iFppp: @@ -1227,12 +1282,37 @@ wrappedlibpthread: - iFhup: - pthread_getaffinity_np - pthread_setaffinity_np +- pFpOM: + - sem_open - iFppLL: - pthread_cond_timedwait - pthread_cond_timedwait@GLIBC_2.0 - iFhppp: - pthread_create wrappedlibrt: +wrappedlibx11: +- iFp: + - XDestroyImage + - XInitImage + - _XInitImageFuncPtrs +- pFp: + - XOpenDisplay +- iFXp: + - XNextEvent +- LFXii: + - XGetPixel +- pFpiiuu: + - XSubImage +- pFXLiiuuLi: + - XGetImage +- iFXLppiiiiuu: + - XPutImage +- pFXpuiipuuii: + - XCreateImage +- pFXLiiuuLipii: + - XGetSubImage +- LFXLiiuuuiupLp: + - XCreateWindow wrappedsdl1: - vFv: - SDL_Quit diff --git a/src/wrapped32/generated/wrappedlibasoundtypes32.h b/src/wrapped32/generated/wrappedlibasoundtypes32.h index 4dbbd14c..5a73ae01 100644 --- a/src/wrapped32/generated/wrappedlibasoundtypes32.h +++ b/src/wrapped32/generated/wrappedlibasoundtypes32.h @@ -11,7 +11,9 @@ #define ADDED_FUNCTIONS() #endif +typedef int32_t (*iFpppp_t)(void*, void*, void*, void*); -#define SUPER() ADDED_FUNCTIONS() +#define SUPER() ADDED_FUNCTIONS() \ + GO(snd_pcm_mmap_begin, iFpppp_t) #endif // __wrappedlibasoundTYPES32_H_ diff --git a/src/wrapped32/generated/wrappedlibgltypes32.h b/src/wrapped32/generated/wrappedlibgltypes32.h index d6aca5ed..4c614ddb 100644 --- a/src/wrapped32/generated/wrappedlibgltypes32.h +++ b/src/wrapped32/generated/wrappedlibgltypes32.h @@ -16,8 +16,9 @@ typedef void* (*pFp_t)(void*); typedef void (*vFpp_t)(void*, void*); typedef int32_t (*iFpp_t)(void*, void*); typedef void (*vFipp_t)(int32_t, void*, void*); -typedef void (*vFppi_t)(void*, void*, int32_t); typedef void (*vFppp_t)(void*, void*, void*); +typedef void (*vFXpi_t)(void*, void*, int32_t); +typedef void (*vFuipp_t)(uint32_t, int32_t, void*, void*); #define SUPER() ADDED_FUNCTIONS() \ GO(glXSwapIntervalMESA, iFi_t) \ @@ -30,7 +31,8 @@ typedef void (*vFppp_t)(void*, void*, void*); GO(glDebugMessageCallbackKHR, vFpp_t) \ GO(eglDebugMessageControlKHR, iFpp_t) \ GO(glProgramCallbackMESA, vFipp_t) \ - GO(glXSwapIntervalEXT, vFppi_t) \ - GO(eglSetBlobCacheFuncsANDROID, vFppp_t) + GO(eglSetBlobCacheFuncsANDROID, vFppp_t) \ + GO(glXSwapIntervalEXT, vFXpi_t) \ + GO(glShaderSource, vFuipp_t) #endif // __wrappedlibglTYPES32_H_ diff --git a/src/wrapped32/generated/wrappedlibpthreadtypes32.h b/src/wrapped32/generated/wrappedlibpthreadtypes32.h index 3b845b79..0ddcd826 100644 --- a/src/wrapped32/generated/wrappedlibpthreadtypes32.h +++ b/src/wrapped32/generated/wrappedlibpthreadtypes32.h @@ -21,10 +21,13 @@ typedef int32_t (*iFpL_t)(void*, uintptr_t); typedef int32_t (*iFpp_t)(void*, void*); typedef int32_t (*iFhi_t)(uintptr_t, int32_t); typedef void (*vFppp_t)(void*, void*, void*); +typedef int32_t (*iFpiu_t)(void*, int32_t, uint32_t); typedef int32_t (*iFpup_t)(void*, uint32_t, void*); +typedef int32_t (*iFpLL_t)(void*, uintptr_t, uintptr_t); typedef int32_t (*iFppL_t)(void*, void*, uintptr_t); typedef int32_t (*iFppp_t)(void*, void*, void*); typedef int32_t (*iFhup_t)(uintptr_t, uint32_t, void*); +typedef void* (*pFpOM_t)(void*, int32_t, ...); typedef int32_t (*iFppLL_t)(void*, void*, uintptr_t, uintptr_t); typedef int32_t (*iFhppp_t)(uintptr_t, void*, void*, void*); @@ -54,6 +57,11 @@ typedef int32_t (*iFhppp_t)(uintptr_t, void*, void*, void*); GO(pthread_rwlock_destroy, iFp_t) \ GO(pthread_rwlock_unlock, iFp_t) \ GO(pthread_rwlock_wrlock, iFp_t) \ + GO(sem_close, iFp_t) \ + GO(sem_destroy, iFp_t) \ + GO(sem_post, iFp_t) \ + GO(sem_trywait, iFp_t) \ + GO(sem_wait, iFp_t) \ GO(pthread_detach, iFh_t) \ GO(_pthread_cleanup_pop, vFpi_t) \ GO(_pthread_cleanup_pop_restore, vFpi_t) \ @@ -87,16 +95,20 @@ typedef int32_t (*iFhppp_t)(uintptr_t, void*, void*, void*); GO(pthread_mutex_timedlock, iFpp_t) \ GO(pthread_once, iFpp_t) \ GO(pthread_rwlock_init, iFpp_t) \ + GO(sem_getvalue, iFpp_t) \ GO(pthread_kill@GLIBC_2.0, iFhi_t) \ GO(_pthread_cleanup_push, vFppp_t) \ GO(_pthread_cleanup_push_defer, vFppp_t) \ + GO(sem_init, iFpiu_t) \ GO(pthread_attr_setaffinity_np, iFpup_t) \ + GO(sem_timedwait, iFpLL_t) \ GO(pthread_attr_setstack, iFppL_t) \ GO(__pthread_atfork, iFppp_t) \ GO(pthread_atfork, iFppp_t) \ GO(pthread_attr_getstack, iFppp_t) \ GO(pthread_getaffinity_np, iFhup_t) \ GO(pthread_setaffinity_np, iFhup_t) \ + GO(sem_open, pFpOM_t) \ GO(pthread_cond_timedwait, iFppLL_t) \ GO(pthread_cond_timedwait@GLIBC_2.0, iFppLL_t) \ GO(pthread_create, iFhppp_t) diff --git a/src/wrapped32/generated/wrappedlibx11defs32.h b/src/wrapped32/generated/wrappedlibx11defs32.h new file mode 100644 index 00000000..d5eb314a --- /dev/null +++ b/src/wrapped32/generated/wrappedlibx11defs32.h @@ -0,0 +1,8 @@ +/****************************************************************** + * File automatically generated by rebuild_wrappers_32.py (v0.0.1.1) * + ******************************************************************/ +#ifndef __wrappedlibx11DEFS32_H_ +#define __wrappedlibx11DEFS32_H_ + + +#endif // __wrappedlibx11DEFS32_H_ diff --git a/src/wrapped32/generated/wrappedlibx11types32.h b/src/wrapped32/generated/wrappedlibx11types32.h new file mode 100644 index 00000000..1312148b --- /dev/null +++ b/src/wrapped32/generated/wrappedlibx11types32.h @@ -0,0 +1,39 @@ +/****************************************************************** + * File automatically generated by rebuild_wrappers_32.py (v0.0.1.1) * + ******************************************************************/ +#ifndef __wrappedlibx11TYPES32_H_ +#define __wrappedlibx11TYPES32_H_ + +#ifndef LIBNAME +#error You should only #include this file inside a wrapped*.c file +#endif +#ifndef ADDED_FUNCTIONS +#define ADDED_FUNCTIONS() +#endif + +typedef int32_t (*iFp_t)(void*); +typedef void* (*pFp_t)(void*); +typedef int32_t (*iFXp_t)(void*, void*); +typedef uintptr_t (*LFXii_t)(void*, int32_t, int32_t); +typedef void* (*pFpiiuu_t)(void*, int32_t, int32_t, uint32_t, uint32_t); +typedef void* (*pFXLiiuuLi_t)(void*, uintptr_t, int32_t, int32_t, uint32_t, uint32_t, uintptr_t, int32_t); +typedef int32_t (*iFXLppiiiiuu_t)(void*, uintptr_t, void*, void*, int32_t, int32_t, int32_t, int32_t, uint32_t, uint32_t); +typedef void* (*pFXpuiipuuii_t)(void*, void*, uint32_t, int32_t, int32_t, void*, uint32_t, uint32_t, int32_t, int32_t); +typedef void* (*pFXLiiuuLipii_t)(void*, uintptr_t, int32_t, int32_t, uint32_t, uint32_t, uintptr_t, int32_t, void*, int32_t, int32_t); +typedef uintptr_t (*LFXLiiuuuiupLp_t)(void*, uintptr_t, int32_t, int32_t, uint32_t, uint32_t, uint32_t, int32_t, uint32_t, void*, uintptr_t, void*); + +#define SUPER() ADDED_FUNCTIONS() \ + GO(XDestroyImage, iFp_t) \ + GO(XInitImage, iFp_t) \ + GO(_XInitImageFuncPtrs, iFp_t) \ + GO(XOpenDisplay, pFp_t) \ + GO(XNextEvent, iFXp_t) \ + GO(XGetPixel, LFXii_t) \ + GO(XSubImage, pFpiiuu_t) \ + GO(XGetImage, pFXLiiuuLi_t) \ + GO(XPutImage, iFXLppiiiiuu_t) \ + GO(XCreateImage, pFXpuiipuuii_t) \ + GO(XGetSubImage, pFXLiiuuLipii_t) \ + GO(XCreateWindow, LFXLiiuuuiupLp_t) + +#endif // __wrappedlibx11TYPES32_H_ diff --git a/src/wrapped32/generated/wrappedlibx11undefs32.h b/src/wrapped32/generated/wrappedlibx11undefs32.h new file mode 100644 index 00000000..f5ba8983 --- /dev/null +++ b/src/wrapped32/generated/wrappedlibx11undefs32.h @@ -0,0 +1,8 @@ +/****************************************************************** + * File automatically generated by rebuild_wrappers_32.py (v0.0.1.1) * + ******************************************************************/ +#ifndef __wrappedlibx11UNDEFS32_H_ +#define __wrappedlibx11UNDEFS32_H_ + + +#endif // __wrappedlibx11UNDEFS32_H_ diff --git a/src/wrapped32/generated/wrapper32.c b/src/wrapped32/generated/wrapper32.c index 62effb9f..d42e8b51 100644 --- a/src/wrapped32/generated/wrapper32.c +++ b/src/wrapped32/generated/wrapper32.c @@ -85,6 +85,8 @@ void VulkanTox86(void* src, void* save); int of_convert32(int); +void* getDisplay(void*); + typedef void (*vFv_t)(void); typedef void (*vFc_t)(int8_t); typedef void (*vFw_t)(int16_t); @@ -99,6 +101,7 @@ typedef void (*vFl_t)(intptr_t); typedef void (*vFp_t)(void*); typedef void (*vFA_t)(void*); typedef void (*vFS_t)(void*); +typedef void (*vFX_t)(void*); typedef int32_t (*iFv_t)(void); typedef int32_t (*iFi_t)(int32_t); typedef int32_t (*iFI_t)(int64_t); @@ -109,6 +112,7 @@ typedef int32_t (*iFL_t)(uintptr_t); typedef int32_t (*iFp_t)(void*); typedef int32_t (*iFh_t)(uintptr_t); typedef int32_t (*iFS_t)(void*); +typedef int32_t (*iFX_t)(void*); typedef int64_t (*IFf_t)(float); typedef int64_t (*IFd_t)(double); typedef int64_t (*IFp_t)(void*); @@ -143,11 +147,13 @@ typedef void* (*pFi_t)(int32_t); typedef void* (*pFu_t)(uint32_t); typedef void* (*pFL_t)(uintptr_t); typedef void* (*pFp_t)(void*); +typedef void* (*pFX_t)(void*); typedef uintptr_t (*hFv_t)(void); typedef void* (*aFa_t)(void*); typedef char* (*tFi_t)(int32_t); typedef char* (*tFu_t)(uint32_t); typedef char* (*tFp_t)(void*); +typedef int32_t (*iFBp__t)(struct_p_t*); typedef uintptr_t (*LFrL__t)(struct_L_t*); typedef void* (*pFrL__t)(struct_L_t*); typedef uintptr_t (*LFriiiiiiiiilt__t)(struct_iiiiiiiiilt_t*); @@ -185,9 +191,11 @@ typedef void (*vFlu_t)(intptr_t, uint32_t); typedef void (*vFlp_t)(intptr_t, void*); typedef void (*vFpC_t)(void*, uint8_t); typedef void (*vFpu_t)(void*, uint32_t); +typedef void (*vFpl_t)(void*, intptr_t); typedef void (*vFpL_t)(void*, uintptr_t); typedef void (*vFpp_t)(void*, void*); typedef void (*vFSp_t)(void*, void*); +typedef void (*vFXp_t)(void*, void*); typedef int16_t (*wFpi_t)(void*, int32_t); typedef int32_t (*iFEv_t)(x64emu_t*); typedef int32_t (*iFEi_t)(x64emu_t*, int32_t); @@ -207,6 +215,7 @@ typedef int32_t (*iFup_t)(uint32_t, void*); typedef int32_t (*iFli_t)(intptr_t, int32_t); typedef int32_t (*iFpi_t)(void*, int32_t); typedef int32_t (*iFpu_t)(void*, uint32_t); +typedef int32_t (*iFpl_t)(void*, intptr_t); typedef int32_t (*iFpL_t)(void*, uintptr_t); typedef int32_t (*iFpp_t)(void*, void*); typedef int32_t (*iFpV_t)(void*, void*); @@ -214,6 +223,9 @@ typedef int32_t (*iFpS_t)(void*, void*); typedef int32_t (*iFhi_t)(uintptr_t, int32_t); typedef int32_t (*iFhp_t)(uintptr_t, void*); typedef int32_t (*iFhh_t)(uintptr_t, uintptr_t); +typedef int32_t (*iFXi_t)(void*, int32_t); +typedef int32_t (*iFXL_t)(void*, uintptr_t); +typedef int32_t (*iFXp_t)(void*, void*); typedef int64_t (*IFII_t)(int64_t, int64_t); typedef uint8_t (*CFip_t)(int32_t, void*); typedef uint8_t (*CFCi_t)(uint8_t, int32_t); @@ -248,6 +260,7 @@ typedef intptr_t (*lFui_t)(uint32_t, int32_t); typedef intptr_t (*lFpl_t)(void*, intptr_t); typedef uintptr_t (*LFpL_t)(void*, uintptr_t); typedef uintptr_t (*LFpp_t)(void*, void*); +typedef uintptr_t (*LFXi_t)(void*, int32_t); typedef void* (*pFEv_t)(x64emu_t*); typedef void* (*pFEu_t)(x64emu_t*, uint32_t); typedef void* (*pFEp_t)(x64emu_t*, void*); @@ -260,6 +273,7 @@ typedef void* (*pFpi_t)(void*, int32_t); typedef void* (*pFpu_t)(void*, uint32_t); typedef void* (*pFpL_t)(void*, uintptr_t); typedef void* (*pFpp_t)(void*, void*); +typedef void* (*pFXi_t)(void*, int32_t); typedef void* (*SFip_t)(int32_t, void*); typedef void* (*SFpp_t)(void*, void*); typedef char* (*tFip_t)(int32_t, void*); @@ -342,6 +356,7 @@ typedef void (*vFplp_t)(void*, intptr_t, void*); typedef void (*vFppi_t)(void*, void*, int32_t); typedef void (*vFppu_t)(void*, void*, uint32_t); typedef void (*vFppp_t)(void*, void*, void*); +typedef void (*vFXpi_t)(void*, void*, int32_t); typedef int32_t (*iFEip_t)(x64emu_t*, int32_t, void*); typedef int32_t (*iFEpi_t)(x64emu_t*, void*, int32_t); typedef int32_t (*iFEpL_t)(x64emu_t*, void*, uintptr_t); @@ -349,6 +364,7 @@ typedef int32_t (*iFEpp_t)(x64emu_t*, void*, void*); typedef int32_t (*iFEpV_t)(x64emu_t*, void*, void*); typedef int32_t (*iFEhi_t)(x64emu_t*, uintptr_t, int32_t); typedef int32_t (*iFESp_t)(x64emu_t*, void*, void*); +typedef int32_t (*iFEXp_t)(x64emu_t*, void*, void*); typedef int32_t (*iFiii_t)(int32_t, int32_t, int32_t); typedef int32_t (*iFiiI_t)(int32_t, int32_t, int64_t); typedef int32_t (*iFiiu_t)(int32_t, int32_t, uint32_t); @@ -367,12 +383,12 @@ typedef int32_t (*iFuuu_t)(uint32_t, uint32_t, uint32_t); typedef int32_t (*iFuup_t)(uint32_t, uint32_t, void*); typedef int32_t (*iFuLp_t)(uint32_t, uintptr_t, void*); typedef int32_t (*iFfff_t)(float, float, float); +typedef int32_t (*iFpii_t)(void*, int32_t, int32_t); typedef int32_t (*iFpiu_t)(void*, int32_t, uint32_t); typedef int32_t (*iFpip_t)(void*, int32_t, void*); typedef int32_t (*iFpuC_t)(void*, uint32_t, uint8_t); typedef int32_t (*iFpuu_t)(void*, uint32_t, uint32_t); typedef int32_t (*iFpuU_t)(void*, uint32_t, uint64_t); -typedef int32_t (*iFpup_t)(void*, uint32_t, void*); typedef int32_t (*iFpLi_t)(void*, uintptr_t, int32_t); typedef int32_t (*iFppi_t)(void*, void*, int32_t); typedef int32_t (*iFppu_t)(void*, void*, uint32_t); @@ -385,6 +401,12 @@ typedef int32_t (*iFhpL_t)(uintptr_t, void*, uintptr_t); typedef int32_t (*iFhpp_t)(uintptr_t, void*, void*); typedef int32_t (*iFSIi_t)(void*, int64_t, int32_t); typedef int32_t (*iFSli_t)(void*, intptr_t, int32_t); +typedef int32_t (*iFXip_t)(void*, int32_t, void*); +typedef int32_t (*iFXuu_t)(void*, uint32_t, uint32_t); +typedef int32_t (*iFXLL_t)(void*, uintptr_t, uintptr_t); +typedef int32_t (*iFXLp_t)(void*, uintptr_t, void*); +typedef int32_t (*iFXpu_t)(void*, void*, uint32_t); +typedef int32_t (*iFXpp_t)(void*, void*, void*); typedef int64_t (*IFiIi_t)(int32_t, int64_t, int32_t); typedef uint8_t (*CFipp_t)(int32_t, void*, void*); typedef uint8_t (*CFuUu_t)(uint32_t, uint64_t, uint32_t); @@ -404,9 +426,12 @@ typedef double (*dFddd_t)(double, double, double); typedef double (*dFddp_t)(double, double, void*); typedef intptr_t (*lFipL_t)(int32_t, void*, uintptr_t); typedef intptr_t (*lFlpi_t)(intptr_t, void*, int32_t); +typedef intptr_t (*lFpLL_t)(void*, uintptr_t, uintptr_t); typedef intptr_t (*lFppL_t)(void*, void*, uintptr_t); +typedef uintptr_t (*LFpii_t)(void*, int32_t, int32_t); typedef uintptr_t (*LFpip_t)(void*, int32_t, void*); typedef uintptr_t (*LFppL_t)(void*, void*, uintptr_t); +typedef uintptr_t (*LFXCi_t)(void*, uint8_t, int32_t); typedef void* (*pFEip_t)(x64emu_t*, int32_t, void*); typedef void* (*pFEpi_t)(x64emu_t*, void*, int32_t); typedef void* (*pFEpp_t)(x64emu_t*, void*, void*); @@ -414,7 +439,6 @@ typedef void* (*pFipi_t)(int32_t, void*, int32_t); typedef void* (*pFulu_t)(uint32_t, intptr_t, uint32_t); typedef void* (*pFpii_t)(void*, int32_t, int32_t); typedef void* (*pFpiL_t)(void*, int32_t, uintptr_t); -typedef void* (*pFpip_t)(void*, int32_t, void*); typedef void* (*pFpiS_t)(void*, int32_t, void*); typedef void* (*pFpuL_t)(void*, uint32_t, uintptr_t); typedef void* (*pFpup_t)(void*, uint32_t, void*); @@ -422,6 +446,7 @@ typedef void* (*pFppu_t)(void*, void*, uint32_t); typedef void* (*pFppL_t)(void*, void*, uintptr_t); typedef void* (*pFppp_t)(void*, void*, void*); typedef void* (*pFpOM_t)(void*, int32_t, ...); +typedef void* (*pFXip_t)(void*, int32_t, void*); typedef void* (*aFipa_t)(int32_t, void*, void*); typedef void* (*SFEpp_t)(x64emu_t*, void*, void*); typedef void* (*SFppS_t)(void*, void*, void*); @@ -430,12 +455,14 @@ typedef int32_t (*iFppbL__t)(void*, void*, struct_L_t*); typedef int32_t (*iFpBp_i_t)(void*, struct_p_t*, int32_t); typedef int32_t (*iFpbL_p_t)(void*, struct_L_t*, void*); typedef int32_t (*iFBp_LL_t)(struct_p_t*, uintptr_t, uintptr_t); +typedef int32_t (*iFBp_pi_t)(struct_p_t*, void*, int32_t); typedef int64_t (*IFpBp_i_t)(void*, struct_p_t*, int32_t); typedef uint64_t (*UFpBp_i_t)(void*, struct_p_t*, int32_t); typedef double (*dFpBp_i_t)(void*, struct_p_t*, int32_t); typedef double (*dFpBp_a_t)(void*, struct_p_t*, void*); typedef intptr_t (*lFpBp_i_t)(void*, struct_p_t*, int32_t); typedef uintptr_t (*LFpBp_i_t)(void*, struct_p_t*, int32_t); +typedef int32_t (*iFXLbhWcc__t)(void*, uintptr_t, struct_hWcc_t*); typedef void* (*pFppriiiiiiiiilt__t)(void*, void*, struct_iiiiiiiiilt_t*); typedef void (*vFEipp_t)(x64emu_t*, int32_t, void*, void*); typedef void (*vFEipV_t)(x64emu_t*, int32_t, void*, void*); @@ -513,13 +540,14 @@ typedef void (*vFuppu_t)(uint32_t, void*, void*, uint32_t); typedef void (*vFffff_t)(float, float, float, float); typedef void (*vFdddd_t)(double, double, double, double); typedef void (*vFllii_t)(intptr_t, intptr_t, int32_t, int32_t); -typedef void (*vFpiii_t)(void*, int32_t, int32_t, int32_t); typedef void (*vFpipp_t)(void*, int32_t, void*, void*); typedef void (*vFpdii_t)(void*, double, int32_t, int32_t); typedef void (*vFpddd_t)(void*, double, double, double); typedef void (*vFplpp_t)(void*, intptr_t, void*, void*); typedef void (*vFppip_t)(void*, void*, int32_t, void*); typedef void (*vFpppp_t)(void*, void*, void*, void*); +typedef void (*vFXiiL_t)(void*, int32_t, int32_t, uintptr_t); +typedef void (*vFXpip_t)(void*, void*, int32_t, void*); typedef int32_t (*iFEiip_t)(x64emu_t*, int32_t, int32_t, void*); typedef int32_t (*iFEiiN_t)(x64emu_t*, int32_t, int32_t, ...); typedef int32_t (*iFEipp_t)(x64emu_t*, int32_t, void*, void*); @@ -544,9 +572,8 @@ typedef int32_t (*iFipup_t)(int32_t, void*, uint32_t, void*); typedef int32_t (*iFippi_t)(int32_t, void*, void*, int32_t); typedef int32_t (*iFuiup_t)(uint32_t, int32_t, uint32_t, void*); typedef int32_t (*iFuupi_t)(uint32_t, uint32_t, void*, int32_t); -typedef int32_t (*iFpiip_t)(void*, int32_t, int32_t, void*); +typedef int32_t (*iFpiiL_t)(void*, int32_t, int32_t, uintptr_t); typedef int32_t (*iFpipp_t)(void*, int32_t, void*, void*); -typedef int32_t (*iFpuup_t)(void*, uint32_t, uint32_t, void*); typedef int32_t (*iFpupp_t)(void*, uint32_t, void*, void*); typedef int32_t (*iFppii_t)(void*, void*, int32_t, int32_t); typedef int32_t (*iFppiU_t)(void*, void*, int32_t, uint64_t); @@ -556,34 +583,41 @@ typedef int32_t (*iFppLi_t)(void*, void*, uintptr_t, int32_t); typedef int32_t (*iFpppi_t)(void*, void*, void*, int32_t); typedef int32_t (*iFpppp_t)(void*, void*, void*, void*); typedef int32_t (*iFhpiL_t)(uintptr_t, void*, int32_t, uintptr_t); +typedef int32_t (*iFXipp_t)(void*, int32_t, void*, void*); +typedef int32_t (*iFXppp_t)(void*, void*, void*, void*); typedef uint8_t (*CFuuff_t)(uint32_t, uint32_t, float, float); typedef uint32_t (*uFuuuu_t)(uint32_t, uint32_t, uint32_t, uint32_t); typedef intptr_t (*lFEipi_t)(x64emu_t*, int32_t, void*, int32_t); typedef intptr_t (*lFiipL_t)(int32_t, int32_t, void*, uintptr_t); typedef intptr_t (*lFipLi_t)(int32_t, void*, uintptr_t, int32_t); typedef intptr_t (*lFpuip_t)(void*, uint32_t, int32_t, void*); +typedef uintptr_t (*LFEXii_t)(x64emu_t*, void*, int32_t, int32_t); typedef uintptr_t (*LFpLLS_t)(void*, uintptr_t, uintptr_t, void*); typedef uintptr_t (*LFppLp_t)(void*, void*, uintptr_t, void*); typedef uintptr_t (*LFppLa_t)(void*, void*, uintptr_t, void*); +typedef uintptr_t (*LFXLpi_t)(void*, uintptr_t, void*, int32_t); typedef void* (*pFEppi_t)(x64emu_t*, void*, void*, int32_t); typedef void* (*pFEppp_t)(x64emu_t*, void*, void*, void*); typedef void* (*pFiiiu_t)(int32_t, int32_t, int32_t, uint32_t); typedef void* (*pFillu_t)(int32_t, intptr_t, intptr_t, uint32_t); typedef void* (*pFullu_t)(uint32_t, intptr_t, intptr_t, uint32_t); typedef void* (*pFlfff_t)(intptr_t, float, float, float); -typedef void* (*pFpiii_t)(void*, int32_t, int32_t, int32_t); typedef void* (*pFpiLL_t)(void*, int32_t, uintptr_t, uintptr_t); -typedef void* (*pFpipp_t)(void*, int32_t, void*, void*); typedef void* (*pFppLL_t)(void*, void*, uintptr_t, uintptr_t); -typedef void* (*pFpppi_t)(void*, void*, void*, int32_t); typedef void* (*pFpppp_t)(void*, void*, void*, void*); +typedef void* (*pFXiii_t)(void*, int32_t, int32_t, int32_t); +typedef void* (*pFXLLp_t)(void*, uintptr_t, uintptr_t, void*); +typedef void* (*pFXppi_t)(void*, void*, void*, int32_t); +typedef int32_t (*iFppbp_p_t)(void*, void*, struct_p_t*, void*); typedef int32_t (*iFBp_pui_t)(struct_p_t*, void*, uint32_t, int32_t); typedef int64_t (*IFpBp_ii_t)(void*, struct_p_t*, int32_t, int32_t); typedef uint64_t (*UFpBp_ii_t)(void*, struct_p_t*, int32_t, int32_t); typedef intptr_t (*lFiibp_L_t)(int32_t, int32_t, struct_p_t*, uintptr_t); typedef uintptr_t (*LFpbp_Lp_t)(void*, struct_p_t*, uintptr_t, void*); typedef int32_t (*iFEpprLL__t)(x64emu_t*, void*, void*, struct_LL_t*); +typedef int32_t (*iFXLpBhWcc__t)(void*, uintptr_t, void*, struct_hWcc_t*); typedef uintptr_t (*LFpLpriiiiiiiiilt__t)(void*, uintptr_t, void*, struct_iiiiiiiiilt_t*); +typedef void (*vFEuipp_t)(x64emu_t*, uint32_t, int32_t, void*, void*); typedef void (*vFEpLLp_t)(x64emu_t*, void*, uintptr_t, uintptr_t, void*); typedef void (*vFiiiii_t)(int32_t, int32_t, int32_t, int32_t, int32_t); typedef void (*vFiiiiu_t)(int32_t, int32_t, int32_t, int32_t, uint32_t); @@ -688,23 +722,23 @@ typedef int32_t (*iFiiipu_t)(int32_t, int32_t, int32_t, void*, uint32_t); typedef int32_t (*iFiiipp_t)(int32_t, int32_t, int32_t, void*, void*); typedef int32_t (*iFiLLLL_t)(int32_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t); typedef int32_t (*iFipLLi_t)(int32_t, void*, uintptr_t, uintptr_t, int32_t); -typedef int32_t (*iFpiiip_t)(void*, int32_t, int32_t, int32_t, void*); -typedef int32_t (*iFpippp_t)(void*, int32_t, void*, void*, void*); -typedef int32_t (*iFppipi_t)(void*, void*, int32_t, void*, int32_t); +typedef int32_t (*iFpLuLi_t)(void*, uintptr_t, uint32_t, uintptr_t, int32_t); typedef int32_t (*iFpppip_t)(void*, void*, void*, int32_t, void*); typedef int32_t (*iFpppup_t)(void*, void*, void*, uint32_t, void*); typedef int32_t (*iFppppp_t)(void*, void*, void*, void*, void*); -typedef int64_t (*IFppIII_t)(void*, void*, int64_t, int64_t, int64_t); +typedef int32_t (*iFXiiip_t)(void*, int32_t, int32_t, int32_t, void*); +typedef int32_t (*iFXpppp_t)(void*, void*, void*, void*, void*); +typedef int64_t (*IFXpIII_t)(void*, void*, int64_t, int64_t, int64_t); typedef uint32_t (*uFpLLLS_t)(void*, uintptr_t, uintptr_t, uintptr_t, void*); typedef uint64_t (*UFuiCiu_t)(uint32_t, int32_t, uint8_t, int32_t, uint32_t); typedef intptr_t (*lFpuipC_t)(void*, uint32_t, int32_t, void*, uint8_t); typedef uintptr_t (*LFpLppa_t)(void*, uintptr_t, void*, void*, void*); +typedef uintptr_t (*LFXLuuu_t)(void*, uintptr_t, uint32_t, uint32_t, uint32_t); typedef void* (*pFuiupp_t)(uint32_t, int32_t, uint32_t, void*, void*); +typedef void* (*pFpiiuu_t)(void*, int32_t, int32_t, uint32_t, uint32_t); typedef void* (*pFpippp_t)(void*, int32_t, void*, void*, void*); -typedef void* (*pFppipi_t)(void*, void*, int32_t, void*, int32_t); typedef void* (*pFppuup_t)(void*, void*, uint32_t, uint32_t, void*); typedef void* (*pFppupp_t)(void*, void*, uint32_t, void*, void*); -typedef void* (*pFpppip_t)(void*, void*, void*, int32_t, void*); typedef int32_t (*iFEBh_ppp_t)(x64emu_t*, struct_h_t*, void*, void*, void*); typedef uintptr_t (*LFpbp_LLp_t)(void*, struct_p_t*, uintptr_t, uintptr_t, void*); typedef uintptr_t (*LFpBp_LLp_t)(void*, struct_p_t*, uintptr_t, uintptr_t, void*); @@ -773,18 +807,17 @@ typedef void (*vFffffff_t)(float, float, float, float, float, float); typedef void (*vFdddddd_t)(double, double, double, double, double, double); typedef void (*vFpipipV_t)(void*, int32_t, void*, int32_t, void*, void*); typedef void (*vFpdddii_t)(void*, double, double, double, int32_t, int32_t); -typedef void (*vFppiiii_t)(void*, void*, int32_t, int32_t, int32_t, int32_t); typedef void (*vFppupii_t)(void*, void*, uint32_t, void*, int32_t, int32_t); typedef int32_t (*iFuiiuup_t)(uint32_t, int32_t, int32_t, uint32_t, uint32_t, void*); -typedef int32_t (*iFpiiipp_t)(void*, int32_t, int32_t, int32_t, void*, void*); typedef int32_t (*iFpiippp_t)(void*, int32_t, int32_t, void*, void*, void*); typedef int32_t (*iFppiiii_t)(void*, void*, int32_t, int32_t, int32_t, int32_t); -typedef int32_t (*iFppIppp_t)(void*, void*, int64_t, void*, void*, void*); +typedef int32_t (*iFXLiiiL_t)(void*, uintptr_t, int32_t, int32_t, int32_t, uintptr_t); +typedef int32_t (*iFXpIppp_t)(void*, void*, int64_t, void*, void*, void*); typedef uint32_t (*uFupuufp_t)(uint32_t, void*, uint32_t, uint32_t, float, void*); typedef intptr_t (*lFipLipu_t)(int32_t, void*, uintptr_t, int32_t, void*, uint32_t); typedef intptr_t (*lFipLipp_t)(int32_t, void*, uintptr_t, int32_t, void*, void*); +typedef void* (*pFEpiiuu_t)(x64emu_t*, void*, int32_t, int32_t, uint32_t, uint32_t); typedef void* (*pFEpLLiN_t)(x64emu_t*, void*, uintptr_t, uintptr_t, int32_t, ...); -typedef void* (*pFpippip_t)(void*, int32_t, void*, void*, int32_t, void*); typedef void (*vFiiiiiip_t)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, void*); typedef void (*vFiiiiuup_t)(int32_t, int32_t, int32_t, int32_t, uint32_t, uint32_t, void*); typedef void (*vFiiuilil_t)(int32_t, int32_t, uint32_t, int32_t, intptr_t, int32_t, intptr_t); @@ -839,7 +872,9 @@ typedef void (*vFpddiidd_t)(void*, double, double, int32_t, int32_t, double, dou typedef int32_t (*iFEpLiipV_t)(x64emu_t*, void*, uintptr_t, int32_t, int32_t, void*, void*); typedef int32_t (*iFuiiiuup_t)(uint32_t, int32_t, int32_t, int32_t, uint32_t, uint32_t, void*); typedef int32_t (*iFpupLpLi_t)(void*, uint32_t, void*, uintptr_t, void*, uintptr_t, int32_t); +typedef int32_t (*iFXiuLiii_t)(void*, int32_t, uint32_t, uintptr_t, int32_t, int32_t, int32_t); typedef uint32_t (*uFuippppp_t)(uint32_t, int32_t, void*, void*, void*, void*, void*); +typedef uintptr_t (*LFXLLppuu_t)(void*, uintptr_t, uintptr_t, void*, void*, uint32_t, uint32_t); typedef void* (*pFEpLiiii_t)(x64emu_t*, void*, uintptr_t, int32_t, int32_t, int32_t, int32_t); typedef void* (*pFEpLiiiI_t)(x64emu_t*, void*, uintptr_t, int32_t, int32_t, int32_t, int64_t); typedef void (*vFiiiiuuip_t)(int32_t, int32_t, int32_t, int32_t, uint32_t, uint32_t, int32_t, void*); @@ -871,11 +906,12 @@ typedef void (*vFuuufffff_t)(uint32_t, uint32_t, uint32_t, float, float, float, typedef void (*vFffffffff_t)(float, float, float, float, float, float, float, float); typedef int32_t (*iFEpippppp_t)(x64emu_t*, void*, int32_t, void*, void*, void*, void*, void*); typedef int32_t (*iFuiiiiuup_t)(uint32_t, int32_t, int32_t, int32_t, int32_t, uint32_t, uint32_t, void*); -typedef int32_t (*iFppIIIppp_t)(void*, void*, int64_t, int64_t, int64_t, void*, void*, void*); +typedef int32_t (*iFXpIIIppp_t)(void*, void*, int64_t, int64_t, int64_t, void*, void*, void*); typedef uint8_t (*CFuiifpppp_t)(uint32_t, int32_t, int32_t, float, void*, void*, void*, void*); typedef uint32_t (*uFuipppppp_t)(uint32_t, int32_t, void*, void*, void*, void*, void*, void*); typedef uint32_t (*uFuupuuiuf_t)(uint32_t, uint32_t, void*, uint32_t, uint32_t, int32_t, uint32_t, float); typedef uint32_t (*uFulpppppp_t)(uint32_t, intptr_t, void*, void*, void*, void*, void*, void*); +typedef uintptr_t (*LFXLpuuLLu_t)(void*, uintptr_t, void*, uint32_t, uint32_t, uintptr_t, uintptr_t, uint32_t); typedef void (*vFiiiiiiiii_t)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t); typedef void (*vFiiiiiiill_t)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, intptr_t, intptr_t); typedef void (*vFiiiiillli_t)(int32_t, int32_t, int32_t, int32_t, int32_t, intptr_t, intptr_t, intptr_t, int32_t); @@ -903,7 +939,9 @@ typedef void (*vFddddddddd_t)(double, double, double, double, double, double, do typedef int32_t (*iFuiiuuiiip_t)(uint32_t, int32_t, int32_t, uint32_t, uint32_t, int32_t, int32_t, int32_t, void*); typedef int32_t (*iFuiiupiiup_t)(uint32_t, int32_t, int32_t, uint32_t, void*, int32_t, int32_t, uint32_t, void*); typedef int32_t (*iFdddpppppp_t)(double, double, double, void*, void*, void*, void*, void*, void*); +typedef int32_t (*iFXLiuiiLLL_t)(void*, uintptr_t, int32_t, uint32_t, int32_t, int32_t, uintptr_t, uintptr_t, uintptr_t); typedef uint32_t (*uFuulpiuiuf_t)(uint32_t, uint32_t, intptr_t, void*, int32_t, uint32_t, int32_t, uint32_t, float); +typedef void* (*pFEXLiiuuLi_t)(x64emu_t*, void*, uintptr_t, int32_t, int32_t, uint32_t, uint32_t, uintptr_t, int32_t); typedef void (*vFiiiiiiiiii_t)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t); typedef void (*vFiiiiiiiiui_t)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, uint32_t, int32_t); typedef void (*vFiiiiiiiiuu_t)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, uint32_t, uint32_t); @@ -923,6 +961,8 @@ typedef void (*vFuffiiffiip_t)(uint32_t, float, float, int32_t, int32_t, float, typedef void (*vFuddiiddiip_t)(uint32_t, double, double, int32_t, int32_t, double, double, int32_t, int32_t, void*); typedef void (*vFffffffffff_t)(float, float, float, float, float, float, float, float, float, float); typedef int32_t (*iFuiiiuuiiip_t)(uint32_t, int32_t, int32_t, int32_t, uint32_t, uint32_t, int32_t, int32_t, int32_t, void*); +typedef int32_t (*iFXuuLiuiiLL_t)(void*, uint32_t, uint32_t, uintptr_t, int32_t, uint32_t, int32_t, int32_t, uintptr_t, uintptr_t); +typedef void* (*pFXpuiipuuii_t)(void*, void*, uint32_t, int32_t, int32_t, void*, uint32_t, uint32_t, int32_t, int32_t); typedef void (*vFiiiiillliip_t)(int32_t, int32_t, int32_t, int32_t, int32_t, intptr_t, intptr_t, intptr_t, int32_t, int32_t, void*); typedef void (*vFiiiiilllilp_t)(int32_t, int32_t, int32_t, int32_t, int32_t, intptr_t, intptr_t, intptr_t, int32_t, intptr_t, void*); typedef void (*vFuiiiiiiiuip_t)(uint32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, uint32_t, int32_t, void*); @@ -938,7 +978,9 @@ typedef void (*vFuUuuuuuuuuu_t)(uint32_t, uint64_t, uint32_t, uint32_t, uint32_t typedef void (*vFuffffffffff_t)(uint32_t, float, float, float, float, float, float, float, float, float, float); typedef void (*vFUufffffffff_t)(uint64_t, uint32_t, float, float, float, float, float, float, float, float, float); typedef void (*vFpipipiipiiu_t)(void*, int32_t, void*, int32_t, void*, int32_t, int32_t, void*, int32_t, int32_t, uint32_t); +typedef int32_t (*iFEXLppiiiiuu_t)(x64emu_t*, void*, uintptr_t, void*, void*, int32_t, int32_t, int32_t, int32_t, uint32_t, uint32_t); typedef int32_t (*iFuiiiiuuiiip_t)(uint32_t, int32_t, int32_t, int32_t, int32_t, uint32_t, uint32_t, int32_t, int32_t, int32_t, void*); +typedef void* (*pFEXpuiipuuii_t)(x64emu_t*, void*, void*, uint32_t, int32_t, int32_t, void*, uint32_t, uint32_t, int32_t, int32_t); typedef void (*vFuiiiiiiiiuUC_t)(uint32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, uint32_t, uint64_t, uint8_t); typedef void (*vFuiiiiiiiuuip_t)(uint32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, uint32_t, uint32_t, int32_t, void*); typedef void (*vFuuiiiiiiiiuu_t)(uint32_t, uint32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, uint32_t, uint32_t); @@ -946,19 +988,20 @@ typedef void (*vFuuiiiiiiiuip_t)(uint32_t, uint32_t, int32_t, int32_t, int32_t, typedef void (*vFuuiiiiiiiuup_t)(uint32_t, uint32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, uint32_t, uint32_t, void*); typedef void (*vFuuuuuuuuuuuu_t)(uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t); typedef void (*vFffffffffffff_t)(float, float, float, float, float, float, float, float, float, float, float, float); +typedef void* (*pFEXLiiuuLipii_t)(x64emu_t*, void*, uintptr_t, int32_t, int32_t, uint32_t, uint32_t, uintptr_t, int32_t, void*, int32_t, int32_t); typedef void (*vFuiiiiiiiiiuup_t)(uint32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, uint32_t, uint32_t, void*); typedef void (*vFuuuuuuuuuuuuu_t)(uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t); typedef void (*vFuUuuuuuuuuuuu_t)(uint32_t, uint64_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t); typedef void (*vFuffffffffffff_t)(uint32_t, float, float, float, float, float, float, float, float, float, float, float, float); typedef int32_t (*iFddddpppddpppp_t)(double, double, double, double, void*, void*, void*, double, double, void*, void*, void*, void*); typedef uint32_t (*uFippuuuulllipp_t)(int32_t, void*, void*, uint32_t, uint32_t, uint32_t, uint32_t, intptr_t, intptr_t, intptr_t, int32_t, void*, void*); +typedef uintptr_t (*LFEXLiiuuuiupLp_t)(x64emu_t*, void*, uintptr_t, int32_t, int32_t, uint32_t, uint32_t, uint32_t, int32_t, uint32_t, void*, uintptr_t, void*); typedef void (*vFuffiiffiiffiip_t)(uint32_t, float, float, int32_t, int32_t, float, float, int32_t, int32_t, float, float, int32_t, int32_t, void*); typedef void (*vFuddiiddiiddiip_t)(uint32_t, double, double, int32_t, int32_t, double, double, int32_t, int32_t, double, double, int32_t, int32_t, void*); typedef void (*vFuiiiiiuiiiiilll_t)(uint32_t, int32_t, int32_t, int32_t, int32_t, int32_t, uint32_t, int32_t, int32_t, int32_t, int32_t, int32_t, intptr_t, intptr_t, intptr_t); typedef void (*vFuuiiiiuuiiiiiii_t)(uint32_t, uint32_t, int32_t, int32_t, int32_t, int32_t, uint32_t, uint32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t); typedef void (*vFfffffffffffffff_t)(float, float, float, float, float, float, float, float, float, float, float, float, float, float, float); typedef void (*vFuuuuiiiiuuiiiiiii_t)(uint32_t, uint32_t, uint32_t, uint32_t, int32_t, int32_t, int32_t, int32_t, uint32_t, uint32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t); -typedef void (*vFppuiiiiipuiiiiiiii_t)(void*, void*, uint32_t, int32_t, int32_t, int32_t, int32_t, int32_t, void*, uint32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t); typedef uint32_t (*uFippuuuuiiiiuuiiiiiiiipp_t)(int32_t, void*, void*, uint32_t, uint32_t, uint32_t, uint32_t, int32_t, int32_t, int32_t, int32_t, uint32_t, uint32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, void*, void*); #if defined(ANDROID) @@ -993,6 +1036,7 @@ void vFl_32(x64emu_t *emu, uintptr_t fcn) { vFl_t fn = (vFl_t)fcn; fn(to_long(fr void vFp_32(x64emu_t *emu, uintptr_t fcn) { vFp_t fn = (vFp_t)fcn; fn(from_ptriv(R_ESP + 4)); } void vFA_32(x64emu_t *emu, uintptr_t fcn) { vFA_t fn = (vFA_t)fcn; fn(from_locale_d(from_ptri(ptr_t, R_ESP + 4))); } void vFS_32(x64emu_t *emu, uintptr_t fcn) { vFS_t fn = (vFS_t)fcn; fn(io_convert32(from_ptriv(R_ESP + 4))); } +void vFX_32(x64emu_t *emu, uintptr_t fcn) { vFX_t fn = (vFX_t)fcn; fn(getDisplay(from_ptriv(R_ESP + 4))); } void iFv_32(x64emu_t *emu, uintptr_t fcn) { iFv_t fn = (iFv_t)fcn; R_EAX = fn(); } void iFi_32(x64emu_t *emu, uintptr_t fcn) { iFi_t fn = (iFi_t)fcn; R_EAX = fn(from_ptri(int32_t, R_ESP + 4)); } void iFI_32(x64emu_t *emu, uintptr_t fcn) { iFI_t fn = (iFI_t)fcn; R_EAX = fn(from_ptri(int64_t, R_ESP + 4)); } @@ -1003,6 +1047,7 @@ void iFL_32(x64emu_t *emu, uintptr_t fcn) { iFL_t fn = (iFL_t)fcn; R_EAX = fn(to void iFp_32(x64emu_t *emu, uintptr_t fcn) { iFp_t fn = (iFp_t)fcn; R_EAX = fn(from_ptriv(R_ESP + 4)); } void iFh_32(x64emu_t *emu, uintptr_t fcn) { iFh_t fn = (iFh_t)fcn; R_EAX = fn(from_hash(from_ptri(ptr_t, R_ESP + 4))); } void iFS_32(x64emu_t *emu, uintptr_t fcn) { iFS_t fn = (iFS_t)fcn; R_EAX = fn(io_convert32(from_ptriv(R_ESP + 4))); } +void iFX_32(x64emu_t *emu, uintptr_t fcn) { iFX_t fn = (iFX_t)fcn; R_EAX = fn(getDisplay(from_ptriv(R_ESP + 4))); } void IFf_32(x64emu_t *emu, uintptr_t fcn) { IFf_t fn = (IFf_t)fcn; ui64_t r; r.i = fn(from_ptri(float, R_ESP + 4)); R_EAX = r.d[0]; R_EDX = r.d[1]; } void IFd_32(x64emu_t *emu, uintptr_t fcn) { IFd_t fn = (IFd_t)fcn; ui64_t r; r.i = fn(from_ptri(double, R_ESP + 4)); R_EAX = r.d[0]; R_EDX = r.d[1]; } void IFp_32(x64emu_t *emu, uintptr_t fcn) { IFp_t fn = (IFp_t)fcn; ui64_t r; r.i = fn(from_ptriv(R_ESP + 4)); R_EAX = r.d[0]; R_EDX = r.d[1]; } @@ -1037,11 +1082,13 @@ void pFi_32(x64emu_t *emu, uintptr_t fcn) { pFi_t fn = (pFi_t)fcn; R_EAX = to_pt void pFu_32(x64emu_t *emu, uintptr_t fcn) { pFu_t fn = (pFu_t)fcn; R_EAX = to_ptrv(fn(from_ptri(uint32_t, R_ESP + 4))); } void pFL_32(x64emu_t *emu, uintptr_t fcn) { pFL_t fn = (pFL_t)fcn; R_EAX = to_ptrv(fn(to_ulong(from_ptri(ulong_t, R_ESP + 4)))); } void pFp_32(x64emu_t *emu, uintptr_t fcn) { pFp_t fn = (pFp_t)fcn; R_EAX = to_ptrv(fn(from_ptriv(R_ESP + 4))); } +void pFX_32(x64emu_t *emu, uintptr_t fcn) { pFX_t fn = (pFX_t)fcn; R_EAX = to_ptrv(fn(getDisplay(from_ptriv(R_ESP + 4)))); } void hFv_32(x64emu_t *emu, uintptr_t fcn) { hFv_t fn = (hFv_t)fcn; R_EAX = to_hash(fn()); } void aFa_32(x64emu_t *emu, uintptr_t fcn) { aFa_t fn = (aFa_t)fcn; R_EAX = to_locale(fn(from_locale(from_ptri(ptr_t, R_ESP + 4)))); } void tFi_32(x64emu_t *emu, uintptr_t fcn) { tFi_t fn = (tFi_t)fcn; R_EAX = to_cstring(fn(from_ptri(int32_t, R_ESP + 4))); } void tFu_32(x64emu_t *emu, uintptr_t fcn) { tFu_t fn = (tFu_t)fcn; R_EAX = to_cstring(fn(from_ptri(uint32_t, R_ESP + 4))); } void tFp_32(x64emu_t *emu, uintptr_t fcn) { tFp_t fn = (tFp_t)fcn; R_EAX = to_cstring(fn(from_ptriv(R_ESP + 4))); } +void iFBp__32(x64emu_t *emu, uintptr_t fcn) { iFBp__t fn = (iFBp__t)fcn; struct_p_t arg_4; R_EAX = fn(*(ptr_t*)(from_ptr((R_ESP + 4))) ? &arg_4 : NULL); if (*(ptr_t*)(from_ptr((R_ESP + 4)))) to_struct_p(*(ptr_t*)(from_ptr((R_ESP + 4))), &arg_4); } void LFrL__32(x64emu_t *emu, uintptr_t fcn) { LFrL__t fn = (LFrL__t)fcn; struct_L_t arg_4; from_struct_L(&arg_4, *(ptr_t*)(from_ptr((R_ESP + 4)))); R_EAX = to_ulong(fn(*(ptr_t*)(from_ptr((R_ESP + 4))) ? &arg_4 : NULL)); } void pFrL__32(x64emu_t *emu, uintptr_t fcn) { pFrL__t fn = (pFrL__t)fcn; struct_L_t arg_4; from_struct_L(&arg_4, *(ptr_t*)(from_ptr((R_ESP + 4)))); R_EAX = to_ptrv(fn(*(ptr_t*)(from_ptr((R_ESP + 4))) ? &arg_4 : NULL)); } void LFriiiiiiiiilt__32(x64emu_t *emu, uintptr_t fcn) { LFriiiiiiiiilt__t fn = (LFriiiiiiiiilt__t)fcn; struct_iiiiiiiiilt_t arg_4; from_struct_iiiiiiiiilt(&arg_4, *(ptr_t*)(from_ptr((R_ESP + 4)))); R_EAX = to_ulong(fn(*(ptr_t*)(from_ptr((R_ESP + 4))) ? &arg_4 : NULL)); } @@ -1079,9 +1126,11 @@ void vFlu_32(x64emu_t *emu, uintptr_t fcn) { vFlu_t fn = (vFlu_t)fcn; fn(to_long void vFlp_32(x64emu_t *emu, uintptr_t fcn) { vFlp_t fn = (vFlp_t)fcn; fn(to_long(from_ptri(long_t, R_ESP + 4)), from_ptriv(R_ESP + 8)); } void vFpC_32(x64emu_t *emu, uintptr_t fcn) { vFpC_t fn = (vFpC_t)fcn; fn(from_ptriv(R_ESP + 4), from_ptri(uint8_t, R_ESP + 8)); } void vFpu_32(x64emu_t *emu, uintptr_t fcn) { vFpu_t fn = (vFpu_t)fcn; fn(from_ptriv(R_ESP + 4), from_ptri(uint32_t, R_ESP + 8)); } +void vFpl_32(x64emu_t *emu, uintptr_t fcn) { vFpl_t fn = (vFpl_t)fcn; fn(from_ptriv(R_ESP + 4), to_long(from_ptri(long_t, R_ESP + 8))); } void vFpL_32(x64emu_t *emu, uintptr_t fcn) { vFpL_t fn = (vFpL_t)fcn; fn(from_ptriv(R_ESP + 4), to_ulong(from_ptri(ulong_t, R_ESP + 8))); } void vFpp_32(x64emu_t *emu, uintptr_t fcn) { vFpp_t fn = (vFpp_t)fcn; fn(from_ptriv(R_ESP + 4), from_ptriv(R_ESP + 8)); } void vFSp_32(x64emu_t *emu, uintptr_t fcn) { vFSp_t fn = (vFSp_t)fcn; fn(io_convert32(from_ptriv(R_ESP + 4)), from_ptriv(R_ESP + 8)); } +void vFXp_32(x64emu_t *emu, uintptr_t fcn) { vFXp_t fn = (vFXp_t)fcn; fn(getDisplay(from_ptriv(R_ESP + 4)), from_ptriv(R_ESP + 8)); } void wFpi_32(x64emu_t *emu, uintptr_t fcn) { wFpi_t fn = (wFpi_t)fcn; R_EAX = fn(from_ptriv(R_ESP + 4), from_ptri(int32_t, R_ESP + 8)); } void iFEv_32(x64emu_t *emu, uintptr_t fcn) { iFEv_t fn = (iFEv_t)fcn; R_EAX = fn(emu); } void iFEi_32(x64emu_t *emu, uintptr_t fcn) { iFEi_t fn = (iFEi_t)fcn; R_EAX = fn(emu, from_ptri(int32_t, R_ESP + 4)); } @@ -1101,6 +1150,7 @@ void iFup_32(x64emu_t *emu, uintptr_t fcn) { iFup_t fn = (iFup_t)fcn; R_EAX = fn void iFli_32(x64emu_t *emu, uintptr_t fcn) { iFli_t fn = (iFli_t)fcn; R_EAX = fn(to_long(from_ptri(long_t, R_ESP + 4)), from_ptri(int32_t, R_ESP + 8)); } void iFpi_32(x64emu_t *emu, uintptr_t fcn) { iFpi_t fn = (iFpi_t)fcn; R_EAX = fn(from_ptriv(R_ESP + 4), from_ptri(int32_t, R_ESP + 8)); } void iFpu_32(x64emu_t *emu, uintptr_t fcn) { iFpu_t fn = (iFpu_t)fcn; R_EAX = fn(from_ptriv(R_ESP + 4), from_ptri(uint32_t, R_ESP + 8)); } +void iFpl_32(x64emu_t *emu, uintptr_t fcn) { iFpl_t fn = (iFpl_t)fcn; R_EAX = fn(from_ptriv(R_ESP + 4), to_long(from_ptri(long_t, R_ESP + 8))); } void iFpL_32(x64emu_t *emu, uintptr_t fcn) { iFpL_t fn = (iFpL_t)fcn; R_EAX = fn(from_ptriv(R_ESP + 4), to_ulong(from_ptri(ulong_t, R_ESP + 8))); } void iFpp_32(x64emu_t *emu, uintptr_t fcn) { iFpp_t fn = (iFpp_t)fcn; R_EAX = fn(from_ptriv(R_ESP + 4), from_ptriv(R_ESP + 8)); } void iFpV_32(x64emu_t *emu, uintptr_t fcn) { iFpV_t fn = (iFpV_t)fcn; R_EAX = fn(from_ptriv(R_ESP + 4), from_ptrv(R_ESP + 8)); } @@ -1108,6 +1158,9 @@ void iFpS_32(x64emu_t *emu, uintptr_t fcn) { iFpS_t fn = (iFpS_t)fcn; R_EAX = fn void iFhi_32(x64emu_t *emu, uintptr_t fcn) { iFhi_t fn = (iFhi_t)fcn; R_EAX = fn(from_hash(from_ptri(ptr_t, R_ESP + 4)), from_ptri(int32_t, R_ESP + 8)); } void iFhp_32(x64emu_t *emu, uintptr_t fcn) { iFhp_t fn = (iFhp_t)fcn; R_EAX = fn(from_hash(from_ptri(ptr_t, R_ESP + 4)), from_ptriv(R_ESP + 8)); } void iFhh_32(x64emu_t *emu, uintptr_t fcn) { iFhh_t fn = (iFhh_t)fcn; R_EAX = fn(from_hash(from_ptri(ptr_t, R_ESP + 4)), from_hash(from_ptri(ptr_t, R_ESP + 8))); } +void iFXi_32(x64emu_t *emu, uintptr_t fcn) { iFXi_t fn = (iFXi_t)fcn; R_EAX = fn(getDisplay(from_ptriv(R_ESP + 4)), from_ptri(int32_t, R_ESP + 8)); } +void iFXL_32(x64emu_t *emu, uintptr_t fcn) { iFXL_t fn = (iFXL_t)fcn; R_EAX = fn(getDisplay(from_ptriv(R_ESP + 4)), to_ulong(from_ptri(ulong_t, R_ESP + 8))); } +void iFXp_32(x64emu_t *emu, uintptr_t fcn) { iFXp_t fn = (iFXp_t)fcn; R_EAX = fn(getDisplay(from_ptriv(R_ESP + 4)), from_ptriv(R_ESP + 8)); } void IFII_32(x64emu_t *emu, uintptr_t fcn) { IFII_t fn = (IFII_t)fcn; ui64_t r; r.i = fn(from_ptri(int64_t, R_ESP + 4), from_ptri(int64_t, R_ESP + 12)); R_EAX = r.d[0]; R_EDX = r.d[1]; } void CFip_32(x64emu_t *emu, uintptr_t fcn) { CFip_t fn = (CFip_t)fcn; R_EAX = (unsigned char)fn(from_ptri(int32_t, R_ESP + 4), from_ptriv(R_ESP + 8)); } void CFCi_32(x64emu_t *emu, uintptr_t fcn) { CFCi_t fn = (CFCi_t)fcn; R_EAX = (unsigned char)fn(from_ptri(uint8_t, R_ESP + 4), from_ptri(int32_t, R_ESP + 8)); } @@ -1142,6 +1195,7 @@ void lFui_32(x64emu_t *emu, uintptr_t fcn) { lFui_t fn = (lFui_t)fcn; R_EAX = to void lFpl_32(x64emu_t *emu, uintptr_t fcn) { lFpl_t fn = (lFpl_t)fcn; R_EAX = to_long(fn(from_ptriv(R_ESP + 4), to_long(from_ptri(long_t, R_ESP + 8)))); } void LFpL_32(x64emu_t *emu, uintptr_t fcn) { LFpL_t fn = (LFpL_t)fcn; R_EAX = to_ulong(fn(from_ptriv(R_ESP + 4), to_ulong(from_ptri(ulong_t, R_ESP + 8)))); } void LFpp_32(x64emu_t *emu, uintptr_t fcn) { LFpp_t fn = (LFpp_t)fcn; R_EAX = to_ulong(fn(from_ptriv(R_ESP + 4), from_ptriv(R_ESP + 8))); } +void LFXi_32(x64emu_t *emu, uintptr_t fcn) { LFXi_t fn = (LFXi_t)fcn; R_EAX = to_ulong(fn(getDisplay(from_ptriv(R_ESP + 4)), from_ptri(int32_t, R_ESP + 8))); } void pFEv_32(x64emu_t *emu, uintptr_t fcn) { pFEv_t fn = (pFEv_t)fcn; R_EAX = to_ptrv(fn(emu)); } void pFEu_32(x64emu_t *emu, uintptr_t fcn) { pFEu_t fn = (pFEu_t)fcn; R_EAX = to_ptrv(fn(emu, from_ptri(uint32_t, R_ESP + 4))); } void pFEp_32(x64emu_t *emu, uintptr_t fcn) { pFEp_t fn = (pFEp_t)fcn; R_EAX = to_ptrv(fn(emu, from_ptriv(R_ESP + 4))); } @@ -1154,6 +1208,7 @@ void pFpi_32(x64emu_t *emu, uintptr_t fcn) { pFpi_t fn = (pFpi_t)fcn; R_EAX = to void pFpu_32(x64emu_t *emu, uintptr_t fcn) { pFpu_t fn = (pFpu_t)fcn; R_EAX = to_ptrv(fn(from_ptriv(R_ESP + 4), from_ptri(uint32_t, R_ESP + 8))); } void pFpL_32(x64emu_t *emu, uintptr_t fcn) { pFpL_t fn = (pFpL_t)fcn; R_EAX = to_ptrv(fn(from_ptriv(R_ESP + 4), to_ulong(from_ptri(ulong_t, R_ESP + 8)))); } void pFpp_32(x64emu_t *emu, uintptr_t fcn) { pFpp_t fn = (pFpp_t)fcn; R_EAX = to_ptrv(fn(from_ptriv(R_ESP + 4), from_ptriv(R_ESP + 8))); } +void pFXi_32(x64emu_t *emu, uintptr_t fcn) { pFXi_t fn = (pFXi_t)fcn; R_EAX = to_ptrv(fn(getDisplay(from_ptriv(R_ESP + 4)), from_ptri(int32_t, R_ESP + 8))); } void SFip_32(x64emu_t *emu, uintptr_t fcn) { SFip_t fn = (SFip_t)fcn; R_EAX = to_ptrv(io_convert_from(fn(from_ptri(int32_t, R_ESP + 4), from_ptriv(R_ESP + 8)))); } void SFpp_32(x64emu_t *emu, uintptr_t fcn) { SFpp_t fn = (SFpp_t)fcn; R_EAX = to_ptrv(io_convert_from(fn(from_ptriv(R_ESP + 4), from_ptriv(R_ESP + 8)))); } void tFip_32(x64emu_t *emu, uintptr_t fcn) { tFip_t fn = (tFip_t)fcn; R_EAX = to_cstring(fn(from_ptri(int32_t, R_ESP + 4), from_ptriv(R_ESP + 8))); } @@ -1236,6 +1291,7 @@ void vFplp_32(x64emu_t *emu, uintptr_t fcn) { vFplp_t fn = (vFplp_t)fcn; fn(from void vFppi_32(x64emu_t *emu, uintptr_t fcn) { vFppi_t fn = (vFppi_t)fcn; fn(from_ptriv(R_ESP + 4), from_ptriv(R_ESP + 8), from_ptri(int32_t, R_ESP + 12)); } void vFppu_32(x64emu_t *emu, uintptr_t fcn) { vFppu_t fn = (vFppu_t)fcn; fn(from_ptriv(R_ESP + 4), from_ptriv(R_ESP + 8), from_ptri(uint32_t, R_ESP + 12)); } void vFppp_32(x64emu_t *emu, uintptr_t fcn) { vFppp_t fn = (vFppp_t)fcn; fn(from_ptriv(R_ESP + 4), from_ptriv(R_ESP + 8), from_ptriv(R_ESP + 12)); } +void vFXpi_32(x64emu_t *emu, uintptr_t fcn) { vFXpi_t fn = (vFXpi_t)fcn; fn(getDisplay(from_ptriv(R_ESP + 4)), from_ptriv(R_ESP + 8), from_ptri(int32_t, R_ESP + 12)); } void iFEip_32(x64emu_t *emu, uintptr_t fcn) { iFEip_t fn = (iFEip_t)fcn; R_EAX = fn(emu, from_ptri(int32_t, R_ESP + 4), from_ptriv(R_ESP + 8)); } void iFEpi_32(x64emu_t *emu, uintptr_t fcn) { iFEpi_t fn = (iFEpi_t)fcn; R_EAX = fn(emu, from_ptriv(R_ESP + 4), from_ptri(int32_t, R_ESP + 8)); } void iFEpL_32(x64emu_t *emu, uintptr_t fcn) { iFEpL_t fn = (iFEpL_t)fcn; R_EAX = fn(emu, from_ptriv(R_ESP + 4), to_ulong(from_ptri(ulong_t, R_ESP + 8))); } @@ -1243,6 +1299,7 @@ void iFEpp_32(x64emu_t *emu, uintptr_t fcn) { iFEpp_t fn = (iFEpp_t)fcn; R_EAX = void iFEpV_32(x64emu_t *emu, uintptr_t fcn) { iFEpV_t fn = (iFEpV_t)fcn; R_EAX = fn(emu, from_ptriv(R_ESP + 4), from_ptrv(R_ESP + 8)); } void iFEhi_32(x64emu_t *emu, uintptr_t fcn) { iFEhi_t fn = (iFEhi_t)fcn; R_EAX = fn(emu, from_hash(from_ptri(ptr_t, R_ESP + 4)), from_ptri(int32_t, R_ESP + 8)); } void iFESp_32(x64emu_t *emu, uintptr_t fcn) { iFESp_t fn = (iFESp_t)fcn; R_EAX = fn(emu, io_convert32(from_ptriv(R_ESP + 4)), from_ptriv(R_ESP + 8)); } +void iFEXp_32(x64emu_t *emu, uintptr_t fcn) { iFEXp_t fn = (iFEXp_t)fcn; R_EAX = fn(emu, getDisplay(from_ptriv(R_ESP + 4)), from_ptriv(R_ESP + 8)); } void iFiii_32(x64emu_t *emu, uintptr_t fcn) { iFiii_t fn = (iFiii_t)fcn; R_EAX = fn(from_ptri(int32_t, R_ESP + 4), from_ptri(int32_t, R_ESP + 8), from_ptri(int32_t, R_ESP + 12)); } void iFiiI_32(x64emu_t *emu, uintptr_t fcn) { iFiiI_t fn = (iFiiI_t)fcn; R_EAX = fn(from_ptri(int32_t, R_ESP + 4), from_ptri(int32_t, R_ESP + 8), from_ptri(int64_t, R_ESP + 12)); } void iFiiu_32(x64emu_t *emu, uintptr_t fcn) { iFiiu_t fn = (iFiiu_t)fcn; R_EAX = fn(from_ptri(int32_t, R_ESP + 4), from_ptri(int32_t, R_ESP + 8), from_ptri(uint32_t, R_ESP + 12)); } @@ -1261,12 +1318,12 @@ void iFuuu_32(x64emu_t *emu, uintptr_t fcn) { iFuuu_t fn = (iFuuu_t)fcn; R_EAX = void iFuup_32(x64emu_t *emu, uintptr_t fcn) { iFuup_t fn = (iFuup_t)fcn; R_EAX = fn(from_ptri(uint32_t, R_ESP + 4), from_ptri(uint32_t, R_ESP + 8), from_ptriv(R_ESP + 12)); } void iFuLp_32(x64emu_t *emu, uintptr_t fcn) { iFuLp_t fn = (iFuLp_t)fcn; R_EAX = fn(from_ptri(uint32_t, R_ESP + 4), to_ulong(from_ptri(ulong_t, R_ESP + 8)), from_ptriv(R_ESP + 12)); } void iFfff_32(x64emu_t *emu, uintptr_t fcn) { iFfff_t fn = (iFfff_t)fcn; R_EAX = fn(from_ptri(float, R_ESP + 4), from_ptri(float, R_ESP + 8), from_ptri(float, R_ESP + 12)); } +void iFpii_32(x64emu_t *emu, uintptr_t fcn) { iFpii_t fn = (iFpii_t)fcn; R_EAX = fn(from_ptriv(R_ESP + 4), from_ptri(int32_t, R_ESP + 8), from_ptri(int32_t, R_ESP + 12)); } void iFpiu_32(x64emu_t *emu, uintptr_t fcn) { iFpiu_t fn = (iFpiu_t)fcn; R_EAX = fn(from_ptriv(R_ESP + 4), from_ptri(int32_t, R_ESP + 8), from_ptri(uint32_t, R_ESP + 12)); } void iFpip_32(x64emu_t *emu, uintptr_t fcn) { iFpip_t fn = (iFpip_t)fcn; R_EAX = fn(from_ptriv(R_ESP + 4), from_ptri(int32_t, R_ESP + 8), from_ptriv(R_ESP + 12)); } void iFpuC_32(x64emu_t *emu, uintptr_t fcn) { iFpuC_t fn = (iFpuC_t)fcn; R_EAX = fn(from_ptriv(R_ESP + 4), from_ptri(uint32_t, R_ESP + 8), from_ptri(uint8_t, R_ESP + 12)); } void iFpuu_32(x64emu_t *emu, uintptr_t fcn) { iFpuu_t fn = (iFpuu_t)fcn; R_EAX = fn(from_ptriv(R_ESP + 4), from_ptri(uint32_t, R_ESP + 8), from_ptri(uint32_t, R_ESP + 12)); } void iFpuU_32(x64emu_t *emu, uintptr_t fcn) { iFpuU_t fn = (iFpuU_t)fcn; R_EAX = fn(from_ptriv(R_ESP + 4), from_ptri(uint32_t, R_ESP + 8), from_ptri(uint64_t, R_ESP + 12)); } -void iFpup_32(x64emu_t *emu, uintptr_t fcn) { iFpup_t fn = (iFpup_t)fcn; R_EAX = fn(from_ptriv(R_ESP + 4), from_ptri(uint32_t, R_ESP + 8), from_ptriv(R_ESP + 12)); } void iFpLi_32(x64emu_t *emu, uintptr_t fcn) { iFpLi_t fn = (iFpLi_t)fcn; R_EAX = fn(from_ptriv(R_ESP + 4), to_ulong(from_ptri(ulong_t, R_ESP + 8)), from_ptri(int32_t, R_ESP + 12)); } void iFppi_32(x64emu_t *emu, uintptr_t fcn) { iFppi_t fn = (iFppi_t)fcn; R_EAX = fn(from_ptriv(R_ESP + 4), from_ptriv(R_ESP + 8), from_ptri(int32_t, R_ESP + 12)); } void iFppu_32(x64emu_t *emu, uintptr_t fcn) { iFppu_t fn = (iFppu_t)fcn; R_EAX = fn(from_ptriv(R_ESP + 4), from_ptriv(R_ESP + 8), from_ptri(uint32_t, R_ESP + 12)); } @@ -1279,6 +1336,12 @@ void iFhpL_32(x64emu_t *emu, uintptr_t fcn) { iFhpL_t fn = (iFhpL_t)fcn; R_EAX = void iFhpp_32(x64emu_t *emu, uintptr_t fcn) { iFhpp_t fn = (iFhpp_t)fcn; R_EAX = fn(from_hash(from_ptri(ptr_t, R_ESP + 4)), from_ptriv(R_ESP + 8), from_ptriv(R_ESP + 12)); } void iFSIi_32(x64emu_t *emu, uintptr_t fcn) { iFSIi_t fn = (iFSIi_t)fcn; R_EAX = fn(io_convert32(from_ptriv(R_ESP + 4)), from_ptri(int64_t, R_ESP + 8), from_ptri(int32_t, R_ESP + 16)); } void iFSli_32(x64emu_t *emu, uintptr_t fcn) { iFSli_t fn = (iFSli_t)fcn; R_EAX = fn(io_convert32(from_ptriv(R_ESP + 4)), to_long(from_ptri(long_t, R_ESP + 8)), from_ptri(int32_t, R_ESP + 12)); } +void iFXip_32(x64emu_t *emu, uintptr_t fcn) { iFXip_t fn = (iFXip_t)fcn; R_EAX = fn(getDisplay(from_ptriv(R_ESP + 4)), from_ptri(int32_t, R_ESP + 8), from_ptriv(R_ESP + 12)); } +void iFXuu_32(x64emu_t *emu, uintptr_t fcn) { iFXuu_t fn = (iFXuu_t)fcn; R_EAX = fn(getDisplay(from_ptriv(R_ESP + 4)), from_ptri(uint32_t, R_ESP + 8), from_ptri(uint32_t, R_ESP + 12)); } +void iFXLL_32(x64emu_t *emu, uintptr_t fcn) { iFXLL_t fn = (iFXLL_t)fcn; R_EAX = fn(getDisplay(from_ptriv(R_ESP + 4)), to_ulong(from_ptri(ulong_t, R_ESP + 8)), to_ulong(from_ptri(ulong_t, R_ESP + 12))); } +void iFXLp_32(x64emu_t *emu, uintptr_t fcn) { iFXLp_t fn = (iFXLp_t)fcn; R_EAX = fn(getDisplay(from_ptriv(R_ESP + 4)), to_ulong(from_ptri(ulong_t, R_ESP + 8)), from_ptriv(R_ESP + 12)); } +void iFXpu_32(x64emu_t *emu, uintptr_t fcn) { iFXpu_t fn = (iFXpu_t)fcn; R_EAX = fn(getDisplay(from_ptriv(R_ESP + 4)), from_ptriv(R_ESP + 8), from_ptri(uint32_t, R_ESP + 12)); } +void iFXpp_32(x64emu_t *emu, uintptr_t fcn) { iFXpp_t fn = (iFXpp_t)fcn; R_EAX = fn(getDisplay(from_ptriv(R_ESP + 4)), from_ptriv(R_ESP + 8), from_ptriv(R_ESP + 12)); } void IFiIi_32(x64emu_t *emu, uintptr_t fcn) { IFiIi_t fn = (IFiIi_t)fcn; ui64_t r; r.i = fn(from_ptri(int32_t, R_ESP + 4), from_ptri(int64_t, R_ESP + 8), from_ptri(int32_t, R_ESP + 16)); R_EAX = r.d[0]; R_EDX = r.d[1]; } void CFipp_32(x64emu_t *emu, uintptr_t fcn) { CFipp_t fn = (CFipp_t)fcn; R_EAX = (unsigned char)fn(from_ptri(int32_t, R_ESP + 4), from_ptriv(R_ESP + 8), from_ptriv(R_ESP + 12)); } void CFuUu_32(x64emu_t *emu, uintptr_t fcn) { CFuUu_t fn = (CFuUu_t)fcn; R_EAX = (unsigned char)fn(from_ptri(uint32_t, R_ESP + 4), from_ptri(uint64_t, R_ESP + 8), from_ptri(uint32_t, R_ESP + 16)); } @@ -1298,9 +1361,12 @@ void dFddd_32(x64emu_t *emu, uintptr_t fcn) { dFddd_t fn = (dFddd_t)fcn; double void dFddp_32(x64emu_t *emu, uintptr_t fcn) { dFddp_t fn = (dFddp_t)fcn; double db = fn(from_ptri(double, R_ESP + 4), from_ptri(double, R_ESP + 12), from_ptriv(R_ESP + 20)); fpu_do_push(emu); ST0val = db; } void lFipL_32(x64emu_t *emu, uintptr_t fcn) { lFipL_t fn = (lFipL_t)fcn; R_EAX = to_long(fn(from_ptri(int32_t, R_ESP + 4), from_ptriv(R_ESP + 8), to_ulong(from_ptri(ulong_t, R_ESP + 12)))); } void lFlpi_32(x64emu_t *emu, uintptr_t fcn) { lFlpi_t fn = (lFlpi_t)fcn; R_EAX = to_long(fn(to_long(from_ptri(long_t, R_ESP + 4)), from_ptriv(R_ESP + 8), from_ptri(int32_t, R_ESP + 12))); } +void lFpLL_32(x64emu_t *emu, uintptr_t fcn) { lFpLL_t fn = (lFpLL_t)fcn; R_EAX = to_long(fn(from_ptriv(R_ESP + 4), to_ulong(from_ptri(ulong_t, R_ESP + 8)), to_ulong(from_ptri(ulong_t, R_ESP + 12)))); } void lFppL_32(x64emu_t *emu, uintptr_t fcn) { lFppL_t fn = (lFppL_t)fcn; R_EAX = to_long(fn(from_ptriv(R_ESP + 4), from_ptriv(R_ESP + 8), to_ulong(from_ptri(ulong_t, R_ESP + 12)))); } +void LFpii_32(x64emu_t *emu, uintptr_t fcn) { LFpii_t fn = (LFpii_t)fcn; R_EAX = to_ulong(fn(from_ptriv(R_ESP + 4), from_ptri(int32_t, R_ESP + 8), from_ptri(int32_t, R_ESP + 12))); } void LFpip_32(x64emu_t *emu, uintptr_t fcn) { LFpip_t fn = (LFpip_t)fcn; R_EAX = to_ulong(fn(from_ptriv(R_ESP + 4), from_ptri(int32_t, R_ESP + 8), from_ptriv(R_ESP + 12))); } void LFppL_32(x64emu_t *emu, uintptr_t fcn) { LFppL_t fn = (LFppL_t)fcn; R_EAX = to_ulong(fn(from_ptriv(R_ESP + 4), from_ptriv(R_ESP + 8), to_ulong(from_ptri(ulong_t, R_ESP + 12)))); } +void LFXCi_32(x64emu_t *emu, uintptr_t fcn) { LFXCi_t fn = (LFXCi_t)fcn; R_EAX = to_ulong(fn(getDisplay(from_ptriv(R_ESP + 4)), from_ptri(uint8_t, R_ESP + 8), from_ptri(int32_t, R_ESP + 12))); } void pFEip_32(x64emu_t *emu, uintptr_t fcn) { pFEip_t fn = (pFEip_t)fcn; R_EAX = to_ptrv(fn(emu, from_ptri(int32_t, R_ESP + 4), from_ptriv(R_ESP + 8))); } void pFEpi_32(x64emu_t *emu, uintptr_t fcn) { pFEpi_t fn = (pFEpi_t)fcn; R_EAX = to_ptrv(fn(emu, from_ptriv(R_ESP + 4), from_ptri(int32_t, R_ESP + 8))); } void pFEpp_32(x64emu_t *emu, uintptr_t fcn) { pFEpp_t fn = (pFEpp_t)fcn; R_EAX = to_ptrv(fn(emu, from_ptriv(R_ESP + 4), from_ptriv(R_ESP + 8))); } @@ -1308,7 +1374,6 @@ void pFipi_32(x64emu_t *emu, uintptr_t fcn) { pFipi_t fn = (pFipi_t)fcn; R_EAX = void pFulu_32(x64emu_t *emu, uintptr_t fcn) { pFulu_t fn = (pFulu_t)fcn; R_EAX = to_ptrv(fn(from_ptri(uint32_t, R_ESP + 4), to_long(from_ptri(long_t, R_ESP + 8)), from_ptri(uint32_t, R_ESP + 12))); } void pFpii_32(x64emu_t *emu, uintptr_t fcn) { pFpii_t fn = (pFpii_t)fcn; R_EAX = to_ptrv(fn(from_ptriv(R_ESP + 4), from_ptri(int32_t, R_ESP + 8), from_ptri(int32_t, R_ESP + 12))); } void pFpiL_32(x64emu_t *emu, uintptr_t fcn) { pFpiL_t fn = (pFpiL_t)fcn; R_EAX = to_ptrv(fn(from_ptriv(R_ESP + 4), from_ptri(int32_t, R_ESP + 8), to_ulong(from_ptri(ulong_t, R_ESP + 12)))); } -void pFpip_32(x64emu_t *emu, uintptr_t fcn) { pFpip_t fn = (pFpip_t)fcn; R_EAX = to_ptrv(fn(from_ptriv(R_ESP + 4), from_ptri(int32_t, R_ESP + 8), from_ptriv(R_ESP + 12))); } void pFpiS_32(x64emu_t *emu, uintptr_t fcn) { pFpiS_t fn = (pFpiS_t)fcn; R_EAX = to_ptrv(fn(from_ptriv(R_ESP + 4), from_ptri(int32_t, R_ESP + 8), io_convert32(from_ptriv(R_ESP + 12)))); } void pFpuL_32(x64emu_t *emu, uintptr_t fcn) { pFpuL_t fn = (pFpuL_t)fcn; R_EAX = to_ptrv(fn(from_ptriv(R_ESP + 4), from_ptri(uint32_t, R_ESP + 8), to_ulong(from_ptri(ulong_t, R_ESP + 12)))); } void pFpup_32(x64emu_t *emu, uintptr_t fcn) { pFpup_t fn = (pFpup_t)fcn; R_EAX = to_ptrv(fn(from_ptriv(R_ESP + 4), from_ptri(uint32_t, R_ESP + 8), from_ptriv(R_ESP + 12))); } @@ -1316,6 +1381,7 @@ void pFppu_32(x64emu_t *emu, uintptr_t fcn) { pFppu_t fn = (pFppu_t)fcn; R_EAX = void pFppL_32(x64emu_t *emu, uintptr_t fcn) { pFppL_t fn = (pFppL_t)fcn; R_EAX = to_ptrv(fn(from_ptriv(R_ESP + 4), from_ptriv(R_ESP + 8), to_ulong(from_ptri(ulong_t, R_ESP + 12)))); } void pFppp_32(x64emu_t *emu, uintptr_t fcn) { pFppp_t fn = (pFppp_t)fcn; R_EAX = to_ptrv(fn(from_ptriv(R_ESP + 4), from_ptriv(R_ESP + 8), from_ptriv(R_ESP + 12))); } void pFpOM_32(x64emu_t *emu, uintptr_t fcn) { pFpOM_t fn = (pFpOM_t)fcn; R_EAX = to_ptrv(fn(from_ptriv(R_ESP + 4), of_convert32(from_ptri(int32_t, R_ESP + 8)), from_ptriv(R_ESP + 12),from_ptriv(R_ESP + 12 + 4))); } +void pFXip_32(x64emu_t *emu, uintptr_t fcn) { pFXip_t fn = (pFXip_t)fcn; R_EAX = to_ptrv(fn(getDisplay(from_ptriv(R_ESP + 4)), from_ptri(int32_t, R_ESP + 8), from_ptriv(R_ESP + 12))); } void aFipa_32(x64emu_t *emu, uintptr_t fcn) { aFipa_t fn = (aFipa_t)fcn; R_EAX = to_locale(fn(from_ptri(int32_t, R_ESP + 4), from_ptriv(R_ESP + 8), from_locale(from_ptri(ptr_t, R_ESP + 12)))); } void SFEpp_32(x64emu_t *emu, uintptr_t fcn) { SFEpp_t fn = (SFEpp_t)fcn; R_EAX = to_ptrv(io_convert_from(fn(emu, from_ptriv(R_ESP + 4), from_ptriv(R_ESP + 8)))); } void SFppS_32(x64emu_t *emu, uintptr_t fcn) { SFppS_t fn = (SFppS_t)fcn; R_EAX = to_ptrv(io_convert_from(fn(from_ptriv(R_ESP + 4), from_ptriv(R_ESP + 8), io_convert32(from_ptriv(R_ESP + 12))))); } @@ -1324,12 +1390,14 @@ void iFppbL__32(x64emu_t *emu, uintptr_t fcn) { iFppbL__t fn = (iFppbL__t)fcn; s void iFpBp_i_32(x64emu_t *emu, uintptr_t fcn) { iFpBp_i_t fn = (iFpBp_i_t)fcn; struct_p_t arg_8; R_EAX = fn(from_ptriv(R_ESP + 4), *(ptr_t*)(from_ptr((R_ESP + 8))) ? &arg_8 : NULL, from_ptri(int32_t, R_ESP + 12)); if (*(ptr_t*)(from_ptr((R_ESP + 8)))) to_struct_p(*(ptr_t*)(from_ptr((R_ESP + 8))), &arg_8); } void iFpbL_p_32(x64emu_t *emu, uintptr_t fcn) { iFpbL_p_t fn = (iFpbL_p_t)fcn; struct_L_t arg_8; from_struct_L(&arg_8, *(ptr_t*)(from_ptr((R_ESP + 8)))); R_EAX = fn(from_ptriv(R_ESP + 4), *(ptr_t*)(from_ptr((R_ESP + 8))) ? &arg_8 : NULL, from_ptriv(R_ESP + 12)); if (*(ptr_t*)(from_ptr((R_ESP + 8)))) to_struct_L(*(ptr_t*)(from_ptr((R_ESP + 8))), &arg_8); } void iFBp_LL_32(x64emu_t *emu, uintptr_t fcn) { iFBp_LL_t fn = (iFBp_LL_t)fcn; struct_p_t arg_4; R_EAX = fn(*(ptr_t*)(from_ptr((R_ESP + 4))) ? &arg_4 : NULL, to_ulong(from_ptri(ulong_t, R_ESP + 8)), to_ulong(from_ptri(ulong_t, R_ESP + 12))); if (*(ptr_t*)(from_ptr((R_ESP + 4)))) to_struct_p(*(ptr_t*)(from_ptr((R_ESP + 4))), &arg_4); } +void iFBp_pi_32(x64emu_t *emu, uintptr_t fcn) { iFBp_pi_t fn = (iFBp_pi_t)fcn; struct_p_t arg_4; R_EAX = fn(*(ptr_t*)(from_ptr((R_ESP + 4))) ? &arg_4 : NULL, from_ptriv(R_ESP + 8), from_ptri(int32_t, R_ESP + 12)); if (*(ptr_t*)(from_ptr((R_ESP + 4)))) to_struct_p(*(ptr_t*)(from_ptr((R_ESP + 4))), &arg_4); } void IFpBp_i_32(x64emu_t *emu, uintptr_t fcn) { IFpBp_i_t fn = (IFpBp_i_t)fcn; struct_p_t arg_8; ui64_t r; r.i = fn(from_ptriv(R_ESP + 4), *(ptr_t*)(from_ptr((R_ESP + 8))) ? &arg_8 : NULL, from_ptri(int32_t, R_ESP + 12)); R_EAX = r.d[0]; R_EDX = r.d[1]; if (*(ptr_t*)(from_ptr((R_ESP + 8)))) to_struct_p(*(ptr_t*)(from_ptr((R_ESP + 8))), &arg_8); } void UFpBp_i_32(x64emu_t *emu, uintptr_t fcn) { UFpBp_i_t fn = (UFpBp_i_t)fcn; struct_p_t arg_8; ui64_t r; r.u = (uint64_t)fn(from_ptriv(R_ESP + 4), *(ptr_t*)(from_ptr((R_ESP + 8))) ? &arg_8 : NULL, from_ptri(int32_t, R_ESP + 12)); R_EAX = r.d[0]; R_EDX = r.d[1]; if (*(ptr_t*)(from_ptr((R_ESP + 8)))) to_struct_p(*(ptr_t*)(from_ptr((R_ESP + 8))), &arg_8); } void dFpBp_i_32(x64emu_t *emu, uintptr_t fcn) { dFpBp_i_t fn = (dFpBp_i_t)fcn; struct_p_t arg_8; double db = fn(from_ptriv(R_ESP + 4), *(ptr_t*)(from_ptr((R_ESP + 8))) ? &arg_8 : NULL, from_ptri(int32_t, R_ESP + 12)); fpu_do_push(emu); ST0val = db; if (*(ptr_t*)(from_ptr((R_ESP + 8)))) to_struct_p(*(ptr_t*)(from_ptr((R_ESP + 8))), &arg_8); } void dFpBp_a_32(x64emu_t *emu, uintptr_t fcn) { dFpBp_a_t fn = (dFpBp_a_t)fcn; struct_p_t arg_8; double db = fn(from_ptriv(R_ESP + 4), *(ptr_t*)(from_ptr((R_ESP + 8))) ? &arg_8 : NULL, from_locale(from_ptri(ptr_t, R_ESP + 12))); fpu_do_push(emu); ST0val = db; if (*(ptr_t*)(from_ptr((R_ESP + 8)))) to_struct_p(*(ptr_t*)(from_ptr((R_ESP + 8))), &arg_8); } void lFpBp_i_32(x64emu_t *emu, uintptr_t fcn) { lFpBp_i_t fn = (lFpBp_i_t)fcn; struct_p_t arg_8; R_EAX = to_long(fn(from_ptriv(R_ESP + 4), *(ptr_t*)(from_ptr((R_ESP + 8))) ? &arg_8 : NULL, from_ptri(int32_t, R_ESP + 12))); if (*(ptr_t*)(from_ptr((R_ESP + 8)))) to_struct_p(*(ptr_t*)(from_ptr((R_ESP + 8))), &arg_8); } void LFpBp_i_32(x64emu_t *emu, uintptr_t fcn) { LFpBp_i_t fn = (LFpBp_i_t)fcn; struct_p_t arg_8; R_EAX = to_ulong(fn(from_ptriv(R_ESP + 4), *(ptr_t*)(from_ptr((R_ESP + 8))) ? &arg_8 : NULL, from_ptri(int32_t, R_ESP + 12))); if (*(ptr_t*)(from_ptr((R_ESP + 8)))) to_struct_p(*(ptr_t*)(from_ptr((R_ESP + 8))), &arg_8); } +void iFXLbhWcc__32(x64emu_t *emu, uintptr_t fcn) { iFXLbhWcc__t fn = (iFXLbhWcc__t)fcn; struct_hWcc_t arg_12; from_struct_hWcc(&arg_12, *(ptr_t*)(from_ptr((R_ESP + 12)))); R_EAX = fn(getDisplay(from_ptriv(R_ESP + 4)), to_ulong(from_ptri(ulong_t, R_ESP + 8)), *(ptr_t*)(from_ptr((R_ESP + 12))) ? &arg_12 : NULL); if (*(ptr_t*)(from_ptr((R_ESP + 12)))) to_struct_hWcc(*(ptr_t*)(from_ptr((R_ESP + 12))), &arg_12); } void pFppriiiiiiiiilt__32(x64emu_t *emu, uintptr_t fcn) { pFppriiiiiiiiilt__t fn = (pFppriiiiiiiiilt__t)fcn; struct_iiiiiiiiilt_t arg_12; from_struct_iiiiiiiiilt(&arg_12, *(ptr_t*)(from_ptr((R_ESP + 12)))); R_EAX = to_ptrv(fn(from_ptriv(R_ESP + 4), from_ptriv(R_ESP + 8), *(ptr_t*)(from_ptr((R_ESP + 12))) ? &arg_12 : NULL)); } void vFEipp_32(x64emu_t *emu, uintptr_t fcn) { vFEipp_t fn = (vFEipp_t)fcn; fn(emu, from_ptri(int32_t, R_ESP + 4), from_ptriv(R_ESP + 8), from_ptriv(R_ESP + 12)); } void vFEipV_32(x64emu_t *emu, uintptr_t fcn) { vFEipV_t fn = (vFEipV_t)fcn; fn(emu, from_ptri(int32_t, R_ESP + 4), from_ptriv(R_ESP + 8), from_ptrv(R_ESP + 12)); } @@ -1407,13 +1475,14 @@ void vFuppu_32(x64emu_t *emu, uintptr_t fcn) { vFuppu_t fn = (vFuppu_t)fcn; fn(f void vFffff_32(x64emu_t *emu, uintptr_t fcn) { vFffff_t fn = (vFffff_t)fcn; fn(from_ptri(float, R_ESP + 4), from_ptri(float, R_ESP + 8), from_ptri(float, R_ESP + 12), from_ptri(float, R_ESP + 16)); } void vFdddd_32(x64emu_t *emu, uintptr_t fcn) { vFdddd_t fn = (vFdddd_t)fcn; fn(from_ptri(double, R_ESP + 4), from_ptri(double, R_ESP + 12), from_ptri(double, R_ESP + 20), from_ptri(double, R_ESP + 28)); } void vFllii_32(x64emu_t *emu, uintptr_t fcn) { vFllii_t fn = (vFllii_t)fcn; fn(to_long(from_ptri(long_t, R_ESP + 4)), to_long(from_ptri(long_t, R_ESP + 8)), from_ptri(int32_t, R_ESP + 12), from_ptri(int32_t, R_ESP + 16)); } -void vFpiii_32(x64emu_t *emu, uintptr_t fcn) { vFpiii_t fn = (vFpiii_t)fcn; fn(from_ptriv(R_ESP + 4), from_ptri(int32_t, R_ESP + 8), from_ptri(int32_t, R_ESP + 12), from_ptri(int32_t, R_ESP + 16)); } void vFpipp_32(x64emu_t *emu, uintptr_t fcn) { vFpipp_t fn = (vFpipp_t)fcn; fn(from_ptriv(R_ESP + 4), from_ptri(int32_t, R_ESP + 8), from_ptriv(R_ESP + 12), from_ptriv(R_ESP + 16)); } void vFpdii_32(x64emu_t *emu, uintptr_t fcn) { vFpdii_t fn = (vFpdii_t)fcn; fn(from_ptriv(R_ESP + 4), from_ptri(double, R_ESP + 8), from_ptri(int32_t, R_ESP + 16), from_ptri(int32_t, R_ESP + 20)); } void vFpddd_32(x64emu_t *emu, uintptr_t fcn) { vFpddd_t fn = (vFpddd_t)fcn; fn(from_ptriv(R_ESP + 4), from_ptri(double, R_ESP + 8), from_ptri(double, R_ESP + 16), from_ptri(double, R_ESP + 24)); } void vFplpp_32(x64emu_t *emu, uintptr_t fcn) { vFplpp_t fn = (vFplpp_t)fcn; fn(from_ptriv(R_ESP + 4), to_long(from_ptri(long_t, R_ESP + 8)), from_ptriv(R_ESP + 12), from_ptriv(R_ESP + 16)); } void vFppip_32(x64emu_t *emu, uintptr_t fcn) { vFppip_t fn = (vFppip_t)fcn; fn(from_ptriv(R_ESP + 4), from_ptriv(R_ESP + 8), from_ptri(int32_t, R_ESP + 12), from_ptriv(R_ESP + 16)); } void vFpppp_32(x64emu_t *emu, uintptr_t fcn) { vFpppp_t fn = (vFpppp_t)fcn; fn(from_ptriv(R_ESP + 4), from_ptriv(R_ESP + 8), from_ptriv(R_ESP + 12), from_ptriv(R_ESP + 16)); } +void vFXiiL_32(x64emu_t *emu, uintptr_t fcn) { vFXiiL_t fn = (vFXiiL_t)fcn; fn(getDisplay(from_ptriv(R_ESP + 4)), from_ptri(int32_t, R_ESP + 8), from_ptri(int32_t, R_ESP + 12), to_ulong(from_ptri(ulong_t, R_ESP + 16))); } +void vFXpip_32(x64emu_t *emu, uintptr_t fcn) { vFXpip_t fn = (vFXpip_t)fcn; fn(getDisplay(from_ptriv(R_ESP + 4)), from_ptriv(R_ESP + 8), from_ptri(int32_t, R_ESP + 12), from_ptriv(R_ESP + 16)); } void iFEiip_32(x64emu_t *emu, uintptr_t fcn) { iFEiip_t fn = (iFEiip_t)fcn; R_EAX = fn(emu, from_ptri(int32_t, R_ESP + 4), from_ptri(int32_t, R_ESP + 8), from_ptriv(R_ESP + 12)); } void iFEiiN_32(x64emu_t *emu, uintptr_t fcn) { iFEiiN_t fn = (iFEiiN_t)fcn; R_EAX = fn(emu, from_ptri(int32_t, R_ESP + 4), from_ptri(int32_t, R_ESP + 8), from_ptriv(R_ESP + 12)); } void iFEipp_32(x64emu_t *emu, uintptr_t fcn) { iFEipp_t fn = (iFEipp_t)fcn; R_EAX = fn(emu, from_ptri(int32_t, R_ESP + 4), from_ptriv(R_ESP + 8), from_ptriv(R_ESP + 12)); } @@ -1438,9 +1507,8 @@ void iFipup_32(x64emu_t *emu, uintptr_t fcn) { iFipup_t fn = (iFipup_t)fcn; R_EA void iFippi_32(x64emu_t *emu, uintptr_t fcn) { iFippi_t fn = (iFippi_t)fcn; R_EAX = fn(from_ptri(int32_t, R_ESP + 4), from_ptriv(R_ESP + 8), from_ptriv(R_ESP + 12), from_ptri(int32_t, R_ESP + 16)); } void iFuiup_32(x64emu_t *emu, uintptr_t fcn) { iFuiup_t fn = (iFuiup_t)fcn; R_EAX = fn(from_ptri(uint32_t, R_ESP + 4), from_ptri(int32_t, R_ESP + 8), from_ptri(uint32_t, R_ESP + 12), from_ptriv(R_ESP + 16)); } void iFuupi_32(x64emu_t *emu, uintptr_t fcn) { iFuupi_t fn = (iFuupi_t)fcn; R_EAX = fn(from_ptri(uint32_t, R_ESP + 4), from_ptri(uint32_t, R_ESP + 8), from_ptriv(R_ESP + 12), from_ptri(int32_t, R_ESP + 16)); } -void iFpiip_32(x64emu_t *emu, uintptr_t fcn) { iFpiip_t fn = (iFpiip_t)fcn; R_EAX = fn(from_ptriv(R_ESP + 4), from_ptri(int32_t, R_ESP + 8), from_ptri(int32_t, R_ESP + 12), from_ptriv(R_ESP + 16)); } +void iFpiiL_32(x64emu_t *emu, uintptr_t fcn) { iFpiiL_t fn = (iFpiiL_t)fcn; R_EAX = fn(from_ptriv(R_ESP + 4), from_ptri(int32_t, R_ESP + 8), from_ptri(int32_t, R_ESP + 12), to_ulong(from_ptri(ulong_t, R_ESP + 16))); } void iFpipp_32(x64emu_t *emu, uintptr_t fcn) { iFpipp_t fn = (iFpipp_t)fcn; R_EAX = fn(from_ptriv(R_ESP + 4), from_ptri(int32_t, R_ESP + 8), from_ptriv(R_ESP + 12), from_ptriv(R_ESP + 16)); } -void iFpuup_32(x64emu_t *emu, uintptr_t fcn) { iFpuup_t fn = (iFpuup_t)fcn; R_EAX = fn(from_ptriv(R_ESP + 4), from_ptri(uint32_t, R_ESP + 8), from_ptri(uint32_t, R_ESP + 12), from_ptriv(R_ESP + 16)); } void iFpupp_32(x64emu_t *emu, uintptr_t fcn) { iFpupp_t fn = (iFpupp_t)fcn; R_EAX = fn(from_ptriv(R_ESP + 4), from_ptri(uint32_t, R_ESP + 8), from_ptriv(R_ESP + 12), from_ptriv(R_ESP + 16)); } void iFppii_32(x64emu_t *emu, uintptr_t fcn) { iFppii_t fn = (iFppii_t)fcn; R_EAX = fn(from_ptriv(R_ESP + 4), from_ptriv(R_ESP + 8), from_ptri(int32_t, R_ESP + 12), from_ptri(int32_t, R_ESP + 16)); } void iFppiU_32(x64emu_t *emu, uintptr_t fcn) { iFppiU_t fn = (iFppiU_t)fcn; R_EAX = fn(from_ptriv(R_ESP + 4), from_ptriv(R_ESP + 8), from_ptri(int32_t, R_ESP + 12), from_ptri(uint64_t, R_ESP + 16)); } @@ -1450,34 +1518,41 @@ void iFppLi_32(x64emu_t *emu, uintptr_t fcn) { iFppLi_t fn = (iFppLi_t)fcn; R_EA void iFpppi_32(x64emu_t *emu, uintptr_t fcn) { iFpppi_t fn = (iFpppi_t)fcn; R_EAX = fn(from_ptriv(R_ESP + 4), from_ptriv(R_ESP + 8), from_ptriv(R_ESP + 12), from_ptri(int32_t, R_ESP + 16)); } void iFpppp_32(x64emu_t *emu, uintptr_t fcn) { iFpppp_t fn = (iFpppp_t)fcn; R_EAX = fn(from_ptriv(R_ESP + 4), from_ptriv(R_ESP + 8), from_ptriv(R_ESP + 12), from_ptriv(R_ESP + 16)); } void iFhpiL_32(x64emu_t *emu, uintptr_t fcn) { iFhpiL_t fn = (iFhpiL_t)fcn; R_EAX = fn(from_hash(from_ptri(ptr_t, R_ESP + 4)), from_ptriv(R_ESP + 8), from_ptri(int32_t, R_ESP + 12), to_ulong(from_ptri(ulong_t, R_ESP + 16))); } +void iFXipp_32(x64emu_t *emu, uintptr_t fcn) { iFXipp_t fn = (iFXipp_t)fcn; R_EAX = fn(getDisplay(from_ptriv(R_ESP + 4)), from_ptri(int32_t, R_ESP + 8), from_ptriv(R_ESP + 12), from_ptriv(R_ESP + 16)); } +void iFXppp_32(x64emu_t *emu, uintptr_t fcn) { iFXppp_t fn = (iFXppp_t)fcn; R_EAX = fn(getDisplay(from_ptriv(R_ESP + 4)), from_ptriv(R_ESP + 8), from_ptriv(R_ESP + 12), from_ptriv(R_ESP + 16)); } void CFuuff_32(x64emu_t *emu, uintptr_t fcn) { CFuuff_t fn = (CFuuff_t)fcn; R_EAX = (unsigned char)fn(from_ptri(uint32_t, R_ESP + 4), from_ptri(uint32_t, R_ESP + 8), from_ptri(float, R_ESP + 12), from_ptri(float, R_ESP + 16)); } void uFuuuu_32(x64emu_t *emu, uintptr_t fcn) { uFuuuu_t fn = (uFuuuu_t)fcn; R_EAX = (uint32_t)fn(from_ptri(uint32_t, R_ESP + 4), from_ptri(uint32_t, R_ESP + 8), from_ptri(uint32_t, R_ESP + 12), from_ptri(uint32_t, R_ESP + 16)); } void lFEipi_32(x64emu_t *emu, uintptr_t fcn) { lFEipi_t fn = (lFEipi_t)fcn; R_EAX = to_long(fn(emu, from_ptri(int32_t, R_ESP + 4), from_ptriv(R_ESP + 8), from_ptri(int32_t, R_ESP + 12))); } void lFiipL_32(x64emu_t *emu, uintptr_t fcn) { lFiipL_t fn = (lFiipL_t)fcn; R_EAX = to_long(fn(from_ptri(int32_t, R_ESP + 4), from_ptri(int32_t, R_ESP + 8), from_ptriv(R_ESP + 12), to_ulong(from_ptri(ulong_t, R_ESP + 16)))); } void lFipLi_32(x64emu_t *emu, uintptr_t fcn) { lFipLi_t fn = (lFipLi_t)fcn; R_EAX = to_long(fn(from_ptri(int32_t, R_ESP + 4), from_ptriv(R_ESP + 8), to_ulong(from_ptri(ulong_t, R_ESP + 12)), from_ptri(int32_t, R_ESP + 16))); } void lFpuip_32(x64emu_t *emu, uintptr_t fcn) { lFpuip_t fn = (lFpuip_t)fcn; R_EAX = to_long(fn(from_ptriv(R_ESP + 4), from_ptri(uint32_t, R_ESP + 8), from_ptri(int32_t, R_ESP + 12), from_ptriv(R_ESP + 16))); } +void LFEXii_32(x64emu_t *emu, uintptr_t fcn) { LFEXii_t fn = (LFEXii_t)fcn; R_EAX = to_ulong(fn(emu, getDisplay(from_ptriv(R_ESP + 4)), from_ptri(int32_t, R_ESP + 8), from_ptri(int32_t, R_ESP + 12))); } void LFpLLS_32(x64emu_t *emu, uintptr_t fcn) { LFpLLS_t fn = (LFpLLS_t)fcn; R_EAX = to_ulong(fn(from_ptriv(R_ESP + 4), to_ulong(from_ptri(ulong_t, R_ESP + 8)), to_ulong(from_ptri(ulong_t, R_ESP + 12)), io_convert32(from_ptriv(R_ESP + 16)))); } void LFppLp_32(x64emu_t *emu, uintptr_t fcn) { LFppLp_t fn = (LFppLp_t)fcn; R_EAX = to_ulong(fn(from_ptriv(R_ESP + 4), from_ptriv(R_ESP + 8), to_ulong(from_ptri(ulong_t, R_ESP + 12)), from_ptriv(R_ESP + 16))); } void LFppLa_32(x64emu_t *emu, uintptr_t fcn) { LFppLa_t fn = (LFppLa_t)fcn; R_EAX = to_ulong(fn(from_ptriv(R_ESP + 4), from_ptriv(R_ESP + 8), to_ulong(from_ptri(ulong_t, R_ESP + 12)), from_locale(from_ptri(ptr_t, R_ESP + 16)))); } +void LFXLpi_32(x64emu_t *emu, uintptr_t fcn) { LFXLpi_t fn = (LFXLpi_t)fcn; R_EAX = to_ulong(fn(getDisplay(from_ptriv(R_ESP + 4)), to_ulong(from_ptri(ulong_t, R_ESP + 8)), from_ptriv(R_ESP + 12), from_ptri(int32_t, R_ESP + 16))); } void pFEppi_32(x64emu_t *emu, uintptr_t fcn) { pFEppi_t fn = (pFEppi_t)fcn; R_EAX = to_ptrv(fn(emu, from_ptriv(R_ESP + 4), from_ptriv(R_ESP + 8), from_ptri(int32_t, R_ESP + 12))); } void pFEppp_32(x64emu_t *emu, uintptr_t fcn) { pFEppp_t fn = (pFEppp_t)fcn; R_EAX = to_ptrv(fn(emu, from_ptriv(R_ESP + 4), from_ptriv(R_ESP + 8), from_ptriv(R_ESP + 12))); } void pFiiiu_32(x64emu_t *emu, uintptr_t fcn) { pFiiiu_t fn = (pFiiiu_t)fcn; R_EAX = to_ptrv(fn(from_ptri(int32_t, R_ESP + 4), from_ptri(int32_t, R_ESP + 8), from_ptri(int32_t, R_ESP + 12), from_ptri(uint32_t, R_ESP + 16))); } void pFillu_32(x64emu_t *emu, uintptr_t fcn) { pFillu_t fn = (pFillu_t)fcn; R_EAX = to_ptrv(fn(from_ptri(int32_t, R_ESP + 4), to_long(from_ptri(long_t, R_ESP + 8)), to_long(from_ptri(long_t, R_ESP + 12)), from_ptri(uint32_t, R_ESP + 16))); } void pFullu_32(x64emu_t *emu, uintptr_t fcn) { pFullu_t fn = (pFullu_t)fcn; R_EAX = to_ptrv(fn(from_ptri(uint32_t, R_ESP + 4), to_long(from_ptri(long_t, R_ESP + 8)), to_long(from_ptri(long_t, R_ESP + 12)), from_ptri(uint32_t, R_ESP + 16))); } void pFlfff_32(x64emu_t *emu, uintptr_t fcn) { pFlfff_t fn = (pFlfff_t)fcn; R_EAX = to_ptrv(fn(to_long(from_ptri(long_t, R_ESP + 4)), from_ptri(float, R_ESP + 8), from_ptri(float, R_ESP + 12), from_ptri(float, R_ESP + 16))); } -void pFpiii_32(x64emu_t *emu, uintptr_t fcn) { pFpiii_t fn = (pFpiii_t)fcn; R_EAX = to_ptrv(fn(from_ptriv(R_ESP + 4), from_ptri(int32_t, R_ESP + 8), from_ptri(int32_t, R_ESP + 12), from_ptri(int32_t, R_ESP + 16))); } void pFpiLL_32(x64emu_t *emu, uintptr_t fcn) { pFpiLL_t fn = (pFpiLL_t)fcn; R_EAX = to_ptrv(fn(from_ptriv(R_ESP + 4), from_ptri(int32_t, R_ESP + 8), to_ulong(from_ptri(ulong_t, R_ESP + 12)), to_ulong(from_ptri(ulong_t, R_ESP + 16)))); } -void pFpipp_32(x64emu_t *emu, uintptr_t fcn) { pFpipp_t fn = (pFpipp_t)fcn; R_EAX = to_ptrv(fn(from_ptriv(R_ESP + 4), from_ptri(int32_t, R_ESP + 8), from_ptriv(R_ESP + 12), from_ptriv(R_ESP + 16))); } void pFppLL_32(x64emu_t *emu, uintptr_t fcn) { pFppLL_t fn = (pFppLL_t)fcn; R_EAX = to_ptrv(fn(from_ptriv(R_ESP + 4), from_ptriv(R_ESP + 8), to_ulong(from_ptri(ulong_t, R_ESP + 12)), to_ulong(from_ptri(ulong_t, R_ESP + 16)))); } -void pFpppi_32(x64emu_t *emu, uintptr_t fcn) { pFpppi_t fn = (pFpppi_t)fcn; R_EAX = to_ptrv(fn(from_ptriv(R_ESP + 4), from_ptriv(R_ESP + 8), from_ptriv(R_ESP + 12), from_ptri(int32_t, R_ESP + 16))); } void pFpppp_32(x64emu_t *emu, uintptr_t fcn) { pFpppp_t fn = (pFpppp_t)fcn; R_EAX = to_ptrv(fn(from_ptriv(R_ESP + 4), from_ptriv(R_ESP + 8), from_ptriv(R_ESP + 12), from_ptriv(R_ESP + 16))); } +void pFXiii_32(x64emu_t *emu, uintptr_t fcn) { pFXiii_t fn = (pFXiii_t)fcn; R_EAX = to_ptrv(fn(getDisplay(from_ptriv(R_ESP + 4)), from_ptri(int32_t, R_ESP + 8), from_ptri(int32_t, R_ESP + 12), from_ptri(int32_t, R_ESP + 16))); } +void pFXLLp_32(x64emu_t *emu, uintptr_t fcn) { pFXLLp_t fn = (pFXLLp_t)fcn; R_EAX = to_ptrv(fn(getDisplay(from_ptriv(R_ESP + 4)), to_ulong(from_ptri(ulong_t, R_ESP + 8)), to_ulong(from_ptri(ulong_t, R_ESP + 12)), from_ptriv(R_ESP + 16))); } +void pFXppi_32(x64emu_t *emu, uintptr_t fcn) { pFXppi_t fn = (pFXppi_t)fcn; R_EAX = to_ptrv(fn(getDisplay(from_ptriv(R_ESP + 4)), from_ptriv(R_ESP + 8), from_ptriv(R_ESP + 12), from_ptri(int32_t, R_ESP + 16))); } +void iFppbp_p_32(x64emu_t *emu, uintptr_t fcn) { iFppbp_p_t fn = (iFppbp_p_t)fcn; struct_p_t arg_12; from_struct_p(&arg_12, *(ptr_t*)(from_ptr((R_ESP + 12)))); R_EAX = fn(from_ptriv(R_ESP + 4), from_ptriv(R_ESP + 8), *(ptr_t*)(from_ptr((R_ESP + 12))) ? &arg_12 : NULL, from_ptriv(R_ESP + 16)); if (*(ptr_t*)(from_ptr((R_ESP + 12)))) to_struct_p(*(ptr_t*)(from_ptr((R_ESP + 12))), &arg_12); } void iFBp_pui_32(x64emu_t *emu, uintptr_t fcn) { iFBp_pui_t fn = (iFBp_pui_t)fcn; struct_p_t arg_4; R_EAX = fn(*(ptr_t*)(from_ptr((R_ESP + 4))) ? &arg_4 : NULL, from_ptriv(R_ESP + 8), from_ptri(uint32_t, R_ESP + 12), from_ptri(int32_t, R_ESP + 16)); if (*(ptr_t*)(from_ptr((R_ESP + 4)))) to_struct_p(*(ptr_t*)(from_ptr((R_ESP + 4))), &arg_4); } void IFpBp_ii_32(x64emu_t *emu, uintptr_t fcn) { IFpBp_ii_t fn = (IFpBp_ii_t)fcn; struct_p_t arg_8; ui64_t r; r.i = fn(from_ptriv(R_ESP + 4), *(ptr_t*)(from_ptr((R_ESP + 8))) ? &arg_8 : NULL, from_ptri(int32_t, R_ESP + 12), from_ptri(int32_t, R_ESP + 16)); R_EAX = r.d[0]; R_EDX = r.d[1]; if (*(ptr_t*)(from_ptr((R_ESP + 8)))) to_struct_p(*(ptr_t*)(from_ptr((R_ESP + 8))), &arg_8); } void UFpBp_ii_32(x64emu_t *emu, uintptr_t fcn) { UFpBp_ii_t fn = (UFpBp_ii_t)fcn; struct_p_t arg_8; ui64_t r; r.u = (uint64_t)fn(from_ptriv(R_ESP + 4), *(ptr_t*)(from_ptr((R_ESP + 8))) ? &arg_8 : NULL, from_ptri(int32_t, R_ESP + 12), from_ptri(int32_t, R_ESP + 16)); R_EAX = r.d[0]; R_EDX = r.d[1]; if (*(ptr_t*)(from_ptr((R_ESP + 8)))) to_struct_p(*(ptr_t*)(from_ptr((R_ESP + 8))), &arg_8); } void lFiibp_L_32(x64emu_t *emu, uintptr_t fcn) { lFiibp_L_t fn = (lFiibp_L_t)fcn; struct_p_t arg_12; from_struct_p(&arg_12, *(ptr_t*)(from_ptr((R_ESP + 12)))); R_EAX = to_long(fn(from_ptri(int32_t, R_ESP + 4), from_ptri(int32_t, R_ESP + 8), *(ptr_t*)(from_ptr((R_ESP + 12))) ? &arg_12 : NULL, to_ulong(from_ptri(ulong_t, R_ESP + 16)))); if (*(ptr_t*)(from_ptr((R_ESP + 12)))) to_struct_p(*(ptr_t*)(from_ptr((R_ESP + 12))), &arg_12); } void LFpbp_Lp_32(x64emu_t *emu, uintptr_t fcn) { LFpbp_Lp_t fn = (LFpbp_Lp_t)fcn; struct_p_t arg_8; from_struct_p(&arg_8, *(ptr_t*)(from_ptr((R_ESP + 8)))); R_EAX = to_ulong(fn(from_ptriv(R_ESP + 4), *(ptr_t*)(from_ptr((R_ESP + 8))) ? &arg_8 : NULL, to_ulong(from_ptri(ulong_t, R_ESP + 12)), from_ptriv(R_ESP + 16))); if (*(ptr_t*)(from_ptr((R_ESP + 8)))) to_struct_p(*(ptr_t*)(from_ptr((R_ESP + 8))), &arg_8); } void iFEpprLL__32(x64emu_t *emu, uintptr_t fcn) { iFEpprLL__t fn = (iFEpprLL__t)fcn; struct_LL_t arg_12; from_struct_LL(&arg_12, *(ptr_t*)(from_ptr((R_ESP + 12)))); R_EAX = fn(emu, from_ptriv(R_ESP + 4), from_ptriv(R_ESP + 8), *(ptr_t*)(from_ptr((R_ESP + 12))) ? &arg_12 : NULL); } +void iFXLpBhWcc__32(x64emu_t *emu, uintptr_t fcn) { iFXLpBhWcc__t fn = (iFXLpBhWcc__t)fcn; struct_hWcc_t arg_16; R_EAX = fn(getDisplay(from_ptriv(R_ESP + 4)), to_ulong(from_ptri(ulong_t, R_ESP + 8)), from_ptriv(R_ESP + 12), *(ptr_t*)(from_ptr((R_ESP + 16))) ? &arg_16 : NULL); if (*(ptr_t*)(from_ptr((R_ESP + 16)))) to_struct_hWcc(*(ptr_t*)(from_ptr((R_ESP + 16))), &arg_16); } void LFpLpriiiiiiiiilt__32(x64emu_t *emu, uintptr_t fcn) { LFpLpriiiiiiiiilt__t fn = (LFpLpriiiiiiiiilt__t)fcn; struct_iiiiiiiiilt_t arg_16; from_struct_iiiiiiiiilt(&arg_16, *(ptr_t*)(from_ptr((R_ESP + 16)))); R_EAX = to_ulong(fn(from_ptriv(R_ESP + 4), to_ulong(from_ptri(ulong_t, R_ESP + 8)), from_ptriv(R_ESP + 12), *(ptr_t*)(from_ptr((R_ESP + 16))) ? &arg_16 : NULL)); } +void vFEuipp_32(x64emu_t *emu, uintptr_t fcn) { vFEuipp_t fn = (vFEuipp_t)fcn; fn(emu, from_ptri(uint32_t, R_ESP + 4), from_ptri(int32_t, R_ESP + 8), from_ptriv(R_ESP + 12), from_ptriv(R_ESP + 16)); } void vFEpLLp_32(x64emu_t *emu, uintptr_t fcn) { vFEpLLp_t fn = (vFEpLLp_t)fcn; fn(emu, from_ptriv(R_ESP + 4), to_ulong(from_ptri(ulong_t, R_ESP + 8)), to_ulong(from_ptri(ulong_t, R_ESP + 12)), from_ptriv(R_ESP + 16)); } void vFiiiii_32(x64emu_t *emu, uintptr_t fcn) { vFiiiii_t fn = (vFiiiii_t)fcn; fn(from_ptri(int32_t, R_ESP + 4), from_ptri(int32_t, R_ESP + 8), from_ptri(int32_t, R_ESP + 12), from_ptri(int32_t, R_ESP + 16), from_ptri(int32_t, R_ESP + 20)); } void vFiiiiu_32(x64emu_t *emu, uintptr_t fcn) { vFiiiiu_t fn = (vFiiiiu_t)fcn; fn(from_ptri(int32_t, R_ESP + 4), from_ptri(int32_t, R_ESP + 8), from_ptri(int32_t, R_ESP + 12), from_ptri(int32_t, R_ESP + 16), from_ptri(uint32_t, R_ESP + 20)); } @@ -1582,23 +1657,23 @@ void iFiiipu_32(x64emu_t *emu, uintptr_t fcn) { iFiiipu_t fn = (iFiiipu_t)fcn; R void iFiiipp_32(x64emu_t *emu, uintptr_t fcn) { iFiiipp_t fn = (iFiiipp_t)fcn; R_EAX = fn(from_ptri(int32_t, R_ESP + 4), from_ptri(int32_t, R_ESP + 8), from_ptri(int32_t, R_ESP + 12), from_ptriv(R_ESP + 16), from_ptriv(R_ESP + 20)); } void iFiLLLL_32(x64emu_t *emu, uintptr_t fcn) { iFiLLLL_t fn = (iFiLLLL_t)fcn; R_EAX = fn(from_ptri(int32_t, R_ESP + 4), to_ulong(from_ptri(ulong_t, R_ESP + 8)), to_ulong(from_ptri(ulong_t, R_ESP + 12)), to_ulong(from_ptri(ulong_t, R_ESP + 16)), to_ulong(from_ptri(ulong_t, R_ESP + 20))); } void iFipLLi_32(x64emu_t *emu, uintptr_t fcn) { iFipLLi_t fn = (iFipLLi_t)fcn; R_EAX = fn(from_ptri(int32_t, R_ESP + 4), from_ptriv(R_ESP + 8), to_ulong(from_ptri(ulong_t, R_ESP + 12)), to_ulong(from_ptri(ulong_t, R_ESP + 16)), from_ptri(int32_t, R_ESP + 20)); } -void iFpiiip_32(x64emu_t *emu, uintptr_t fcn) { iFpiiip_t fn = (iFpiiip_t)fcn; R_EAX = fn(from_ptriv(R_ESP + 4), from_ptri(int32_t, R_ESP + 8), from_ptri(int32_t, R_ESP + 12), from_ptri(int32_t, R_ESP + 16), from_ptriv(R_ESP + 20)); } -void iFpippp_32(x64emu_t *emu, uintptr_t fcn) { iFpippp_t fn = (iFpippp_t)fcn; R_EAX = fn(from_ptriv(R_ESP + 4), from_ptri(int32_t, R_ESP + 8), from_ptriv(R_ESP + 12), from_ptriv(R_ESP + 16), from_ptriv(R_ESP + 20)); } -void iFppipi_32(x64emu_t *emu, uintptr_t fcn) { iFppipi_t fn = (iFppipi_t)fcn; R_EAX = fn(from_ptriv(R_ESP + 4), from_ptriv(R_ESP + 8), from_ptri(int32_t, R_ESP + 12), from_ptriv(R_ESP + 16), from_ptri(int32_t, R_ESP + 20)); } +void iFpLuLi_32(x64emu_t *emu, uintptr_t fcn) { iFpLuLi_t fn = (iFpLuLi_t)fcn; R_EAX = fn(from_ptriv(R_ESP + 4), to_ulong(from_ptri(ulong_t, R_ESP + 8)), from_ptri(uint32_t, R_ESP + 12), to_ulong(from_ptri(ulong_t, R_ESP + 16)), from_ptri(int32_t, R_ESP + 20)); } void iFpppip_32(x64emu_t *emu, uintptr_t fcn) { iFpppip_t fn = (iFpppip_t)fcn; R_EAX = fn(from_ptriv(R_ESP + 4), from_ptriv(R_ESP + 8), from_ptriv(R_ESP + 12), from_ptri(int32_t, R_ESP + 16), from_ptriv(R_ESP + 20)); } void iFpppup_32(x64emu_t *emu, uintptr_t fcn) { iFpppup_t fn = (iFpppup_t)fcn; R_EAX = fn(from_ptriv(R_ESP + 4), from_ptriv(R_ESP + 8), from_ptriv(R_ESP + 12), from_ptri(uint32_t, R_ESP + 16), from_ptriv(R_ESP + 20)); } void iFppppp_32(x64emu_t *emu, uintptr_t fcn) { iFppppp_t fn = (iFppppp_t)fcn; R_EAX = fn(from_ptriv(R_ESP + 4), from_ptriv(R_ESP + 8), from_ptriv(R_ESP + 12), from_ptriv(R_ESP + 16), from_ptriv(R_ESP + 20)); } -void IFppIII_32(x64emu_t *emu, uintptr_t fcn) { IFppIII_t fn = (IFppIII_t)fcn; ui64_t r; r.i = fn(from_ptriv(R_ESP + 4), from_ptriv(R_ESP + 8), from_ptri(int64_t, R_ESP + 12), from_ptri(int64_t, R_ESP + 20), from_ptri(int64_t, R_ESP + 28)); R_EAX = r.d[0]; R_EDX = r.d[1]; } +void iFXiiip_32(x64emu_t *emu, uintptr_t fcn) { iFXiiip_t fn = (iFXiiip_t)fcn; R_EAX = fn(getDisplay(from_ptriv(R_ESP + 4)), from_ptri(int32_t, R_ESP + 8), from_ptri(int32_t, R_ESP + 12), from_ptri(int32_t, R_ESP + 16), from_ptriv(R_ESP + 20)); } +void iFXpppp_32(x64emu_t *emu, uintptr_t fcn) { iFXpppp_t fn = (iFXpppp_t)fcn; R_EAX = fn(getDisplay(from_ptriv(R_ESP + 4)), from_ptriv(R_ESP + 8), from_ptriv(R_ESP + 12), from_ptriv(R_ESP + 16), from_ptriv(R_ESP + 20)); } +void IFXpIII_32(x64emu_t *emu, uintptr_t fcn) { IFXpIII_t fn = (IFXpIII_t)fcn; ui64_t r; r.i = fn(getDisplay(from_ptriv(R_ESP + 4)), from_ptriv(R_ESP + 8), from_ptri(int64_t, R_ESP + 12), from_ptri(int64_t, R_ESP + 20), from_ptri(int64_t, R_ESP + 28)); R_EAX = r.d[0]; R_EDX = r.d[1]; } void uFpLLLS_32(x64emu_t *emu, uintptr_t fcn) { uFpLLLS_t fn = (uFpLLLS_t)fcn; R_EAX = (uint32_t)fn(from_ptriv(R_ESP + 4), to_ulong(from_ptri(ulong_t, R_ESP + 8)), to_ulong(from_ptri(ulong_t, R_ESP + 12)), to_ulong(from_ptri(ulong_t, R_ESP + 16)), io_convert32(from_ptriv(R_ESP + 20))); } void UFuiCiu_32(x64emu_t *emu, uintptr_t fcn) { UFuiCiu_t fn = (UFuiCiu_t)fcn; ui64_t r; r.u = (uint64_t)fn(from_ptri(uint32_t, R_ESP + 4), from_ptri(int32_t, R_ESP + 8), from_ptri(uint8_t, R_ESP + 12), from_ptri(int32_t, R_ESP + 16), from_ptri(uint32_t, R_ESP + 20)); R_EAX = r.d[0]; R_EDX = r.d[1]; } void lFpuipC_32(x64emu_t *emu, uintptr_t fcn) { lFpuipC_t fn = (lFpuipC_t)fcn; R_EAX = to_long(fn(from_ptriv(R_ESP + 4), from_ptri(uint32_t, R_ESP + 8), from_ptri(int32_t, R_ESP + 12), from_ptriv(R_ESP + 16), from_ptri(uint8_t, R_ESP + 20))); } void LFpLppa_32(x64emu_t *emu, uintptr_t fcn) { LFpLppa_t fn = (LFpLppa_t)fcn; R_EAX = to_ulong(fn(from_ptriv(R_ESP + 4), to_ulong(from_ptri(ulong_t, R_ESP + 8)), from_ptriv(R_ESP + 12), from_ptriv(R_ESP + 16), from_locale(from_ptri(ptr_t, R_ESP + 20)))); } +void LFXLuuu_32(x64emu_t *emu, uintptr_t fcn) { LFXLuuu_t fn = (LFXLuuu_t)fcn; R_EAX = to_ulong(fn(getDisplay(from_ptriv(R_ESP + 4)), to_ulong(from_ptri(ulong_t, R_ESP + 8)), from_ptri(uint32_t, R_ESP + 12), from_ptri(uint32_t, R_ESP + 16), from_ptri(uint32_t, R_ESP + 20))); } void pFuiupp_32(x64emu_t *emu, uintptr_t fcn) { pFuiupp_t fn = (pFuiupp_t)fcn; R_EAX = to_ptrv(fn(from_ptri(uint32_t, R_ESP + 4), from_ptri(int32_t, R_ESP + 8), from_ptri(uint32_t, R_ESP + 12), from_ptriv(R_ESP + 16), from_ptriv(R_ESP + 20))); } +void pFpiiuu_32(x64emu_t *emu, uintptr_t fcn) { pFpiiuu_t fn = (pFpiiuu_t)fcn; R_EAX = to_ptrv(fn(from_ptriv(R_ESP + 4), from_ptri(int32_t, R_ESP + 8), from_ptri(int32_t, R_ESP + 12), from_ptri(uint32_t, R_ESP + 16), from_ptri(uint32_t, R_ESP + 20))); } void pFpippp_32(x64emu_t *emu, uintptr_t fcn) { pFpippp_t fn = (pFpippp_t)fcn; R_EAX = to_ptrv(fn(from_ptriv(R_ESP + 4), from_ptri(int32_t, R_ESP + 8), from_ptriv(R_ESP + 12), from_ptriv(R_ESP + 16), from_ptriv(R_ESP + 20))); } -void pFppipi_32(x64emu_t *emu, uintptr_t fcn) { pFppipi_t fn = (pFppipi_t)fcn; R_EAX = to_ptrv(fn(from_ptriv(R_ESP + 4), from_ptriv(R_ESP + 8), from_ptri(int32_t, R_ESP + 12), from_ptriv(R_ESP + 16), from_ptri(int32_t, R_ESP + 20))); } void pFppuup_32(x64emu_t *emu, uintptr_t fcn) { pFppuup_t fn = (pFppuup_t)fcn; R_EAX = to_ptrv(fn(from_ptriv(R_ESP + 4), from_ptriv(R_ESP + 8), from_ptri(uint32_t, R_ESP + 12), from_ptri(uint32_t, R_ESP + 16), from_ptriv(R_ESP + 20))); } void pFppupp_32(x64emu_t *emu, uintptr_t fcn) { pFppupp_t fn = (pFppupp_t)fcn; R_EAX = to_ptrv(fn(from_ptriv(R_ESP + 4), from_ptriv(R_ESP + 8), from_ptri(uint32_t, R_ESP + 12), from_ptriv(R_ESP + 16), from_ptriv(R_ESP + 20))); } -void pFpppip_32(x64emu_t *emu, uintptr_t fcn) { pFpppip_t fn = (pFpppip_t)fcn; R_EAX = to_ptrv(fn(from_ptriv(R_ESP + 4), from_ptriv(R_ESP + 8), from_ptriv(R_ESP + 12), from_ptri(int32_t, R_ESP + 16), from_ptriv(R_ESP + 20))); } void iFEBh_ppp_32(x64emu_t *emu, uintptr_t fcn) { iFEBh_ppp_t fn = (iFEBh_ppp_t)fcn; struct_h_t arg_4; R_EAX = fn(emu, *(ptr_t*)(from_ptr((R_ESP + 4))) ? &arg_4 : NULL, from_ptriv(R_ESP + 8), from_ptriv(R_ESP + 12), from_ptriv(R_ESP + 16)); if (*(ptr_t*)(from_ptr((R_ESP + 4)))) to_struct_h(*(ptr_t*)(from_ptr((R_ESP + 4))), &arg_4); } void LFpbp_LLp_32(x64emu_t *emu, uintptr_t fcn) { LFpbp_LLp_t fn = (LFpbp_LLp_t)fcn; struct_p_t arg_8; from_struct_p(&arg_8, *(ptr_t*)(from_ptr((R_ESP + 8)))); R_EAX = to_ulong(fn(from_ptriv(R_ESP + 4), *(ptr_t*)(from_ptr((R_ESP + 8))) ? &arg_8 : NULL, to_ulong(from_ptri(ulong_t, R_ESP + 12)), to_ulong(from_ptri(ulong_t, R_ESP + 16)), from_ptriv(R_ESP + 20))); if (*(ptr_t*)(from_ptr((R_ESP + 8)))) to_struct_p(*(ptr_t*)(from_ptr((R_ESP + 8))), &arg_8); } void LFpBp_LLp_32(x64emu_t *emu, uintptr_t fcn) { LFpBp_LLp_t fn = (LFpBp_LLp_t)fcn; struct_p_t arg_8; R_EAX = to_ulong(fn(from_ptriv(R_ESP + 4), *(ptr_t*)(from_ptr((R_ESP + 8))) ? &arg_8 : NULL, to_ulong(from_ptri(ulong_t, R_ESP + 12)), to_ulong(from_ptri(ulong_t, R_ESP + 16)), from_ptriv(R_ESP + 20))); if (*(ptr_t*)(from_ptr((R_ESP + 8)))) to_struct_p(*(ptr_t*)(from_ptr((R_ESP + 8))), &arg_8); } @@ -1667,18 +1742,17 @@ void vFffffff_32(x64emu_t *emu, uintptr_t fcn) { vFffffff_t fn = (vFffffff_t)fcn void vFdddddd_32(x64emu_t *emu, uintptr_t fcn) { vFdddddd_t fn = (vFdddddd_t)fcn; fn(from_ptri(double, R_ESP + 4), from_ptri(double, R_ESP + 12), from_ptri(double, R_ESP + 20), from_ptri(double, R_ESP + 28), from_ptri(double, R_ESP + 36), from_ptri(double, R_ESP + 44)); } void vFpipipV_32(x64emu_t *emu, uintptr_t fcn) { vFpipipV_t fn = (vFpipipV_t)fcn; fn(from_ptriv(R_ESP + 4), from_ptri(int32_t, R_ESP + 8), from_ptriv(R_ESP + 12), from_ptri(int32_t, R_ESP + 16), from_ptriv(R_ESP + 20), from_ptrv(R_ESP + 24)); } void vFpdddii_32(x64emu_t *emu, uintptr_t fcn) { vFpdddii_t fn = (vFpdddii_t)fcn; fn(from_ptriv(R_ESP + 4), from_ptri(double, R_ESP + 8), from_ptri(double, R_ESP + 16), from_ptri(double, R_ESP + 24), from_ptri(int32_t, R_ESP + 32), from_ptri(int32_t, R_ESP + 36)); } -void vFppiiii_32(x64emu_t *emu, uintptr_t fcn) { vFppiiii_t fn = (vFppiiii_t)fcn; fn(from_ptriv(R_ESP + 4), from_ptriv(R_ESP + 8), from_ptri(int32_t, R_ESP + 12), from_ptri(int32_t, R_ESP + 16), from_ptri(int32_t, R_ESP + 20), from_ptri(int32_t, R_ESP + 24)); } void vFppupii_32(x64emu_t *emu, uintptr_t fcn) { vFppupii_t fn = (vFppupii_t)fcn; fn(from_ptriv(R_ESP + 4), from_ptriv(R_ESP + 8), from_ptri(uint32_t, R_ESP + 12), from_ptriv(R_ESP + 16), from_ptri(int32_t, R_ESP + 20), from_ptri(int32_t, R_ESP + 24)); } void iFuiiuup_32(x64emu_t *emu, uintptr_t fcn) { iFuiiuup_t fn = (iFuiiuup_t)fcn; R_EAX = fn(from_ptri(uint32_t, R_ESP + 4), from_ptri(int32_t, R_ESP + 8), from_ptri(int32_t, R_ESP + 12), from_ptri(uint32_t, R_ESP + 16), from_ptri(uint32_t, R_ESP + 20), from_ptriv(R_ESP + 24)); } -void iFpiiipp_32(x64emu_t *emu, uintptr_t fcn) { iFpiiipp_t fn = (iFpiiipp_t)fcn; R_EAX = fn(from_ptriv(R_ESP + 4), from_ptri(int32_t, R_ESP + 8), from_ptri(int32_t, R_ESP + 12), from_ptri(int32_t, R_ESP + 16), from_ptriv(R_ESP + 20), from_ptriv(R_ESP + 24)); } void iFpiippp_32(x64emu_t *emu, uintptr_t fcn) { iFpiippp_t fn = (iFpiippp_t)fcn; R_EAX = fn(from_ptriv(R_ESP + 4), from_ptri(int32_t, R_ESP + 8), from_ptri(int32_t, R_ESP + 12), from_ptriv(R_ESP + 16), from_ptriv(R_ESP + 20), from_ptriv(R_ESP + 24)); } void iFppiiii_32(x64emu_t *emu, uintptr_t fcn) { iFppiiii_t fn = (iFppiiii_t)fcn; R_EAX = fn(from_ptriv(R_ESP + 4), from_ptriv(R_ESP + 8), from_ptri(int32_t, R_ESP + 12), from_ptri(int32_t, R_ESP + 16), from_ptri(int32_t, R_ESP + 20), from_ptri(int32_t, R_ESP + 24)); } -void iFppIppp_32(x64emu_t *emu, uintptr_t fcn) { iFppIppp_t fn = (iFppIppp_t)fcn; R_EAX = fn(from_ptriv(R_ESP + 4), from_ptriv(R_ESP + 8), from_ptri(int64_t, R_ESP + 12), from_ptriv(R_ESP + 20), from_ptriv(R_ESP + 24), from_ptriv(R_ESP + 28)); } +void iFXLiiiL_32(x64emu_t *emu, uintptr_t fcn) { iFXLiiiL_t fn = (iFXLiiiL_t)fcn; R_EAX = fn(getDisplay(from_ptriv(R_ESP + 4)), to_ulong(from_ptri(ulong_t, R_ESP + 8)), from_ptri(int32_t, R_ESP + 12), from_ptri(int32_t, R_ESP + 16), from_ptri(int32_t, R_ESP + 20), to_ulong(from_ptri(ulong_t, R_ESP + 24))); } +void iFXpIppp_32(x64emu_t *emu, uintptr_t fcn) { iFXpIppp_t fn = (iFXpIppp_t)fcn; R_EAX = fn(getDisplay(from_ptriv(R_ESP + 4)), from_ptriv(R_ESP + 8), from_ptri(int64_t, R_ESP + 12), from_ptriv(R_ESP + 20), from_ptriv(R_ESP + 24), from_ptriv(R_ESP + 28)); } void uFupuufp_32(x64emu_t *emu, uintptr_t fcn) { uFupuufp_t fn = (uFupuufp_t)fcn; R_EAX = (uint32_t)fn(from_ptri(uint32_t, R_ESP + 4), from_ptriv(R_ESP + 8), from_ptri(uint32_t, R_ESP + 12), from_ptri(uint32_t, R_ESP + 16), from_ptri(float, R_ESP + 20), from_ptriv(R_ESP + 24)); } void lFipLipu_32(x64emu_t *emu, uintptr_t fcn) { lFipLipu_t fn = (lFipLipu_t)fcn; R_EAX = to_long(fn(from_ptri(int32_t, R_ESP + 4), from_ptriv(R_ESP + 8), to_ulong(from_ptri(ulong_t, R_ESP + 12)), from_ptri(int32_t, R_ESP + 16), from_ptriv(R_ESP + 20), from_ptri(uint32_t, R_ESP + 24))); } void lFipLipp_32(x64emu_t *emu, uintptr_t fcn) { lFipLipp_t fn = (lFipLipp_t)fcn; R_EAX = to_long(fn(from_ptri(int32_t, R_ESP + 4), from_ptriv(R_ESP + 8), to_ulong(from_ptri(ulong_t, R_ESP + 12)), from_ptri(int32_t, R_ESP + 16), from_ptriv(R_ESP + 20), from_ptriv(R_ESP + 24))); } +void pFEpiiuu_32(x64emu_t *emu, uintptr_t fcn) { pFEpiiuu_t fn = (pFEpiiuu_t)fcn; R_EAX = to_ptrv(fn(emu, from_ptriv(R_ESP + 4), from_ptri(int32_t, R_ESP + 8), from_ptri(int32_t, R_ESP + 12), from_ptri(uint32_t, R_ESP + 16), from_ptri(uint32_t, R_ESP + 20))); } void pFEpLLiN_32(x64emu_t *emu, uintptr_t fcn) { pFEpLLiN_t fn = (pFEpLLiN_t)fcn; R_EAX = to_ptrv(fn(emu, from_ptriv(R_ESP + 4), to_ulong(from_ptri(ulong_t, R_ESP + 8)), to_ulong(from_ptri(ulong_t, R_ESP + 12)), from_ptri(int32_t, R_ESP + 16), from_ptriv(R_ESP + 20))); } -void pFpippip_32(x64emu_t *emu, uintptr_t fcn) { pFpippip_t fn = (pFpippip_t)fcn; R_EAX = to_ptrv(fn(from_ptriv(R_ESP + 4), from_ptri(int32_t, R_ESP + 8), from_ptriv(R_ESP + 12), from_ptriv(R_ESP + 16), from_ptri(int32_t, R_ESP + 20), from_ptriv(R_ESP + 24))); } void vFiiiiiip_32(x64emu_t *emu, uintptr_t fcn) { vFiiiiiip_t fn = (vFiiiiiip_t)fcn; fn(from_ptri(int32_t, R_ESP + 4), from_ptri(int32_t, R_ESP + 8), from_ptri(int32_t, R_ESP + 12), from_ptri(int32_t, R_ESP + 16), from_ptri(int32_t, R_ESP + 20), from_ptri(int32_t, R_ESP + 24), from_ptriv(R_ESP + 28)); } void vFiiiiuup_32(x64emu_t *emu, uintptr_t fcn) { vFiiiiuup_t fn = (vFiiiiuup_t)fcn; fn(from_ptri(int32_t, R_ESP + 4), from_ptri(int32_t, R_ESP + 8), from_ptri(int32_t, R_ESP + 12), from_ptri(int32_t, R_ESP + 16), from_ptri(uint32_t, R_ESP + 20), from_ptri(uint32_t, R_ESP + 24), from_ptriv(R_ESP + 28)); } void vFiiuilil_32(x64emu_t *emu, uintptr_t fcn) { vFiiuilil_t fn = (vFiiuilil_t)fcn; fn(from_ptri(int32_t, R_ESP + 4), from_ptri(int32_t, R_ESP + 8), from_ptri(uint32_t, R_ESP + 12), from_ptri(int32_t, R_ESP + 16), to_long(from_ptri(long_t, R_ESP + 20)), from_ptri(int32_t, R_ESP + 24), to_long(from_ptri(long_t, R_ESP + 28))); } @@ -1733,7 +1807,9 @@ void vFpddiidd_32(x64emu_t *emu, uintptr_t fcn) { vFpddiidd_t fn = (vFpddiidd_t) void iFEpLiipV_32(x64emu_t *emu, uintptr_t fcn) { iFEpLiipV_t fn = (iFEpLiipV_t)fcn; R_EAX = fn(emu, from_ptriv(R_ESP + 4), to_ulong(from_ptri(ulong_t, R_ESP + 8)), from_ptri(int32_t, R_ESP + 12), from_ptri(int32_t, R_ESP + 16), from_ptriv(R_ESP + 20), from_ptrv(R_ESP + 24)); } void iFuiiiuup_32(x64emu_t *emu, uintptr_t fcn) { iFuiiiuup_t fn = (iFuiiiuup_t)fcn; R_EAX = fn(from_ptri(uint32_t, R_ESP + 4), from_ptri(int32_t, R_ESP + 8), from_ptri(int32_t, R_ESP + 12), from_ptri(int32_t, R_ESP + 16), from_ptri(uint32_t, R_ESP + 20), from_ptri(uint32_t, R_ESP + 24), from_ptriv(R_ESP + 28)); } void iFpupLpLi_32(x64emu_t *emu, uintptr_t fcn) { iFpupLpLi_t fn = (iFpupLpLi_t)fcn; R_EAX = fn(from_ptriv(R_ESP + 4), from_ptri(uint32_t, R_ESP + 8), from_ptriv(R_ESP + 12), to_ulong(from_ptri(ulong_t, R_ESP + 16)), from_ptriv(R_ESP + 20), to_ulong(from_ptri(ulong_t, R_ESP + 24)), from_ptri(int32_t, R_ESP + 28)); } +void iFXiuLiii_32(x64emu_t *emu, uintptr_t fcn) { iFXiuLiii_t fn = (iFXiuLiii_t)fcn; R_EAX = fn(getDisplay(from_ptriv(R_ESP + 4)), from_ptri(int32_t, R_ESP + 8), from_ptri(uint32_t, R_ESP + 12), to_ulong(from_ptri(ulong_t, R_ESP + 16)), from_ptri(int32_t, R_ESP + 20), from_ptri(int32_t, R_ESP + 24), from_ptri(int32_t, R_ESP + 28)); } void uFuippppp_32(x64emu_t *emu, uintptr_t fcn) { uFuippppp_t fn = (uFuippppp_t)fcn; R_EAX = (uint32_t)fn(from_ptri(uint32_t, R_ESP + 4), from_ptri(int32_t, R_ESP + 8), from_ptriv(R_ESP + 12), from_ptriv(R_ESP + 16), from_ptriv(R_ESP + 20), from_ptriv(R_ESP + 24), from_ptriv(R_ESP + 28)); } +void LFXLLppuu_32(x64emu_t *emu, uintptr_t fcn) { LFXLLppuu_t fn = (LFXLLppuu_t)fcn; R_EAX = to_ulong(fn(getDisplay(from_ptriv(R_ESP + 4)), to_ulong(from_ptri(ulong_t, R_ESP + 8)), to_ulong(from_ptri(ulong_t, R_ESP + 12)), from_ptriv(R_ESP + 16), from_ptriv(R_ESP + 20), from_ptri(uint32_t, R_ESP + 24), from_ptri(uint32_t, R_ESP + 28))); } void pFEpLiiii_32(x64emu_t *emu, uintptr_t fcn) { pFEpLiiii_t fn = (pFEpLiiii_t)fcn; R_EAX = to_ptrv(fn(emu, from_ptriv(R_ESP + 4), to_ulong(from_ptri(ulong_t, R_ESP + 8)), from_ptri(int32_t, R_ESP + 12), from_ptri(int32_t, R_ESP + 16), from_ptri(int32_t, R_ESP + 20), from_ptri(int32_t, R_ESP + 24))); } void pFEpLiiiI_32(x64emu_t *emu, uintptr_t fcn) { pFEpLiiiI_t fn = (pFEpLiiiI_t)fcn; R_EAX = to_ptrv(fn(emu, from_ptriv(R_ESP + 4), to_ulong(from_ptri(ulong_t, R_ESP + 8)), from_ptri(int32_t, R_ESP + 12), from_ptri(int32_t, R_ESP + 16), from_ptri(int32_t, R_ESP + 20), from_ptri(int64_t, R_ESP + 24))); } void vFiiiiuuip_32(x64emu_t *emu, uintptr_t fcn) { vFiiiiuuip_t fn = (vFiiiiuuip_t)fcn; fn(from_ptri(int32_t, R_ESP + 4), from_ptri(int32_t, R_ESP + 8), from_ptri(int32_t, R_ESP + 12), from_ptri(int32_t, R_ESP + 16), from_ptri(uint32_t, R_ESP + 20), from_ptri(uint32_t, R_ESP + 24), from_ptri(int32_t, R_ESP + 28), from_ptriv(R_ESP + 32)); } @@ -1765,11 +1841,12 @@ void vFuuufffff_32(x64emu_t *emu, uintptr_t fcn) { vFuuufffff_t fn = (vFuuufffff void vFffffffff_32(x64emu_t *emu, uintptr_t fcn) { vFffffffff_t fn = (vFffffffff_t)fcn; fn(from_ptri(float, R_ESP + 4), from_ptri(float, R_ESP + 8), from_ptri(float, R_ESP + 12), from_ptri(float, R_ESP + 16), from_ptri(float, R_ESP + 20), from_ptri(float, R_ESP + 24), from_ptri(float, R_ESP + 28), from_ptri(float, R_ESP + 32)); } void iFEpippppp_32(x64emu_t *emu, uintptr_t fcn) { iFEpippppp_t fn = (iFEpippppp_t)fcn; R_EAX = fn(emu, from_ptriv(R_ESP + 4), from_ptri(int32_t, R_ESP + 8), from_ptriv(R_ESP + 12), from_ptriv(R_ESP + 16), from_ptriv(R_ESP + 20), from_ptriv(R_ESP + 24), from_ptriv(R_ESP + 28)); } void iFuiiiiuup_32(x64emu_t *emu, uintptr_t fcn) { iFuiiiiuup_t fn = (iFuiiiiuup_t)fcn; R_EAX = fn(from_ptri(uint32_t, R_ESP + 4), from_ptri(int32_t, R_ESP + 8), from_ptri(int32_t, R_ESP + 12), from_ptri(int32_t, R_ESP + 16), from_ptri(int32_t, R_ESP + 20), from_ptri(uint32_t, R_ESP + 24), from_ptri(uint32_t, R_ESP + 28), from_ptriv(R_ESP + 32)); } -void iFppIIIppp_32(x64emu_t *emu, uintptr_t fcn) { iFppIIIppp_t fn = (iFppIIIppp_t)fcn; R_EAX = fn(from_ptriv(R_ESP + 4), from_ptriv(R_ESP + 8), from_ptri(int64_t, R_ESP + 12), from_ptri(int64_t, R_ESP + 20), from_ptri(int64_t, R_ESP + 28), from_ptriv(R_ESP + 36), from_ptriv(R_ESP + 40), from_ptriv(R_ESP + 44)); } +void iFXpIIIppp_32(x64emu_t *emu, uintptr_t fcn) { iFXpIIIppp_t fn = (iFXpIIIppp_t)fcn; R_EAX = fn(getDisplay(from_ptriv(R_ESP + 4)), from_ptriv(R_ESP + 8), from_ptri(int64_t, R_ESP + 12), from_ptri(int64_t, R_ESP + 20), from_ptri(int64_t, R_ESP + 28), from_ptriv(R_ESP + 36), from_ptriv(R_ESP + 40), from_ptriv(R_ESP + 44)); } void CFuiifpppp_32(x64emu_t *emu, uintptr_t fcn) { CFuiifpppp_t fn = (CFuiifpppp_t)fcn; R_EAX = (unsigned char)fn(from_ptri(uint32_t, R_ESP + 4), from_ptri(int32_t, R_ESP + 8), from_ptri(int32_t, R_ESP + 12), from_ptri(float, R_ESP + 16), from_ptriv(R_ESP + 20), from_ptriv(R_ESP + 24), from_ptriv(R_ESP + 28), from_ptriv(R_ESP + 32)); } void uFuipppppp_32(x64emu_t *emu, uintptr_t fcn) { uFuipppppp_t fn = (uFuipppppp_t)fcn; R_EAX = (uint32_t)fn(from_ptri(uint32_t, R_ESP + 4), from_ptri(int32_t, R_ESP + 8), from_ptriv(R_ESP + 12), from_ptriv(R_ESP + 16), from_ptriv(R_ESP + 20), from_ptriv(R_ESP + 24), from_ptriv(R_ESP + 28), from_ptriv(R_ESP + 32)); } void uFuupuuiuf_32(x64emu_t *emu, uintptr_t fcn) { uFuupuuiuf_t fn = (uFuupuuiuf_t)fcn; R_EAX = (uint32_t)fn(from_ptri(uint32_t, R_ESP + 4), from_ptri(uint32_t, R_ESP + 8), from_ptriv(R_ESP + 12), from_ptri(uint32_t, R_ESP + 16), from_ptri(uint32_t, R_ESP + 20), from_ptri(int32_t, R_ESP + 24), from_ptri(uint32_t, R_ESP + 28), from_ptri(float, R_ESP + 32)); } void uFulpppppp_32(x64emu_t *emu, uintptr_t fcn) { uFulpppppp_t fn = (uFulpppppp_t)fcn; R_EAX = (uint32_t)fn(from_ptri(uint32_t, R_ESP + 4), to_long(from_ptri(long_t, R_ESP + 8)), from_ptriv(R_ESP + 12), from_ptriv(R_ESP + 16), from_ptriv(R_ESP + 20), from_ptriv(R_ESP + 24), from_ptriv(R_ESP + 28), from_ptriv(R_ESP + 32)); } +void LFXLpuuLLu_32(x64emu_t *emu, uintptr_t fcn) { LFXLpuuLLu_t fn = (LFXLpuuLLu_t)fcn; R_EAX = to_ulong(fn(getDisplay(from_ptriv(R_ESP + 4)), to_ulong(from_ptri(ulong_t, R_ESP + 8)), from_ptriv(R_ESP + 12), from_ptri(uint32_t, R_ESP + 16), from_ptri(uint32_t, R_ESP + 20), to_ulong(from_ptri(ulong_t, R_ESP + 24)), to_ulong(from_ptri(ulong_t, R_ESP + 28)), from_ptri(uint32_t, R_ESP + 32))); } void vFiiiiiiiii_32(x64emu_t *emu, uintptr_t fcn) { vFiiiiiiiii_t fn = (vFiiiiiiiii_t)fcn; fn(from_ptri(int32_t, R_ESP + 4), from_ptri(int32_t, R_ESP + 8), from_ptri(int32_t, R_ESP + 12), from_ptri(int32_t, R_ESP + 16), from_ptri(int32_t, R_ESP + 20), from_ptri(int32_t, R_ESP + 24), from_ptri(int32_t, R_ESP + 28), from_ptri(int32_t, R_ESP + 32), from_ptri(int32_t, R_ESP + 36)); } void vFiiiiiiill_32(x64emu_t *emu, uintptr_t fcn) { vFiiiiiiill_t fn = (vFiiiiiiill_t)fcn; fn(from_ptri(int32_t, R_ESP + 4), from_ptri(int32_t, R_ESP + 8), from_ptri(int32_t, R_ESP + 12), from_ptri(int32_t, R_ESP + 16), from_ptri(int32_t, R_ESP + 20), from_ptri(int32_t, R_ESP + 24), from_ptri(int32_t, R_ESP + 28), to_long(from_ptri(long_t, R_ESP + 32)), to_long(from_ptri(long_t, R_ESP + 36))); } void vFiiiiillli_32(x64emu_t *emu, uintptr_t fcn) { vFiiiiillli_t fn = (vFiiiiillli_t)fcn; fn(from_ptri(int32_t, R_ESP + 4), from_ptri(int32_t, R_ESP + 8), from_ptri(int32_t, R_ESP + 12), from_ptri(int32_t, R_ESP + 16), from_ptri(int32_t, R_ESP + 20), to_long(from_ptri(long_t, R_ESP + 24)), to_long(from_ptri(long_t, R_ESP + 28)), to_long(from_ptri(long_t, R_ESP + 32)), from_ptri(int32_t, R_ESP + 36)); } @@ -1797,7 +1874,9 @@ void vFddddddddd_32(x64emu_t *emu, uintptr_t fcn) { vFddddddddd_t fn = (vFdddddd void iFuiiuuiiip_32(x64emu_t *emu, uintptr_t fcn) { iFuiiuuiiip_t fn = (iFuiiuuiiip_t)fcn; R_EAX = fn(from_ptri(uint32_t, R_ESP + 4), from_ptri(int32_t, R_ESP + 8), from_ptri(int32_t, R_ESP + 12), from_ptri(uint32_t, R_ESP + 16), from_ptri(uint32_t, R_ESP + 20), from_ptri(int32_t, R_ESP + 24), from_ptri(int32_t, R_ESP + 28), from_ptri(int32_t, R_ESP + 32), from_ptriv(R_ESP + 36)); } void iFuiiupiiup_32(x64emu_t *emu, uintptr_t fcn) { iFuiiupiiup_t fn = (iFuiiupiiup_t)fcn; R_EAX = fn(from_ptri(uint32_t, R_ESP + 4), from_ptri(int32_t, R_ESP + 8), from_ptri(int32_t, R_ESP + 12), from_ptri(uint32_t, R_ESP + 16), from_ptriv(R_ESP + 20), from_ptri(int32_t, R_ESP + 24), from_ptri(int32_t, R_ESP + 28), from_ptri(uint32_t, R_ESP + 32), from_ptriv(R_ESP + 36)); } void iFdddpppppp_32(x64emu_t *emu, uintptr_t fcn) { iFdddpppppp_t fn = (iFdddpppppp_t)fcn; R_EAX = fn(from_ptri(double, R_ESP + 4), from_ptri(double, R_ESP + 12), from_ptri(double, R_ESP + 20), from_ptriv(R_ESP + 28), from_ptriv(R_ESP + 32), from_ptriv(R_ESP + 36), from_ptriv(R_ESP + 40), from_ptriv(R_ESP + 44), from_ptriv(R_ESP + 48)); } +void iFXLiuiiLLL_32(x64emu_t *emu, uintptr_t fcn) { iFXLiuiiLLL_t fn = (iFXLiuiiLLL_t)fcn; R_EAX = fn(getDisplay(from_ptriv(R_ESP + 4)), to_ulong(from_ptri(ulong_t, R_ESP + 8)), from_ptri(int32_t, R_ESP + 12), from_ptri(uint32_t, R_ESP + 16), from_ptri(int32_t, R_ESP + 20), from_ptri(int32_t, R_ESP + 24), to_ulong(from_ptri(ulong_t, R_ESP + 28)), to_ulong(from_ptri(ulong_t, R_ESP + 32)), to_ulong(from_ptri(ulong_t, R_ESP + 36))); } void uFuulpiuiuf_32(x64emu_t *emu, uintptr_t fcn) { uFuulpiuiuf_t fn = (uFuulpiuiuf_t)fcn; R_EAX = (uint32_t)fn(from_ptri(uint32_t, R_ESP + 4), from_ptri(uint32_t, R_ESP + 8), to_long(from_ptri(long_t, R_ESP + 12)), from_ptriv(R_ESP + 16), from_ptri(int32_t, R_ESP + 20), from_ptri(uint32_t, R_ESP + 24), from_ptri(int32_t, R_ESP + 28), from_ptri(uint32_t, R_ESP + 32), from_ptri(float, R_ESP + 36)); } +void pFEXLiiuuLi_32(x64emu_t *emu, uintptr_t fcn) { pFEXLiiuuLi_t fn = (pFEXLiiuuLi_t)fcn; R_EAX = to_ptrv(fn(emu, getDisplay(from_ptriv(R_ESP + 4)), to_ulong(from_ptri(ulong_t, R_ESP + 8)), from_ptri(int32_t, R_ESP + 12), from_ptri(int32_t, R_ESP + 16), from_ptri(uint32_t, R_ESP + 20), from_ptri(uint32_t, R_ESP + 24), to_ulong(from_ptri(ulong_t, R_ESP + 28)), from_ptri(int32_t, R_ESP + 32))); } void vFiiiiiiiiii_32(x64emu_t *emu, uintptr_t fcn) { vFiiiiiiiiii_t fn = (vFiiiiiiiiii_t)fcn; fn(from_ptri(int32_t, R_ESP + 4), from_ptri(int32_t, R_ESP + 8), from_ptri(int32_t, R_ESP + 12), from_ptri(int32_t, R_ESP + 16), from_ptri(int32_t, R_ESP + 20), from_ptri(int32_t, R_ESP + 24), from_ptri(int32_t, R_ESP + 28), from_ptri(int32_t, R_ESP + 32), from_ptri(int32_t, R_ESP + 36), from_ptri(int32_t, R_ESP + 40)); } void vFiiiiiiiiui_32(x64emu_t *emu, uintptr_t fcn) { vFiiiiiiiiui_t fn = (vFiiiiiiiiui_t)fcn; fn(from_ptri(int32_t, R_ESP + 4), from_ptri(int32_t, R_ESP + 8), from_ptri(int32_t, R_ESP + 12), from_ptri(int32_t, R_ESP + 16), from_ptri(int32_t, R_ESP + 20), from_ptri(int32_t, R_ESP + 24), from_ptri(int32_t, R_ESP + 28), from_ptri(int32_t, R_ESP + 32), from_ptri(uint32_t, R_ESP + 36), from_ptri(int32_t, R_ESP + 40)); } void vFiiiiiiiiuu_32(x64emu_t *emu, uintptr_t fcn) { vFiiiiiiiiuu_t fn = (vFiiiiiiiiuu_t)fcn; fn(from_ptri(int32_t, R_ESP + 4), from_ptri(int32_t, R_ESP + 8), from_ptri(int32_t, R_ESP + 12), from_ptri(int32_t, R_ESP + 16), from_ptri(int32_t, R_ESP + 20), from_ptri(int32_t, R_ESP + 24), from_ptri(int32_t, R_ESP + 28), from_ptri(int32_t, R_ESP + 32), from_ptri(uint32_t, R_ESP + 36), from_ptri(uint32_t, R_ESP + 40)); } @@ -1817,6 +1896,8 @@ void vFuffiiffiip_32(x64emu_t *emu, uintptr_t fcn) { vFuffiiffiip_t fn = (vFuffi void vFuddiiddiip_32(x64emu_t *emu, uintptr_t fcn) { vFuddiiddiip_t fn = (vFuddiiddiip_t)fcn; fn(from_ptri(uint32_t, R_ESP + 4), from_ptri(double, R_ESP + 8), from_ptri(double, R_ESP + 16), from_ptri(int32_t, R_ESP + 24), from_ptri(int32_t, R_ESP + 28), from_ptri(double, R_ESP + 32), from_ptri(double, R_ESP + 40), from_ptri(int32_t, R_ESP + 48), from_ptri(int32_t, R_ESP + 52), from_ptriv(R_ESP + 56)); } void vFffffffffff_32(x64emu_t *emu, uintptr_t fcn) { vFffffffffff_t fn = (vFffffffffff_t)fcn; fn(from_ptri(float, R_ESP + 4), from_ptri(float, R_ESP + 8), from_ptri(float, R_ESP + 12), from_ptri(float, R_ESP + 16), from_ptri(float, R_ESP + 20), from_ptri(float, R_ESP + 24), from_ptri(float, R_ESP + 28), from_ptri(float, R_ESP + 32), from_ptri(float, R_ESP + 36), from_ptri(float, R_ESP + 40)); } void iFuiiiuuiiip_32(x64emu_t *emu, uintptr_t fcn) { iFuiiiuuiiip_t fn = (iFuiiiuuiiip_t)fcn; R_EAX = fn(from_ptri(uint32_t, R_ESP + 4), from_ptri(int32_t, R_ESP + 8), from_ptri(int32_t, R_ESP + 12), from_ptri(int32_t, R_ESP + 16), from_ptri(uint32_t, R_ESP + 20), from_ptri(uint32_t, R_ESP + 24), from_ptri(int32_t, R_ESP + 28), from_ptri(int32_t, R_ESP + 32), from_ptri(int32_t, R_ESP + 36), from_ptriv(R_ESP + 40)); } +void iFXuuLiuiiLL_32(x64emu_t *emu, uintptr_t fcn) { iFXuuLiuiiLL_t fn = (iFXuuLiuiiLL_t)fcn; R_EAX = fn(getDisplay(from_ptriv(R_ESP + 4)), from_ptri(uint32_t, R_ESP + 8), from_ptri(uint32_t, R_ESP + 12), to_ulong(from_ptri(ulong_t, R_ESP + 16)), from_ptri(int32_t, R_ESP + 20), from_ptri(uint32_t, R_ESP + 24), from_ptri(int32_t, R_ESP + 28), from_ptri(int32_t, R_ESP + 32), to_ulong(from_ptri(ulong_t, R_ESP + 36)), to_ulong(from_ptri(ulong_t, R_ESP + 40))); } +void pFXpuiipuuii_32(x64emu_t *emu, uintptr_t fcn) { pFXpuiipuuii_t fn = (pFXpuiipuuii_t)fcn; R_EAX = to_ptrv(fn(getDisplay(from_ptriv(R_ESP + 4)), from_ptriv(R_ESP + 8), from_ptri(uint32_t, R_ESP + 12), from_ptri(int32_t, R_ESP + 16), from_ptri(int32_t, R_ESP + 20), from_ptriv(R_ESP + 24), from_ptri(uint32_t, R_ESP + 28), from_ptri(uint32_t, R_ESP + 32), from_ptri(int32_t, R_ESP + 36), from_ptri(int32_t, R_ESP + 40))); } void vFiiiiillliip_32(x64emu_t *emu, uintptr_t fcn) { vFiiiiillliip_t fn = (vFiiiiillliip_t)fcn; fn(from_ptri(int32_t, R_ESP + 4), from_ptri(int32_t, R_ESP + 8), from_ptri(int32_t, R_ESP + 12), from_ptri(int32_t, R_ESP + 16), from_ptri(int32_t, R_ESP + 20), to_long(from_ptri(long_t, R_ESP + 24)), to_long(from_ptri(long_t, R_ESP + 28)), to_long(from_ptri(long_t, R_ESP + 32)), from_ptri(int32_t, R_ESP + 36), from_ptri(int32_t, R_ESP + 40), from_ptriv(R_ESP + 44)); } void vFiiiiilllilp_32(x64emu_t *emu, uintptr_t fcn) { vFiiiiilllilp_t fn = (vFiiiiilllilp_t)fcn; fn(from_ptri(int32_t, R_ESP + 4), from_ptri(int32_t, R_ESP + 8), from_ptri(int32_t, R_ESP + 12), from_ptri(int32_t, R_ESP + 16), from_ptri(int32_t, R_ESP + 20), to_long(from_ptri(long_t, R_ESP + 24)), to_long(from_ptri(long_t, R_ESP + 28)), to_long(from_ptri(long_t, R_ESP + 32)), from_ptri(int32_t, R_ESP + 36), to_long(from_ptri(long_t, R_ESP + 40)), from_ptriv(R_ESP + 44)); } void vFuiiiiiiiuip_32(x64emu_t *emu, uintptr_t fcn) { vFuiiiiiiiuip_t fn = (vFuiiiiiiiuip_t)fcn; fn(from_ptri(uint32_t, R_ESP + 4), from_ptri(int32_t, R_ESP + 8), from_ptri(int32_t, R_ESP + 12), from_ptri(int32_t, R_ESP + 16), from_ptri(int32_t, R_ESP + 20), from_ptri(int32_t, R_ESP + 24), from_ptri(int32_t, R_ESP + 28), from_ptri(int32_t, R_ESP + 32), from_ptri(uint32_t, R_ESP + 36), from_ptri(int32_t, R_ESP + 40), from_ptriv(R_ESP + 44)); } @@ -1832,7 +1913,9 @@ void vFuUuuuuuuuuu_32(x64emu_t *emu, uintptr_t fcn) { vFuUuuuuuuuuu_t fn = (vFuU void vFuffffffffff_32(x64emu_t *emu, uintptr_t fcn) { vFuffffffffff_t fn = (vFuffffffffff_t)fcn; fn(from_ptri(uint32_t, R_ESP + 4), from_ptri(float, R_ESP + 8), from_ptri(float, R_ESP + 12), from_ptri(float, R_ESP + 16), from_ptri(float, R_ESP + 20), from_ptri(float, R_ESP + 24), from_ptri(float, R_ESP + 28), from_ptri(float, R_ESP + 32), from_ptri(float, R_ESP + 36), from_ptri(float, R_ESP + 40), from_ptri(float, R_ESP + 44)); } void vFUufffffffff_32(x64emu_t *emu, uintptr_t fcn) { vFUufffffffff_t fn = (vFUufffffffff_t)fcn; fn(from_ptri(uint64_t, R_ESP + 4), from_ptri(uint32_t, R_ESP + 12), from_ptri(float, R_ESP + 16), from_ptri(float, R_ESP + 20), from_ptri(float, R_ESP + 24), from_ptri(float, R_ESP + 28), from_ptri(float, R_ESP + 32), from_ptri(float, R_ESP + 36), from_ptri(float, R_ESP + 40), from_ptri(float, R_ESP + 44), from_ptri(float, R_ESP + 48)); } void vFpipipiipiiu_32(x64emu_t *emu, uintptr_t fcn) { vFpipipiipiiu_t fn = (vFpipipiipiiu_t)fcn; fn(from_ptriv(R_ESP + 4), from_ptri(int32_t, R_ESP + 8), from_ptriv(R_ESP + 12), from_ptri(int32_t, R_ESP + 16), from_ptriv(R_ESP + 20), from_ptri(int32_t, R_ESP + 24), from_ptri(int32_t, R_ESP + 28), from_ptriv(R_ESP + 32), from_ptri(int32_t, R_ESP + 36), from_ptri(int32_t, R_ESP + 40), from_ptri(uint32_t, R_ESP + 44)); } +void iFEXLppiiiiuu_32(x64emu_t *emu, uintptr_t fcn) { iFEXLppiiiiuu_t fn = (iFEXLppiiiiuu_t)fcn; R_EAX = fn(emu, getDisplay(from_ptriv(R_ESP + 4)), to_ulong(from_ptri(ulong_t, R_ESP + 8)), from_ptriv(R_ESP + 12), from_ptriv(R_ESP + 16), from_ptri(int32_t, R_ESP + 20), from_ptri(int32_t, R_ESP + 24), from_ptri(int32_t, R_ESP + 28), from_ptri(int32_t, R_ESP + 32), from_ptri(uint32_t, R_ESP + 36), from_ptri(uint32_t, R_ESP + 40)); } void iFuiiiiuuiiip_32(x64emu_t *emu, uintptr_t fcn) { iFuiiiiuuiiip_t fn = (iFuiiiiuuiiip_t)fcn; R_EAX = fn(from_ptri(uint32_t, R_ESP + 4), from_ptri(int32_t, R_ESP + 8), from_ptri(int32_t, R_ESP + 12), from_ptri(int32_t, R_ESP + 16), from_ptri(int32_t, R_ESP + 20), from_ptri(uint32_t, R_ESP + 24), from_ptri(uint32_t, R_ESP + 28), from_ptri(int32_t, R_ESP + 32), from_ptri(int32_t, R_ESP + 36), from_ptri(int32_t, R_ESP + 40), from_ptriv(R_ESP + 44)); } +void pFEXpuiipuuii_32(x64emu_t *emu, uintptr_t fcn) { pFEXpuiipuuii_t fn = (pFEXpuiipuuii_t)fcn; R_EAX = to_ptrv(fn(emu, getDisplay(from_ptriv(R_ESP + 4)), from_ptriv(R_ESP + 8), from_ptri(uint32_t, R_ESP + 12), from_ptri(int32_t, R_ESP + 16), from_ptri(int32_t, R_ESP + 20), from_ptriv(R_ESP + 24), from_ptri(uint32_t, R_ESP + 28), from_ptri(uint32_t, R_ESP + 32), from_ptri(int32_t, R_ESP + 36), from_ptri(int32_t, R_ESP + 40))); } void vFuiiiiiiiiuUC_32(x64emu_t *emu, uintptr_t fcn) { vFuiiiiiiiiuUC_t fn = (vFuiiiiiiiiuUC_t)fcn; fn(from_ptri(uint32_t, R_ESP + 4), from_ptri(int32_t, R_ESP + 8), from_ptri(int32_t, R_ESP + 12), from_ptri(int32_t, R_ESP + 16), from_ptri(int32_t, R_ESP + 20), from_ptri(int32_t, R_ESP + 24), from_ptri(int32_t, R_ESP + 28), from_ptri(int32_t, R_ESP + 32), from_ptri(int32_t, R_ESP + 36), from_ptri(uint32_t, R_ESP + 40), from_ptri(uint64_t, R_ESP + 44), from_ptri(uint8_t, R_ESP + 52)); } void vFuiiiiiiiuuip_32(x64emu_t *emu, uintptr_t fcn) { vFuiiiiiiiuuip_t fn = (vFuiiiiiiiuuip_t)fcn; fn(from_ptri(uint32_t, R_ESP + 4), from_ptri(int32_t, R_ESP + 8), from_ptri(int32_t, R_ESP + 12), from_ptri(int32_t, R_ESP + 16), from_ptri(int32_t, R_ESP + 20), from_ptri(int32_t, R_ESP + 24), from_ptri(int32_t, R_ESP + 28), from_ptri(int32_t, R_ESP + 32), from_ptri(uint32_t, R_ESP + 36), from_ptri(uint32_t, R_ESP + 40), from_ptri(int32_t, R_ESP + 44), from_ptriv(R_ESP + 48)); } void vFuuiiiiiiiiuu_32(x64emu_t *emu, uintptr_t fcn) { vFuuiiiiiiiiuu_t fn = (vFuuiiiiiiiiuu_t)fcn; fn(from_ptri(uint32_t, R_ESP + 4), from_ptri(uint32_t, R_ESP + 8), from_ptri(int32_t, R_ESP + 12), from_ptri(int32_t, R_ESP + 16), from_ptri(int32_t, R_ESP + 20), from_ptri(int32_t, R_ESP + 24), from_ptri(int32_t, R_ESP + 28), from_ptri(int32_t, R_ESP + 32), from_ptri(int32_t, R_ESP + 36), from_ptri(int32_t, R_ESP + 40), from_ptri(uint32_t, R_ESP + 44), from_ptri(uint32_t, R_ESP + 48)); } @@ -1840,19 +1923,20 @@ void vFuuiiiiiiiuip_32(x64emu_t *emu, uintptr_t fcn) { vFuuiiiiiiiuip_t fn = (vF void vFuuiiiiiiiuup_32(x64emu_t *emu, uintptr_t fcn) { vFuuiiiiiiiuup_t fn = (vFuuiiiiiiiuup_t)fcn; fn(from_ptri(uint32_t, R_ESP + 4), from_ptri(uint32_t, R_ESP + 8), from_ptri(int32_t, R_ESP + 12), from_ptri(int32_t, R_ESP + 16), from_ptri(int32_t, R_ESP + 20), from_ptri(int32_t, R_ESP + 24), from_ptri(int32_t, R_ESP + 28), from_ptri(int32_t, R_ESP + 32), from_ptri(int32_t, R_ESP + 36), from_ptri(uint32_t, R_ESP + 40), from_ptri(uint32_t, R_ESP + 44), from_ptriv(R_ESP + 48)); } void vFuuuuuuuuuuuu_32(x64emu_t *emu, uintptr_t fcn) { vFuuuuuuuuuuuu_t fn = (vFuuuuuuuuuuuu_t)fcn; fn(from_ptri(uint32_t, R_ESP + 4), from_ptri(uint32_t, R_ESP + 8), from_ptri(uint32_t, R_ESP + 12), from_ptri(uint32_t, R_ESP + 16), from_ptri(uint32_t, R_ESP + 20), from_ptri(uint32_t, R_ESP + 24), from_ptri(uint32_t, R_ESP + 28), from_ptri(uint32_t, R_ESP + 32), from_ptri(uint32_t, R_ESP + 36), from_ptri(uint32_t, R_ESP + 40), from_ptri(uint32_t, R_ESP + 44), from_ptri(uint32_t, R_ESP + 48)); } void vFffffffffffff_32(x64emu_t *emu, uintptr_t fcn) { vFffffffffffff_t fn = (vFffffffffffff_t)fcn; fn(from_ptri(float, R_ESP + 4), from_ptri(float, R_ESP + 8), from_ptri(float, R_ESP + 12), from_ptri(float, R_ESP + 16), from_ptri(float, R_ESP + 20), from_ptri(float, R_ESP + 24), from_ptri(float, R_ESP + 28), from_ptri(float, R_ESP + 32), from_ptri(float, R_ESP + 36), from_ptri(float, R_ESP + 40), from_ptri(float, R_ESP + 44), from_ptri(float, R_ESP + 48)); } +void pFEXLiiuuLipii_32(x64emu_t *emu, uintptr_t fcn) { pFEXLiiuuLipii_t fn = (pFEXLiiuuLipii_t)fcn; R_EAX = to_ptrv(fn(emu, getDisplay(from_ptriv(R_ESP + 4)), to_ulong(from_ptri(ulong_t, R_ESP + 8)), from_ptri(int32_t, R_ESP + 12), from_ptri(int32_t, R_ESP + 16), from_ptri(uint32_t, R_ESP + 20), from_ptri(uint32_t, R_ESP + 24), to_ulong(from_ptri(ulong_t, R_ESP + 28)), from_ptri(int32_t, R_ESP + 32), from_ptriv(R_ESP + 36), from_ptri(int32_t, R_ESP + 40), from_ptri(int32_t, R_ESP + 44))); } void vFuiiiiiiiiiuup_32(x64emu_t *emu, uintptr_t fcn) { vFuiiiiiiiiiuup_t fn = (vFuiiiiiiiiiuup_t)fcn; fn(from_ptri(uint32_t, R_ESP + 4), from_ptri(int32_t, R_ESP + 8), from_ptri(int32_t, R_ESP + 12), from_ptri(int32_t, R_ESP + 16), from_ptri(int32_t, R_ESP + 20), from_ptri(int32_t, R_ESP + 24), from_ptri(int32_t, R_ESP + 28), from_ptri(int32_t, R_ESP + 32), from_ptri(int32_t, R_ESP + 36), from_ptri(int32_t, R_ESP + 40), from_ptri(uint32_t, R_ESP + 44), from_ptri(uint32_t, R_ESP + 48), from_ptriv(R_ESP + 52)); } void vFuuuuuuuuuuuuu_32(x64emu_t *emu, uintptr_t fcn) { vFuuuuuuuuuuuuu_t fn = (vFuuuuuuuuuuuuu_t)fcn; fn(from_ptri(uint32_t, R_ESP + 4), from_ptri(uint32_t, R_ESP + 8), from_ptri(uint32_t, R_ESP + 12), from_ptri(uint32_t, R_ESP + 16), from_ptri(uint32_t, R_ESP + 20), from_ptri(uint32_t, R_ESP + 24), from_ptri(uint32_t, R_ESP + 28), from_ptri(uint32_t, R_ESP + 32), from_ptri(uint32_t, R_ESP + 36), from_ptri(uint32_t, R_ESP + 40), from_ptri(uint32_t, R_ESP + 44), from_ptri(uint32_t, R_ESP + 48), from_ptri(uint32_t, R_ESP + 52)); } void vFuUuuuuuuuuuuu_32(x64emu_t *emu, uintptr_t fcn) { vFuUuuuuuuuuuuu_t fn = (vFuUuuuuuuuuuuu_t)fcn; fn(from_ptri(uint32_t, R_ESP + 4), from_ptri(uint64_t, R_ESP + 8), from_ptri(uint32_t, R_ESP + 16), from_ptri(uint32_t, R_ESP + 20), from_ptri(uint32_t, R_ESP + 24), from_ptri(uint32_t, R_ESP + 28), from_ptri(uint32_t, R_ESP + 32), from_ptri(uint32_t, R_ESP + 36), from_ptri(uint32_t, R_ESP + 40), from_ptri(uint32_t, R_ESP + 44), from_ptri(uint32_t, R_ESP + 48), from_ptri(uint32_t, R_ESP + 52), from_ptri(uint32_t, R_ESP + 56)); } void vFuffffffffffff_32(x64emu_t *emu, uintptr_t fcn) { vFuffffffffffff_t fn = (vFuffffffffffff_t)fcn; fn(from_ptri(uint32_t, R_ESP + 4), from_ptri(float, R_ESP + 8), from_ptri(float, R_ESP + 12), from_ptri(float, R_ESP + 16), from_ptri(float, R_ESP + 20), from_ptri(float, R_ESP + 24), from_ptri(float, R_ESP + 28), from_ptri(float, R_ESP + 32), from_ptri(float, R_ESP + 36), from_ptri(float, R_ESP + 40), from_ptri(float, R_ESP + 44), from_ptri(float, R_ESP + 48), from_ptri(float, R_ESP + 52)); } void iFddddpppddpppp_32(x64emu_t *emu, uintptr_t fcn) { iFddddpppddpppp_t fn = (iFddddpppddpppp_t)fcn; R_EAX = fn(from_ptri(double, R_ESP + 4), from_ptri(double, R_ESP + 12), from_ptri(double, R_ESP + 20), from_ptri(double, R_ESP + 28), from_ptriv(R_ESP + 36), from_ptriv(R_ESP + 40), from_ptriv(R_ESP + 44), from_ptri(double, R_ESP + 48), from_ptri(double, R_ESP + 56), from_ptriv(R_ESP + 64), from_ptriv(R_ESP + 68), from_ptriv(R_ESP + 72), from_ptriv(R_ESP + 76)); } void uFippuuuulllipp_32(x64emu_t *emu, uintptr_t fcn) { uFippuuuulllipp_t fn = (uFippuuuulllipp_t)fcn; R_EAX = (uint32_t)fn(from_ptri(int32_t, R_ESP + 4), from_ptriv(R_ESP + 8), from_ptriv(R_ESP + 12), from_ptri(uint32_t, R_ESP + 16), from_ptri(uint32_t, R_ESP + 20), from_ptri(uint32_t, R_ESP + 24), from_ptri(uint32_t, R_ESP + 28), to_long(from_ptri(long_t, R_ESP + 32)), to_long(from_ptri(long_t, R_ESP + 36)), to_long(from_ptri(long_t, R_ESP + 40)), from_ptri(int32_t, R_ESP + 44), from_ptriv(R_ESP + 48), from_ptriv(R_ESP + 52)); } +void LFEXLiiuuuiupLp_32(x64emu_t *emu, uintptr_t fcn) { LFEXLiiuuuiupLp_t fn = (LFEXLiiuuuiupLp_t)fcn; R_EAX = to_ulong(fn(emu, getDisplay(from_ptriv(R_ESP + 4)), to_ulong(from_ptri(ulong_t, R_ESP + 8)), from_ptri(int32_t, R_ESP + 12), from_ptri(int32_t, R_ESP + 16), from_ptri(uint32_t, R_ESP + 20), from_ptri(uint32_t, R_ESP + 24), from_ptri(uint32_t, R_ESP + 28), from_ptri(int32_t, R_ESP + 32), from_ptri(uint32_t, R_ESP + 36), from_ptriv(R_ESP + 40), to_ulong(from_ptri(ulong_t, R_ESP + 44)), from_ptriv(R_ESP + 48))); } void vFuffiiffiiffiip_32(x64emu_t *emu, uintptr_t fcn) { vFuffiiffiiffiip_t fn = (vFuffiiffiiffiip_t)fcn; fn(from_ptri(uint32_t, R_ESP + 4), from_ptri(float, R_ESP + 8), from_ptri(float, R_ESP + 12), from_ptri(int32_t, R_ESP + 16), from_ptri(int32_t, R_ESP + 20), from_ptri(float, R_ESP + 24), from_ptri(float, R_ESP + 28), from_ptri(int32_t, R_ESP + 32), from_ptri(int32_t, R_ESP + 36), from_ptri(float, R_ESP + 40), from_ptri(float, R_ESP + 44), from_ptri(int32_t, R_ESP + 48), from_ptri(int32_t, R_ESP + 52), from_ptriv(R_ESP + 56)); } void vFuddiiddiiddiip_32(x64emu_t *emu, uintptr_t fcn) { vFuddiiddiiddiip_t fn = (vFuddiiddiiddiip_t)fcn; fn(from_ptri(uint32_t, R_ESP + 4), from_ptri(double, R_ESP + 8), from_ptri(double, R_ESP + 16), from_ptri(int32_t, R_ESP + 24), from_ptri(int32_t, R_ESP + 28), from_ptri(double, R_ESP + 32), from_ptri(double, R_ESP + 40), from_ptri(int32_t, R_ESP + 48), from_ptri(int32_t, R_ESP + 52), from_ptri(double, R_ESP + 56), from_ptri(double, R_ESP + 64), from_ptri(int32_t, R_ESP + 72), from_ptri(int32_t, R_ESP + 76), from_ptriv(R_ESP + 80)); } void vFuiiiiiuiiiiilll_32(x64emu_t *emu, uintptr_t fcn) { vFuiiiiiuiiiiilll_t fn = (vFuiiiiiuiiiiilll_t)fcn; fn(from_ptri(uint32_t, R_ESP + 4), from_ptri(int32_t, R_ESP + 8), from_ptri(int32_t, R_ESP + 12), from_ptri(int32_t, R_ESP + 16), from_ptri(int32_t, R_ESP + 20), from_ptri(int32_t, R_ESP + 24), from_ptri(uint32_t, R_ESP + 28), from_ptri(int32_t, R_ESP + 32), from_ptri(int32_t, R_ESP + 36), from_ptri(int32_t, R_ESP + 40), from_ptri(int32_t, R_ESP + 44), from_ptri(int32_t, R_ESP + 48), to_long(from_ptri(long_t, R_ESP + 52)), to_long(from_ptri(long_t, R_ESP + 56)), to_long(from_ptri(long_t, R_ESP + 60))); } void vFuuiiiiuuiiiiiii_32(x64emu_t *emu, uintptr_t fcn) { vFuuiiiiuuiiiiiii_t fn = (vFuuiiiiuuiiiiiii_t)fcn; fn(from_ptri(uint32_t, R_ESP + 4), from_ptri(uint32_t, R_ESP + 8), from_ptri(int32_t, R_ESP + 12), from_ptri(int32_t, R_ESP + 16), from_ptri(int32_t, R_ESP + 20), from_ptri(int32_t, R_ESP + 24), from_ptri(uint32_t, R_ESP + 28), from_ptri(uint32_t, R_ESP + 32), from_ptri(int32_t, R_ESP + 36), from_ptri(int32_t, R_ESP + 40), from_ptri(int32_t, R_ESP + 44), from_ptri(int32_t, R_ESP + 48), from_ptri(int32_t, R_ESP + 52), from_ptri(int32_t, R_ESP + 56), from_ptri(int32_t, R_ESP + 60)); } void vFfffffffffffffff_32(x64emu_t *emu, uintptr_t fcn) { vFfffffffffffffff_t fn = (vFfffffffffffffff_t)fcn; fn(from_ptri(float, R_ESP + 4), from_ptri(float, R_ESP + 8), from_ptri(float, R_ESP + 12), from_ptri(float, R_ESP + 16), from_ptri(float, R_ESP + 20), from_ptri(float, R_ESP + 24), from_ptri(float, R_ESP + 28), from_ptri(float, R_ESP + 32), from_ptri(float, R_ESP + 36), from_ptri(float, R_ESP + 40), from_ptri(float, R_ESP + 44), from_ptri(float, R_ESP + 48), from_ptri(float, R_ESP + 52), from_ptri(float, R_ESP + 56), from_ptri(float, R_ESP + 60)); } void vFuuuuiiiiuuiiiiiii_32(x64emu_t *emu, uintptr_t fcn) { vFuuuuiiiiuuiiiiiii_t fn = (vFuuuuiiiiuuiiiiiii_t)fcn; fn(from_ptri(uint32_t, R_ESP + 4), from_ptri(uint32_t, R_ESP + 8), from_ptri(uint32_t, R_ESP + 12), from_ptri(uint32_t, R_ESP + 16), from_ptri(int32_t, R_ESP + 20), from_ptri(int32_t, R_ESP + 24), from_ptri(int32_t, R_ESP + 28), from_ptri(int32_t, R_ESP + 32), from_ptri(uint32_t, R_ESP + 36), from_ptri(uint32_t, R_ESP + 40), from_ptri(int32_t, R_ESP + 44), from_ptri(int32_t, R_ESP + 48), from_ptri(int32_t, R_ESP + 52), from_ptri(int32_t, R_ESP + 56), from_ptri(int32_t, R_ESP + 60), from_ptri(int32_t, R_ESP + 64), from_ptri(int32_t, R_ESP + 68)); } -void vFppuiiiiipuiiiiiiii_32(x64emu_t *emu, uintptr_t fcn) { vFppuiiiiipuiiiiiiii_t fn = (vFppuiiiiipuiiiiiiii_t)fcn; fn(from_ptriv(R_ESP + 4), from_ptriv(R_ESP + 8), from_ptri(uint32_t, R_ESP + 12), from_ptri(int32_t, R_ESP + 16), from_ptri(int32_t, R_ESP + 20), from_ptri(int32_t, R_ESP + 24), from_ptri(int32_t, R_ESP + 28), from_ptri(int32_t, R_ESP + 32), from_ptriv(R_ESP + 36), from_ptri(uint32_t, R_ESP + 40), from_ptri(int32_t, R_ESP + 44), from_ptri(int32_t, R_ESP + 48), from_ptri(int32_t, R_ESP + 52), from_ptri(int32_t, R_ESP + 56), from_ptri(int32_t, R_ESP + 60), from_ptri(int32_t, R_ESP + 64), from_ptri(int32_t, R_ESP + 68), from_ptri(int32_t, R_ESP + 72)); } void uFippuuuuiiiiuuiiiiiiiipp_32(x64emu_t *emu, uintptr_t fcn) { uFippuuuuiiiiuuiiiiiiiipp_t fn = (uFippuuuuiiiiuuiiiiiiiipp_t)fcn; R_EAX = (uint32_t)fn(from_ptri(int32_t, R_ESP + 4), from_ptriv(R_ESP + 8), from_ptriv(R_ESP + 12), from_ptri(uint32_t, R_ESP + 16), from_ptri(uint32_t, R_ESP + 20), from_ptri(uint32_t, R_ESP + 24), from_ptri(uint32_t, R_ESP + 28), from_ptri(int32_t, R_ESP + 32), from_ptri(int32_t, R_ESP + 36), from_ptri(int32_t, R_ESP + 40), from_ptri(int32_t, R_ESP + 44), from_ptri(uint32_t, R_ESP + 48), from_ptri(uint32_t, R_ESP + 52), from_ptri(int32_t, R_ESP + 56), from_ptri(int32_t, R_ESP + 60), from_ptri(int32_t, R_ESP + 64), from_ptri(int32_t, R_ESP + 68), from_ptri(int32_t, R_ESP + 72), from_ptri(int32_t, R_ESP + 76), from_ptri(int32_t, R_ESP + 80), from_ptri(int32_t, R_ESP + 84), from_ptriv(R_ESP + 88), from_ptriv(R_ESP + 92)); } #if defined(ANDROID) diff --git a/src/wrapped32/generated/wrapper32.h b/src/wrapped32/generated/wrapper32.h index cfc9dfd3..6b5ee7bb 100644 --- a/src/wrapped32/generated/wrapper32.h +++ b/src/wrapped32/generated/wrapper32.h @@ -37,6 +37,7 @@ typedef void (*wrapper_t)(x64emu_t* emu, uintptr_t fnc); // B..._ = pointer to write-only structure // b..._ = pointer to read-write structure // t = char* as a return value (copies to a lower address if the return address is too high) +// X = Display* void vFv_32(x64emu_t *emu, uintptr_t fnc); void vFc_32(x64emu_t *emu, uintptr_t fnc); @@ -52,6 +53,7 @@ void vFl_32(x64emu_t *emu, uintptr_t fnc); void vFp_32(x64emu_t *emu, uintptr_t fnc); void vFA_32(x64emu_t *emu, uintptr_t fnc); void vFS_32(x64emu_t *emu, uintptr_t fnc); +void vFX_32(x64emu_t *emu, uintptr_t fnc); void iFv_32(x64emu_t *emu, uintptr_t fnc); void iFi_32(x64emu_t *emu, uintptr_t fnc); void iFI_32(x64emu_t *emu, uintptr_t fnc); @@ -62,6 +64,7 @@ void iFL_32(x64emu_t *emu, uintptr_t fnc); void iFp_32(x64emu_t *emu, uintptr_t fnc); void iFh_32(x64emu_t *emu, uintptr_t fnc); void iFS_32(x64emu_t *emu, uintptr_t fnc); +void iFX_32(x64emu_t *emu, uintptr_t fnc); void IFf_32(x64emu_t *emu, uintptr_t fnc); void IFd_32(x64emu_t *emu, uintptr_t fnc); void IFp_32(x64emu_t *emu, uintptr_t fnc); @@ -96,11 +99,13 @@ void pFi_32(x64emu_t *emu, uintptr_t fnc); void pFu_32(x64emu_t *emu, uintptr_t fnc); void pFL_32(x64emu_t *emu, uintptr_t fnc); void pFp_32(x64emu_t *emu, uintptr_t fnc); +void pFX_32(x64emu_t *emu, uintptr_t fnc); void hFv_32(x64emu_t *emu, uintptr_t fnc); void aFa_32(x64emu_t *emu, uintptr_t fnc); void tFi_32(x64emu_t *emu, uintptr_t fnc); void tFu_32(x64emu_t *emu, uintptr_t fnc); void tFp_32(x64emu_t *emu, uintptr_t fnc); +void iFBp__32(x64emu_t *emu, uintptr_t fnc); void LFrL__32(x64emu_t *emu, uintptr_t fnc); void pFrL__32(x64emu_t *emu, uintptr_t fnc); void LFriiiiiiiiilt__32(x64emu_t *emu, uintptr_t fnc); @@ -138,9 +143,11 @@ void vFlu_32(x64emu_t *emu, uintptr_t fnc); void vFlp_32(x64emu_t *emu, uintptr_t fnc); void vFpC_32(x64emu_t *emu, uintptr_t fnc); void vFpu_32(x64emu_t *emu, uintptr_t fnc); +void vFpl_32(x64emu_t *emu, uintptr_t fnc); void vFpL_32(x64emu_t *emu, uintptr_t fnc); void vFpp_32(x64emu_t *emu, uintptr_t fnc); void vFSp_32(x64emu_t *emu, uintptr_t fnc); +void vFXp_32(x64emu_t *emu, uintptr_t fnc); void wFpi_32(x64emu_t *emu, uintptr_t fnc); void iFEv_32(x64emu_t *emu, uintptr_t fnc); void iFEi_32(x64emu_t *emu, uintptr_t fnc); @@ -160,6 +167,7 @@ void iFup_32(x64emu_t *emu, uintptr_t fnc); void iFli_32(x64emu_t *emu, uintptr_t fnc); void iFpi_32(x64emu_t *emu, uintptr_t fnc); void iFpu_32(x64emu_t *emu, uintptr_t fnc); +void iFpl_32(x64emu_t *emu, uintptr_t fnc); void iFpL_32(x64emu_t *emu, uintptr_t fnc); void iFpp_32(x64emu_t *emu, uintptr_t fnc); void iFpV_32(x64emu_t *emu, uintptr_t fnc); @@ -167,6 +175,9 @@ void iFpS_32(x64emu_t *emu, uintptr_t fnc); void iFhi_32(x64emu_t *emu, uintptr_t fnc); void iFhp_32(x64emu_t *emu, uintptr_t fnc); void iFhh_32(x64emu_t *emu, uintptr_t fnc); +void iFXi_32(x64emu_t *emu, uintptr_t fnc); +void iFXL_32(x64emu_t *emu, uintptr_t fnc); +void iFXp_32(x64emu_t *emu, uintptr_t fnc); void IFII_32(x64emu_t *emu, uintptr_t fnc); void CFip_32(x64emu_t *emu, uintptr_t fnc); void CFCi_32(x64emu_t *emu, uintptr_t fnc); @@ -201,6 +212,7 @@ void lFui_32(x64emu_t *emu, uintptr_t fnc); void lFpl_32(x64emu_t *emu, uintptr_t fnc); void LFpL_32(x64emu_t *emu, uintptr_t fnc); void LFpp_32(x64emu_t *emu, uintptr_t fnc); +void LFXi_32(x64emu_t *emu, uintptr_t fnc); void pFEv_32(x64emu_t *emu, uintptr_t fnc); void pFEu_32(x64emu_t *emu, uintptr_t fnc); void pFEp_32(x64emu_t *emu, uintptr_t fnc); @@ -213,6 +225,7 @@ void pFpi_32(x64emu_t *emu, uintptr_t fnc); void pFpu_32(x64emu_t *emu, uintptr_t fnc); void pFpL_32(x64emu_t *emu, uintptr_t fnc); void pFpp_32(x64emu_t *emu, uintptr_t fnc); +void pFXi_32(x64emu_t *emu, uintptr_t fnc); void SFip_32(x64emu_t *emu, uintptr_t fnc); void SFpp_32(x64emu_t *emu, uintptr_t fnc); void tFip_32(x64emu_t *emu, uintptr_t fnc); @@ -295,6 +308,7 @@ void vFplp_32(x64emu_t *emu, uintptr_t fnc); void vFppi_32(x64emu_t *emu, uintptr_t fnc); void vFppu_32(x64emu_t *emu, uintptr_t fnc); void vFppp_32(x64emu_t *emu, uintptr_t fnc); +void vFXpi_32(x64emu_t *emu, uintptr_t fnc); void iFEip_32(x64emu_t *emu, uintptr_t fnc); void iFEpi_32(x64emu_t *emu, uintptr_t fnc); void iFEpL_32(x64emu_t *emu, uintptr_t fnc); @@ -302,6 +316,7 @@ void iFEpp_32(x64emu_t *emu, uintptr_t fnc); void iFEpV_32(x64emu_t *emu, uintptr_t fnc); void iFEhi_32(x64emu_t *emu, uintptr_t fnc); void iFESp_32(x64emu_t *emu, uintptr_t fnc); +void iFEXp_32(x64emu_t *emu, uintptr_t fnc); void iFiii_32(x64emu_t *emu, uintptr_t fnc); void iFiiI_32(x64emu_t *emu, uintptr_t fnc); void iFiiu_32(x64emu_t *emu, uintptr_t fnc); @@ -320,12 +335,12 @@ void iFuuu_32(x64emu_t *emu, uintptr_t fnc); void iFuup_32(x64emu_t *emu, uintptr_t fnc); void iFuLp_32(x64emu_t *emu, uintptr_t fnc); void iFfff_32(x64emu_t *emu, uintptr_t fnc); +void iFpii_32(x64emu_t *emu, uintptr_t fnc); void iFpiu_32(x64emu_t *emu, uintptr_t fnc); void iFpip_32(x64emu_t *emu, uintptr_t fnc); void iFpuC_32(x64emu_t *emu, uintptr_t fnc); void iFpuu_32(x64emu_t *emu, uintptr_t fnc); void iFpuU_32(x64emu_t *emu, uintptr_t fnc); -void iFpup_32(x64emu_t *emu, uintptr_t fnc); void iFpLi_32(x64emu_t *emu, uintptr_t fnc); void iFppi_32(x64emu_t *emu, uintptr_t fnc); void iFppu_32(x64emu_t *emu, uintptr_t fnc); @@ -338,6 +353,12 @@ void iFhpL_32(x64emu_t *emu, uintptr_t fnc); void iFhpp_32(x64emu_t *emu, uintptr_t fnc); void iFSIi_32(x64emu_t *emu, uintptr_t fnc); void iFSli_32(x64emu_t *emu, uintptr_t fnc); +void iFXip_32(x64emu_t *emu, uintptr_t fnc); +void iFXuu_32(x64emu_t *emu, uintptr_t fnc); +void iFXLL_32(x64emu_t *emu, uintptr_t fnc); +void iFXLp_32(x64emu_t *emu, uintptr_t fnc); +void iFXpu_32(x64emu_t *emu, uintptr_t fnc); +void iFXpp_32(x64emu_t *emu, uintptr_t fnc); void IFiIi_32(x64emu_t *emu, uintptr_t fnc); void CFipp_32(x64emu_t *emu, uintptr_t fnc); void CFuUu_32(x64emu_t *emu, uintptr_t fnc); @@ -357,9 +378,12 @@ void dFddd_32(x64emu_t *emu, uintptr_t fnc); void dFddp_32(x64emu_t *emu, uintptr_t fnc); void lFipL_32(x64emu_t *emu, uintptr_t fnc); void lFlpi_32(x64emu_t *emu, uintptr_t fnc); +void lFpLL_32(x64emu_t *emu, uintptr_t fnc); void lFppL_32(x64emu_t *emu, uintptr_t fnc); +void LFpii_32(x64emu_t *emu, uintptr_t fnc); void LFpip_32(x64emu_t *emu, uintptr_t fnc); void LFppL_32(x64emu_t *emu, uintptr_t fnc); +void LFXCi_32(x64emu_t *emu, uintptr_t fnc); void pFEip_32(x64emu_t *emu, uintptr_t fnc); void pFEpi_32(x64emu_t *emu, uintptr_t fnc); void pFEpp_32(x64emu_t *emu, uintptr_t fnc); @@ -367,7 +391,6 @@ void pFipi_32(x64emu_t *emu, uintptr_t fnc); void pFulu_32(x64emu_t *emu, uintptr_t fnc); void pFpii_32(x64emu_t *emu, uintptr_t fnc); void pFpiL_32(x64emu_t *emu, uintptr_t fnc); -void pFpip_32(x64emu_t *emu, uintptr_t fnc); void pFpiS_32(x64emu_t *emu, uintptr_t fnc); void pFpuL_32(x64emu_t *emu, uintptr_t fnc); void pFpup_32(x64emu_t *emu, uintptr_t fnc); @@ -375,6 +398,7 @@ void pFppu_32(x64emu_t *emu, uintptr_t fnc); void pFppL_32(x64emu_t *emu, uintptr_t fnc); void pFppp_32(x64emu_t *emu, uintptr_t fnc); void pFpOM_32(x64emu_t *emu, uintptr_t fnc); +void pFXip_32(x64emu_t *emu, uintptr_t fnc); void aFipa_32(x64emu_t *emu, uintptr_t fnc); void SFEpp_32(x64emu_t *emu, uintptr_t fnc); void SFppS_32(x64emu_t *emu, uintptr_t fnc); @@ -383,12 +407,14 @@ void iFppbL__32(x64emu_t *emu, uintptr_t fnc); void iFpBp_i_32(x64emu_t *emu, uintptr_t fnc); void iFpbL_p_32(x64emu_t *emu, uintptr_t fnc); void iFBp_LL_32(x64emu_t *emu, uintptr_t fnc); +void iFBp_pi_32(x64emu_t *emu, uintptr_t fnc); void IFpBp_i_32(x64emu_t *emu, uintptr_t fnc); void UFpBp_i_32(x64emu_t *emu, uintptr_t fnc); void dFpBp_i_32(x64emu_t *emu, uintptr_t fnc); void dFpBp_a_32(x64emu_t *emu, uintptr_t fnc); void lFpBp_i_32(x64emu_t *emu, uintptr_t fnc); void LFpBp_i_32(x64emu_t *emu, uintptr_t fnc); +void iFXLbhWcc__32(x64emu_t *emu, uintptr_t fnc); void pFppriiiiiiiiilt__32(x64emu_t *emu, uintptr_t fnc); void vFEipp_32(x64emu_t *emu, uintptr_t fnc); void vFEipV_32(x64emu_t *emu, uintptr_t fnc); @@ -466,13 +492,14 @@ void vFuppu_32(x64emu_t *emu, uintptr_t fnc); void vFffff_32(x64emu_t *emu, uintptr_t fnc); void vFdddd_32(x64emu_t *emu, uintptr_t fnc); void vFllii_32(x64emu_t *emu, uintptr_t fnc); -void vFpiii_32(x64emu_t *emu, uintptr_t fnc); void vFpipp_32(x64emu_t *emu, uintptr_t fnc); void vFpdii_32(x64emu_t *emu, uintptr_t fnc); void vFpddd_32(x64emu_t *emu, uintptr_t fnc); void vFplpp_32(x64emu_t *emu, uintptr_t fnc); void vFppip_32(x64emu_t *emu, uintptr_t fnc); void vFpppp_32(x64emu_t *emu, uintptr_t fnc); +void vFXiiL_32(x64emu_t *emu, uintptr_t fnc); +void vFXpip_32(x64emu_t *emu, uintptr_t fnc); void iFEiip_32(x64emu_t *emu, uintptr_t fnc); void iFEiiN_32(x64emu_t *emu, uintptr_t fnc); void iFEipp_32(x64emu_t *emu, uintptr_t fnc); @@ -497,9 +524,8 @@ void iFipup_32(x64emu_t *emu, uintptr_t fnc); void iFippi_32(x64emu_t *emu, uintptr_t fnc); void iFuiup_32(x64emu_t *emu, uintptr_t fnc); void iFuupi_32(x64emu_t *emu, uintptr_t fnc); -void iFpiip_32(x64emu_t *emu, uintptr_t fnc); +void iFpiiL_32(x64emu_t *emu, uintptr_t fnc); void iFpipp_32(x64emu_t *emu, uintptr_t fnc); -void iFpuup_32(x64emu_t *emu, uintptr_t fnc); void iFpupp_32(x64emu_t *emu, uintptr_t fnc); void iFppii_32(x64emu_t *emu, uintptr_t fnc); void iFppiU_32(x64emu_t *emu, uintptr_t fnc); @@ -509,34 +535,41 @@ void iFppLi_32(x64emu_t *emu, uintptr_t fnc); void iFpppi_32(x64emu_t *emu, uintptr_t fnc); void iFpppp_32(x64emu_t *emu, uintptr_t fnc); void iFhpiL_32(x64emu_t *emu, uintptr_t fnc); +void iFXipp_32(x64emu_t *emu, uintptr_t fnc); +void iFXppp_32(x64emu_t *emu, uintptr_t fnc); void CFuuff_32(x64emu_t *emu, uintptr_t fnc); void uFuuuu_32(x64emu_t *emu, uintptr_t fnc); void lFEipi_32(x64emu_t *emu, uintptr_t fnc); void lFiipL_32(x64emu_t *emu, uintptr_t fnc); void lFipLi_32(x64emu_t *emu, uintptr_t fnc); void lFpuip_32(x64emu_t *emu, uintptr_t fnc); +void LFEXii_32(x64emu_t *emu, uintptr_t fnc); void LFpLLS_32(x64emu_t *emu, uintptr_t fnc); void LFppLp_32(x64emu_t *emu, uintptr_t fnc); void LFppLa_32(x64emu_t *emu, uintptr_t fnc); +void LFXLpi_32(x64emu_t *emu, uintptr_t fnc); void pFEppi_32(x64emu_t *emu, uintptr_t fnc); void pFEppp_32(x64emu_t *emu, uintptr_t fnc); void pFiiiu_32(x64emu_t *emu, uintptr_t fnc); void pFillu_32(x64emu_t *emu, uintptr_t fnc); void pFullu_32(x64emu_t *emu, uintptr_t fnc); void pFlfff_32(x64emu_t *emu, uintptr_t fnc); -void pFpiii_32(x64emu_t *emu, uintptr_t fnc); void pFpiLL_32(x64emu_t *emu, uintptr_t fnc); -void pFpipp_32(x64emu_t *emu, uintptr_t fnc); void pFppLL_32(x64emu_t *emu, uintptr_t fnc); -void pFpppi_32(x64emu_t *emu, uintptr_t fnc); void pFpppp_32(x64emu_t *emu, uintptr_t fnc); +void pFXiii_32(x64emu_t *emu, uintptr_t fnc); +void pFXLLp_32(x64emu_t *emu, uintptr_t fnc); +void pFXppi_32(x64emu_t *emu, uintptr_t fnc); +void iFppbp_p_32(x64emu_t *emu, uintptr_t fnc); void iFBp_pui_32(x64emu_t *emu, uintptr_t fnc); void IFpBp_ii_32(x64emu_t *emu, uintptr_t fnc); void UFpBp_ii_32(x64emu_t *emu, uintptr_t fnc); void lFiibp_L_32(x64emu_t *emu, uintptr_t fnc); void LFpbp_Lp_32(x64emu_t *emu, uintptr_t fnc); void iFEpprLL__32(x64emu_t *emu, uintptr_t fnc); +void iFXLpBhWcc__32(x64emu_t *emu, uintptr_t fnc); void LFpLpriiiiiiiiilt__32(x64emu_t *emu, uintptr_t fnc); +void vFEuipp_32(x64emu_t *emu, uintptr_t fnc); void vFEpLLp_32(x64emu_t *emu, uintptr_t fnc); void vFiiiii_32(x64emu_t *emu, uintptr_t fnc); void vFiiiiu_32(x64emu_t *emu, uintptr_t fnc); @@ -641,23 +674,23 @@ void iFiiipu_32(x64emu_t *emu, uintptr_t fnc); void iFiiipp_32(x64emu_t *emu, uintptr_t fnc); void iFiLLLL_32(x64emu_t *emu, uintptr_t fnc); void iFipLLi_32(x64emu_t *emu, uintptr_t fnc); -void iFpiiip_32(x64emu_t *emu, uintptr_t fnc); -void iFpippp_32(x64emu_t *emu, uintptr_t fnc); -void iFppipi_32(x64emu_t *emu, uintptr_t fnc); +void iFpLuLi_32(x64emu_t *emu, uintptr_t fnc); void iFpppip_32(x64emu_t *emu, uintptr_t fnc); void iFpppup_32(x64emu_t *emu, uintptr_t fnc); void iFppppp_32(x64emu_t *emu, uintptr_t fnc); -void IFppIII_32(x64emu_t *emu, uintptr_t fnc); +void iFXiiip_32(x64emu_t *emu, uintptr_t fnc); +void iFXpppp_32(x64emu_t *emu, uintptr_t fnc); +void IFXpIII_32(x64emu_t *emu, uintptr_t fnc); void uFpLLLS_32(x64emu_t *emu, uintptr_t fnc); void UFuiCiu_32(x64emu_t *emu, uintptr_t fnc); void lFpuipC_32(x64emu_t *emu, uintptr_t fnc); void LFpLppa_32(x64emu_t *emu, uintptr_t fnc); +void LFXLuuu_32(x64emu_t *emu, uintptr_t fnc); void pFuiupp_32(x64emu_t *emu, uintptr_t fnc); +void pFpiiuu_32(x64emu_t *emu, uintptr_t fnc); void pFpippp_32(x64emu_t *emu, uintptr_t fnc); -void pFppipi_32(x64emu_t *emu, uintptr_t fnc); void pFppuup_32(x64emu_t *emu, uintptr_t fnc); void pFppupp_32(x64emu_t *emu, uintptr_t fnc); -void pFpppip_32(x64emu_t *emu, uintptr_t fnc); void iFEBh_ppp_32(x64emu_t *emu, uintptr_t fnc); void LFpbp_LLp_32(x64emu_t *emu, uintptr_t fnc); void LFpBp_LLp_32(x64emu_t *emu, uintptr_t fnc); @@ -726,18 +759,17 @@ void vFffffff_32(x64emu_t *emu, uintptr_t fnc); void vFdddddd_32(x64emu_t *emu, uintptr_t fnc); void vFpipipV_32(x64emu_t *emu, uintptr_t fnc); void vFpdddii_32(x64emu_t *emu, uintptr_t fnc); -void vFppiiii_32(x64emu_t *emu, uintptr_t fnc); void vFppupii_32(x64emu_t *emu, uintptr_t fnc); void iFuiiuup_32(x64emu_t *emu, uintptr_t fnc); -void iFpiiipp_32(x64emu_t *emu, uintptr_t fnc); void iFpiippp_32(x64emu_t *emu, uintptr_t fnc); void iFppiiii_32(x64emu_t *emu, uintptr_t fnc); -void iFppIppp_32(x64emu_t *emu, uintptr_t fnc); +void iFXLiiiL_32(x64emu_t *emu, uintptr_t fnc); +void iFXpIppp_32(x64emu_t *emu, uintptr_t fnc); void uFupuufp_32(x64emu_t *emu, uintptr_t fnc); void lFipLipu_32(x64emu_t *emu, uintptr_t fnc); void lFipLipp_32(x64emu_t *emu, uintptr_t fnc); +void pFEpiiuu_32(x64emu_t *emu, uintptr_t fnc); void pFEpLLiN_32(x64emu_t *emu, uintptr_t fnc); -void pFpippip_32(x64emu_t *emu, uintptr_t fnc); void vFiiiiiip_32(x64emu_t *emu, uintptr_t fnc); void vFiiiiuup_32(x64emu_t *emu, uintptr_t fnc); void vFiiuilil_32(x64emu_t *emu, uintptr_t fnc); @@ -792,7 +824,9 @@ void vFpddiidd_32(x64emu_t *emu, uintptr_t fnc); void iFEpLiipV_32(x64emu_t *emu, uintptr_t fnc); void iFuiiiuup_32(x64emu_t *emu, uintptr_t fnc); void iFpupLpLi_32(x64emu_t *emu, uintptr_t fnc); +void iFXiuLiii_32(x64emu_t *emu, uintptr_t fnc); void uFuippppp_32(x64emu_t *emu, uintptr_t fnc); +void LFXLLppuu_32(x64emu_t *emu, uintptr_t fnc); void pFEpLiiii_32(x64emu_t *emu, uintptr_t fnc); void pFEpLiiiI_32(x64emu_t *emu, uintptr_t fnc); void vFiiiiuuip_32(x64emu_t *emu, uintptr_t fnc); @@ -824,11 +858,12 @@ void vFuuufffff_32(x64emu_t *emu, uintptr_t fnc); void vFffffffff_32(x64emu_t *emu, uintptr_t fnc); void iFEpippppp_32(x64emu_t *emu, uintptr_t fnc); void iFuiiiiuup_32(x64emu_t *emu, uintptr_t fnc); -void iFppIIIppp_32(x64emu_t *emu, uintptr_t fnc); +void iFXpIIIppp_32(x64emu_t *emu, uintptr_t fnc); void CFuiifpppp_32(x64emu_t *emu, uintptr_t fnc); void uFuipppppp_32(x64emu_t *emu, uintptr_t fnc); void uFuupuuiuf_32(x64emu_t *emu, uintptr_t fnc); void uFulpppppp_32(x64emu_t *emu, uintptr_t fnc); +void LFXLpuuLLu_32(x64emu_t *emu, uintptr_t fnc); void vFiiiiiiiii_32(x64emu_t *emu, uintptr_t fnc); void vFiiiiiiill_32(x64emu_t *emu, uintptr_t fnc); void vFiiiiillli_32(x64emu_t *emu, uintptr_t fnc); @@ -856,7 +891,9 @@ void vFddddddddd_32(x64emu_t *emu, uintptr_t fnc); void iFuiiuuiiip_32(x64emu_t *emu, uintptr_t fnc); void iFuiiupiiup_32(x64emu_t *emu, uintptr_t fnc); void iFdddpppppp_32(x64emu_t *emu, uintptr_t fnc); +void iFXLiuiiLLL_32(x64emu_t *emu, uintptr_t fnc); void uFuulpiuiuf_32(x64emu_t *emu, uintptr_t fnc); +void pFEXLiiuuLi_32(x64emu_t *emu, uintptr_t fnc); void vFiiiiiiiiii_32(x64emu_t *emu, uintptr_t fnc); void vFiiiiiiiiui_32(x64emu_t *emu, uintptr_t fnc); void vFiiiiiiiiuu_32(x64emu_t *emu, uintptr_t fnc); @@ -876,6 +913,8 @@ void vFuffiiffiip_32(x64emu_t *emu, uintptr_t fnc); void vFuddiiddiip_32(x64emu_t *emu, uintptr_t fnc); void vFffffffffff_32(x64emu_t *emu, uintptr_t fnc); void iFuiiiuuiiip_32(x64emu_t *emu, uintptr_t fnc); +void iFXuuLiuiiLL_32(x64emu_t *emu, uintptr_t fnc); +void pFXpuiipuuii_32(x64emu_t *emu, uintptr_t fnc); void vFiiiiillliip_32(x64emu_t *emu, uintptr_t fnc); void vFiiiiilllilp_32(x64emu_t *emu, uintptr_t fnc); void vFuiiiiiiiuip_32(x64emu_t *emu, uintptr_t fnc); @@ -891,7 +930,9 @@ void vFuUuuuuuuuuu_32(x64emu_t *emu, uintptr_t fnc); void vFuffffffffff_32(x64emu_t *emu, uintptr_t fnc); void vFUufffffffff_32(x64emu_t *emu, uintptr_t fnc); void vFpipipiipiiu_32(x64emu_t *emu, uintptr_t fnc); +void iFEXLppiiiiuu_32(x64emu_t *emu, uintptr_t fnc); void iFuiiiiuuiiip_32(x64emu_t *emu, uintptr_t fnc); +void pFEXpuiipuuii_32(x64emu_t *emu, uintptr_t fnc); void vFuiiiiiiiiuUC_32(x64emu_t *emu, uintptr_t fnc); void vFuiiiiiiiuuip_32(x64emu_t *emu, uintptr_t fnc); void vFuuiiiiiiiiuu_32(x64emu_t *emu, uintptr_t fnc); @@ -899,19 +940,20 @@ void vFuuiiiiiiiuip_32(x64emu_t *emu, uintptr_t fnc); void vFuuiiiiiiiuup_32(x64emu_t *emu, uintptr_t fnc); void vFuuuuuuuuuuuu_32(x64emu_t *emu, uintptr_t fnc); void vFffffffffffff_32(x64emu_t *emu, uintptr_t fnc); +void pFEXLiiuuLipii_32(x64emu_t *emu, uintptr_t fnc); void vFuiiiiiiiiiuup_32(x64emu_t *emu, uintptr_t fnc); void vFuuuuuuuuuuuuu_32(x64emu_t *emu, uintptr_t fnc); void vFuUuuuuuuuuuuu_32(x64emu_t *emu, uintptr_t fnc); void vFuffffffffffff_32(x64emu_t *emu, uintptr_t fnc); void iFddddpppddpppp_32(x64emu_t *emu, uintptr_t fnc); void uFippuuuulllipp_32(x64emu_t *emu, uintptr_t fnc); +void LFEXLiiuuuiupLp_32(x64emu_t *emu, uintptr_t fnc); void vFuffiiffiiffiip_32(x64emu_t *emu, uintptr_t fnc); void vFuddiiddiiddiip_32(x64emu_t *emu, uintptr_t fnc); void vFuiiiiiuiiiiilll_32(x64emu_t *emu, uintptr_t fnc); void vFuuiiiiuuiiiiiii_32(x64emu_t *emu, uintptr_t fnc); void vFfffffffffffffff_32(x64emu_t *emu, uintptr_t fnc); void vFuuuuiiiiuuiiiiiii_32(x64emu_t *emu, uintptr_t fnc); -void vFppuiiiiipuiiiiiiii_32(x64emu_t *emu, uintptr_t fnc); void uFippuuuuiiiiuuiiiiiiiipp_32(x64emu_t *emu, uintptr_t fnc); #if defined(ANDROID) diff --git a/src/wrapped32/wrappedlibasound.c b/src/wrapped32/wrappedlibasound.c index 0e583717..824364ff 100644 --- a/src/wrapped32/wrappedlibasound.c +++ b/src/wrapped32/wrappedlibasound.c @@ -23,6 +23,13 @@ #define LIBNAME libasound static const char* libasoundName = "libasound.so.2"; +typedef void (*vFp_t)(void*); +typedef void* (*pFp_t)(void*); + +#define ADDED_FUNCTIONS() \ + GO(snd_pcm_query_chmaps, pFp_t) \ + GO(snd_pcm_free_chmaps, vFp_t) \ + #include "generated/wrappedlibasoundtypes32.h" EXPORT uintptr_t my32_snd_lib_error = 0; @@ -275,6 +282,45 @@ static void empty_error_handler(const char *file, int line, const char *function // return my->snd_mixer_class_set_compare(class, findMixerCompareFct(f)); //} +typedef struct _my_snd_pcm_channel_area_s { + void *addr; + unsigned int first; + unsigned int step; +} my_snd_pcm_channel_area_t; +typedef struct _my_snd_pcm_channel_area_32_s { + ptr_t addr; + unsigned int first; + unsigned int step; +} my_snd_pcm_channel_area_32_t; + +EXPORT int my32_snd_pcm_mmap_begin(x64emu_t* emu, void* pcm, ptr_t* areas, ulong_t* offset, ulong_t* frames) +{ + my_snd_pcm_channel_area_t *l_areas; + unsigned long l_offset; + unsigned long l_frames = from_ulong(*frames); + int ret = my->snd_pcm_mmap_begin(pcm, &l_areas, &l_offset, &l_frames); + if(ret) + return ret; + *offset = to_ulong(l_offset); + *frames = to_ulong(l_frames); + static my_snd_pcm_channel_area_32_t my_areas[15] = {0}; + // get the number of channels + void** chmaps = my->snd_pcm_query_chmaps(pcm); + int nch = 1; + if(chmaps) { + while(chmaps[nch]) nch++; + my->snd_pcm_free_chmaps(chmaps); + } else printf_log(LOG_INFO, "Warning, could not get number of pcm channels in 32bits alsa for pcm_mmap_begin"); + if(nch>15) {printf_log(LOG_INFO, "Warning, too many channels in pcm of 32bits alsa: %d\n", nch); nch=15; } + for(int i=0; i<nch; ++i) { + my_areas[i].addr = to_ptrv(l_areas[i].addr); + my_areas[i].first = l_areas[i].first; + my_areas[i].step = l_areas[i].step; + } + *areas = to_ptrv(&my_areas); + return ret; +} + void* my_dlopen(x64emu_t* emu, void *filename, int flag); // defined in wrappedlibdl.c char* my_dlerror(x64emu_t* emu); int my_dlclose(x64emu_t* emu, void *handle); diff --git a/src/wrapped32/wrappedlibasound_private.h b/src/wrapped32/wrappedlibasound_private.h index a0474385..be88a179 100644 --- a/src/wrapped32/wrappedlibasound_private.h +++ b/src/wrapped32/wrappedlibasound_private.h @@ -168,10 +168,10 @@ GO(snd_strerror, pFi) //GO(snd_pcm_area_copy, iFpLpLui) //GO(snd_pcm_area_silence, iFpLui) //GO(snd_pcm_areas_copy, iFpLpLuLi) -//GO(snd_pcm_areas_silence, iFpLuLi) +GO(snd_pcm_areas_silence, iFpLuLi) //GO(snd_pcm_avail, lFp) //GO(snd_pcm_avail_delay, iFppp) -//GO(snd_pcm_avail_update, lFp) +GO(snd_pcm_avail_update, lFp) //GO(snd_pcm_build_linear_format, iFiiii) GO(snd_pcm_bytes_to_frames, lFpl) GO(snd_pcm_bytes_to_samples, lFpl) @@ -183,7 +183,7 @@ GO(snd_pcm_chmap_from_string, uFp) GO(snd_pcm_chmap_parse_string, pFp) GO(snd_pcm_close, iFp) //GO(snd_pcm_delay, iFpp) -//GO(snd_pcm_drain, iFp) +GO(snd_pcm_drain, iFp) GO(snd_pcm_drop, iFp) //GO(snd_pcm_dump, iFpp) //GO(snd_pcm_dump_hw_setup, iFpp) @@ -217,7 +217,7 @@ GO(snd_pcm_drop, iFp) //GO(snd_pcm_format_value, iFp) //GO(snd_pcm_format_width, iFi) //GO(snd_pcm_forward, lFpL) -//GO(snd_pcm_frames_to_bytes, lFpl) +GO(snd_pcm_frames_to_bytes, lFpl) //GO(snd_pcm_get_params, iFppp) //GO(snd_pcm_get_chmap, pFp) //GOM(snd_pcm_hook_add, iFEppupp) @@ -278,7 +278,7 @@ GO(snd_pcm_hw_params_get_rate_min, iFppp) //GO(snd_pcm_hw_params_is_double, iFp) //GO(snd_pcm_hw_params_is_half_duplex, iFp) //GO(snd_pcm_hw_params_is_joint_duplex, iFp) -//GO(snd_pcm_hw_params_malloc, iFp) +GO(snd_pcm_hw_params_malloc, iFBp_) GO(snd_pcm_hw_params_set_access, iFppu) //GO(snd_pcm_hw_params_set_access_first, iFppp) //GO(snd_pcm_hw_params_set_access_last, iFppp) @@ -286,8 +286,8 @@ GO(snd_pcm_hw_params_set_access, iFppu) GO(snd_pcm_hw_params_set_buffer_size, iFppL) //GO(snd_pcm_hw_params_set_buffer_size_first, iFppp) //GO(snd_pcm_hw_params_set_buffer_size_last, iFppp) -//GO(snd_pcm_hw_params_set_buffer_size_max, iFppp) -//GO(snd_pcm_hw_params_set_buffer_size_min, iFppp) +GO(snd_pcm_hw_params_set_buffer_size_max, iFppbL_) +GO(snd_pcm_hw_params_set_buffer_size_min, iFppbL_) //GO(snd_pcm_hw_params_set_buffer_size_minmax, iFpppp) GO(snd_pcm_hw_params_set_buffer_size_near, iFppbL_) //GO(snd_pcm_hw_params_set_buffer_time, iFppui) @@ -316,7 +316,7 @@ GO(snd_pcm_hw_params_set_format, iFppi) //GO(snd_pcm_hw_params_set_period_size_max, iFpppp) //GO(snd_pcm_hw_params_set_period_size_min, iFpppp) //GO(snd_pcm_hw_params_set_period_size_minmax, iFpppppp) -//GO(snd_pcm_hw_params_set_period_size_near, iFpppp) +GO(snd_pcm_hw_params_set_period_size_near, iFppbp_p) //GO(snd_pcm_hw_params_set_period_time, iFppui) //GO(snd_pcm_hw_params_set_period_time_first, iFpppp) //GO(snd_pcm_hw_params_set_period_time_last, iFpppp) @@ -339,7 +339,7 @@ GO(snd_pcm_hw_params_set_rate, iFppui) //GO(snd_pcm_hw_params_set_rate_min, iFpppp) //GO(snd_pcm_hw_params_set_rate_minmax, iFpppppp) GO(snd_pcm_hw_params_set_rate_near, iFpppp) -//GO(snd_pcm_hw_params_set_rate_resample, iFppu) +GO(snd_pcm_hw_params_set_rate_resample, iFppu) //GO(snd_pcm_hw_params_set_subformat, iFppi) //GO(snd_pcm_hw_params_set_subformat_first, iFppp) //GO(snd_pcm_hw_params_set_subformat_last, iFppp) @@ -365,12 +365,12 @@ GO(snd_pcm_hw_params_test_tick_time, iFppui) //GO(snd_pcm_hwsync, iFp) //GO(snd_pcm_info, iFpp) //GO(snd_pcm_info_copy, vFpp) -//GO(snd_pcm_info_free, vFp) +GO(snd_pcm_info_free, vFp) //GO(snd_pcm_info_get_card, iFp) //GO(snd_pcm_info_get_class, uFp) //GO(snd_pcm_info_get_device, uFp) //GO(snd_pcm_info_get_id, pFp) -//GO(snd_pcm_info_get_name, pFp) +GO(snd_pcm_info_get_name, pFp) //GO(snd_pcm_info_get_stream, uFp) //GO(snd_pcm_info_get_subclass, uFp) //GO(snd_pcm_info_get_subdevice, uFp) @@ -378,12 +378,12 @@ GO(snd_pcm_hw_params_test_tick_time, iFppui) //GO(snd_pcm_info_get_subdevices_avail, uFp) //GO(snd_pcm_info_get_subdevices_count, uFp) //GO(snd_pcm_info_get_sync, HFp) -//GO(snd_pcm_info_malloc, iFp) +GO(snd_pcm_info_malloc, iFBp_) //GO(snd_pcm_info_sizeof, LFv) //GO(snd_pcm_access_mask_sizeof, LFv) -//GO(snd_pcm_info_set_device, vFpu) -//GO(snd_pcm_info_set_stream, vFpu) -//GO(snd_pcm_info_set_subdevice, vFpu) +GO(snd_pcm_info_set_device, vFpu) +GO(snd_pcm_info_set_stream, vFpu) +GO(snd_pcm_info_set_subdevice, vFpu) //GO(snd_pcm_link, iFpp) //GO(snd_pcm_meter_add_scope, iFpp) //GO(snd_pcm_meter_get_boundary, LFp) @@ -392,8 +392,8 @@ GO(snd_pcm_hw_params_test_tick_time, iFppui) //GO(snd_pcm_meter_get_now, LFp) //GO(snd_pcm_meter_get_rate, uFp) //GO(snd_pcm_meter_search_scope, pFpp) -//GO(snd_pcm_mmap_begin, iFpppp) -//GO(snd_pcm_mmap_commit, lFpLL) +GOM(snd_pcm_mmap_begin, iFEpppp) +GO(snd_pcm_mmap_commit, lFpLL) //GO(snd_pcm_mmap_readi, lFppL) //GO(snd_pcm_mmap_readn, lFppL) //GO(snd_pcm_mmap_writei, lFppL) @@ -409,9 +409,9 @@ GO(snd_pcm_open, iFBp_pui) GO(snd_pcm_prepare, iFp) GO(snd_pcm_readi, lFppL) //GO(snd_pcm_readn, lFppL) -//GO(snd_pcm_recover, iFpii) +GO(snd_pcm_recover, iFpii) //GO(snd_pcm_reset, iFp) -//GO(snd_pcm_resume, iFp) +GO(snd_pcm_resume, iFp) //GO(snd_pcm_rewind, lFpL) //GO(snd_pcm_samples_to_bytes, lFpl) //GOM(snd_pcm_scope_get_callback_private, pFEp) @@ -427,9 +427,9 @@ GO(snd_pcm_sw_params_sizeof, LFv) //GOM(snd_pcm_scope_set_ops, vFEpp) //GO(snd_pcm_set_chmap, iFpp) //GO(snd_pcm_set_params, iFpiuuuiu) -//GO(snd_pcm_start, iFp) +GO(snd_pcm_start, iFp) //GO(snd_pcm_start_mode_name, pFu) -//GO(snd_pcm_state, uFp) +GO(snd_pcm_state, uFp) //GO(snd_pcm_state_name, pFu) //GO(snd_pcm_status, iFpp) //GO(snd_pcm_status_copy, vFpp) @@ -458,11 +458,11 @@ GO(snd_pcm_sw_params_sizeof, LFv) //GO(snd_pcm_subformat_mask_set, vFpi) //GO(snd_pcm_subformat_mask_test, iFpi) //GO(snd_pcm_subformat_name, pFi) -//GO(snd_pcm_sw_params, iFpp) +GO(snd_pcm_sw_params, iFpp) //GO(snd_pcm_sw_params_copy, vFpp) -//GO(snd_pcm_sw_params_current, iFpp) +GO(snd_pcm_sw_params_current, iFpp) //GO(snd_pcm_sw_params_dump, iFpp) -//GO(snd_pcm_sw_params_free, vFp) +GO(snd_pcm_sw_params_free, vFp) //GO(snd_pcm_sw_params_get_avail_min, iFpp) //GO(snd_pcm_sw_params_get_boundary, iFpp) //GO(snd_pcm_sw_params_get_silence_size, iFpp) @@ -474,8 +474,8 @@ GO(snd_pcm_sw_params_sizeof, LFv) //GO(snd_pcm_sw_params_get_tstamp_mode, iFpp) //GO(snd_pcm_sw_params_get_xfer_align, iFpp) //GO(snd_pcm_sw_params_get_xrun_mode, uFp) -//GO(snd_pcm_sw_params_malloc, iFp) -//GO(snd_pcm_sw_params_set_avail_min, iFppL) +GO(snd_pcm_sw_params_malloc, iFBp_) +GO(snd_pcm_sw_params_set_avail_min, iFppL) //GO(snd_pcm_sw_params_set_period_event, iFppi) //GO(snd_pcm_sw_params_set_silence_size, iFppL) //GO(snd_pcm_sw_params_set_silence_threshold, iFppL) @@ -491,7 +491,7 @@ GO(snd_pcm_sw_params_sizeof, LFv) //GO(snd_pcm_type, uFp) //GO(snd_pcm_type_name, pFu) //GO(snd_pcm_unlink, iFp) -//GO(snd_pcm_wait, iFpi) +GO(snd_pcm_wait, iFpi) GO(snd_pcm_writei, lFppL) //GO(snd_pcm_writen, lFppL) //GO(snd_pcm_xrun_mode_name, pFu) @@ -673,9 +673,9 @@ GO(snd_card_next, iFp) //GO(snd_card_get_index, iFp) GO(snd_card_get_name, iFiBp_ ) //GO(snd_card_get_longname, iFip) -//GO(snd_ctl_open, iFppi) +GO(snd_ctl_open, iFBp_pi) //GO(snd_ctl_open_lconf, iFppip) -//GO(snd_ctl_close, iFp) +GO(snd_ctl_close, iFp) //GO(snd_ctl_nonblock, iFpi) //GOM(snd_async_add_ctl_handler, iFpppp) //GO(snd_async_handler_get_ctl, pFp) @@ -683,7 +683,7 @@ GO(snd_card_get_name, iFiBp_ ) //GO(snd_ctl_poll_descriptors, iFppu) //GO(snd_ctl_poll_descriptors_revents, iFppup) //GO(snd_ctl_subscribe_events, iFpi) -//GO(snd_ctl_card_info, iFpp) +GO(snd_ctl_card_info, iFpp) //GO(snd_ctl_elem_list, iFpp) //GO(snd_ctl_elem_info, iFpp) //GO(snd_ctl_elem_read, iFpp) @@ -695,8 +695,8 @@ GO(snd_card_get_name, iFiBp_ ) //GO(snd_ctl_elem_tlv_command, iFppp) //GO(snd_ctl_hwdep_next_device, iFpp) //GO(snd_ctl_hwdep_info, iFpp) -//GO(snd_ctl_pcm_next_device, iFpp) -//GO(snd_ctl_pcm_info, iFpp) +GO(snd_ctl_pcm_next_device, iFpp) +GO(snd_ctl_pcm_info, iFpp) //GO(snd_ctl_pcm_prefer_subdevice, iFpi) //GO(snd_ctl_rawmidi_next_device, iFpp) //GO(snd_ctl_rawmidi_info, iFpp) @@ -738,16 +738,16 @@ GO(snd_card_get_name, iFiBp_ ) //GO(snd_ctl_elem_id_set_name, vFpp) //GO(snd_ctl_elem_id_set_index, vFpu) //GO(snd_ctl_card_info_sizeof, LFv) -//GO(snd_ctl_card_info_malloc, iFp) -//GO(snd_ctl_card_info_free, vFp) +GO(snd_ctl_card_info_malloc, iFBp_) +GO(snd_ctl_card_info_free, vFp) //GO(snd_ctl_card_info_clear, vFp) //GO(snd_ctl_card_info_copy, vFpp) //GO(snd_ctl_card_info_get_card, iFp) //GO(snd_ctl_card_info_get_id, pFp) //GO(snd_ctl_card_info_get_driver, pFp) -//GO(snd_ctl_card_info_get_name, pFp) -//GO(snd_ctl_card_info_get_longname, pFp) -//GO(snd_ctl_card_info_get_mixername, pFp) +GO(snd_ctl_card_info_get_name, pFp) +GO(snd_ctl_card_info_get_longname, pFp) +GO(snd_ctl_card_info_get_mixername, pFp) //GO(snd_ctl_card_info_get_components, pFp) //GO(snd_ctl_event_sizeof, LFv) //GO(snd_ctl_event_malloc, iFp) diff --git a/src/wrapped32/wrappedlibc_private.h b/src/wrapped32/wrappedlibc_private.h index 1f474f61..f9d29f93 100755 --- a/src/wrapped32/wrappedlibc_private.h +++ b/src/wrapped32/wrappedlibc_private.h @@ -1623,7 +1623,7 @@ GO(__strcat_chk, pFppL) GO(strchr, pFpi) //GOW(strchrnul, pFpi) GO(strcmp, iFpp) -//GO(strcoll, iFpp) +GO(strcoll, iFpp) GO(__strcoll_l, iFppa) //GOW(strcoll_l, iFppp) GO(strcpy, pFpp) diff --git a/src/wrapped32/wrappedlibgl.c b/src/wrapped32/wrappedlibgl.c index 9d18fe23..d0599197 100644 --- a/src/wrapped32/wrappedlibgl.c +++ b/src/wrapped32/wrappedlibgl.c @@ -19,7 +19,10 @@ extern const char* libglName; #define LIBNAME libgl -static library_t* my_lib = NULL; + +#include "generated/wrappedlibgltypes32.h" + +#include "wrappercallback32.h" // FIXME: old wrapped* type of file, cannot use generated/wrappedlibgltypes.h void* getGLProcAddress32(x64emu_t* emu, glprocaddress_t procaddr, const char* rname); @@ -36,6 +39,7 @@ typedef void (*vFpp_t)(void*, void*); typedef void (*vFppp_t)(void*, void*, void*); typedef void (*vFppi_t)(void*, void*, int); typedef void*(*pFp_t)(void*); +typedef void (*vFuipp_t)(uint32_t, int, void*, void*); typedef void (*debugProc_t)(int32_t, int32_t, uint32_t, int32_t, int32_t, void*, void*); typedef struct gl_wrappers_s { @@ -408,6 +412,31 @@ static void* find_glGetVkProcAddrNV_Fct(void* fct) printf_log(LOG_NONE, "Warning, no more slot for libGL glGetVkProcAddrNV callback\n"); return NULL; } +// glShaderSource ... +#define GO(A) \ +static vFuipp_t my32_glShaderSource_fct_##A = NULL; \ +static void my32_glShaderSource_##A(x64emu_t* emu, uint32_t shader, int count, ptr_t* string, int* length) \ +{ \ + if(!my32_glShaderSource_fct_##A) \ + return; \ + char* str[count]; \ + if(string) for(int i=0; i<count; ++i) str[i] = from_ptrv(string[i]); \ + my32_glShaderSource_fct_##A (shader, count, string?str:NULL, length); \ +} +SUPER() +#undef GO +static void* find_glShaderSource_Fct(void* fct) +{ + if(!fct) return fct; + #define GO(A) if(my32_glShaderSource_fct_##A == (vFuipp_t)fct) return my32_glShaderSource_##A; + SUPER() + #undef GO + #define GO(A) if(my32_glShaderSource_fct_##A == 0) {my32_glShaderSource_fct_##A = (vFuipp_t)fct; return my32_glShaderSource_##A; } + SUPER() + #undef GO + printf_log(LOG_NONE, "Warning, no more slot for libGL glShaderSource callback\n"); + return NULL; +} #undef SUPER #define PRE_INIT if(box64_libGL) {lib->w.lib = dlopen(box64_libGL, RTLD_LAZY | RTLD_GLOBAL); lib->path = strdup(box64_libGL);} else @@ -436,6 +465,14 @@ static void* find_glGetVkProcAddrNV_Fct(void* fct) s->addr = AddBridge(lib->w.bridge, s->w, find_glXSwapIntervalEXT_Fct(symb), 0, "glXSwapIntervalEXT"); \ } \ +// creating function for direct access, just in case +EXPORT void my32_glShaderSource(x64emu_t* emu, uint32_t shader, int count, ptr_t* string, int* length) +{ + char* str[count]; + if(string) for(int i=0; i<count; ++i) str[i] = from_ptrv(string[i]); + my->glShaderSource(shader, count, string?str:NULL, length); +} + #include "wrappedlib_init32.h" #define SUPER() \ @@ -449,6 +486,7 @@ static void* find_glGetVkProcAddrNV_Fct(void* fct) GO(vFpp_t, glProgramCallbackMESA) \ GO(pFp_t, glGetVkProcAddrNV) \ GO(vFppp_t, eglSetBlobCacheFuncsANDROID) \ + GO(vFuipp_t, glShaderSource) \ gl_wrappers_t* getGLProcWrapper32(box64context_t* context, glprocaddress_t procaddress) diff --git a/src/wrapped32/wrappedlibgl_private.h b/src/wrapped32/wrappedlibgl_private.h index d154c602..95f9f30e 100644 --- a/src/wrapped32/wrappedlibgl_private.h +++ b/src/wrapped32/wrappedlibgl_private.h @@ -523,7 +523,7 @@ GO(glGetVertexAttribiv, vFuup) GO(glIsProgram, CFu) GO(glIsShader, CFu) GO(glLinkProgram, vFu) -GO(glShaderSource, vFuipp) +GOM(glShaderSource, vFEuipp) GO(glStencilFuncSeparate, vFuuiu) GO(glStencilMaskSeparate, vFuu) GO(glStencilOpSeparate, vFuuuu) @@ -2926,128 +2926,128 @@ GO(glNamedBufferPageCommitmentEXT, vFullC) GO(TexPageCommitmentARB, vFiiiiiiiii) //glx -GO(glXBindHyperpipeSGIX, iFpi) -GO(glXBindTexImageEXT, vFppip) -GO(glXBindSwapBarrierNV, iFpuu) +GO(glXBindHyperpipeSGIX, iFXi) +GO(glXBindTexImageEXT, vFXpip) +GO(glXBindSwapBarrierNV, iFXuu) GO(glXBindSwapBarrierSGIX,vFii) -GO(glXBindVideoCaptureDeviceNV, iFpup) -GO(glXBindVideoDeviceNV, iFpuup) -GO(glXBindVideoImageNV, iFpppi) -GO(glXChangeDrawableAttributes, vFp) -GO(glXChangeDrawableAttributesSGIX, vFp) +//GO(glXBindVideoCaptureDeviceNV, iFpup) +//GO(glXBindVideoDeviceNV, iFpuup) +//GO(glXBindVideoImageNV, iFpppi) +//GO(glXChangeDrawableAttributes, vFp) +//GO(glXChangeDrawableAttributesSGIX, vFp) GO(glXClientInfo, vFv) -GO(glXCopyContext, vFppp) -GO(glXChooseFBConfig, pFpipp) -GO(glXChooseFBConfigSGIX, pFpipp) -GO(glXCreateContext,pFpppi) -GO(glXCreateContextAttribsARB, pFpppip) -GO(glXCreateContextWithConfigSGIX, pFppipi) -GO(glXCreateGLXPbufferSGIX, pFppuup) -GO(glXCreateGLXPixmap, pFppp) -GO(glXCreateGLXPixmapWithConfigSGIX, pFppp) -GO(glXCreateGLXVideoSourceSGIX, pFpippip) -GO(glXCreateNewContext, pFppipi) -GO(glXCreatePbuffer, pFppp) -GO(glXCreatePixmap, pFppp) -GO(glXCreateWindow, pFpppp) -GO(glXChooseVisual, pFpip) -GO(glXCopyImageSubDataNV, vFppuiiiiipuiiiiiiii) -GO(glXCopySubBufferMESA, vFppiiii) -GO(glXDestroyContext,vFpp) -GO(glXDestroyGLXPbufferSGIX,vFpp) -GO(glXDestroyGLXPixmap,vFpp) -GO(glXDestroyGLXVideoSourceSGIX,vFpp) -GO(glXDestroyHyperpipeConfigSGIX,iFpi) -GO(glXDestroyPbuffer,vFpp) -GO(glXDestroyPixmap,vFpp) -GO(glXDestroyWindow,vFpp) -GO(glXEnumerateVideoCaptureDevicesNV, pFpip) -GO(glXEnumerateVideoDevicesNV, pFpip) -GO(glXFreeContextEXT, vFpp) -GO(glXGetClientString, pFpi) -GO(glXGetConfig, iFppip) -GO(glXGetContextIDEXT, uFp) -GO(glXGetCurrentContext, pFv) -GO(glXGetCurrentDisplay, pFv) -GO(glXGetCurrentDrawable, pFv) -GO(glXGetCurrentReadDrawable, pFv) -GO(glXGetDrawableAttributes,vFi) -GO(glXGetDrawableAttributesSGIX,vFi) -GO(glXGetFBConfigs,pFpip) -GO(glXGetFBConfigAttrib, iFppip) -GO(glXGetFBConfigAttribSGIX, iFppip) -GO(glXGetFBConfigFromVisualSGIX, pFpp) -GO(glXGetFBConfigsSGIX,pFpip) -GO(glXGetSelectedEvent, vFppp) -GO(glXGetSelectedEventSGIX, vFppp) -GO(glXGetVideoDeviceNV, iFpiip) -GO(glXGetVideoInfoNV, iFpippp) -GO(glXGetVideoSyncSGI, iFp) -GO(glXGetVisualConfigs,pFpp) -GO(glXGetVisualFromFBConfig, pFpp) -GO(glXGetVisualFromFBConfigSGIX, pFpp) -GO(glXHyperpipeAttribSGIX,iFpiiip) +//GO(glXCopyContext, vFppp) +//GO(glXChooseFBConfig, pFpipp) +//GO(glXChooseFBConfigSGIX, pFpipp) +GO(glXCreateContext,pFXppi) +//GO(glXCreateContextAttribsARB, pFpppip) +//GO(glXCreateContextWithConfigSGIX, pFppipi) +//GO(glXCreateGLXPbufferSGIX, pFppuup) +//GO(glXCreateGLXPixmap, pFppp) +//GO(glXCreateGLXPixmapWithConfigSGIX, pFppp) +//GO(glXCreateGLXVideoSourceSGIX, pFpippip) +//GO(glXCreateNewContext, pFppipi) +//GO(glXCreatePbuffer, pFppp) +//GO(glXCreatePixmap, pFppp) +//GO(glXCreateWindow, pFpppp) +GO(glXChooseVisual, pFXip) // need to wrap XVisualInfo? +//GO(glXCopyImageSubDataNV, vFppuiiiiipuiiiiiiii) +//GO(glXCopySubBufferMESA, vFppiiii) +GO(glXDestroyContext,vFXp) +//GO(glXDestroyGLXPbufferSGIX,vFpp) +//GO(glXDestroyGLXPixmap,vFpp) +//GO(glXDestroyGLXVideoSourceSGIX,vFpp) +//GO(glXDestroyHyperpipeConfigSGIX,iFpi) +//GO(glXDestroyPbuffer,vFpp) +//GO(glXDestroyPixmap,vFpp) +//GO(glXDestroyWindow,vFpp) +//GO(glXEnumerateVideoCaptureDevicesNV, pFpip) +//GO(glXEnumerateVideoDevicesNV, pFpip) +//GO(glXFreeContextEXT, vFpp) +GO(glXGetClientString, pFXi) +//GO(glXGetConfig, iFppip) +//GO(glXGetContextIDEXT, uFp) +//GO(glXGetCurrentContext, pFv) +//GO(glXGetCurrentDisplay, pFv) +//GO(glXGetCurrentDrawable, pFv) +//GO(glXGetCurrentReadDrawable, pFv) +//GO(glXGetDrawableAttributes,vFi) +//GO(glXGetDrawableAttributesSGIX,vFi) +//GO(glXGetFBConfigs,pFpip) +//GO(glXGetFBConfigAttrib, iFppip) +//GO(glXGetFBConfigAttribSGIX, iFppip) +//GO(glXGetFBConfigFromVisualSGIX, pFpp) +//GO(glXGetFBConfigsSGIX,pFpip) +//GO(glXGetSelectedEvent, vFppp) +//GO(glXGetSelectedEventSGIX, vFppp) +//GO(glXGetVideoDeviceNV, iFpiip) +//GO(glXGetVideoInfoNV, iFpippp) +//GO(glXGetVideoSyncSGI, iFp) +//GO(glXGetVisualConfigs,pFpp) +//GO(glXGetVisualFromFBConfig, pFpp) +//GO(glXGetVisualFromFBConfigSGIX, pFpp) +//GO(glXHyperpipeAttribSGIX,iFpiiip) //GO(glXHyperpipeConfigSGIX, iFpiipp) -GO(glXImportContextEXT, pFpu) -GO(glXIsDirect,iFpp) -GO(glXJoinSwapGroupNV, iFppu) -GO(glXJoinSwapGroupSGIX,vFpp) -GO(glXLockVideoCaptureDeviceNV, vFpp) -GO(glXMakeContextCurrent,iFpppp) -GO(glXMakeCurrent,iFppp) -GO(glXQueryContext,iFppip) -GO(glXQueryContextInfoEXT,iFppip) -GO(glXQueryDrawable, iFppip) -GO(glXQueryExtension, iFppp) -GO(glXQueryExtensionsString,pFpi) -GO(glXQueryFrameCountNV, iFpip) -GO(glXQueryGLXPbufferSGIX, vFppip) -GO(glXQueryHyperpipeAttribSGIX,iFpiiip) -GO(glXQueryHyperpipeBestAttribSGIX,iFpiiipp) -GO(glXQueryHyperpipeConfigSGIX,pFpip) -GO(glXQueryHyperpipeNetworkSGIX,pFpp) -GO(glXQueryMaxSwapBarriersSGIX,pFpp) //? -GO(glXQueryMaxSwapGroupsNV, iFpipp) -GO(glXQueryServerString,pFpii) -GO(glXQuerySwapGroupNV, iFpipp) -GO(glXQueryVersion,iFppp) -GO(glXQueryVideoCaptureDeviceNV, iFppip) -GO(glXReleaseTexImageEXT, vFppi) -GO(glXReleaseVideoCaptureDeviceNV, vFpp) -GO(glXReleaseVideoDeviceNV, iFpip) -GO(glXReleaseVideoImageNV, iFpp) +//GO(glXImportContextEXT, pFpu) +//GO(glXIsDirect,iFpp) +GO(glXJoinSwapGroupNV, iFXpu) +//GO(glXJoinSwapGroupSGIX,vFpp) +//GO(glXLockVideoCaptureDeviceNV, vFpp) +//GO(glXMakeContextCurrent,iFpppp) +GO(glXMakeCurrent,iFXpp) +//GO(glXQueryContext,iFppip) +//GO(glXQueryContextInfoEXT,iFppip) +//GO(glXQueryDrawable, iFppip) +//GO(glXQueryExtension, iFppp) +GO(glXQueryExtensionsString,pFXi) +GO(glXQueryFrameCountNV, iFXip) +//GO(glXQueryGLXPbufferSGIX, vFppip) +//GO(glXQueryHyperpipeAttribSGIX,iFpiiip) +//GO(glXQueryHyperpipeBestAttribSGIX,iFpiiipp) +//GO(glXQueryHyperpipeConfigSGIX,pFpip) +//GO(glXQueryHyperpipeNetworkSGIX,pFpp) +//GO(glXQueryMaxSwapBarriersSGIX,pFpp) //? +GO(glXQueryMaxSwapGroupsNV, iFXipp) +//GO(glXQueryServerString,pFpii) +GO(glXQuerySwapGroupNV, iFXipp) +//GO(glXQueryVersion,iFppp) +//GO(glXQueryVideoCaptureDeviceNV, iFppip) +GO(glXReleaseTexImageEXT, vFXpi) +//GO(glXReleaseVideoCaptureDeviceNV, vFpp) +//GO(glXReleaseVideoDeviceNV, iFpip) +//GO(glXReleaseVideoImageNV, iFpp) //GO(glXRender, vFv) //GO(glXRenderLarge, vFv) -GO(glXResetFrameCountNV, iFpi) -GO(glXSelectEvent, vFppu) -GO(glXSelectEventSGIX, vFppu) -GO(glXSendPbufferToVideoNV, iFppipi) -GO(glXSwapBuffers,vFpp) -GO(glXUseXFont,vFpiii) +GO(glXResetFrameCountNV, iFXi) +//GO(glXSelectEvent, vFppu) +//GO(glXSelectEventSGIX, vFppu) +//GO(glXSendPbufferToVideoNV, iFppipi) +GO(glXSwapBuffers,vFXp) +//GO(glXUseXFont,vFpiii) //GO(glXVendorPrivate, vFv) //GO(glXVendorPrivateWithReply, vFv) -GO(glXWaitGL,vFv) -GO(glXWaitVideoSyncSGI, iFiip) -GO(glXWaitX,vFv) +//GO(glXWaitGL,vFv) +//GO(glXWaitVideoSyncSGI, iFiip) +//GO(glXWaitX,vFv) GOM(glXGetProcAddress, pFEp) GOM(glXGetProcAddressARB, pFEp) //GLX_MESA_query_renderer -GO(glXQueryRendererIntegerMESA, iFpiiip) +GO(glXQueryRendererIntegerMESA, iFXiiip) GO(glXQueryCurrentRendererIntegerMESA, iFip) -GO(glXQueryRendererStringMESA, pFpiii) +GO(glXQueryRendererStringMESA, pFXiii) GO(glXQueryCurrentRendererStringMESA, pFi) //GLX_OML_sync_control -GO(glXGetSyncValuesOML, iFppppp) -GO(glXGetMscRateOML, iFpppp) -GO(glXSwapBuffersMscOML, IFppIII) -GO(glXWaitForMscOML, iFppIIIppp) -GO(glXWaitForSbcOML, iFppIppp) +GO(glXGetSyncValuesOML, iFXpppp) +GO(glXGetMscRateOML, iFXppp) +GO(glXSwapBuffersMscOML, IFXpIII) +GO(glXWaitForMscOML, iFXpIIIppp) +GO(glXWaitForSbcOML, iFXpIppp) //GLX_EXT_swap_control -GOM(glXSwapIntervalEXT, vFppi) //%noE +GOM(glXSwapIntervalEXT, vFXpi) //%noE //GLX_EXT_swap_control_tear //nothing @@ -4061,3 +4061,5 @@ GO(glGetInteger64vEXT, vFup) GO(glGetBufferPointervOES, vFuup) GO(glMapBufferOES, pFuu) GO(glUnmapBufferOES, iFu) + +GO(dummmy_vFppi, vFppi) \ No newline at end of file diff --git a/src/wrapped32/wrappedlibpthread.c b/src/wrapped32/wrappedlibpthread.c index 5c3be2e4..5589d360 100755 --- a/src/wrapped32/wrappedlibpthread.c +++ b/src/wrapped32/wrappedlibpthread.c @@ -5,6 +5,7 @@ #include <dlfcn.h> #include <errno.h> #include <pthread.h> +#include <semaphore.h> #include "wrappedlibs.h" @@ -55,6 +56,64 @@ EXPORT void my32___pthread_initialize() // nothing, the lib initialize itself now } +EXPORT int my32_sem_close(void** sem) +{ + int ret = 0; + ret = sem_close(*sem); + box_free(sem); + return ret; +} +EXPORT int my32_sem_destroy(void** sem) +{ + int ret = 0; + ret = sem_destroy(*sem); + box_free(*sem); + *sem = NULL; + return ret; +} +EXPORT int my32_sem_getvalue(void** sem, int* val) +{ + int ret = 0; + ret = sem_getvalue(*sem, val); + box_free(*sem); + *sem = NULL; + return ret; +} +EXPORT int my32_sem_init(void** sem, int pshared, uint32_t val) +{ + int ret = 0; + *sem = box_calloc(1, sizeof(sem_t)); + ret = sem_init(*sem, pshared, val); + return ret; +} +EXPORT void* my32_sem_open(const char* name, int flags) +{ + sem_t* sem = sem_open(name, flags); + if(!sem) + return sem; + void** ret = (void**)box_calloc(1, sizeof(void*)); + *ret = sem; + return ret; +} +EXPORT int my32_sem_post(void** sem) +{ + return sem_post(*sem); +} +EXPORT int my32_sem_timedwait(void** sem, void* t) +{ + return sem_timedwait(*sem, t); +} +EXPORT int my32_sem_trywait(void** sem) +{ + return sem_trywait(*sem); +} +EXPORT int my32_sem_wait(void** sem) +{ + return sem_wait(*sem); +} + + + #define PRE_INIT\ if(1) \ lib->w.lib = dlopen(NULL, RTLD_LAZY | RTLD_GLOBAL); \ diff --git a/src/wrapped32/wrappedlibpthread_private.h b/src/wrapped32/wrappedlibpthread_private.h index 73a28343..83ba3bd0 100755 --- a/src/wrapped32/wrappedlibpthread_private.h +++ b/src/wrapped32/wrappedlibpthread_private.h @@ -172,16 +172,16 @@ GOM(__pthread_unwind_next, vFEp) GO(pthread_yield, iFv) // raise // __res_state -GO(sem_close, iFp) -GO(sem_destroy, iFp) -GO(sem_getvalue, iFpp) -GO(sem_init, iFpiu) -GO(sem_open, pFpOM) -GO(sem_post, iFp) -GO(sem_timedwait, iFpp) -GO(sem_trywait, iFp) -GO(sem_unlink, iFp) -GO(sem_wait, iFp) +GOM(sem_close, iFp) //%noE +GOM(sem_destroy, iFp) //%noE +GOM(sem_getvalue, iFpp) //%noE +GOM(sem_init, iFpiu) //%noE +GOM(sem_open, pFpOM) //%noE +GOM(sem_post, iFp) //%noE +GOM(sem_timedwait, iFprLL_) //%noE +GOM(sem_trywait, iFp) //%noE +GO(sem_unlink, iFp) // no need for M here? +GOM(sem_wait, iFp) //%noE // __sigaction // system // __vfork diff --git a/src/wrapped32/wrappedlibx11.c b/src/wrapped32/wrappedlibx11.c new file mode 100644 index 00000000..36b79d39 --- /dev/null +++ b/src/wrapped32/wrappedlibx11.c @@ -0,0 +1,1948 @@ +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#define _GNU_SOURCE /* See feature_test_macros(7) */ +#include <dlfcn.h> + +#include "wrappedlibs.h" + +#include "debug.h" +#include "wrapper32.h" +#include "bridge.h" +#include "librarian/library_private.h" +#include "x64emu.h" +#include "callback.h" +#include "librarian.h" +#include "box32context.h" +#include "emu/x64emu_private.h" +#include "myalign32.h" +#include "elfloader.h" + +#ifdef ANDROID + static const char* libx11Name = "libX11.so"; +#else + static const char* libx11Name = "libX11.so.6"; +#endif + +#define LIBNAME libx11 +#if 0 +typedef int (*XErrorHandler)(void *, void *); +void* my32_XSetErrorHandler(x64emu_t* t, XErrorHandler handler); +typedef int (*XIOErrorHandler)(void *); +void* my32_XSetIOErrorHandler(x64emu_t* t, XIOErrorHandler handler); +void* my32_XESetCloseDisplay(x64emu_t* emu, void* display, int32_t extension, void* handler); +typedef int (*WireToEventProc)(void*, void*, void*); +typedef int(*EventHandler) (void*,void*,void*); +int32_t my32_XIfEvent(x64emu_t* emu, void* d,void* ev, EventHandler h, void* arg); +#endif + +#include "libtools/my_x11_defs.h" +#include "libtools/my_x11_defs_32.h" + +void UnwrapXImage(void* d, void* s); +void WrapXImage(void* d, void* s); + +typedef void (*vFp_t)(void*); +typedef uint32_t (*uFv_t)(void); +typedef int32_t (*iFpl_t)(void*, intptr_t); +typedef uintptr_t (*LFpii_t)(void*, int32_t, int32_t); +typedef int32_t (*iFpiiL_t)(void*, int32_t, int32_t, uintptr_t); +typedef void* (*pFpiiuu_t)(void*, int32_t, int32_t, uint32_t, uint32_t); + +#define ADDED_FUNCTIONS() \ + GO(XInitThreads, uFv_t) \ + GO(XLockDisplay, vFp_t) \ + GO(XUnlockDisplay, vFp_t) + +#include "generated/wrappedlibx11types32.h" + +#include "wrappercallback32.h" + +void* FindDisplay(void* d); + +#define SUPER() \ +GO(0) \ +GO(1) \ +GO(2) \ +GO(3) \ +GO(4) \ +GO(5) \ +GO(6) \ +GO(7) \ +GO(8) \ +GO(9) \ +GO(10) \ +GO(11) \ +GO(12) \ +GO(13) \ +GO(14) \ +GO(15) +#if 0 +// wire_to_event +#define GO(A) \ +static uintptr_t my32_wire_to_event_fct_##A = 0; \ +static int my32_wire_to_event_##A(void* dpy, void* re, void* event) \ +{ \ + return (int)RunFunctionFmt(my32_wire_to_event_fct_##A, "ppp", dpy, re, event);\ +} +SUPER() +#undef GO +static void* findwire_to_eventFct(void* fct) +{ + if(!fct) return fct; + if(GetNativeFnc((uintptr_t)fct)) return GetNativeFnc((uintptr_t)fct); + #define GO(A) if(my32_wire_to_event_fct_##A == (uintptr_t)fct) return my32_wire_to_event_##A; + SUPER() + #undef GO + #define GO(A) if(my32_wire_to_event_fct_##A == 0) {my32_wire_to_event_fct_##A = (uintptr_t)fct; return my32_wire_to_event_##A; } + SUPER() + #undef GO + printf_log(LOG_NONE, "Warning, no more slot for libX11 wire_to_event callback\n"); + return NULL; +} +static void* reverse_wire_to_eventFct(library_t* lib, void* fct) +{ + if(!fct) return fct; + if(CheckBridged(lib->w.bridge, fct)) + return (void*)CheckBridged(lib->w.bridge, fct); + #define GO(A) if(my32_wire_to_event_##A == fct) return (void*)my32_wire_to_event_fct_##A; + SUPER() + #undef GO + return (void*)AddBridge(lib->w.bridge, iFppp, fct, 0, NULL); +} + +// event_to_wire +#define GO(A) \ +static uintptr_t my32_event_to_wire_fct_##A = 0; \ +static int my32_event_to_wire_##A(void* dpy, void* re, void* event) \ +{ \ + return (int)RunFunctionFmt(my32_event_to_wire_fct_##A, "ppp", dpy, re, event);\ +} +SUPER() +#undef GO +static void* findevent_to_wireFct(void* fct) +{ + if(!fct) return fct; + if(GetNativeFnc((uintptr_t)fct)) return GetNativeFnc((uintptr_t)fct); + #define GO(A) if(my32_event_to_wire_fct_##A == (uintptr_t)fct) return my32_event_to_wire_##A; + SUPER() + #undef GO + #define GO(A) if(my32_event_to_wire_fct_##A == 0) {my32_event_to_wire_fct_##A = (uintptr_t)fct; return my32_event_to_wire_##A; } + SUPER() + #undef GO + printf_log(LOG_NONE, "Warning, no more slot for libX11 event_to_wire callback\n"); + return NULL; +} +static void* reverse_event_to_wireFct(library_t* lib, void* fct) +{ + if(!fct) return fct; + if(CheckBridged(lib->w.bridge, fct)) + return (void*)CheckBridged(lib->w.bridge, fct); + #define GO(A) if(my32_event_to_wire_##A == fct) return (void*)my32_event_to_wire_fct_##A; + SUPER() + #undef GO + return (void*)AddBridge(lib->w.bridge, iFppp, fct, 0, NULL); +} + +// error_handler +#define GO(A) \ +static uintptr_t my32_error_handler_fct_##A = 0; \ +static int my32_error_handler_##A(void* dpy, void* error) \ +{ \ + return (int)RunFunctionFmt(my32_error_handler_fct_##A, "pp", dpy, error);\ +} +SUPER() +#undef GO +static void* finderror_handlerFct(void* fct) +{ + if(!fct) return fct; + if(GetNativeFnc((uintptr_t)fct)) return GetNativeFnc((uintptr_t)fct); + #define GO(A) if(my32_error_handler_fct_##A == (uintptr_t)fct) return my32_error_handler_##A; + SUPER() + #undef GO + #define GO(A) if(my32_error_handler_fct_##A == 0) {my32_error_handler_fct_##A = (uintptr_t)fct; return my32_error_handler_##A; } + SUPER() + #undef GO + printf_log(LOG_NONE, "Warning, no more slot for libX11 error_handler callback\n"); + return NULL; +} +static void* reverse_error_handlerFct(library_t* lib, void* fct) +{ + if(!fct) return fct; + if(CheckBridged(lib->w.bridge, fct)) + return (void*)CheckBridged(lib->w.bridge, fct); + #define GO(A) if(my32_error_handler_##A == fct) return (void*)my32_error_handler_fct_##A; + SUPER() + #undef GO + return (void*)AddBridge(lib->w.bridge, iFpp, fct, 0, NULL); +} + +// ioerror_handler +#define GO(A) \ +static uintptr_t my32_ioerror_handler_fct_##A = 0; \ +static int my32_ioerror_handler_##A(void* dpy) \ +{ \ + return (int)RunFunctionFmt(my32_ioerror_handler_fct_##A, "p", dpy);\ +} +SUPER() +#undef GO +static void* findioerror_handlerFct(void* fct) +{ + if(!fct) return fct; + if(GetNativeFnc((uintptr_t)fct)) return GetNativeFnc((uintptr_t)fct); + #define GO(A) if(my32_ioerror_handler_fct_##A == (uintptr_t)fct) return my32_ioerror_handler_##A; + SUPER() + #undef GO + #define GO(A) if(my32_ioerror_handler_fct_##A == 0) {my32_ioerror_handler_fct_##A = (uintptr_t)fct; return my32_ioerror_handler_##A; } + SUPER() + #undef GO + printf_log(LOG_NONE, "Warning, no more slot for libX11 ioerror_handler callback\n"); + return NULL; +} +static void* reverse_ioerror_handlerFct(library_t* lib, void* fct) +{ + if(!fct) return fct; + if(CheckBridged(lib->w.bridge, fct)) + return (void*)CheckBridged(lib->w.bridge, fct); + #define GO(A) if(my32_ioerror_handler_##A == fct) return (void*)my32_ioerror_handler_fct_##A; + SUPER() + #undef GO + return (void*)AddBridge(lib->w.bridge, iFp, fct, 0, NULL); +} + +// exterror_handler +#define GO(A) \ +static uintptr_t my32_exterror_handler_fct_##A = 0; \ +static int my32_exterror_handler_##A(void* dpy, void* err, void* codes, int* ret_code) \ +{ \ + return (int)RunFunctionFmt(my32_exterror_handler_fct_##A, "pppp", dpy, err, codes, ret_code);\ +} +SUPER() +#undef GO +static void* findexterror_handlerFct(void* fct) +{ + if(!fct) return fct; + if(GetNativeFnc((uintptr_t)fct)) return GetNativeFnc((uintptr_t)fct); + #define GO(A) if(my32_exterror_handler_fct_##A == (uintptr_t)fct) return my32_exterror_handler_##A; + SUPER() + #undef GO + #define GO(A) if(my32_exterror_handler_fct_##A == 0) {my32_exterror_handler_fct_##A = (uintptr_t)fct; return my32_exterror_handler_##A; } + SUPER() + #undef GO + printf_log(LOG_NONE, "Warning, no more slot for libX11 exterror_handler callback\n"); + return NULL; +} +static void* reverse_exterror_handlerFct(library_t* lib, void* fct) +{ + if(!fct) return fct; + if(CheckBridged(lib->w.bridge, fct)) + return (void*)CheckBridged(lib->w.bridge, fct); + #define GO(A) if(my32_exterror_handler_##A == fct) return (void*)my32_exterror_handler_fct_##A; + SUPER() + #undef GO + return (void*)AddBridge(lib->w.bridge, iFpppp, fct, 0, NULL); +} + +// close_display +#define GO(A) \ +static uintptr_t my32_close_display_fct_##A = 0; \ +static int my32_close_display_##A(void* dpy, void* codes) \ +{ \ + return (int)RunFunctionFmt(my32_close_display_fct_##A, "pp", dpy, codes);\ +} +SUPER() +#undef GO +static void* findclose_displayFct(void* fct) +{ + if(!fct) return fct; + if(GetNativeFnc((uintptr_t)fct)) return GetNativeFnc((uintptr_t)fct); + #define GO(A) if(my32_close_display_fct_##A == (uintptr_t)fct) return my32_close_display_##A; + SUPER() + #undef GO + #define GO(A) if(my32_close_display_fct_##A == 0) {my32_close_display_fct_##A = (uintptr_t)fct; return my32_close_display_##A; } + SUPER() + #undef GO + printf_log(LOG_NONE, "Warning, no more slot for libX11 close_display callback\n"); + return NULL; +} +static void* reverse_close_displayFct(library_t* lib, void* fct) +{ + if(!fct) return fct; + if(CheckBridged(lib->w.bridge, fct)) + return (void*)CheckBridged(lib->w.bridge, fct); + #define GO(A) if(my32_close_display_##A == fct) return (void*)my32_close_display_fct_##A; + SUPER() + #undef GO + return (void*)AddBridge(lib->w.bridge, iFpp, fct, 0, NULL); +} + +// register_im +#define GO(A) \ +static uintptr_t my32_register_im_fct_##A = 0; \ +static void my32_register_im_##A(void* dpy, void* u, void* d) \ +{ \ + RunFunctionFmt(my32_register_im_fct_##A, "ppp", dpy, u, d); \ +} +SUPER() +#undef GO +static void* findregister_imFct(void* fct) +{ + if(!fct) return fct; + if(GetNativeFnc((uintptr_t)fct)) return GetNativeFnc((uintptr_t)fct); + #define GO(A) if(my32_register_im_fct_##A == (uintptr_t)fct) return my32_register_im_##A; + SUPER() + #undef GO + #define GO(A) if(my32_register_im_fct_##A == 0) {my32_register_im_fct_##A = (uintptr_t)fct; return my32_register_im_##A; } + SUPER() + #undef GO + printf_log(LOG_NONE, "Warning, no more slot for libX11 register_im callback\n"); + return NULL; +} +static void* reverse_register_imFct(library_t* lib, void* fct) +{ + if(!fct) return fct; + if(CheckBridged(lib->w.bridge, fct)) + return (void*)CheckBridged(lib->w.bridge, fct); + #define GO(A) if(my32_register_im_##A == fct) return (void*)my32_register_im_fct_##A; + SUPER() + #undef GO + return (void*)AddBridge(lib->w.bridge, iFppp, fct, 0, NULL); +} + +// XConnectionWatchProc +#define GO(A) \ +static uintptr_t my32_XConnectionWatchProc_fct_##A = 0; \ +static void my32_XConnectionWatchProc_##A(void* dpy, void* data, int op, void* d) \ +{ \ + RunFunctionFmt(my32_XConnectionWatchProc_fct_##A, "ppip", dpy, data, op, d); \ +} +SUPER() +#undef GO +static void* findXConnectionWatchProcFct(void* fct) +{ + if(!fct) return fct; + if(GetNativeFnc((uintptr_t)fct)) return GetNativeFnc((uintptr_t)fct); + #define GO(A) if(my32_XConnectionWatchProc_fct_##A == (uintptr_t)fct) return my32_XConnectionWatchProc_##A; + SUPER() + #undef GO + #define GO(A) if(my32_XConnectionWatchProc_fct_##A == 0) {my32_XConnectionWatchProc_fct_##A = (uintptr_t)fct; return my32_XConnectionWatchProc_##A; } + SUPER() + #undef GO + printf_log(LOG_NONE, "Warning, no more slot for libX11 XConnectionWatchProc callback\n"); + return NULL; +} +// xifevent +#define GO(A) \ +static uintptr_t my32_xifevent_fct_##A = 0; \ +static int my32_xifevent_##A(void* dpy, void* event, void* d) \ +{ \ + return RunFunctionFmt(my32_xifevent_fct_##A, "ppp", dpy, event, d); \ +} +SUPER() +#undef GO +static void* findxifeventFct(void* fct) +{ + if(!fct) return fct; + if(GetNativeFnc((uintptr_t)fct)) return GetNativeFnc((uintptr_t)fct); + #define GO(A) if(my32_xifevent_fct_##A == (uintptr_t)fct) return my32_xifevent_##A; + SUPER() + #undef GO + #define GO(A) if(my32_xifevent_fct_##A == 0) {my32_xifevent_fct_##A = (uintptr_t)fct; return my32_xifevent_##A; } + SUPER() + #undef GO + printf_log(LOG_NONE, "Warning, no more slot for libX11 xifevent callback\n"); + return NULL; +} +// XInternalAsyncHandler +#define GO(A) \ +static uintptr_t my32_XInternalAsyncHandler_fct_##A = 0; \ +static int my32_XInternalAsyncHandler_##A(void* dpy, void* rep, void* buf, int len, void* data) \ +{ \ + return RunFunctionFmt(my32_XInternalAsyncHandler_fct_##A, "pppip", dpy, rep, buf, len, data); \ +} +SUPER() +#undef GO +static void* findXInternalAsyncHandlerFct(void* fct) +{ + if(!fct) return fct; + if(GetNativeFnc((uintptr_t)fct)) return GetNativeFnc((uintptr_t)fct); + #define GO(A) if(my32_XInternalAsyncHandler_fct_##A == (uintptr_t)fct) return my32_XInternalAsyncHandler_##A; + SUPER() + #undef GO + #define GO(A) if(my32_XInternalAsyncHandler_fct_##A == 0) {my32_XInternalAsyncHandler_fct_##A = (uintptr_t)fct; return my32_XInternalAsyncHandler_##A; } + SUPER() + #undef GO + printf_log(LOG_NONE, "Warning, no more slot for libX11 XInternalAsyncHandler callback\n"); + return NULL; +} + +// XSynchronizeProc +#define GO(A) \ +static uintptr_t my32_XSynchronizeProc_fct_##A = 0; \ +static int my32_XSynchronizeProc_##A() \ +{ \ + return (int)RunFunctionFmt(my32_XSynchronizeProc_fct_##A, "");\ +} +SUPER() +#undef GO +static void* findXSynchronizeProcFct(void* fct) +{ + if(!fct) return fct; + if(GetNativeFnc((uintptr_t)fct)) return GetNativeFnc((uintptr_t)fct); + #define GO(A) if(my32_XSynchronizeProc_fct_##A == (uintptr_t)fct) return my32_XSynchronizeProc_##A; + SUPER() + #undef GO + #define GO(A) if(my32_XSynchronizeProc_fct_##A == 0) {my32_XSynchronizeProc_fct_##A = (uintptr_t)fct; return my32_XSynchronizeProc_##A; } + SUPER() + #undef GO + printf_log(LOG_NONE, "Warning, no more slot for libX11 XSynchronizeProc callback\n"); + return NULL; +} +static void* reverse_XSynchronizeProcFct(library_t* lib, void* fct) +{ + if(!fct) return fct; + if(CheckBridged(lib->w.bridge, fct)) + return (void*)CheckBridged(lib->w.bridge, fct); + #define GO(A) if(my32_XSynchronizeProc_##A == fct) return (void*)my32_XSynchronizeProc_fct_##A; + SUPER() + #undef GO + return (void*)AddBridge(lib->w.bridge, iFppp, fct, 0, NULL); +} + +// XLockDisplay +#define GO(A) \ +static uintptr_t my32_XLockDisplay_fct_##A = 0; \ +static void my32_XLockDisplay_##A(void* dpy) \ +{ \ + RunFunctionFmt(my32_XLockDisplay_fct_##A, "p", dpy); \ +} +SUPER() +#undef GO +static void* findXLockDisplayFct(void* fct) +{ + if(!fct) return fct; + if(GetNativeFnc((uintptr_t)fct)) return GetNativeFnc((uintptr_t)fct); + #define GO(A) if(my32_XLockDisplay_fct_##A == (uintptr_t)fct) return my32_XLockDisplay_##A; + SUPER() + #undef GO + #define GO(A) if(my32_XLockDisplay_fct_##A == 0) {my32_XLockDisplay_fct_##A = (uintptr_t)fct; return my32_XLockDisplay_##A; } + SUPER() + #undef GO + printf_log(LOG_NONE, "Warning, no more slot for libX11 XLockDisplay callback\n"); + return NULL; +} +// XUnlockDisplay +#define GO(A) \ +static uintptr_t my32_XUnlockDisplay_fct_##A = 0; \ +static void my32_XUnlockDisplay_##A(void* dpy) \ +{ \ + RunFunctionFmt(my32_XUnlockDisplay_fct_##A, "p", dpy); \ +} +SUPER() +#undef GO +static void* findXUnlockDisplayFct(void* fct) +{ + if(!fct) return fct; + if(GetNativeFnc((uintptr_t)fct)) return GetNativeFnc((uintptr_t)fct); + #define GO(A) if(my32_XUnlockDisplay_fct_##A == (uintptr_t)fct) return my32_XUnlockDisplay_##A; + SUPER() + #undef GO + #define GO(A) if(my32_XUnlockDisplay_fct_##A == 0) {my32_XUnlockDisplay_fct_##A = (uintptr_t)fct; return my32_XUnlockDisplay_##A; } + SUPER() + #undef GO + printf_log(LOG_NONE, "Warning, no more slot for libX11 XUnlockDisplay callback\n"); + return NULL; +} +// async_handler +#define GO(A) \ +static uintptr_t my32_async_handler_fct_##A = 0; \ +static int my32_async_handler_##A(void* a, void* b, void* c, int d, void* e) \ +{ \ + return (int)RunFunctionFmt(my32_async_handler_fct_##A, "pppip", a, b, c, d, e); \ +} +SUPER() +#undef GO +static void* find_async_handler_Fct(void* fct) +{ + if(!fct) return fct; + if(GetNativeFnc((uintptr_t)fct)) return GetNativeFnc((uintptr_t)fct); + #define GO(A) if(my32_async_handler_fct_##A == (uintptr_t)fct) return my32_async_handler_##A; + SUPER() + #undef GO + #define GO(A) if(my32_async_handler_fct_##A == 0) {my32_async_handler_fct_##A = (uintptr_t)fct; return my32_async_handler_##A; } + SUPER() + #undef GO + printf_log(LOG_NONE, "Warning, no more slot for libX11 async_handler callback\n"); + return NULL; +} +#endif +// XImage function wrappers +// create_image +#define GO(A) \ +static uintptr_t my32_create_image_fct_##A = 0; \ +static void* my32_create_image_##A(void* a, void* b, uint32_t c, int d, int e, void* f, uint32_t g, uint32_t h, int i, int j) \ +{ \ + void* ret = (void*)RunFunctionFmt(my32_create_image_fct_##A, "ppuiipuuii", FindDisplay(a), b, c, d, e, f, g, h, i, j); \ + UnwrapXImage(ret, ret); \ + return ret; \ +} \ +static pFXpuiipuuii_t my32_rev_create_image_fct_##A = NULL; \ +static void* my32_rev_create_image_##A(void* a, void* b, uint32_t c, int d, int e, void* f, uint32_t g, uint32_t h, int i, int j) \ +{ \ + void* ret = my32_rev_create_image_fct_##A (FindDisplay(a), b, c, d, e, f, g, h, i, j); \ + WrapXImage(ret, ret); \ + return ret; \ +} +SUPER() +#undef GO +static void* find_create_image_Fct(void* fct) +{ + if(!fct) return fct; + if(GetNativeFnc((uintptr_t)fct)) return GetNativeFnc((uintptr_t)fct); + #define GO(A) if(my32_create_image_fct_##A == (uintptr_t)fct) return my32_create_image_##A; + SUPER() + #undef GO + #define GO(A) if(my32_create_image_fct_##A == 0) {my32_create_image_fct_##A = (uintptr_t)fct; return my32_create_image_##A; } + SUPER() + #undef GO + printf_log(LOG_NONE, "Warning, no more slot for libX11 create_image callback\n"); + return NULL; +} +static void* reverse_create_image_Fct(library_t* lib, void* fct) +{ + //Callsed from x86 world -> native world + if(!fct) return fct; + // first check if it's a wrapped function, that could be easy + #define GO(A) if(my32_create_image_fct_##A == (uintptr_t)fct) return my32_create_image_##A; + SUPER() + #undef GO + if(FindElfAddress(my_context, (uintptr_t)fct)) + return fct; + // it's a naitve one... so bridge it, but need transform XImage32 to XImage + void* f = NULL; + #define GO(A) if(!f && my32_rev_create_image_fct_##A == fct) f = (void*)my32_rev_create_image_##A; + SUPER() + #undef GO + #define GO(A) if(!f && !my32_rev_create_image_fct_##A) {my32_rev_create_image_fct_##A = fct; f = my32_rev_create_image_##A;} + SUPER() + #undef GO + if(f) + return (void*)AddCheckBridge(lib->w.bridge, pFXpuiipuuii_32, f, 0, "ximage_create_image"); + printf_log(LOG_NONE, "Warning, no more slot for reverse 32bits libX11 create_image callback\n"); + return fct; +} +// destroy_image +#define GO(A) \ +static uintptr_t my32_destroy_image_fct_##A = 0; \ +static int my32_destroy_image_##A(void* a) \ +{ \ + WrapXImage(a, a); \ + return (int)RunFunctionFmt(my32_destroy_image_fct_##A, "p", a); \ +} \ +static iFp_t my32_rev_destroy_image_fct_##A = NULL; \ +static int my32_rev_destroy_image_##A(void* a) \ +{ \ + UnwrapXImage(a, a); \ + return my32_rev_destroy_image_fct_##A (a); \ +} +SUPER() +#undef GO +static void* find_destroy_image_Fct(void* fct) +{ + if(!fct) return fct; + if(GetNativeFnc((uintptr_t)fct)) return GetNativeFnc((uintptr_t)fct); + #define GO(A) if(my32_destroy_image_fct_##A == (uintptr_t)fct) return my32_destroy_image_##A; + SUPER() + #undef GO + #define GO(A) if(my32_destroy_image_fct_##A == 0) {my32_destroy_image_fct_##A = (uintptr_t)fct; return my32_destroy_image_##A; } + SUPER() + #undef GO + printf_log(LOG_NONE, "Warning, no more slot for 32bits libX11 destroy_image callback\n"); + return NULL; +} +static void* reverse_destroy_image_Fct(library_t* lib, void* fct) +{ + //Callsed from x86 world -> native world + if(!fct) return fct; + // first check if it's a wrapped function, that could be easy + #define GO(A) if(my32_destroy_image_fct_##A == (uintptr_t)fct) return my32_destroy_image_##A; + SUPER() + #undef GO + if(FindElfAddress(my_context, (uintptr_t)fct)) + return fct; + // it's a naitve one... so bridge it, but need transform XImage32 to XImage + void* f = NULL; + #define GO(A) if(!f && my32_rev_destroy_image_fct_##A == fct) f = (void*)my32_rev_destroy_image_##A; + SUPER() + #undef GO + #define GO(A) if(!f && !my32_rev_destroy_image_fct_##A) {my32_rev_destroy_image_fct_##A = fct; f = my32_rev_destroy_image_##A;} + SUPER() + #undef GO + if(f) + return (void*)AddCheckBridge(lib->w.bridge, iFp_32, f, 0, "ximage_destroy_image"); + printf_log(LOG_NONE, "Warning, no more slot for reverse 32bits libX11 destroy_image callback\n"); + return fct; +} +// get_pixel +#define GO(A) \ +static uintptr_t my32_get_pixel_fct_##A = 0; \ +static unsigned long my32_get_pixel_##A(void* a, int b, int c) \ +{ \ + WrapXImage(a, a); \ + uint32_t ret = RunFunctionFmt(my32_get_pixel_fct_##A, "pii", a, b, c); \ + UnwrapXImage(a, a); \ + return from_ulong(ret); \ +} \ +static LFpii_t my32_rev_get_pixel_fct_##A = NULL; \ +static ulong_t my32_rev_get_pixel_##A(void* a, int b, int c) \ +{ \ + UnwrapXImage(a, a); \ + ulong_t ret = to_ulong(my32_rev_get_pixel_fct_##A (a, b, c)); \ + WrapXImage(a, a); \ + return ret; \ +} +SUPER() +#undef GO +static void* find_get_pixel_Fct(void* fct) +{ + if(!fct) return fct; + if(GetNativeFnc((uintptr_t)fct)) return GetNativeFnc((uintptr_t)fct); + #define GO(A) if(my32_get_pixel_fct_##A == (uintptr_t)fct) return my32_get_pixel_##A; + SUPER() + #undef GO + #define GO(A) if(my32_get_pixel_fct_##A == 0) {my32_get_pixel_fct_##A = (uintptr_t)fct; return my32_get_pixel_##A; } + SUPER() + #undef GO + printf_log(LOG_NONE, "Warning, no more slot for libX11 get_pixel callback\n"); + return NULL; +} +static void* reverse_get_pixel_Fct(library_t* lib, void* fct) +{ + //Callsed from x86 world -> native world + if(!fct) return fct; + // first check if it's a wrapped function, that could be easy + #define GO(A) if(my32_get_pixel_fct_##A == (uintptr_t)fct) return my32_get_pixel_##A; + SUPER() + #undef GO + if(FindElfAddress(my_context, (uintptr_t)fct)) + return fct; + // it's a naitve one... so bridge it, but need transform XImage32 to XImage + void* f = NULL; + #define GO(A) if(!f && my32_rev_get_pixel_fct_##A == fct) f = (void*)my32_rev_get_pixel_##A; + SUPER() + #undef GO + #define GO(A) if(!f && !my32_rev_get_pixel_fct_##A) {my32_rev_get_pixel_fct_##A = fct; f = my32_rev_get_pixel_##A;} + SUPER() + #undef GO + if(f) + return (void*)AddCheckBridge(lib->w.bridge, LFpii_32, f, 0, "ximage_get_pixel"); + printf_log(LOG_NONE, "Warning, no more slot for reverse 32bits libX11 get_pixel callback\n"); + return fct; +} +// put_pixel +#define GO(A) \ +static uintptr_t my32_put_pixel_fct_##A = 0; \ +static int my32_put_pixel_##A(void* a, int b, int c,unsigned long d) \ +{ \ + WrapXImage(a, a); \ + int ret = (int)RunFunctionFmt(my32_put_pixel_fct_##A, "piiL", a, b, c, d); \ + UnwrapXImage(a, a); \ + return ret; \ +} \ +static iFpiiL_t my32_rev_put_pixel_fct_##A = NULL; \ +static int my32_rev_put_pixel_##A(void* a, int b, int c, ulong_t d) \ +{ \ + UnwrapXImage(a, a); \ + int ret = to_ulong(my32_rev_put_pixel_fct_##A (a, b, c, from_ulong(d))); \ + WrapXImage(a, a); \ + return ret; \ +} +SUPER() +#undef GO +static void* find_put_pixel_Fct(void* fct) +{ + if(!fct) return fct; + if(GetNativeFnc((uintptr_t)fct)) return GetNativeFnc((uintptr_t)fct); + #define GO(A) if(my32_put_pixel_fct_##A == (uintptr_t)fct) return my32_put_pixel_##A; + SUPER() + #undef GO + #define GO(A) if(my32_put_pixel_fct_##A == 0) {my32_put_pixel_fct_##A = (uintptr_t)fct; return my32_put_pixel_##A; } + SUPER() + #undef GO + printf_log(LOG_NONE, "Warning, no more slot for libX11 put_pixel callback\n"); + return NULL; +} +static void* reverse_put_pixel_Fct(library_t* lib, void* fct) +{ + //Callsed from x86 world -> native world + if(!fct) return fct; + // first check if it's a wrapped function, that could be easy + #define GO(A) if(my32_put_pixel_fct_##A == (uintptr_t)fct) return my32_put_pixel_##A; + SUPER() + #undef GO + if(FindElfAddress(my_context, (uintptr_t)fct)) + return fct; + // it's a naitve one... so bridge it, but need transform XImage32 to XImage + void* f = NULL; + #define GO(A) if(!f && my32_rev_put_pixel_fct_##A == fct) f = (void*)my32_rev_put_pixel_##A; + SUPER() + #undef GO + #define GO(A) if(!f && !my32_rev_put_pixel_fct_##A) {my32_rev_put_pixel_fct_##A = fct; f = my32_rev_put_pixel_##A;} + SUPER() + #undef GO + if(f) + return (void*)AddCheckBridge(lib->w.bridge, iFpiiL_32, f, 0, "ximage_put_pixel"); + printf_log(LOG_NONE, "Warning, no more slot for reverse 32bits libX11 put_pixel callback\n"); + return fct; +} +// sub_image +#define GO(A) \ +static uintptr_t my32_sub_image_fct_##A = 0; \ +static void* my32_sub_image_##A(void* a, int b, int c, uint32_t d, uint32_t e) \ +{ \ + WrapXImage(a, a); \ + void* ret = (void*)RunFunctionFmt(my32_sub_image_fct_##A, "piiuu", a, b, c, d, e);\ + if(ret!=a) UnwrapXImage(ret, ret); \ + UnwrapXImage(a, a); \ + return ret; \ +} \ +static pFpiiuu_t my32_rev_sub_image_fct_##A = NULL; \ +static void* my32_rev_sub_image_##A(void* a, int b, int c, uint32_t d, uint32_t e) \ +{ \ + UnwrapXImage(a, a); \ + void* ret = my32_rev_sub_image_fct_##A (a, b, c, d, e); \ + if(ret!=a) \ + WrapXImage(ret, ret); \ + WrapXImage(a, a); \ + return ret; \ +} +SUPER() +#undef GO +static void* find_sub_image_Fct(void* fct) +{ + if(!fct) return fct; + if(GetNativeFnc((uintptr_t)fct)) return GetNativeFnc((uintptr_t)fct); + #define GO(A) if(my32_sub_image_fct_##A == (uintptr_t)fct) return my32_sub_image_##A; + SUPER() + #undef GO + #define GO(A) if(my32_sub_image_fct_##A == 0) {my32_sub_image_fct_##A = (uintptr_t)fct; return my32_sub_image_##A; } + SUPER() + #undef GO + printf_log(LOG_NONE, "Warning, no more slot for libX11 sub_image callback\n"); + return NULL; +} +static void* reverse_sub_image_Fct(library_t* lib, void* fct) +{ + //Callsed from x86 world -> native world + if(!fct) return fct; + // first check if it's a wrapped function, that could be easy + #define GO(A) if(my32_sub_image_fct_##A == (uintptr_t)fct) return my32_sub_image_##A; + SUPER() + #undef GO + if(FindElfAddress(my_context, (uintptr_t)fct)) + return fct; + // it's a naitve one... so bridge it, but need transform XImage32 to XImage + void* f = NULL; + #define GO(A) if(!f && my32_rev_sub_image_fct_##A == fct) f = (void*)my32_rev_sub_image_##A; + SUPER() + #undef GO + #define GO(A) if(!f && !my32_rev_sub_image_fct_##A) {my32_rev_sub_image_fct_##A = fct; f = my32_rev_sub_image_##A;} + SUPER() + #undef GO + if(f) + return (void*)AddCheckBridge(lib->w.bridge, pFpiiuu_32, f, 0, "ximage_sub_image"); + printf_log(LOG_NONE, "Warning, no more slot for reverse 32bits libX11 sub_image callback\n"); + return fct; +} +// add_pixel +#define GO(A) \ +static uintptr_t my32_add_pixel_fct_##A = 0; \ +static int my32_add_pixel_##A(void* a, long b) \ +{ \ + WrapXImage(a, a); \ + int ret = (int)RunFunctionFmt(my32_add_pixel_fct_##A, "pl", a, b); \ + UnwrapXImage(a, a); \ + return ret; \ +} \ +static iFpl_t my32_rev_add_pixel_fct_##A = NULL; \ +static int my32_rev_add_pixel_##A(void* a, long_t b) \ +{ \ + UnwrapXImage(a, a); \ + int ret = my32_rev_add_pixel_fct_##A (a, from_long(b)); \ + WrapXImage(a, a); \ + return ret; \ +} +SUPER() +#undef GO +static void* find_add_pixel_Fct(void* fct) +{ + if(!fct) return fct; + if(GetNativeFnc((uintptr_t)fct)) return GetNativeFnc((uintptr_t)fct); + #define GO(A) if(my32_add_pixel_fct_##A == (uintptr_t)fct) return my32_add_pixel_##A; + SUPER() + #undef GO + #define GO(A) if(my32_add_pixel_fct_##A == 0) {my32_add_pixel_fct_##A = (uintptr_t)fct; return my32_add_pixel_##A; } + SUPER() + #undef GO + printf_log(LOG_NONE, "Warning, no more slot for libX11 add_pixel callback\n"); + return NULL; +} +static void* reverse_add_pixel_Fct(library_t* lib, void* fct) +{ + //Callsed from x86 world -> native world + if(!fct) return fct; + // first check if it's a wrapped function, that could be easy + #define GO(A) if(my32_add_pixel_fct_##A == (uintptr_t)fct) return my32_add_pixel_##A; + SUPER() + #undef GO + if(FindElfAddress(my_context, (uintptr_t)fct)) + return fct; + // it's a naitve one... so bridge it, but need transform XImage32 to XImage + void* f = NULL; + #define GO(A) if(!f && my32_rev_add_pixel_fct_##A == fct) f = (void*)my32_rev_add_pixel_##A; + SUPER() + #undef GO + #define GO(A) if(!f && !my32_rev_add_pixel_fct_##A) {my32_rev_add_pixel_fct_##A = fct; f = my32_rev_add_pixel_##A;} + SUPER() + #undef GO + if(f) + return (void*)AddCheckBridge(lib->w.bridge, iFpl_32, f, 0, "ximage_add_pixel"); + printf_log(LOG_NONE, "Warning, no more slot for reverse 32bits libX11 add_pixel callback\n"); + return fct; +} +// end of XImage functions callbacks + +#undef SUPER + +void* my32_XCreateImage(x64emu_t* emu, void* disp, void* vis, uint32_t depth, int32_t fmt, int32_t off + , void* data, uint32_t w, uint32_t h, int32_t pad, int32_t bpl); + +int32_t my32_XInitImage(x64emu_t* emu, void* img); + +void* my32_XGetImage(x64emu_t* emu, void* disp, size_t drawable, int32_t x, int32_t y + , uint32_t w, uint32_t h, uint32_t plane, int32_t fmt); + +int32_t my32_XPutImage(x64emu_t* emu, void* disp, size_t drawable, void* gc, void* image + , int32_t src_x, int32_t src_y, int32_t dst_x, int32_t dst_y + , uint32_t w, uint32_t h); + +void* my32_XGetSubImage(x64emu_t* emu, void* disp, size_t drawable + , int32_t x, int32_t y + , uint32_t w, uint32_t h, size_t plane, int32_t fmt + , void* image, int32_t dst_x, int32_t dst_y); + +void my32_XDestroyImage(x64emu_t* emu, void* image); +#if 0 +#ifdef PANDORA +void* my32_XLoadQueryFont(x64emu_t* emu, void* d, void* name); +#endif + +typedef void (*XIMProc)(void*, void*, void*); +typedef int (*XICProc)(void*, void*, void*); +typedef struct { + void* client_data; + XIMProc callback; +} XIMCallback; + +typedef struct { + void* client_data; + XICProc callback; +} XICCallback; + +#define XNGeometryCallback "geometryCallback" +#define XNDestroyCallback "destroyCallback" +#define XNPreeditStartCallback "preeditStartCallback" +#define XNPreeditDoneCallback "preeditDoneCallback" +#define XNPreeditDrawCallback "preeditDrawCallback" +#define XNPreeditCaretCallback "preeditCaretCallback" +#define XNPreeditStateNotifyCallback "preeditStateNotifyCallback" +#define XNStatusStartCallback "statusStartCallback" +#define XNStatusDoneCallback "statusDoneCallback" +#define XNStatusDrawCallback "statusDrawCallback" +#define XNR6PreeditCallback "r6PreeditCallback" +#define XNStringConversionCallback "stringConversionCallback" + +// utility functions +#include "super100.h" + +// XNGeometryCallback +#define GO(A) \ +static uintptr_t my32_XNGeometryCallback_fct_##A = 0; \ +static void my32_XNGeometryCallback_##A(void* a, void* b, void* c) \ +{ \ + RunFunctionFmt(my32_XNGeometryCallback_fct_##A, "ppp", a, b); \ +} +SUPER() +#undef GO +static void* findXNGeometryCallbackFct(void* fct) +{ + if(!fct) return NULL; + void* p; + if((p = GetNativeFnc((uintptr_t)fct))) return p; + #define GO(A) if(my32_XNGeometryCallback_fct_##A == (uintptr_t)fct) return my32_XNGeometryCallback_##A; + SUPER() + #undef GO + #define GO(A) if(my32_XNGeometryCallback_fct_##A == 0) {my32_XNGeometryCallback_fct_##A = (uintptr_t)fct; return my32_XNGeometryCallback_##A; } + SUPER() + #undef GO + printf_log(LOG_NONE, "Warning, no more slot for libX11 XNGeometryCallback callback\n"); + return NULL; +} +// XNDestroyCallback +#define GO(A) \ +static uintptr_t my32_XNDestroyCallback_fct_##A = 0; \ +static void my32_XNDestroyCallback_##A(void* a, void* b, void* c) \ +{ \ + RunFunctionFmt(my32_XNDestroyCallback_fct_##A, "ppp", a, b); \ +} +SUPER() +#undef GO +static void* findXNDestroyCallbackFct(void* fct) +{ + if(!fct) return NULL; + void* p; + if((p = GetNativeFnc((uintptr_t)fct))) return p; + #define GO(A) if(my32_XNDestroyCallback_fct_##A == (uintptr_t)fct) return my32_XNDestroyCallback_##A; + SUPER() + #undef GO + #define GO(A) if(my32_XNDestroyCallback_fct_##A == 0) {my32_XNDestroyCallback_fct_##A = (uintptr_t)fct; return my32_XNDestroyCallback_##A; } + SUPER() + #undef GO + printf_log(LOG_NONE, "Warning, no more slot for libX11 XNDestroyCallback callback\n"); + return NULL; +} +// XNPreeditStartCallback +#define GO(A) \ +static uintptr_t my32_XNPreeditStartCallback_fct_##A = 0; \ +static void my32_XNPreeditStartCallback_##A(void* a, void* b, void* c) \ +{ \ + RunFunctionFmt(my32_XNPreeditStartCallback_fct_##A, "ppp", a, b); \ +} +SUPER() +#undef GO +static void* findXNPreeditStartCallbackFct(void* fct) +{ + if(!fct) return NULL; + void* p; + if((p = GetNativeFnc((uintptr_t)fct))) return p; + #define GO(A) if(my32_XNPreeditStartCallback_fct_##A == (uintptr_t)fct) return my32_XNPreeditStartCallback_##A; + SUPER() + #undef GO + #define GO(A) if(my32_XNPreeditStartCallback_fct_##A == 0) {my32_XNPreeditStartCallback_fct_##A = (uintptr_t)fct; return my32_XNPreeditStartCallback_##A; } + SUPER() + #undef GO + printf_log(LOG_NONE, "Warning, no more slot for libX11 XNPreeditStartCallback callback\n"); + return NULL; +} +// XNPreeditDoneCallback +#define GO(A) \ +static uintptr_t my32_XNPreeditDoneCallback_fct_##A = 0; \ +static void my32_XNPreeditDoneCallback_##A(void* a, void* b, void* c) \ +{ \ + RunFunctionFmt(my32_XNPreeditDoneCallback_fct_##A, "ppp", a, b); \ +} +SUPER() +#undef GO +static void* findXNPreeditDoneCallbackFct(void* fct) +{ + if(!fct) return NULL; + void* p; + if((p = GetNativeFnc((uintptr_t)fct))) return p; + #define GO(A) if(my32_XNPreeditDoneCallback_fct_##A == (uintptr_t)fct) return my32_XNPreeditDoneCallback_##A; + SUPER() + #undef GO + #define GO(A) if(my32_XNPreeditDoneCallback_fct_##A == 0) {my32_XNPreeditDoneCallback_fct_##A = (uintptr_t)fct; return my32_XNPreeditDoneCallback_##A; } + SUPER() + #undef GO + printf_log(LOG_NONE, "Warning, no more slot for libX11 XNPreeditDoneCallback callback\n"); + return NULL; +} +// XNPreeditDrawCallback +#define GO(A) \ +static uintptr_t my32_XNPreeditDrawCallback_fct_##A = 0; \ +static void my32_XNPreeditDrawCallback_##A(void* a, void* b, void* c) \ +{ \ + RunFunctionFmt(my32_XNPreeditDrawCallback_fct_##A, "ppp", a, b); \ +} +SUPER() +#undef GO +static void* findXNPreeditDrawCallbackFct(void* fct) +{ + if(!fct) return NULL; + void* p; + if((p = GetNativeFnc((uintptr_t)fct))) return p; + #define GO(A) if(my32_XNPreeditDrawCallback_fct_##A == (uintptr_t)fct) return my32_XNPreeditDrawCallback_##A; + SUPER() + #undef GO + #define GO(A) if(my32_XNPreeditDrawCallback_fct_##A == 0) {my32_XNPreeditDrawCallback_fct_##A = (uintptr_t)fct; return my32_XNPreeditDrawCallback_##A; } + SUPER() + #undef GO + printf_log(LOG_NONE, "Warning, no more slot for libX11 XNPreeditDrawCallback callback\n"); + return NULL; +} +// XNPreeditCaretCallback +#define GO(A) \ +static uintptr_t my32_XNPreeditCaretCallback_fct_##A = 0; \ +static void my32_XNPreeditCaretCallback_##A(void* a, void* b, void* c) \ +{ \ + RunFunctionFmt(my32_XNPreeditCaretCallback_fct_##A, "ppp", a, b); \ +} +SUPER() +#undef GO +static void* findXNPreeditCaretCallbackFct(void* fct) +{ + if(!fct) return NULL; + void* p; + if((p = GetNativeFnc((uintptr_t)fct))) return p; + #define GO(A) if(my32_XNPreeditCaretCallback_fct_##A == (uintptr_t)fct) return my32_XNPreeditCaretCallback_##A; + SUPER() + #undef GO + #define GO(A) if(my32_XNPreeditCaretCallback_fct_##A == 0) {my32_XNPreeditCaretCallback_fct_##A = (uintptr_t)fct; return my32_XNPreeditCaretCallback_##A; } + SUPER() + #undef GO + printf_log(LOG_NONE, "Warning, no more slot for libX11 XNPreeditCaretCallback callback\n"); + return NULL; +} +// XNPreeditStateNotifyCallback +#define GO(A) \ +static uintptr_t my32_XNPreeditStateNotifyCallback_fct_##A = 0; \ +static void my32_XNPreeditStateNotifyCallback_##A(void* a, void* b, void* c) \ +{ \ + RunFunctionFmt(my32_XNPreeditStateNotifyCallback_fct_##A, "ppp", a, b); \ +} +SUPER() +#undef GO +static void* findXNPreeditStateNotifyCallbackFct(void* fct) +{ + if(!fct) return NULL; + void* p; + if((p = GetNativeFnc((uintptr_t)fct))) return p; + #define GO(A) if(my32_XNPreeditStateNotifyCallback_fct_##A == (uintptr_t)fct) return my32_XNPreeditStateNotifyCallback_##A; + SUPER() + #undef GO + #define GO(A) if(my32_XNPreeditStateNotifyCallback_fct_##A == 0) {my32_XNPreeditStateNotifyCallback_fct_##A = (uintptr_t)fct; return my32_XNPreeditStateNotifyCallback_##A; } + SUPER() + #undef GO + printf_log(LOG_NONE, "Warning, no more slot for libX11 XNPreeditStateNotifyCallback callback\n"); + return NULL; +} +// XNStatusStartCallback +#define GO(A) \ +static uintptr_t my32_XNStatusStartCallback_fct_##A = 0; \ +static void my32_XNStatusStartCallback_##A(void* a, void* b, void* c) \ +{ \ + RunFunctionFmt(my32_XNStatusStartCallback_fct_##A, "ppp", a, b); \ +} +SUPER() +#undef GO +static void* findXNStatusStartCallbackFct(void* fct) +{ + if(!fct) return NULL; + void* p; + if((p = GetNativeFnc((uintptr_t)fct))) return p; + #define GO(A) if(my32_XNStatusStartCallback_fct_##A == (uintptr_t)fct) return my32_XNStatusStartCallback_##A; + SUPER() + #undef GO + #define GO(A) if(my32_XNStatusStartCallback_fct_##A == 0) {my32_XNStatusStartCallback_fct_##A = (uintptr_t)fct; return my32_XNStatusStartCallback_##A; } + SUPER() + #undef GO + printf_log(LOG_NONE, "Warning, no more slot for libX11 XNStatusStartCallback callback\n"); + return NULL; +} +// XNStatusDoneCallback +#define GO(A) \ +static uintptr_t my32_XNStatusDoneCallback_fct_##A = 0; \ +static void my32_XNStatusDoneCallback_##A(void* a, void* b, void* c) \ +{ \ + RunFunctionFmt(my32_XNStatusDoneCallback_fct_##A, "ppp", a, b); \ +} +SUPER() +#undef GO +static void* findXNStatusDoneCallbackFct(void* fct) +{ + if(!fct) return NULL; + void* p; + if((p = GetNativeFnc((uintptr_t)fct))) return p; + #define GO(A) if(my32_XNStatusDoneCallback_fct_##A == (uintptr_t)fct) return my32_XNStatusDoneCallback_##A; + SUPER() + #undef GO + #define GO(A) if(my32_XNStatusDoneCallback_fct_##A == 0) {my32_XNStatusDoneCallback_fct_##A = (uintptr_t)fct; return my32_XNStatusDoneCallback_##A; } + SUPER() + #undef GO + printf_log(LOG_NONE, "Warning, no more slot for libX11 XNStatusDoneCallback callback\n"); + return NULL; +} +// XNStatusDrawCallback +#define GO(A) \ +static uintptr_t my32_XNStatusDrawCallback_fct_##A = 0; \ +static void my32_XNStatusDrawCallback_##A(void* a, void* b, void* c) \ +{ \ + RunFunctionFmt(my32_XNStatusDrawCallback_fct_##A, "ppp", a, b); \ +} +SUPER() +#undef GO +static void* findXNStatusDrawCallbackFct(void* fct) +{ + if(!fct) return NULL; + void* p; + if((p = GetNativeFnc((uintptr_t)fct))) return p; + #define GO(A) if(my32_XNStatusDrawCallback_fct_##A == (uintptr_t)fct) return my32_XNStatusDrawCallback_##A; + SUPER() + #undef GO + #define GO(A) if(my32_XNStatusDrawCallback_fct_##A == 0) {my32_XNStatusDrawCallback_fct_##A = (uintptr_t)fct; return my32_XNStatusDrawCallback_##A; } + SUPER() + #undef GO + printf_log(LOG_NONE, "Warning, no more slot for libX11 XNStatusDrawCallback callback\n"); + return NULL; +} +// XNR6PreeditCallback +#define GO(A) \ +static uintptr_t my32_XNR6PreeditCallback_fct_##A = 0; \ +static void my32_XNR6PreeditCallback_##A(void* a, void* b, void* c) \ +{ \ + RunFunctionFmt(my32_XNR6PreeditCallback_fct_##A, "ppp", a, b); \ +} +SUPER() +#undef GO +static void* findXNR6PreeditCallbackFct(void* fct) +{ + if(!fct) return NULL; + void* p; + if((p = GetNativeFnc((uintptr_t)fct))) return p; + #define GO(A) if(my32_XNR6PreeditCallback_fct_##A == (uintptr_t)fct) return my32_XNR6PreeditCallback_##A; + SUPER() + #undef GO + #define GO(A) if(my32_XNR6PreeditCallback_fct_##A == 0) {my32_XNR6PreeditCallback_fct_##A = (uintptr_t)fct; return my32_XNR6PreeditCallback_##A; } + SUPER() + #undef GO + printf_log(LOG_NONE, "Warning, no more slot for libX11 XNR6PreeditCallback callback\n"); + return NULL; +} +// XNStringConversionCallback +#define GO(A) \ +static uintptr_t my32_XNStringConversionCallback_fct_##A = 0; \ +static void my32_XNStringConversionCallback_##A(void* a, void* b, void* c) \ +{ \ + RunFunctionFmt(my32_XNStringConversionCallback_fct_##A, "ppp", a, b); \ +} +SUPER() +#undef GO +static void* findXNStringConversionCallbackFct(void* fct) +{ + if(!fct) return NULL; + void* p; + if((p = GetNativeFnc((uintptr_t)fct))) return p; + #define GO(A) if(my32_XNStringConversionCallback_fct_##A == (uintptr_t)fct) return my32_XNStringConversionCallback_##A; + SUPER() + #undef GO + #define GO(A) if(my32_XNStringConversionCallback_fct_##A == 0) {my32_XNStringConversionCallback_fct_##A = (uintptr_t)fct; return my32_XNStringConversionCallback_##A; } + SUPER() + #undef GO + printf_log(LOG_NONE, "Warning, no more slot for libX11 XNStringConversionCallback callback\n"); + return NULL; +} + +#undef SUPER + +#define SUPER() \ +GO(XNGeometryCallback) \ +GO(XNDestroyCallback) \ +GO(XNPreeditStartCallback) \ +GO(XNPreeditDoneCallback) \ +GO(XNPreeditDrawCallback) \ +GO(XNPreeditCaretCallback) \ +GO(XNPreeditStateNotifyCallback) \ +GO(XNStatusStartCallback) \ +GO(XNStatusDoneCallback) \ +GO(XNStatusDrawCallback) \ +GO(XNR6PreeditCallback) \ +GO(XNStringConversionCallback) + +#define VA_CALL(FUNC, FIRST_ARG, N, VAARGSZ, RESULT) \ +switch (VAARGSZ) \ +{ \ +case 2: \ + RESULT = FUNC(FIRST_ARG, getVArgs(emu, N, va, 0), getVArgs(emu, N, va, 1), NULL); \ + break; \ +case 4: \ + RESULT = FUNC(FIRST_ARG, getVArgs(emu, N, va, 0), getVArgs(emu, N, va, 1), getVArgs(emu, N, va, 2), getVArgs(emu, N, va, 3), NULL); \ + break; \ +case 6: \ + RESULT = FUNC(FIRST_ARG, getVArgs(emu, N, va, 0), getVArgs(emu, N, va, 1), getVArgs(emu, N, va, 2), getVArgs(emu, N, va, 3), getVArgs(emu, N, va, 4), getVArgs(emu, N, va, 5), NULL); \ + break; \ +case 8: \ + RESULT = FUNC(FIRST_ARG, getVArgs(emu, N, va, 0), getVArgs(emu, N, va, 1), getVArgs(emu, N, va, 2), getVArgs(emu, N, va, 3), getVArgs(emu, N, va, 4), getVArgs(emu, N, va, 5), getVArgs(emu, N, va, 6), getVArgs(emu, N, va, 7), NULL); \ + break; \ +case 10: \ + RESULT = FUNC(FIRST_ARG, getVArgs(emu, N, va, 0), getVArgs(emu, N, va, 1), getVArgs(emu, N, va, 2), getVArgs(emu, N, va, 3), getVArgs(emu, N, va, 4), getVArgs(emu, N, va, 5), getVArgs(emu, N, va, 6), getVArgs(emu, N, va, 7), getVArgs(emu, N, va, 8), getVArgs(emu, N, va, 9), NULL); \ + break; \ +case 12: \ + RESULT = FUNC(FIRST_ARG, getVArgs(emu, N, va, 0), getVArgs(emu, N, va, 1), getVArgs(emu, N, va, 2), getVArgs(emu, N, va, 3), getVArgs(emu, N, va, 4), getVArgs(emu, N, va, 5), getVArgs(emu, N, va, 6), getVArgs(emu, N, va, 7), getVArgs(emu, N, va, 8), getVArgs(emu, N, va, 9), getVArgs(emu, N, va, 10), getVArgs(emu, N, va, 11), NULL); \ + break; \ +case 14: \ + RESULT = FUNC(FIRST_ARG, getVArgs(emu, N, va, 0), getVArgs(emu, N, va, 1), getVArgs(emu, N, va, 2), getVArgs(emu, N, va, 3), getVArgs(emu, N, va, 4), getVArgs(emu, N, va, 5), getVArgs(emu, N, va, 6), getVArgs(emu, N, va, 7), getVArgs(emu, N, va, 8), getVArgs(emu, N, va, 9), getVArgs(emu, N, va, 10), getVArgs(emu, N, va, 11), getVArgs(emu, N, va, 12), getVArgs(emu, N, va, 13), NULL); \ + break; \ +case 16: \ + RESULT = FUNC(FIRST_ARG, getVArgs(emu, N, va, 0), getVArgs(emu, N, va, 1), getVArgs(emu, N, va, 2), getVArgs(emu, N, va, 3), getVArgs(emu, N, va, 4), getVArgs(emu, N, va, 5), getVArgs(emu, N, va, 6), getVArgs(emu, N, va, 7), getVArgs(emu, N, va, 8), getVArgs(emu, N, va, 9), getVArgs(emu, N, va, 10), getVArgs(emu, N, va, 11), getVArgs(emu, N, va, 12), getVArgs(emu, N, va, 13), getVArgs(emu, N, va, 14), getVArgs(emu, N, va, 15), NULL); \ + break; \ +case 18: \ + RESULT = FUNC(FIRST_ARG, getVArgs(emu, N, va, 0), getVArgs(emu, N, va, 1), getVArgs(emu, N, va, 2), getVArgs(emu, N, va, 3), getVArgs(emu, N, va, 4), getVArgs(emu, N, va, 5), getVArgs(emu, N, va, 6), getVArgs(emu, N, va, 7), getVArgs(emu, N, va, 8), getVArgs(emu, N, va, 9), getVArgs(emu, N, va, 10), getVArgs(emu, N, va, 11), getVArgs(emu, N, va, 12), getVArgs(emu, N, va, 13), getVArgs(emu, N, va, 14), getVArgs(emu, N, va, 15), getVArgs(emu, N, va, 16), getVArgs(emu, N, va, 17), NULL); \ + break; \ +case 20: \ + RESULT = FUNC(FIRST_ARG, getVArgs(emu, N, va, 0), getVArgs(emu, N, va, 1), getVArgs(emu, N, va, 2), getVArgs(emu, N, va, 3), getVArgs(emu, N, va, 4), getVArgs(emu, N, va, 5), getVArgs(emu, N, va, 6), getVArgs(emu, N, va, 7), getVArgs(emu, N, va, 8), getVArgs(emu, N, va, 9), getVArgs(emu, N, va, 10), getVArgs(emu, N, va, 11), getVArgs(emu, N, va, 12), getVArgs(emu, N, va, 13), getVArgs(emu, N, va, 14), getVArgs(emu, N, va, 15), getVArgs(emu, N, va, 16), getVArgs(emu, N, va, 17), getVArgs(emu, N, va, 18), getVArgs(emu, N, va, 19), NULL); \ + break; \ +default: \ + printf_log(LOG_NONE, "warning: %s's vasize (%d) is too large, need create new call case!\n", __func__, VAARGSZ); \ + break; \ +} + +#define GO(A) \ +if (getVArgs(emu, 1, va, i) && strcmp((char*)getVArgs(emu, 1, va, i), A) == 0) { \ + XICCallback* origin = (XICCallback*)getVArgs(emu, 1, va, i+1); \ + setVArgs(emu, 1, va, i+1, (uintptr_t)find##A##Fct(origin)); \ +} + +EXPORT void* my32_XVaCreateNestedList(x64emu_t* emu, int unused, uintptr_t* va) { + int n = 0; + while (getVArgs(emu, 1, va, n)) n+=2 ; + + for (int i = 0; i < n; i += 2) { + SUPER() + } + + void* res = NULL; + VA_CALL(my->XVaCreateNestedList, unused, 1, n, res); + return res; +} + +EXPORT void* my32_XCreateIC(x64emu_t* emu, void* xim, uintptr_t* va) { + int n = 0; + while (getVArgs(emu, 1, va, n)) n+=2; + + for (int i = 0; i < n; i += 2) { + SUPER() + } + + void* res = NULL; + VA_CALL(my->XCreateIC, xim, 1, n, res); + return res; +} + +EXPORT void* my32_XSetICValues(x64emu_t* emu, void* xic, uintptr_t* va) { + int n = 0; + while (getVArgs(emu, 1, va, n)) n+=2; + + for (int i = 0; i < n; i += 2) { + SUPER() + } + + void* res = NULL; + VA_CALL(my->XSetICValues, xic, 1, n, res); + return res; +} +#undef GO + +EXPORT void* my32_XSetIMValues(x64emu_t* emu, void* xim, uintptr_t* va) { + int n = 0; + while (getVArgs(emu, 1, va, n)) n+=2; + + #define GO(A) \ + if (getVArgs(emu, 1, va, i) && strcmp((char*)getVArgs(emu, 1, va, i), A) == 0) { \ + XIMCallback* origin = (XIMCallback*)getVArgs(emu, 1, va, i+1); \ + setVArgs(emu, 1, va, i+1, (uintptr_t)find##A##Fct(origin)); \ + } + for (int i = 0; i < n; i += 2) { + SUPER() + } + #undef GO + + void* res = NULL; + VA_CALL(my->XSetIMValues, xim, 1, n, res) + return res; +} +#undef VA_CALL +#undef SUPER + +EXPORT void* my32_XSetErrorHandler(x64emu_t* emu, XErrorHandler handler) +{ + void* ret = my->XSetErrorHandler(finderror_handlerFct(handler)); + return reverse_error_handlerFct(my_lib, ret); +} + +EXPORT void* my32_XSetIOErrorHandler(x64emu_t* emu, XIOErrorHandler handler) +{ + void* ret = my->XSetIOErrorHandler(findioerror_handlerFct(handler)); + return reverse_ioerror_handlerFct(my_lib, ret); +} + +EXPORT void* my32_XESetError(x64emu_t* emu, void* display, int32_t extension, void* handler) +{ + void* ret = my->XESetError(display, extension, findexterror_handlerFct(handler)); + return reverse_exterror_handlerFct(my_lib, ret); +} + +EXPORT void* my32_XESetCloseDisplay(x64emu_t* emu, void* display, int32_t extension, void* handler) +{ + void* ret = my->XESetCloseDisplay(display, extension, findclose_displayFct(handler)); + return reverse_close_displayFct(my_lib, ret); +} + +EXPORT int32_t my32_XIfEvent(x64emu_t* emu, void* d,void* ev, EventHandler h, void* arg) +{ + int32_t ret = my->XIfEvent(d, ev, findxifeventFct(h), arg); + return ret; +} + +EXPORT int32_t my32_XCheckIfEvent(x64emu_t* emu, void* d,void* ev, EventHandler h, void* arg) +{ + int32_t ret = my->XCheckIfEvent(d, ev, findxifeventFct(h), arg); + return ret; +} + +EXPORT int32_t my32_XPeekIfEvent(x64emu_t* emu, void* d,void* ev, EventHandler h, void* arg) +{ + int32_t ret = my->XPeekIfEvent(d, ev, findxifeventFct(h), arg); + return ret; +} + +#endif +void WrapXImage(void* d, void* s) +{ + XImage *src = s; + XImage_32 *dst = d; + + // inplace "shrink" + + dst->width = src->width; + dst->height = src->height; + dst->xoffset = src->xoffset; + dst->format = src->format; + dst->data = to_ptrv(src->data); + dst->byte_order = src->byte_order; + dst->bitmap_unit = src->bitmap_unit; + dst->bitmap_bit_order = src->bitmap_bit_order; + dst->bitmap_pad = src->bitmap_pad; + dst->depth = src->depth; + dst->bytes_per_line = src->bytes_per_line; + dst->bits_per_pixel = src->bits_per_pixel; + dst->red_mask = to_ulong(src->red_mask); + dst->green_mask = to_ulong(src->green_mask); + dst->blue_mask = to_ulong(src->blue_mask); + dst->obdata = to_ptrv(src->obdata); + + #define GO(A, W) \ + dst->f.A = to_ptrv((W##_t)reverse_##A##_Fct(my_lib, src->f.A)); + + GO(create_image, pFXpuiipuuii) + GO(destroy_image, iFp) + GO(get_pixel, LFpii) + GO(put_pixel, iFpiiL) + GO(sub_image, pFpiiuu) + GO(add_pixel, iFpl) + #undef GO +} + +void UnwrapXImage(void* d, void* s) +{ + XImage_32* src = s; + XImage *dst = d; + + // inplace "enlarge", so reverse order + + #define GO(A, W) \ + dst->f.A = (W##_t)find_##A##_Fct(from_ptrv(src->f.A)); + + GO(add_pixel, iFpl) + GO(sub_image, pFpiiuu) + GO(put_pixel, iFpiiL) + GO(get_pixel, LFpii) + GO(destroy_image, iFp) + GO(create_image, pFXpuiipuuii) + #undef GO + + dst->obdata = from_ptrv(src->obdata); + dst->blue_mask = from_ulong(src->blue_mask); + dst->green_mask = from_ulong(src->green_mask); + dst->red_mask = from_ulong(src->red_mask); + dst->bits_per_pixel = src->bits_per_pixel; + dst->bytes_per_line = src->bytes_per_line; + dst->depth = src->depth; + dst->bitmap_pad = src->bitmap_pad; + dst->bitmap_bit_order = src->bitmap_bit_order; + dst->bitmap_unit = src->bitmap_unit; + dst->byte_order = src->byte_order; + dst->data = from_ptrv(src->data); + dst->format = src->format; + dst->xoffset = src->xoffset; + dst->height = src->height; + dst->width = src->width; +} + +EXPORT void* my32_XCreateImage(x64emu_t* emu, void* disp, void* vis, uint32_t depth, int32_t fmt, int32_t off + , void* data, uint32_t w, uint32_t h, int32_t pad, int32_t bpl) +{ + + XImage *img = my->XCreateImage(disp, vis, depth, fmt, off, data, w, h, pad, bpl); + if(!img) + return img; + // bridge all access functions... + WrapXImage(img, img); + return img; +} + +EXPORT int32_t my32_XInitImage(x64emu_t* emu, void* img) +{ + XImage l_img = {0}; + UnwrapXImage(&l_img, img); + int ret = my->XInitImage(&l_img); + // bridge all access functions... + WrapXImage(img, &l_img); + return ret; +} + +EXPORT void* my32_XGetImage(x64emu_t* emu, void* disp, size_t drawable, int32_t x, int32_t y + , uint32_t w, uint32_t h, uint32_t plane, int32_t fmt) +{ + + XImage *img = my->XGetImage(disp, drawable, x, y, w, h, plane, fmt); + if(!img) + return img; + // bridge all access functions... + WrapXImage(img, img); + return img; +} + +EXPORT void my32__XInitImageFuncPtrs(x64emu_t* emu, XImage* img) +{ + my->_XInitImageFuncPtrs(img); + WrapXImage(emu, img); +} + +EXPORT int32_t my32_XPutImage(x64emu_t* emu, void* disp, size_t drawable, void* gc, void* image + , int32_t src_x, int32_t src_y, int32_t dst_x, int32_t dst_y + , uint32_t w, uint32_t h) +{ + UnwrapXImage(image, image); // what if the image was created on x86 side and is smaller? + int32_t r = my->XPutImage(disp, drawable, gc, image, src_x, src_y, dst_x, dst_y, w, h); + // bridge all access functions... + WrapXImage(image, image); + return r; +} + +EXPORT void* my32_XGetSubImage(x64emu_t* emu, void* disp, size_t drawable + , int32_t x, int32_t y + , uint32_t w, uint32_t h, size_t plane, int32_t fmt + , void* image, int32_t dst_x, int32_t dst_y) +{ + + UnwrapXImage(image, image); + XImage *img = my->XGetSubImage(disp, drawable, x, y, w, h, plane, fmt, image, dst_x, dst_y); + if(img && img!=image) + WrapXImage(img, img); + + WrapXImage(image, image); + return img; +} + +EXPORT void my32_XDestroyImage(x64emu_t* emu, void* image) +{ + + UnwrapXImage(image, image); + my->XDestroyImage(image); +} +#if 0 +typedef struct xintasync_s { + struct xintasync_s *next; + int (*handler)( + void*, + void*, + void*, + int, + void* + ); + void* data; +} xintasync_t; + +EXPORT void my32__XDeqAsyncHandler(x64emu_t* emu, void* cb, void* data) +{ + my->_XDeqAsyncHandler(findXInternalAsyncHandlerFct(cb), data); +} + +EXPORT void* my32_XESetWireToEvent(x64emu_t* emu, void* display, int32_t event_number, void* proc) +{ + void* ret = NULL; + + ret = my->XESetWireToEvent(display, event_number, findwire_to_eventFct(proc)); + + return reverse_wire_to_eventFct(my_lib, ret); +} +EXPORT void* my32_XESetEventToWire(x64emu_t* emu, void* display, int32_t event_number, void* proc) +{ + void* ret = NULL; + + ret = my->XESetEventToWire(display, event_number, findevent_to_wireFct(proc)); + + return reverse_event_to_wireFct(my_lib, ret); +} + +EXPORT int my32_XRegisterIMInstantiateCallback(x64emu_t* emu, void* d, void* db, void* res_name, void* res_class, void* cb, void* data) +{ + return my->XRegisterIMInstantiateCallback(d, db, res_name, res_class, findregister_imFct(cb), data); +} + +EXPORT int my32_XUnregisterIMInstantiateCallback(x64emu_t* emu, void* d, void* db, void* res_name, void* res_class, void* cb, void* data) +{ + return my->XUnregisterIMInstantiateCallback(d, db, res_name, res_class, reverse_register_imFct(my_lib, cb), data); +} + +EXPORT int my32_XQueryExtension(x64emu_t* emu, void* display, char* name, int* major, int* first_event, int* first_error) +{ + int ret = my->XQueryExtension(display, name, major, first_event, first_error); + if(!ret && name && !strcmp(name, "GLX") && box64_x11glx) { + // hack to force GLX to be accepted, even if not present + // left major and first_XXX to default... + ret = 1; + } + return ret; +} + +EXPORT int my32_XAddConnectionWatch(x64emu_t* emu, void* display, char* f, void* data) +{ + return my->XAddConnectionWatch(display, findXConnectionWatchProcFct(f), data); +} + +EXPORT void my32_XRemoveConnectionWatch(x64emu_t* emu, void* display, char* f, void* data) +{ + my->XRemoveConnectionWatch(display, findXConnectionWatchProcFct(f), data); +} + +EXPORT void* my32_XSetAfterFunction(x64emu_t* emu, void* display, void* f) +{ + + return reverse_XSynchronizeProcFct(my_lib, my->XSetAfterFunction(display, findXSynchronizeProcFct(f))); +} + +EXPORT void* my32_XSynchronize(x64emu_t* emu, void* display, int onoff) +{ + return reverse_XSynchronizeProcFct(my_lib, my->XSynchronize(display, onoff)); +} +#endif + +#define N_DISPLAY 4 +#define N_SCREENS 16 +my_XDisplay_t* my32_Displays_64[N_DISPLAY] = {0}; +struct my_XFreeFuncs_32 my32_free_funcs_32[N_DISPLAY] = {0}; +struct my_XLockPtrs_32 my32_lock_fns_32[N_DISPLAY] = {0}; +my_Screen_32_t my32_screens[N_DISPLAY*N_SCREENS] = {0}; +int n_screeens = 0; +my_XDisplay_32_t my32_Displays_32[N_DISPLAY] = {0}; + +void* getDisplay(void* d) +{ + for(int i=0; i<N_DISPLAY; ++i) + if(&my32_Displays_32[i]==d) + return my32_Displays_64[i]; + printf_log(LOG_INFO, "BOX32: Warning, 32bits Display not found"); + return d; +} + +void* FindDisplay(void* d) +{ + for(int i=0; i<N_DISPLAY; ++i) + if(my32_Displays_64[i]==d) + return &my32_Displays_32[i]; + return d; +} + +void refreshScreen(void* d, void* s) +{ + my_Screen_t* src = s; + my_Screen_32_t* dst = d; + dst->ext_data = to_ptrv(src->ext_data); + dst->display = to_ptrv(FindDisplay(src->display)); + dst->root = to_ulong(src->root); + dst->width = src->width; + dst->mwidth = src->mwidth; + dst->ndepths = src->ndepths; + dst->depths = to_ptrv(src->depths); + dst->root_depth = src->root_depth; + dst->root_visual = to_ptrv(src->root_visual); + dst->default_gc = to_ptrv(src->default_gc); + dst->cmap = to_ulong(src->cmap); + dst->white_pixel = to_ulong(src->white_pixel); + dst->black_pixel = to_ulong(src->black_pixel); + dst->max_maps = src->max_maps; + dst->backing_store = src->backing_store; + dst->save_unders = src->save_unders; + dst->root_input_mask = to_long(src->root_input_mask); +} + +EXPORT void* my32_XOpenDisplay(x64emu_t* emu, void* d) +{ + void* r = my->XOpenDisplay(d); + // Added automatic bridge because of thos macro from Xlibint.h + //#define LockDisplay(d) if ((d)->lock_fns) (*(d)->lock_fns->lock_display)(d) + //#define UnlockDisplay(d) if ((d)->lock_fns) (*(d)->lock_fns->unlock_display)(d) + if(!r) + return r; + + my_XDisplay_t* dpy = (my_XDisplay_t*)r; + // look for a free slot, or a display already there + my_XDisplay_32_t* ret = NULL; + struct my_XFreeFuncs_32 *free_funcs = NULL; + struct my_XLockPtrs_32 *lock_fns = NULL; + for(int i=0; i<N_DISPLAY && !ret; ++i) { + if(my32_Displays_64[i]==dpy || !my32_Displays_64[i]) { + my32_Displays_64[i] = dpy; + ret = &my32_Displays_32[i]; + free_funcs = &my32_free_funcs_32[i]; + ret->free_funcs = to_ptrv(free_funcs); + lock_fns = &my32_lock_fns_32[i]; + ret->lock_fns = to_ptrv(lock_fns); + } + } + if(!ret) { + printf_log(LOG_INFO, "BOX32: No more slot available for libX11 Display!"); + return r; + } + + bridge_t* system = my_lib->w.bridge; + + // partial copy... + + #define GO(A, W)\ + if(dpy->A) \ + if(!CheckBridged(system, dpy->A)) \ + ret->A = AddCheckBridge(system, W, dpy->A, 0, #A); \ + + #define GO2(A, B, W) \ + if(dpy->A && dpy->A->B) \ + if(!CheckBridged(system, dpy->A->B)) \ + A->B = AddCheckBridge(system, W, dpy->A->B, 0, #B "_" #A); \ + + ret->vendor = to_cstring(dpy->vendor); + ret->fd = dpy->fd; + ret->conn_checker = dpy->conn_checker; + ret->proto_major_version = dpy->proto_major_version; + ret->proto_minor_version = dpy->proto_minor_version; + ret->xdefaults = to_cstring(dpy->xdefaults); + ret->display_name = to_cstring(dpy->display_name); + ret->default_screen = dpy->default_screen; + ret->nscreens = dpy->nscreens; + if(dpy->screens) { + ret->screens = to_ptrv(&my32_screens[n_screeens]); + for(int i=0; i<dpy->nscreens; ++i) { + if(n_screeens==N_DISPLAY*N_SCREENS) { + printf_log(LOG_INFO, "BOX32: Warning, no more libX11 Screen slots!"); + break; + } + refreshScreen(&my32_screens[n_screeens++], &dpy->screens[i]); + } + } else + ret->screens = 0; + + GO2(free_funcs, atoms, vFp_32) + GO2(free_funcs, modifiermap, iFp_32) + GO2(free_funcs, key_bindings, vFp_32) + GO2(free_funcs, context_db, vFp_32) + GO2(free_funcs, defaultCCCs, vFp_32) + GO2(free_funcs, clientCmaps, vFp_32) + GO2(free_funcs, intensityMaps, vFp_32) + GO2(free_funcs, im_filters, vFp_32) + GO2(free_funcs, xkb, vFp_32) + GO(resource_alloc, LFp_32) + GO(synchandler, iFp_32) + //TODO: ext_procs? + //TODO: event_vec? + //TODO: wire_vec? + //TODO: async_handlers? + GO2(lock_fns, lock_display, vFp_32) + GO2(lock_fns, unlock_display, vFp_32) + GO(idlist_alloc, vFppi_32) + //TODO: error_vec? + //TODO: flushes + //TODO: im_fd_info? + //TODO: conn_watchers + GO(savedsynchandler, iFp_32) + //TODO: generic_event_vec? + //TODO: generic_event_copy_vec? + + + #undef GO + #undef GO2 + + return ret; +} + +EXPORT XID my32_XCreateWindow(x64emu_t* emu, void* d, XID Window, int x, int y, uint32_t width, uint32_t height, uint32_t border_width, int depth, uint32_t cl, void* visual, unsigned long mask, my_XSetWindowAttributes_32_t* attr) +{ + my_XSetWindowAttributes_t attrib; + if(attr) { + attrib.background_pixmap = from_ulong(attr->background_pixmap); + attrib.background_pixel = from_ulong(attr->background_pixel); + attrib.border_pixmap = from_ulong(attr->border_pixmap); + attrib.border_pixel = from_ulong(attr->border_pixel); + attrib.bit_gravity = attr->bit_gravity; + attrib.win_gravity = attr->win_gravity; + attrib.backing_store = attr->backing_store; + attrib.backing_planes = from_ulong(attr->backing_planes); + attrib.backing_pixel = from_ulong(attr->backing_pixel); + attrib.save_under = attr->save_under; + attrib.event_mask = from_long(attr->event_mask); + attrib.do_not_propagate_mask = from_long(attr->do_not_propagate_mask); + attrib.override_redirect = attr->override_redirect; + attrib.colormap = from_ulong(attr->colormap); + attrib.cursor = from_ulong(attr->cursor); + } + return my->XCreateWindow(d, Window, x, y, width, height, border_width, depth, cl, visual, mask, attr?(&attrib):NULL); +} + +void convertXEvent(my_XEvent_32_t* dst, my_XEvent_t* src) +{ + // convert the XAnyEvent first, as it's a common set + dst->type = src->type; + dst->xany.display = to_ptrv(FindDisplay(src->xany.display)); + dst->xany.window = to_ulong(src->xany.window); + dst->xany.send_event = src->xany.serial; + dst->xany.serial = to_ulong(src->xany.serial); + switch(src->type) { + case XEVT_KeyPress: + case XEVT_KeyRelease: + dst->xkey.root = to_ulong(src->xkey.root); + dst->xkey.subwindow = to_ulong(src->xkey.subwindow); + dst->xkey.time = to_ulong(src->xkey.time); + dst->xkey.x = src->xkey.x; + dst->xkey.y = src->xkey.y; + dst->xkey.x_root = src->xkey.x_root; + dst->xkey.y_root = src->xkey.y_root; + dst->xkey.state = src->xkey.state; + dst->xkey.keycode = src->xkey.keycode; + dst->xkey.same_screen = src->xkey.same_screen; + break; + case XEVT_ButtonPress: + case XEVT_ButtonRelease: + dst->xbutton.root = to_ulong(src->xbutton.root); + dst->xbutton.subwindow = to_ulong(src->xbutton.subwindow); + dst->xbutton.time = to_ulong(src->xbutton.time); + dst->xbutton.x = src->xbutton.x; + dst->xbutton.y = src->xbutton.y; + dst->xbutton.x_root = src->xbutton.x_root; + dst->xbutton.y_root = src->xbutton.y_root; + dst->xbutton.state = src->xbutton.state; + dst->xbutton.button = src->xbutton.button; + dst->xbutton.same_screen = src->xbutton.same_screen; + break; + case XEVT_MotionNotify: + dst->xmotion.root = to_ulong(src->xmotion.root); + dst->xmotion.subwindow = to_ulong(src->xmotion.subwindow); + dst->xmotion.time = to_ulong(src->xmotion.time); + dst->xmotion.x = src->xmotion.x; + dst->xmotion.y = src->xmotion.y; + dst->xmotion.x_root = src->xmotion.x_root; + dst->xmotion.y_root = src->xmotion.y_root; + dst->xmotion.state = src->xmotion.state; + dst->xmotion.is_hint = src->xmotion.is_hint; + dst->xmotion.same_screen = src->xmotion.same_screen; + break; + case XEVT_EnterNotify: + case XEVT_LeaveNotify: + dst->xcrossing.root = to_ulong(src->xcrossing.root); + dst->xcrossing.subwindow = to_ulong(src->xcrossing.subwindow); + dst->xcrossing.time = to_ulong(src->xcrossing.time); + dst->xcrossing.x = src->xcrossing.x; + dst->xcrossing.y = src->xcrossing.y; + dst->xcrossing.x_root = src->xcrossing.x_root; + dst->xcrossing.y_root = src->xcrossing.y_root; + dst->xcrossing.mode = src->xcrossing.mode; + dst->xcrossing.detail = src->xcrossing.detail; + dst->xcrossing.same_screen = src->xcrossing.same_screen; + dst->xcrossing.focus = src->xcrossing.focus; + dst->xcrossing.state = src->xcrossing.state; + break; + case XEVT_FocusIn: + case XEVT_FocusOut: + dst->xfocus.mode = src->xfocus.mode; + dst->xfocus.detail = src->xfocus.detail; + break; + case XEVT_KeymapNotify: + memcpy(dst->xkeymap.key_vector, src->xkeymap.key_vector, 32); + break; + case XEVT_Expose: + dst->xexpose.x = src->xexpose.x; + dst->xexpose.y = src->xexpose.y; + dst->xexpose.width = src->xexpose.width; + dst->xexpose.height = src->xexpose.height; + dst->xexpose.count = src->xexpose.count; + break; + case XEVT_GraphicsExpose: + dst->xgraphicsexpose.x = src->xgraphicsexpose.x; + dst->xgraphicsexpose.y = src->xgraphicsexpose.y; + dst->xgraphicsexpose.width = src->xgraphicsexpose.width; + dst->xgraphicsexpose.height = src->xgraphicsexpose.height; + dst->xgraphicsexpose.count = src->xgraphicsexpose.count; + dst->xgraphicsexpose.major_code = src->xgraphicsexpose.major_code; + dst->xgraphicsexpose.minor_code = src->xgraphicsexpose.minor_code; + break; + case XEVT_NoExpose: + dst->xnoexpose.major_code = src->xnoexpose.major_code; + dst->xnoexpose.minor_code = src->xnoexpose.minor_code; + break; + case XEVT_VisibilityNotify: + dst->xvisibility.state = src->xvisibility.state; + break; + case XEVT_CreateNotify: + dst->xcreatewindow.window = to_ulong(src->xcreatewindow.window); + dst->xcreatewindow.x = src->xcreatewindow.x; + dst->xcreatewindow.y = src->xcreatewindow.y; + dst->xcreatewindow.width = src->xcreatewindow.width; + dst->xcreatewindow.height = src->xcreatewindow.height; + dst->xcreatewindow.border_width = src->xcreatewindow.border_width; + dst->xcreatewindow.override_redirect = src->xcreatewindow.override_redirect; + break; + case XEVT_DestroyNotify: + dst->xdestroywindow.window = to_ulong(src->xdestroywindow.window); + break; + case XEVT_UnmapNotify: + dst->xunmap.window = to_ulong(src->xunmap.window); + dst->xunmap.from_configure = src->xunmap.from_configure; + break; + case XEVT_MapNotify: + dst->xmap.window = to_ulong(src->xmap.window); + dst->xmap.override_redirect = src->xmap.override_redirect; + break; + case XEVT_MapRequest: + dst->xmaprequest.window = to_ulong(src->xmaprequest.window); + break; + case XEVT_ReparentNotify: + dst->xreparent.window = to_ulong(src->xreparent.window); + dst->xreparent.parent = to_ulong(src->xreparent.parent); + dst->xreparent.x = src->xreparent.x; + dst->xreparent.y = src->xreparent.y; + dst->xreparent.override_redirect = src->xreparent.override_redirect; + break; + case XEVT_ConfigureNotify: + dst->xconfigure.window = to_ulong(src->xconfigure.window); + dst->xconfigure.x = src->xconfigure.x; + dst->xconfigure.y = src->xconfigure.y; + dst->xconfigure.width = src->xconfigure.width; + dst->xconfigure.height = src->xconfigure.height; + dst->xconfigure.border_width = src->xconfigure.border_width; + dst->xconfigure.above = to_ulong(src->xconfigure.above); + dst->xconfigure.override_redirect = src->xconfigure.override_redirect; + break; + case XEVT_ConfigureRequest: + dst->xconfigurerequest.window = to_ulong(src->xconfigurerequest.window); + dst->xconfigurerequest.x = src->xconfigurerequest.x; + dst->xconfigurerequest.y = src->xconfigurerequest.y; + dst->xconfigurerequest.width = src->xconfigurerequest.width; + dst->xconfigurerequest.height = src->xconfigurerequest.height; + dst->xconfigurerequest.border_width = src->xconfigurerequest.border_width; + dst->xconfigurerequest.above = to_ulong(src->xconfigurerequest.above); + dst->xconfigurerequest.detail = src->xconfigurerequest.detail; + dst->xconfigurerequest.value_mask = to_ulong(src->xconfigurerequest.value_mask); + break; + case XEVT_GravityNotify: + dst->xgravity.window = to_ulong(src->xgravity.window); + dst->xgravity.x = src->xgravity.x; + dst->xgravity.y = src->xgravity.y; + break; + case XEVT_ResizeRequest: + dst->xresizerequest.width = src->xresizerequest.width; + dst->xresizerequest.height = src->xresizerequest.height; + break; + case XEVT_CirculateNotify: + dst->xcirculate.window = to_ulong(src->xcirculate.window); + dst->xcirculate.place = src->xcirculate.place; + break; + case XEVT_CirculateRequest: + dst->xcirculaterequest.window = to_ulong(src->xcirculaterequest.window); + dst->xcirculaterequest.place = src->xcirculaterequest.place; + break; + case XEVT_PropertyNotify: + dst->xproperty.atom = to_ulong(src->xproperty.atom); + dst->xproperty.time = to_ulong(src->xproperty.time); + dst->xproperty.state = src->xproperty.state; + break; + case XEVT_SelectionClear: + dst->xselectionclear.selection = to_ulong(src->xselectionclear.selection); + dst->xselectionclear.time = to_ulong(src->xselectionclear.time); + break; + case XEVT_SelectionRequest: + dst->xselectionrequest.requestor = to_ulong(src->xselectionrequest.requestor); + dst->xselectionrequest.selection = to_ulong(src->xselectionrequest.selection); + dst->xselectionrequest.target = to_ulong(src->xselectionrequest.target); + dst->xselectionrequest.property = to_ulong(src->xselectionrequest.property); + dst->xselectionrequest.time = to_ulong(src->xselectionrequest.time); + break; + case XEVT_SelectionNotify: + dst->xselection.selection = to_ulong(src->xselection.selection); + dst->xselection.target = to_ulong(src->xselection.target); + dst->xselection.property = to_ulong(src->xselection.property); + dst->xselection.time = to_ulong(src->xselection.time); + break; + case XEVT_ColormapNotify: + dst->xcolormap.colormap = to_ulong(src->xcolormap.colormap); + dst->xcolormap.c_new = src->xcolormap.c_new; + dst->xcolormap.state = src->xcolormap.state; + break; + case XEVT_ClientMessage: + dst->xclient.message_type = to_ulong(src->xclient.message_type); + dst->xclient.format = src->xclient.format; + if(src->xclient.format==32) + for(int i=0; i<5; ++i) dst->xclient.data.l[i] = to_ulong(src->xclient.data.l[i]); + else + memcpy(dst->xclient.data.b, src->xclient.data.b, 20); + break; + case XEVT_MappingNotify: + dst->xmapping.request = src->xmapping.request; + dst->xmapping.first_keycode = src->xmapping.first_keycode; + dst->xmapping.count = src->xmapping.count; + break; + case XEVT_GenericEvent: + dst->xgeneric.extension = src->xgeneric.extension; + dst->xgeneric.evtype = src->xgeneric.evtype; + break; + + default: + printf_log(LOG_INFO, "Warning, unsupported 32bits XEvent type=%d\n", src->type); + } +} + +EXPORT int my32_XNextEvent(x64emu_t* emu, void* dpy, my_XEvent_32_t* evt) +{ + my_XEvent_t event = {0}; + int ret = my->XNextEvent(dpy, &event); + convertXEvent(evt, &event); + return ret; +} +#if 0 +EXPORT void* my32__XGetRequest(x64emu_t* emu, my_XDisplay_t* dpy, uint8_t type, size_t len) +{ + // check if asynchandler needs updated wrapping + struct my32_XInternalAsync * p = dpy->async_handlers; + while(p) { + if(GetNativeFnc((uintptr_t)p->handler)!=p->handler) { + // needs wrapping and autobridge! + void* new_handler = find_async_handler_Fct(p->handler); + AddAutomaticBridge(my_lib->w.bridge, iFpppip, new_handler, 0, "async_handler"); + p->handler = new_handler; + } + p = p->next; + } + + return my->_XGetRequest(dpy, type, len); +} +#endif +#define CUSTOM_INIT \ + AddAutomaticBridge(lib->w.bridge, vFp_32, *(void**)dlsym(lib->w.lib, "_XLockMutex_fn"), 0, "_XLockMutex_fn"); \ + AddAutomaticBridge(lib->w.bridge, vFp_32, *(void**)dlsym(lib->w.lib, "_XUnlockMutex_fn"), 0, "_XUnlockMutex_fn"); \ + if(box64_x11threads) my->XInitThreads(); +#if 0 +#ifdef ANDROID +#define NEEDED_LIBS "libxcb.so" +#else +#define NEEDED_LIBS "libxcb.so.1" +#endif +#endif + +#include "wrappedlib_init32.h" diff --git a/src/wrapped32/wrappedlibx11_private.h b/src/wrapped32/wrappedlibx11_private.h new file mode 100644 index 00000000..200c4bb1 --- /dev/null +++ b/src/wrapped32/wrappedlibx11_private.h @@ -0,0 +1,1246 @@ +#if !(defined(GO) && defined(GOM) && defined(GO2) && defined(DATA)) +#error Meh... +#endif + +//XColor is a struct: hWcc + +DATAB(_qfree, 4) // Warning: failed to confirm + +//GO(XActivateScreenSaver, iFp) +//GOM(XAddConnectionWatch, iFEppp) +//GO(XAddExtension, pFp) +//GO(XAddHost, iFpp) +//GO(XAddHosts, iFppi) +GO(XAddPixel, vFpl) +//GO(XAddToExtensionList, iFpp) +//GO(XAddToSaveSet, iFpL) +//GO(XAllocClassHint, pFv) +GO(XAllocColor, iFXLbhWcc_) +//GO(XAllocColorCells, iFpLipupu) +//GO(XAllocColorPlanes, iFpLipiiiippp) +//GO(XAllocIconSize, pFv) +//GO(_XAllocID, LFp) +//GO(_XAllocIDs, vFppi) +//GO(XAllocNamedColor, iFpLppp) +//GO(_XAllocScratch, pFpL) +//GO(XAllocSizeHints, pFv) +//GO(XAllocStandardColormap, pFv) +//GO(_XAllocTemp, pFpL) +//GO(XAllocWMHints, pFv) +//GO(XAllowEvents, iFpiL) +//GO(XAllPlanes, LFv) +//GO(_XAsyncErrorHandler, iFpppip) +//GO(XAutoRepeatOff, iFp) +//GO(XAutoRepeatOn, iFp) +//GO(XBaseFontNameListOfFontSet, pFp) +//GO(XBell, iFpi) +//GO(XBitmapBitOrder, iFp) +//GO(XBitmapPad, iFp) +//GO(XBitmapUnit, iFp) +//GO(XBlackPixel, LFpi) +//GO(XBlackPixelOfScreen, LFp) +//GO(XCellsOfScreen, iFp) +//GO(XChangeActivePointerGrab, iFpuLL) +//GO(XChangeGC, iFppLp) +//GO(XChangeKeyboardControl, iFpLp) +//GO(XChangeKeyboardMapping, iFpiipi) +//GO(XChangePointerControl, iFpiiiii) +//GO(XChangeProperty, iFpLLLiipi) +//GO(XChangeSaveSet, iFpLi) +//GO(XChangeWindowAttributes, iFpLLp) +//GOM(XCheckIfEvent, iFEpppp) +//GO(XCheckMaskEvent, iFplp) +//GO(XCheckTypedEvent, iFpip) +//GO(XCheckTypedWindowEvent, iFpLip) +//GO(XCheckWindowEvent, iFpLlp) +//GO(XCirculateSubwindows, iFpLi) +//GO(XCirculateSubwindowsDown, iFpL) +//GO(XCirculateSubwindowsUp, iFpL) +//GO(XClearArea, iFpLiiuui) +//GO(XClearWindow, iFpL) +//GO(XClipBox, iFpp) +//GO(XCloseDisplay, iFp) +//GO(XCloseIM, iFp) +//GO(_XCloseLC, +//GO(XCloseOM, iFp) +//GO(_XcmsAddCmapRec, +//GOM(XcmsAddColorSpace, iFEp) +//GO(XcmsAddFunctionSet, iFp) +//GO(XcmsAllocColor, iFpLpL) +//GO(XcmsAllocNamedColor, iFpLpppL) +//GO(_XcmsArcTangent, +//GOM(XcmsCCCOfColormap, pFEpL) +//GOM(XcmsCIELabClipab, iFEppuup) +//GOM(XcmsCIELabClipL, iFEppuup) +//GOM(XcmsCIELabClipLab, iFEppuup) +//DATA(XcmsCIELabColorSpace, 6*4) +//DATA(_XcmsCIELab_prefix, +//GOM(XcmsCIELabQueryMaxC, iFEpddp) +//GOM(XcmsCIELabQueryMaxL, iFEpddp) +//GOM(XcmsCIELabQueryMaxLC, iFEpdp) +//GO(_XcmsCIELabQueryMaxLCRGB, +//GOM(XcmsCIELabQueryMinL, iFEpddp) +//GOM(XcmsCIELabToCIEXYZ, iFEpppu) +//GOM(XcmsCIELabWhiteShiftColors, iFEpppLpup) +//GOM(XcmsCIELuvClipL, iFEppuup) +//GOM(XcmsCIELuvClipLuv, iFEppuup) +//GOM(XcmsCIELuvClipuv, iFEppuup) +//DATA(XcmsCIELuvColorSpace, 6*4) +//DATA(_XcmsCIELuv_prefix, +//GOM(XcmsCIELuvQueryMaxC, iFEpddp) +//GOM(XcmsCIELuvQueryMaxL, iFEpddp) +//GOM(XcmsCIELuvQueryMaxLC, iFEpdp) +//GO(_XcmsCIELuvQueryMaxLCRGB, +//GOM(XcmsCIELuvQueryMinL, iFEpddp) +//GOM(XcmsCIELuvToCIEuvY, iFEpppu) +//GOM(XcmsCIELuvWhiteShiftColors, iFEpppLpup) +//DATA(XcmsCIEuvYColorSpace, 6*4) +//DATA(_XcmsCIEuvY_prefix, +//GOM(XcmsCIEuvYToCIELuv, iFEpppu) +//GOM(XcmsCIEuvYToCIEXYZ, iFEpppu) +//GOM(XcmsCIEuvYToTekHVC, iFEpppu) +//GO(_XcmsCIEuvY_ValidSpec, +//DATA(XcmsCIExyYColorSpace, 6*4) // probably need some wrapping +//DATA(_XcmsCIExyY_prefix, +//GOM(XcmsCIExyYToCIEXYZ, iFEpppu) +//DATA(XcmsCIEXYZColorSpace, 6*4) +//DATA(_XcmsCIEXYZ_prefix, +//GOM(XcmsCIEXYZToCIELab, iFEpppu) +//GOM(XcmsCIEXYZToCIEuvY, iFEpppu) +//GOM(XcmsCIEXYZToCIExyY, iFEpppu) +//GOM(XcmsCIEXYZToRGBi, iFEppup) +//GO(_XcmsCIEXYZ_ValidSpec, +//GOM(XcmsClientWhitePointOfCCC, pFEp) +//GOM(XcmsConvertColors, iFEppuLp) +//GO(_XcmsConvertColorsWithWhitePt, +//GO(_XcmsCopyCmapRecAndFree, +//GO(_XcmsCopyISOLatin1Lowered, +//GO(_XcmsCopyPointerArray, +//GO(_XcmsCosine, +//GOM(XcmsCreateCCC, pFEpipppppp) +//GO(_XcmsCubeRoot, +//DATA(_XcmsDDColorSpaces, 6*4) +//DATA(_XcmsDDColorSpacesInit, 6*4) +//GO(_XcmsDDConvertColors, +//GOM(XcmsDefaultCCC, pFEpi) +//GO(_XcmsDeleteCmapRec, +//DATA(_XcmsDIColorSpaces, 6*4) +//DATA(_XcmsDIColorSpacesInit, 6*4) +//GO(_XcmsDIConvertColors, +//GOM(XcmsDisplayOfCCC, pFEp) +//GO(_XcmsEqualWhitePts, +//GO(XcmsFormatOfPrefix, LFp) +GO(XcmsFreeCCC, vFp) +//GO(_XcmsFreeIntensityMaps, +//GO(_XcmsFreePointerArray, +//GO(_XcmsGetElement, +//GO(_XcmsGetIntensityMap, +//GO(_XcmsGetProperty, +//GO(_XcmsInitDefaultCCCs, +//GO(_XcmsInitScrnInfo, +//DATA(XcmsLinearRGBFunctionSet, 3*4) // probably needs some wrapping +//GO(XcmsLookupColor, iFpLpppL) +//GO(_XcmsLRGB_InitScrnDefault, +//GO(XcmsPrefixOfFormat, pFL) +//GO(_XcmsPushPointerArray, +//GOM(XcmsQueryBlack, iFEpLp) +//GOM(XcmsQueryBlue, iFEpLp) +//GO(XcmsQueryColor, iFpLpL) +//GO(XcmsQueryColors, iFpLpuL) +//GOM(XcmsQueryGreen, iFEpLp) +//GOM(XcmsQueryRed, iFEpLp) +//GOM(XcmsQueryWhite, iFEpLp) +//DATA(_XcmsRegColorSpaces, 6*4) +//GO(_XcmsRegFormatOfPrefix, +//GO(_XcmsResolveColor, +//GO(_XcmsResolveColorString, +//DATA(XcmsRGBColorSpace, 6*4) +//DATA(XcmsRGBiColorSpace, 6*4) +//DATA(_XcmsRGBi_prefix, +//GOM(XcmsRGBiToCIEXYZ, iFEppup) +//GOM(XcmsRGBiToRGB, iFEppup) +//DATA(_XcmsRGB_prefix, +//GOM(XcmsRGBToRGBi, iFEppup) +//GO(_XcmsRGB_to_XColor, +//DATA(_XcmsSCCFuncSets, 3*4) +//DATA(_XcmsSCCFuncSetsInit, 3*4) +//GOM(XcmsScreenNumberOfCCC, iFEp) +//GOM(XcmsScreenWhitePointOfCCC, pFEp) +//GOM(XcmsSetCCCOfColormap, pFEpLp) +//GOM(XcmsSetCompressionProc, pFEppp) +//GO(_XcmsSetGetColor, +//GO(_XcmsSetGetColors, +//GOM(XcmsSetWhiteAdjustProc, pFEppp) +//GOM(XcmsSetWhitePoint, iFEpp) +//GO(_XcmsSine, +//GO(_XcmsSquareRoot, +//GO(XcmsStoreColor, iFpLp) +//GO(XcmsStoreColors, iFpLpup) +//GO(_XcmsTekHVC_CheckModify, +//GOM(XcmsTekHVCClipC, iFEppuup) +//GOM(XcmsTekHVCClipV, iFEppuup) +//GOM(XcmsTekHVCClipVC, iFEppuup) +//DATA(XcmsTekHVCColorSpace, 6*4) +//DATA(_XcmsTekHVC_prefix, +//GOM(XcmsTekHVCQueryMaxC, iFEpddp) +//GOM(XcmsTekHVCQueryMaxV, iFEpddp) +//GOM(XcmsTekHVCQueryMaxVC, iFEpdp) +//GO(_XcmsTekHVCQueryMaxVCRGB, +//GOM(XcmsTekHVCQueryMaxVSamples, iFEpdpu) +//GOM(XcmsTekHVCQueryMinV, iFEpddp) +//GOM(XcmsTekHVCToCIEuvY, iFEpppu) +//GOM(XcmsTekHVCWhiteShiftColors, iFEpppLpup) +//DATA(XcmsUNDEFINEDColorSpace, 6*4) +//GO(_XcmsUnresolveColor, +//GOM(XcmsVisualOfCCC, pFEp) +//GO(_XColor_to_XcmsRGB, +//GO(XConfigureWindow, iFpLup) +//GO(XConnectionNumber, iFp) +//GO(_XConnectXCB, +//GO(XContextDependentDrawing, iFp) +//GO(XContextualDrawing, iFp) +//GO(XConvertCase, vFLpp) +//GO(XConvertSelection, iFpLLLLL) +//GO(XCopyArea, iFpLLpiiuuii) +//GO(XCopyColormapAndFree, LFpL) +//GO(_XCopyEventCookie, iFppp) +//GO(XCopyGC, iFppLp) +//GO(XCopyPlane, iFpLLpiiuuiiL) +//GO(_XCopyToArg, +//GO(XCreateBitmapFromData, LFpLpuu) +GO(XCreateColormap, LFXLpi) +//GO(XCreateFontCursor, LFpu) +//GO(XCreateFontSet, pFppppp) +GO(XCreateGC, pFXLLp) +//GO(XCreateGlyphCursor, LFpLLuupp) +//GOM(XCreateIC, pFEpV) // use vararg +GOM(XCreateImage, pFEXpuiipuuii) +GO(dummy_XCreateImage, pFXpuiipuuii) // to have the wrapper +//DATAB(_XCreateMutex_fn, 4) +//GO(XCreateOC, pFppppppppppppppppppp) // is pFpV +GO(XCreatePixmap, LFXLuuu) +GO(XCreatePixmapCursor, LFXLLppuu) +GO(XCreatePixmapFromBitmapData, LFXLpuuLLu) +//GO(XCreateRegion, pFv) +//GO(XCreateSimpleWindow, LFpLiiuuuLL) +GOM(XCreateWindow, LFEXLiiuuuiupLp) +//DATAB(_Xdebug, 4) +GO(XDefaultColormap, LFXi) +//GO(XDefaultColormapOfScreen, LFp) +GO(XDefaultDepth, iFXi) +//GO(XDefaultDepthOfScreen, iFp) +//GO(_XDefaultError, iFpp) +GO(XDefaultGC, pFXi) +//GO(XDefaultGCOfScreen, pFp) +//GO(_XDefaultIOError, iFp) +//GO(_XDefaultIOErrorExit, vFpp) +//GO(_XDefaultOpenIM, +//GO(_XDefaultOpenOM, +//GO(XDefaultRootWindow, LFp) +GO(XDefaultScreen, iFX) +//GO(XDefaultScreenOfDisplay, pFp) +//GO(XDefaultString, pFv) +GO(XDefaultVisual, pFXi) +//GO(XDefaultVisualOfScreen, pFp) +//GO(_XDefaultWireError, iFppp) +GO(XDefineCursor, iFXLL) +//GO(XDeleteContext, iFpLi) +//GO(XDeleteModifiermapEntry, pFpCi) +//GO(XDeleteProperty, iFpLL) +//GO(_XDeq, vFppp) +//GOM(_XDeqAsyncHandler, vFEpp) +//GO(XDestroyIC, vFp) +GOM(XDestroyImage, iFEp) //need to unbridge +//GO(XDestroyOC, vFp) +//GO(XDestroyRegion, iFp) +//GO(XDestroySubwindows, iFpL) +//GO(XDestroyWindow, iFpL) +//GO(XDirectionalDependentDrawing, iFp) +//GO(XDisableAccessControl, iFp) +//GO(XDisplayCells, iFpi) +GO(XDisplayHeight, iFXi) +GO(XDisplayHeightMM, iFXi) +//GO(XDisplayKeycodes, iFppp) +//GO(XDisplayMotionBufferSize, LFp) +//GO(XDisplayName, pFp) +//GO(XDisplayOfIM, pFp) +//GO(XDisplayOfOM, pFp) +//GO(XDisplayOfScreen, pFp) +GO(XDisplayPlanes, iFXi) +GO(XDisplayString, pFX) +GO(XDisplayWidth, iFXi) +GO(XDisplayWidthMM, iFXi) +//GO(XDoesBackingStore, iFp) +//GO(XDoesSaveUnders, iFp) +//GO(XDrawArc, iFpLpiiuuii) +//GO(XDrawArcs, iFpLppi) +//GO(XDrawImageString, iFpLpiipi) +//GO(XDrawImageString16, iFpLpiipi) +//GO(XDrawLine, iFpLpiiii) +//GO(XDrawLines, iFpLppii) +//GO(XDrawPoint, iFpLpii) +//GO(XDrawPoints, iFpLppii) +//GO(XDrawRectangle, iFpLpiiuu) +//GO(XDrawRectangles, iFpLppi) +//GO(XDrawSegments, iFpLppi) +//GO(XDrawString, iFpLpiipi) +//GO(XDrawString16, iFpLpiipi) +//GO(XDrawText, iFpLpiipi) +//GO(XDrawText16, iFpLpiipi) +//GO(_XEatData, vFpL) +//GO(_XEatDataWords, vFpL) +//GO(XEHeadOfExtensionList, +//GO(XEmptyRegion, iFp) +//GO(XEnableAccessControl, iFp) +//GO(_XEnq, vFpp) +//GO(XEqualRegion, iFpp) +//GO(_XError, iFpp) +//DATAB(_XErrorFunction, 4) +//GOM(XESetBeforeFlush, pFEpip) +//GOM(XESetCloseDisplay, pFEpip) +//GOM(XESetCopyEventCookie, pFEpip) +//GOM(XESetCopyGC, pFEpip) +//GOM(XESetCreateFont, pFEpip) +//GOM(XESetCreateGC, pFEpip) +//GOM(XESetError, pFEpip) +//GOM(XESetErrorString, pFEpip) +//GOM(XESetEventToWire, pFEpip) +//GOM(XESetFlushGC, pFEpip) +//GOM(XESetFreeFont, pFEpip) +//GOM(XESetFreeGC, pFEpip) +//GOM(XESetPrintErrorValues, pFEpip) +//GOM(XESetWireToError, pFEpip) +//GOM(XESetWireToEvent, pFEpip) +//GOM(XESetWireToEventCookie, pFEpip) +//GO(XEventMaskOfScreen, lFp) +//GO(_XEventsQueued, iFpi) +//GO(XEventsQueued, iFpi) +//DATA(_Xevent_to_mask, +//GO(_XEventToWire, iFppp) +//GO(XExtendedMaxRequestSize, lFp) +//GO(XExtentsOfFontSet, pFp) +//GO(_XF86BigfontFreeFontMetrics, +//GO(_XF86LoadQueryLocaleFont, iFpppp) +//GO(XFetchBuffer, pFppi) +//GO(XFetchBytes, pFpp) +//GO(_XFetchEventCookie, iFpp) +//GO(XFetchName, iFpLp) +//GO(XFillArc, iFpLpiiuuii) +//GO(XFillArcs, iFpLppi) +//GO(XFillPolygon, iFpLppiii) +//GO(XFillRectangle, iFpLpiiuu) +//GO(XFillRectangles, iFpLppi) +//GO(XFilterEvent, iFpL) +//GO(XFindContext, iFpLip) +//GO(XFindOnExtensionList, pFpi) +//GO(_XFlush, vFp) +//GO(XFlush, iFp) +//GO(XFlushGC, vFpp) +//GO(_XFlushGCCache, vFpp) +//GO(XFontsOfFontSet, iFppp) +//GO(XForceScreenSaver, iFpi) +//GO(XFree, iFp) +//GO(_XFreeAtomTable, +//GO(XFreeColormap, iFpL) +//GO(XFreeColors, iFpLpiL) +//GO(XFreeCursor, iFpL) +//DATAB(_XFreeDisplayLock_fn, 4) +//GO(_XFreeDisplayStructure, +//GO(_XFreeEventCookies, vFp) +//GO(XFreeEventData, vFpp) +//GO(_XFreeExtData, iFp) +//GO(XFreeExtensionList, iFp) +//GO(XFreeFont, iFpp) +//GO(XFreeFontInfo, iFppi) +//GO(XFreeFontNames, iFp) +//GO(XFreeFontPath, iFp) +//GO(XFreeFontSet, vFpp) +GO(XFreeGC, iFXp) +//GO(XFreeModifiermap, iFp) +//DATAB(_XFreeMutex_fn, 4) +GO(XFreePixmap, iFXL) +//GO(XFreeStringList, vFp) +//GO(_XFreeTemp, vFppL) +//GO(XFreeThreads, iFv) +//GO(_XFreeX11XCBStructure, +//GO(XGContextFromGC, LFp) +//GO(XGeometry, iFpippuuuiipppp) +//GO(_XGetAsyncData, vFpppiiii) +//GO(_XGetAsyncReply, pFppppiii) +//GO(XGetAtomName, pFpL) +//GO(XGetAtomNames, iFppip) +//GO(_XGetBitsPerPixel, +//GO(XGetClassHint, iFpLp) +//GO(XGetCommand, iFpLpp) +//GO(XGetDefault, pFppp) +//GO(XGetErrorDatabaseText, iFpppppi) +//GO(XGetErrorText, iFpipi) +//GO(XGetEventData, iFpp) +//GO(XGetFontPath, pFpp) +//GO(XGetFontProperty, iFpLp) +//GO(XGetGCValues, iFppLp) +//GO(XGetGeometry, iFpLppppppp) +//GO(_XGetHostname, iFpi) +//GO(XGetIconName, iFpLp) +//GO(XGetIconSizes, iFpLpp) +//GO(XGetICValues, pFpppppppppp) // use varargs... +GOM(XGetImage, pFEXLiiuuLi) // return an XImage with callbacks that needs wrapping +//GO(XGetIMValues, pFppppppp) // use varargs +//GO(XGetInputFocus, iFppp) +//GO(XGetKeyboardControl, iFpp) +//GO(XGetKeyboardMapping, pFpCip) +//GO(_XGetLCValues, +//GO(XGetModifierMapping, pFp) +//GO(XGetMotionEvents, pFpLLLp) +//GO(XGetNormalHints, iFpLp) +//GO(XGetOCValues, pFpppppppppp) // use varargs +//GO(XGetOMValues, pFp) +GOM(XGetPixel, LFEXii) // need unbridging +GO(dummy_XGetPixel, LFpii) // for the wrapper +//GO(XGetPointerControl, iFpppp) +//GO(XGetPointerMapping, iFppi) +//GOM(_XGetRequest, pFEpCL) +//GO(XGetRGBColormaps, iFpLppL) +//GO(_XGetScanlinePad, +//GO(XGetScreenSaver, iFppppp) +//GO(XGetSelectionOwner, LFpL) +//GO(XGetSizeHints, iFpLpL) +//GO(XGetStandardColormap, iFpLpL) +GOM(XGetSubImage, pFEXLiiuuLipii) +//GO(XGetTextProperty, iFpLpL) +//GO(XGetTransientForHint, iFpLp) +//GO(XGetVisualInfo, pFplpp) +//GO(_XGetWindowAttributes, iFpLp) +//GO(XGetWindowAttributes, iFpLp) +//GO(XGetWindowProperty, iFpLLlliLppppp) +//GO(XGetWMClientMachine, iFpLp) +//GO(XGetWMColormapWindows, iFpLpp) +//GO(XGetWMHints, pFpL) +//GO(XGetWMIconName, iFpLp) +//GO(XGetWMName, iFpLp) +//GO(XGetWMNormalHints, iFpLpp) +//GO(XGetWMProtocols, iFpLpp) +//GO(XGetWMSizeHints, iFpLppL) +//GO(XGetZoomHints, iFpLp) +//DATAB(_Xglobal_lock, 4) +GO(XGrabButton, iFXuuLiuiiLL) +GO(XGrabKey, iFXiuLiii) +GO(XGrabKeyboard, iFXLiiiL) +GO(XGrabPointer, iFXLiuiiLLL) +GO(XGrabServer, iFX) +//DATAB(_XHeadOfDisplayList, 4) +//GO(XHeightMMOfScreen, iFp) +//GO(XHeightOfScreen, iFp) +//DATAB(_Xi18n_lock, 4) +//GO(XIconifyWindow, iFpLi) +//GOM(XIfEvent, iFEpppp) +//GO(XImageByteOrder, iFp) +//GO(_XimCbDispatch, +//GO(_XimCheckCreateICValues, +//GO(_XimCheckDataSize, +//GO(_XimCheckICMode, +//GO(_XimCheckIfLocalProcessing, +//GO(_XimCheckIfThaiProcessing, +//GO(_XimCheckIMMode, +//GO(_XimCheckLocalInputStyle, +//GO(_XimCommitCallback, +//GO(_XIMCompileResourceList, +//GO(_XimConnect, +//GO(_Ximctstombs, +//GO(_Ximctstoutf8, +//GO(_Ximctstowcs, +//GO(_XimDecodeICATTRIBUTE, +//GO(_XimDecodeIMATTRIBUTE, +//GO(_XimDecodeLocalICAttr, +//GO(_XimDecodeLocalIMAttr, +//GO(_XimDestroyIMStructureList, +//GO(_XimDispatchInit, +//GO(_XimEncodeICATTRIBUTE, +//GO(_XimEncodeIMATTRIBUTE, +//GO(_XimEncodeLocalICAttr, +//GO(_XimEncodeLocalIMAttr, +//GO(_XimError, +//GO(_XimErrorCallback, +//GO(_XimExtension, +//GO(_XimFilterWaitEvent, +//GO(_XimFlush, +//GO(_XimForwardEvent, +//GO(_XimForwardEventCallback, +//GO(_XimFreeCommitInfo, +//GO(_XimFreeProtoIntrCallback, +//GO(_XimFreeTransIntrCallback, +//GO(_XimGetAttributeID, +//GO(_XimGetCharCode, +//GO(_XimGetCurrentICValues, +//GO(_XimGetCurrentIMValues, +//GO(_XimGetICValueData, +//GO(_XimGetIMValueData, +//GO(_XimGetLocaleCode, +//GO(_XimGetMyEndian, +//GO(_XimGetResourceListRec, +//GO(_XimGetResourceListRecByQuark, +//GO(_XimGetWindowEventmask, +//GO(_XimICOfXICID, +//DATA(_XimImSportRec, +//GO(_XimInitialResourceInfo, +//GO(_XimLcctstombs, +//GO(_XimLcctstoutf8, +//GO(_XimLcctstowcs, +//GO(_XimLocalCreateIC, +//GO(_XimLocalFilter, +//GO(_XimLocalGetICValues, +//GO(_XimLocalGetIMValues, +//GO(_XimLocalIMFree, +//GO(_XimLocalMbLookupString, +//GO(_XimLocalOpenIM, +//GO(_XimLocalSetICValues, +//GO(_XimLocalSetIMValues, +//GO(_XimLocalUtf8LookupString, +//GO(_XimLocalWcLookupString, +//GO(_XimLookupMBText, +//GO(_XimLookupUTF8Text, +//GO(_XimLookupWCText, +//GO(_XimMakeICAttrIDList, +//GO(_XimMakeIMAttrIDList, +//GO(XIMOfIC, pFp) +//GO(_XimOpenIM, +//GO(_XimParseStringFile, +//GO(_XimProcError, +//GO(_XimProcSyncReply, +//GO(_XimProtoCreateIC, +//GO(_XimProtoEventToWire, +//GO(_XimProtoIMFree, +//GO(_XimProtoMbLookupString, +//GO(_XimProtoOpenIM, +//GO(_XimProtoUtf8LookupString, +//GO(_XimProtoWcLookupString, +//GO(_XimProtoWireToEvent, +//GO(_XimRead, +//GO(_XimRegisterDispatcher, +//GO(_XimRegisterFilter, +//GO(_XimRegisterIMInstantiateCallback, +//GO(_XimRegisterServerFilter, +//GO(_XimRegisterTriggerKeysCallback, +//GO(_XimRegProtoIntrCallback, +//GO(_XimReregisterFilter, +//GO(_XimResetIMInstantiateCallback, +//GO(_XimRespSyncReply, +//GO(_XimServerDestroy, +//GO(_XimSetCurrentICValues, +//GO(_XimSetCurrentIMValues, +//GO(_XimSetEventMaskCallback, +//GO(_XimSetHeader, +//GO(_XimSetICDefaults, +//GO(_XimSetICMode, +//GO(_XimSetICResourceList, +//GO(_XimSetICValueData, +//GO(_XimSetIMMode, +//GO(_XimSetIMResourceList, +//GO(_XimSetIMValueData, +//GO(_XimSetInnerICResourceList, +//GO(_XimSetInnerIMResourceList, +//GO(_XimSetLocalIMDefaults, +//GO(_XimShutdown, +//GO(_XimSync, +//GO(_XimSyncCallback, +//GO(_XimThaiCloseIM, +//GO(_XimThaiCreateIC, +//GO(_XimThaiFilter, +//GO(_XimThaiIMFree, +//GO(_XimThaiOpenIM, +//GO(_XimTransCallDispatcher, +//GO(_XimTransConf, +//GO(_XimTransFilterWaitEvent, +//GO(_XimTransFlush, +//GO(_XimTransInternalConnection, +//DATA(_XimTransportRec, +//GO(_XimTransRead, +//GO(_XimTransRegisterDispatcher, +//GO(_XimTransWrite, +//GO(_XimTriggerNotify, +//GO(_XimUnregisterFilter, +//GO(_XimUnRegisterIMInstantiateCallback, +//GO(_XimUnregisterServerFilter, +//GO(_XimWrite, +//GO(_XimXConf, +//GO(_XimXTransBytesReadable, +//GO(_XimXTransClose, +//GO(_XimXTransCloseForCloning, +//GO(_XimXTransConnect, +//GO(_XimXTransDisconnect, +//GO(_XimXTransFreeConnInfo, +//GO(_XimXTransGetConnectionNumber, +//GO(_XimXTransGetHostname, +//GO(_XimXTransGetPeerAddr, +//GO(_XimXTransIsLocal, +//GO(_XimXTransOpenCOTSClient, +//GO(_XimXTransRead, +//GO(_XimXTransReadv, +//GO(_XimXTransSetOption, +DATA(_XimXTransSocketINET6Funcs, 4) +DATA(_XimXTransSocketINETFuncs, 4) +DATA(_XimXTransSocketLocalFuncs, 4) +DATA(_XimXTransSocketTCPFuncs, 4) +DATA(_XimXTransSocketUNIXFuncs, 4) +//GO(_XimXTransWrite, +//GO(_XimXTransWritev, +DATAB(_XInitDisplayLock_fn, 4) +//GO(XInitExtension, pFpp) +//GO(_XInitIM, +GOM(XInitImage, iFEp) +GOM(_XInitImageFuncPtrs, iFEp) +//GO(_XInitKeysymDB, +//GO(_XInitOM, +GO(XInitThreads, iFv) +//GO(XInsertModifiermapEntry, pFpCi) +//GO(XInstallColormap, iFpL) +//GO(XInternalConnectionNumbers, iFppp) +//GO(XInternAtom, LFppi) +//GO(XInternAtoms, iFppiip) +//GO(XIntersectRegion, iFppp) +//GO(_XIOError, iFp) +//DATAB(_XIOErrorFunction, 4) +//GO(_XIsEventCookie, iFpp) +//GO(XkbAddDeviceLedInfo, pFpuu) +//GO(XkbAddGeomColor, pFppu) +//GO(XkbAddGeomDoodad, pFppL) +//GO(XkbAddGeomKey, pFp) +//GO(XkbAddGeomKeyAlias, pFppp) +//GO(XkbAddGeomOutline, pFpi) +//GO(XkbAddGeomOverlay, pFpLi) +//GO(XkbAddGeomOverlayKey, pFpppp) +//GO(XkbAddGeomOverlayRow, pFpii) +//GO(XkbAddGeomProperty, pFppp) +//GO(XkbAddGeomRow, pFpi) +//GO(XkbAddGeomSection, pFpLiii) +//GO(XkbAddGeomShape, pFpLi) +//GO(XkbAddKeyType, pFpLiii) +//GO(XkbAllocClientMap, iFpuu) +//GO(XkbAllocCompatMap, iFpuu) +//GO(XkbAllocControls, iFpu) +//GO(XkbAllocDeviceInfo, pFuuu) +//GO(XkbAllocGeomColors, iFpi) +//GO(XkbAllocGeomDoodads, iFpi) +//GO(XkbAllocGeometry, iFpp) +//GO(XkbAllocGeomKeyAliases, iFpi) +//GO(XkbAllocGeomKeys, iFpi) +//GO(XkbAllocGeomOutlines, iFpi) +//GO(XkbAllocGeomOverlayKeys, iFpi) +//GO(XkbAllocGeomOverlayRows, iFpi) +//GO(XkbAllocGeomOverlays, iFpi) +//GO(XkbAllocGeomPoints, iFpi) +//GO(XkbAllocGeomProps, iFpi) +//GO(XkbAllocGeomRows, iFpi) +//GO(XkbAllocGeomSectionDoodads, iFpi) +//GO(XkbAllocGeomSections, iFpi) +//GO(XkbAllocGeomShapes, iFpi) +//GO(XkbAllocIndicatorMaps, iFp) +//GO(XkbAllocKeyboard, pFv) +//GO(XkbAllocNames, iFpuii) +//GO(XkbAllocServerMap, iFpuu) +//GO(XkbApplyCompatMapToKey, iFpCp) +//GO(XkbApplyVirtualModChanges, iFpup) +//GO(XkbBell, iFpLiL) +//GO(XkbBellEvent, iFpLiL) +//GO(XkbChangeDeviceInfo, iFppp) +//GO(XkbChangeEnabledControls, iFpuuu) +//GO(XkbChangeKeycodeRange, iFpiip) +//GO(XkbChangeMap, iFppp) +//GO(XkbChangeNames, iFppp) +//GO(XkbChangeTypesOfKey, iFpiiupp) +//GO(XkbComputeEffectiveMap, iFppp) +//GO(XkbComputeRowBounds, iFppp) +//GO(XkbComputeSectionBounds, iFpp) +//GO(XkbComputeShapeBounds, iFp) +//GO(XkbComputeShapeTop, iFpp) +//GO(_XkbCopyFromReadBuffer, +//GO(XkbCopyKeyType, iFpp) +//GO(XkbCopyKeyTypes, iFppi) +//GO(XkbDeviceBell, iFpLiiiiL) +//GO(XkbDeviceBellEvent, iFpLiiiiL) +//GO(XkbFindOverlayForKey, pFppp) +//GO(XkbForceBell, iFpi) +//GO(XkbForceDeviceBell, iFpiiii) +//GO(XkbFreeClientMap, vFpui) +//GO(XkbFreeCompatMap, vFpui) +//GO(XkbFreeComponentList, vFp) +//GO(XkbFreeControls, vFpui) +//GO(XkbFreeDeviceInfo, vFpui) +//GO(XkbFreeGeomColors, vFpiii) +//GO(XkbFreeGeomDoodads, vFpii) +//GO(XkbFreeGeometry, vFpui) +//GO(XkbFreeGeomKeyAliases, vFpiii) +//GO(XkbFreeGeomKeys, vFpiii) +//GO(XkbFreeGeomOutlines, vFpiii) +//GO(XkbFreeGeomOverlayKeys, vFpiii) +//GO(XkbFreeGeomOverlayRows, vFpiii) +//GO(XkbFreeGeomOverlays, vFpiii) +//GO(XkbFreeGeomPoints, vFpiii) +//GO(XkbFreeGeomProperties, vFpiii) +//GO(XkbFreeGeomRows, vFpiii) +//GO(XkbFreeGeomSections, vFpiii) +//GO(XkbFreeGeomShapes, vFpiii) +//GO(XkbFreeIndicatorMaps, vFp) +//GO(XkbFreeKeyboard, vFpui) +//GO(XkbFreeNames, vFpui) +//GO(_XkbFreeReadBuffer, +//GO(XkbFreeServerMap, vFpui) +//DATA(_XkbGetAtomNameFunc, 4) +//GO(XkbGetAutoRepeatRate, iFpupp) +//GO(XkbGetAutoResetControls, iFppp) +//GO(_XkbGetCharset, +//GO(XkbGetCompatMap, iFpup) +//GO(XkbGetControls, iFpLp) +//GO(_XkbGetConverters, +//GO(XkbGetDetectableAutoRepeat, iFpp) +//GO(XkbGetDeviceButtonActions, iFppiuu) +//GO(XkbGetDeviceInfo, pFpuuuu) +//GO(XkbGetDeviceInfoChanges, iFppp) +//GO(XkbGetDeviceLedInfo, iFppuuu) +//GO(XkbGetGeometry, iFpp) +//GO(XkbGetIndicatorMap, iFpLp) +//GO(XkbGetIndicatorState, iFpup) +//GO(XkbGetKeyActions, iFpuup) +//GO(XkbGetKeyBehaviors, iFpuup) +//GO(XkbGetKeyboard, pFpuu) +//GO(XkbGetKeyboardByName, pFpupuui) +//GO(XkbGetKeyExplicitComponents, iFpuup) +//GO(XkbGetKeyModifierMap, iFpuup) +//GO(XkbGetKeySyms, iFpuup) +//GO(XkbGetKeyTypes, iFpuup) +//GO(XkbGetKeyVirtualModMap, iFpuup) +//GO(XkbGetMap, pFpuu) +//GO(XkbGetMapChanges, iFppp) +//GO(XkbGetNamedDeviceIndicator, iFpuuuLpppp) +//GO(XkbGetNamedGeometry, iFppL) +//GO(XkbGetNamedIndicator, iFpLpppp) +//GO(XkbGetNames, iFpup) +//GO(XkbGetPerClientControls, iFpp) +//GO(_XkbGetReadBufferCountedString, +//GO(_XkbGetReadBufferPtr, +//GO(XkbGetState, iFpup) +//GO(XkbGetUpdatedMap, iFpup) +//GO(XkbGetVirtualMods, iFpup) +//GO(XkbGetXlibControls, uFp) +//GO(XkbIgnoreExtension, iFi) +//GO(XkbInitCanonicalKeyTypes, iFpui) +//GO(_XkbInitReadBuffer, +//DATA(_XkbInternAtomFunc, 4) +//GO(XkbKeycodeToKeysym, LFpCii) +//GO(XkbKeysymToModifiers, uFpL) +//GO(XkbKeyTypesForCoreSymbols, iFpipupp) +//GO(XkbLatchGroup, iFpuu) +//GO(XkbLatchModifiers, iFpuuu) +//GO(XkbLibraryVersion, iFpp) +//GO(XkbListComponents, pFpupp) +//GO(XkbLockGroup, iFpuu) +//GO(XkbLockModifiers, iFpuuu) +//GO(XkbLookupKeyBinding, iFpLupip) +//GO(XkbLookupKeySym, iFpCupp) +//GO(XkbNoteControlsChanges, vFppu) +//GO(_XkbNoteCoreMapChanges, +//GO(XkbNoteDeviceChanges, vFppu) +//GO(XkbNoteMapChanges, vFppu) +//GO(XkbNoteNameChanges, vFppu) +//GO(XkbOpenDisplay, pFpppppp) +//GO(_XkbPeekAtReadBuffer, +//GO(XkbQueryExtension, iFpppppp) +//GO(_XkbReadBufferCopy32, +//GO(_XkbReadBufferCopyKeySyms, +//GO(_XkbReadCopyData32, +//GO(_XkbReadCopyKeySyms, +//GO(_XkbReadGetCompatMapReply, +//GO(_XkbReadGetGeometryReply, +//GO(_XkbReadGetIndicatorMapReply, +//GO(_XkbReadGetMapReply, +//GO(_XkbReadGetNamesReply, +//GO(XkbRefreshKeyboardMapping, iFp) +//GO(_XkbReloadDpy, +//GO(XkbResizeDeviceButtonActions, iFpu) +//GO(XkbResizeKeyActions, pFpii) +//GO(XkbResizeKeySyms, pFpii) +//GO(XkbResizeKeyType, iFpiiii) +//GO(XkbSelectEventDetails, iFpuuLL) +//GO(XkbSelectEvents, iFpuuu) +//GOM(XkbSetAtomFuncs, vFEpp) +//GO(XkbSetAutoRepeatRate, iFpuuu) +//GO(XkbSetAutoResetControls, iFpupp) +//GO(XkbSetCompatMap, iFpupi) +//GO(XkbSetControls, iFpLp) +//GO(XkbSetDebuggingFlags, iFpuupuupp) +//GO(XkbSetDetectableAutoRepeat, iFpip) +//GO(XkbSetDeviceButtonActions, iFppuu) +//GO(XkbSetDeviceInfo, iFpup) +//GO(XkbSetDeviceLedInfo, iFppuuu) +//GO(XkbSetGeometry, iFpup) +//GO(XkbSetIgnoreLockMods, iFpuuuuu) +//GO(XkbSetIndicatorMap, iFpLp) +//GO(XkbSetMap, iFpup) +//GO(XkbSetNamedDeviceIndicator, iFpuuuLiiip) +//GO(XkbSetNamedIndicator, iFpLiiip) +//GO(XkbSetNames, iFpuuup) +//GO(XkbSetPerClientControls, iFpup) +//GO(XkbSetServerInternalMods, iFpuuuuu) +//GO(XkbSetXlibControls, uFpuu) +//GO(_XkbSkipReadBufferData, +//GO(XkbToControl, cFc) +//GO(XkbTranslateKey, +//GO(XkbTranslateKeyCode, iFpCupp) +//GO(XkbTranslateKeySym, iFppupip) +//GO(XkbUpdateActionVirtualMods, iFppu) +//GO(XkbUpdateKeyTypeVirtualMods, vFppup) +//GO(XkbUpdateMapFromCore, iFpCiipp) +//GO(XkbUseExtension, iFppp) +//GO(XkbVirtualModsToReal, iFpup) +//GO(_XkbWriteCopyData32, +//GO(_XkbWriteCopyKeySyms, +//GO(XkbXlibControlsImplemented, uFv) +//GO(_XKeycodeToKeysym, +GO(XKeycodeToKeysym, LFXCi) +//GO(_XKeyInitialize, +//GO(_XKeysymToKeycode, +//GO(XKeysymToKeycode, CFpL) +//GO(_XKeysymToModifiers, +//GO(XKeysymToString, pFL) +//DATA(_XkeyTable, +//GO(XKillClient, iFpL) +//GO(XLastKnownRequestProcessed, LFp) +//GO(_XlcAddCharSet, +//GO(_XlcAddCT, +//GO(_XlcAddGB18030LocaleConverters, +//GO(_XlcAddLoader, +//GO(_XlcAddUtf8Converters, +//GO(_XlcAddUtf8LocaleConverters, +//GO(_XlcCloseConverter, +//GO(_XlcCompareISOLatin1, +//GO(_XlcCompileResourceList, +//GO(_XlcConvert, +//GO(_XlcCopyFromArg, +//GO(_XlcCopyToArg, +//GO(_XlcCountVaList, +//GO(_XlcCreateDefaultCharSet, +//GO(_XlcCreateLC, +//GO(_XlcCreateLocaleDataBase, +//GO(_XlcCurrentLC, +//GO(_XlcDbg_printValue, +//GO(_XlcDefaultLoader, +//GO(_XlcDefaultMapModifiers, +//GO(_XlcDeInitLoader, +//GO(_XlcDestroyLC, +//GO(_XlcDestroyLocaleDataBase, +//GO(_XlcFileName, +//GO(_XlcGenericLoader, +DATA(_XlcGenericMethods, 4) +//GO(_XlcGetCharSet, +//GO(_XlcGetCharSetWithSide, +//GO(_XlcGetCSValues, +//GO(_XlcGetLocaleDataBase, +//GO(_XlcGetResource, +//GO(_XlcGetValues, +//GO(_XlcInitCTInfo, +//GO(_XlcInitLoader, +//GO(_XlcLocaleDirName, +//GO(_XlcLocaleLibDirName, +//GO(_XlcMapOSLocaleName, +//GO(_Xlcmbstoutf8, +//GO(_Xlcmbstowcs, +//GO(_Xlcmbtowc, +//GO(_XlcNCompareISOLatin1, +//GO(_XlcOpenConverter, +//GO(_XlcParseCharSet, +//GO(_XlcParse_scopemaps, +DATA(_XlcPublicMethods, 4) +//GO(_XlcRemoveLoader, +//GO(_XlcResetConverter, +//GO(_XlcResolveI18NPath, +//GO(_XlcResolveLocaleName, +//GO(_XlcSetConverter, +//GO(_XlcSetValues, +//GO(_XlcUtf8Loader, +//GO(_XlcValidModSyntax, +//GO(_XlcVaToArgList, +//GO(_Xlcwcstombs, +//GO(_Xlcwctomb, +//GO(XListDepths, pFpip) +//GO(XListExtensions, pFpp) +//GO(XListFonts, pFppip) +//GO(XListFontsWithInfo, pFppipp) +//GO(XListHosts, pFppp) +//GO(XListInstalledColormaps, pFpLp) +//GO(XListPixmapFormats, pFpp) +//GO(XListProperties, pFpLp) +//GO(XLoadFont, LFpp) +//GO(XLoadQueryFont, pFpp) +//GO(xlocaledir, vFpi) +//GO(XLocaleOfFontSet, pFp) +//GO(XLocaleOfIM, pFp) +//GO(XLocaleOfOM, pFp) +GO(XLockDisplay, vFX) +DATAB(_XLockMutex_fn, 4) +//GO(XLookupColor, iFpLppp) +//GO(_XLookupKeysym, +//GO(XLookupKeysym, LFpi) +//GO(_XLookupString, +//GO(XLookupString, iFppipp) +GO(XLowerWindow, iFXL) +GO(XMapRaised, iFXL) +GO(XMapSubwindows, iFXL) +//GO(XMapWindow, iFpL) +//GO(XMaskEvent, iFplp) +//GO(XMatchVisualInfo, iFpiiip) +//GO(XMaxCmapsOfScreen, iFp) +//GO(XMaxRequestSize, lFp) +//GO(_XmbDefaultDrawImageString, +//GO(_XmbDefaultDrawString, +//GO(_XmbDefaultTextEscapement, +//GO(_XmbDefaultTextExtents, +//GO(_XmbDefaultTextPerCharExtents, +//GO(XmbDrawImageString, vFpLppiipi) +//GO(XmbDrawString, vFpLppiipi) +//GO(XmbDrawText, vFpLpiipi) +//GO(_XmbGenericDrawImageString, +//GO(_XmbGenericDrawString, +//GO(_XmbGenericTextEscapement, +//GO(_XmbGenericTextExtents, +//GO(_XmbGenericTextPerCharExtents, +//GO(_Xmblen, iFpi) +//GO(XmbLookupString, iFpppipp) +//GO(XmbResetIC, pFp) +//GO(XmbSetWMProperties, vFpLpppippp) +//GO(_Xmbstoutf8, +//GO(_Xmbstowcs, +//GO(XmbTextEscapement, iFppi) +//GO(XmbTextExtents, iFppipp) +//GO(_XmbTextListToTextProperty, +//GO(XmbTextListToTextProperty, iFppiup) +//GO(XmbTextPerCharExtents, iFppippippp) +//GO(_XmbTextPropertyToTextList, +//GO(XmbTextPropertyToTextList, iFpppp) +//GO(_Xmbtowc, iFppi) +//GO(XMinCmapsOfScreen, iFp) +//GO(XMoveResizeWindow, iFpLiiuu) +//GO(XMoveWindow, iFpLii) +//GO(XNewModifiermap, pFi) +GOM(XNextEvent, iFEXp) +//GO(XNextRequest, LFp) +//GO(XNoOp, iFp) +//GO(_XNoticeCreateBitmap, +//GO(_XNoticePutBitmap, +//GO(XOffsetRegion, iFpii) +//GO(_XomConvert, +//GO(_XomGenericDrawString, +//GO(_XomGenericOpenOM, +//GO(_XomGenericTextExtents, +//GO(_XomGetFontDataFromFontSet, +//GO(_XomInitConverter, +//GO(XOMOfOC, pFp) +GOM(XOpenDisplay, pFEp) +//GO(XOpenIM, pFpppp) +//GO(_XOpenLC, +//GO(XOpenOM, pFpppp) +//GO(_XParseBaseFontNameList, +GO(XParseColor, iFXLpBhWcc_) +//GO(XParseGeometry, iFppppp) +//GO(XPeekEvent, iFpp) +//GOM(XPeekIfEvent, iFEpppp) +GO(XPending, iFX) +//GO(Xpermalloc, pFu) +//GO(XPlanesOfScreen, iFp) +//GO(XPointInRegion, iFpii) +//GO(_XPollfdCacheAdd, vFpi) +//GO(_XPollfdCacheDel, vFpi) +//GO(_XPollfdCacheInit, iFp) +//GO(XPolygonRegion, pFpii) +//GOM(_XProcessInternalConnection, vFEpp) +//GO(XProcessInternalConnection, vFpi) +//GO(_XProcessWindowAttributes, vFppLp) +//GO(XProtocolRevision, iFp) +//GO(XProtocolVersion, iFp) +//GO(_XPutBackEvent, iFpp) +//GO(XPutBackEvent, iFpp) +GOM(XPutImage, iFEXLppiiiiuu) +GO(XPutPixel, vFXiiL) +//GO(XQLength, iFp) +//GO(XQueryBestCursor, iFpLuupp) +//GO(XQueryBestSize, iFpiLuupp) +//GO(XQueryBestStipple, iFpLuupp) +//GO(XQueryBestTile, iFpLuupp) +//GO(XQueryColor, iFpLp) +//GO(XQueryColors, iFpLpi) +//GOM(XQueryExtension, iFEppppp) +//GO(XQueryFont, pFpL) +//GO(XQueryKeymap, iFpp) +//GO(XQueryPointer, iFpLppppppp) +//GO(XQueryTextExtents, iFpLpipppp) +//GO(XQueryTextExtents16, iFpLpipppp) +//GO(XQueryTree, iFpLpppp) +//GO(XRaiseWindow, iFpL) +//GO(_XRead, iFppl) +//GO(XReadBitmapFile, iFpLpppppp) +//GO(XReadBitmapFileData, iFpppppp) +//GO(_XReadEvents, vFp) +//GO(_XReadPad, vFppl) +//GO(XRebindKeysym, iFpLpipi) +//GO(XRecolorCursor, iFpLpp) +//GO(XReconfigureWMWindow, iFpLiup) +//GO(XRectInRegion, iFpiiuu) +//GO(_XRefreshKeyboardMapping, +//GO(XRefreshKeyboardMapping, iFp) +//GO(_XRegisterFilterByMask, +//GO(_XRegisterFilterByType, +//GOM(XRegisterIMInstantiateCallback, iFEpppppp) +//GOM(_XRegisterInternalConnection, iFEpipp) +//GOM(XRemoveConnectionWatch, vFEppp) +//GO(XRemoveFromSaveSet, iFpL) +//GO(XRemoveHost, iFpp) +//GO(XRemoveHosts, iFppi) +//GO(XReparentWindow, iFpLLii) +//GO(_XReply, iFppii) +//GO(XResetScreenSaver, iFp) +//GO(XResizeWindow, iFpLuu) +//GO(XResourceManagerString, pFp) +//GO(XRestackWindows, iFppi) +//GO(_XReverse_Bytes, +//GO(XrmCombineDatabase, vFppi) +//GO(XrmCombineFileDatabase, iFppi) +//GO(_XrmDefaultInitParseInfo, +//GO(XrmDestroyDatabase, vFp) +//GOM(XrmEnumerateDatabase, iFEpppipp) +//GO(XrmGetDatabase, pFp) +//GO(XrmGetFileDatabase, pFp) +//GO(XrmGetResource, iFppppp) +//GO(XrmGetStringDatabase, pFp) +//GO(XrmInitialize, vFv) +//GO(_XrmInitParseInfo, +//GO(_XrmInternalStringToQuark, +//GO(XrmLocaleOfDatabase, pFp) +//GO(XrmMergeDatabases, vFpp) +//GO(XrmParseCommand, vFppippp) +//GO(XrmPermStringToQuark, iFp) +//GO(XrmPutFileDatabase, vFpp) +//GO(XrmPutLineResource, vFpp) +//GO(XrmPutResource, vFpppp) +//GO(XrmPutStringResource, vFppp) +//GO(XrmQGetResource, iFppppp) +//GO(XrmQGetSearchList, iFppppi) +//GO(XrmQGetSearchResource, iFpiipp) +//GO(XrmQPutResource, vFpppip) +//GO(XrmQPutStringResource, vFpppp) +//GO(XrmQuarkToString, pFi) +//GO(XrmSetDatabase, vFpp) +//GO(XrmStringToBindingQuarkList, vFppp) +//GO(XrmStringToQuark, iFp) +//GO(XrmStringToQuarkList, vFpp) +//GO(XrmUniqueQuark, iFv) +//GO(XRootWindow, LFpi) +//GO(XRootWindowOfScreen, LFp) +//GO(XRotateBuffers, iFpi) +//GO(XRotateWindowProperties, iFpLpii) +//GO(XSaveContext, iFpLip) +//GO(XScreenCount, iFp) +//GO(XScreenNumberOfScreen, iFp) +//GO(XScreenOfDisplay, pFpi) +//GO(_XScreenOfWindow, pFpL) +//GO(XScreenResourceString, pFp) +//GO(XSelectInput, iFpLl) +//GO(_XSend, vFppl) +//GO(XSendEvent, iFpLilp) +//GO(XServerVendor, pFp) +//GO(XSetAccessControl, iFpi) +//GOM(XSetAfterFunction, pFEpp) +//GO(XSetArcMode, iFppi) +//GO(XSetAuthorization, vFpipi) +//GO(XSetBackground, iFppL) +//GO(XSetClassHint, iFpLp) +//GO(XSetClipMask, iFppL) +//GO(XSetClipOrigin, iFppii) +//GO(_XSetClipRectangles, vFppiipii) +//GO(XSetClipRectangles, iFppiipii) +//GO(XSetCloseDownMode, iFpi) +//GO(XSetCommand, iFpLpi) +//GO(XSetDashes, iFppipi) +//GOM(XSetErrorHandler, pFEp) +//GO(XSetFillRule, iFppi) +//GO(XSetFillStyle, iFppi) +//GO(XSetFont, iFppL) +//GO(XSetFontPath, iFppi) +//GO(XSetForeground, iFppL) +//GO(XSetFunction, iFppi) +//GO(XSetGraphicsExposures, iFppi) +//GO(XSetICFocus, vFp) +//GO(XSetIconName, iFpLp) +//GO(XSetIconSizes, iFpLpi) +//GOM(XSetICValues, pFEpV) +//GO(_XSetImage, +//GOM(XSetIMValues, pFEpV) +//GO(XSetInputFocus, iFpLiL) +//GOM(XSetIOErrorExitHandler, vFEppp) +//GOM(XSetIOErrorHandler, pFEp) +//GO(_XSetLastRequestRead, LFpp) +//GO(XSetLineAttributes, iFppuiii) +//GO(XSetLocaleModifiers, pFp) +//GO(XSetModifierMapping, iFpp) +//GO(XSetNormalHints, iFpLp) +//GO(XSetOCValues, pFpppppppppppppppp) // use vaarg +//GO(XSetOMValues, pFpppppppppppppppp) // use vaarg +//GO(XSetPlaneMask, iFppL) +//GO(XSetPointerMapping, iFppi) +//GO(XSetRegion, iFppp) +//GO(XSetRGBColormaps, vFpLpiL) +//GO(XSetScreenSaver, iFpiiii) +//GO(XSetSelectionOwner, iFpLLL) +//GO(XSetSizeHints, iFpLpL) +//GO(XSetStandardColormap, vFpLpL) +//GO(XSetStandardProperties, iFpLppLpip) +//GO(XSetState, iFppLLiL) +//GO(XSetStipple, iFppL) +//GO(XSetSubwindowMode, iFppi) +//GO(XSetTextProperty, vFpLpL) +//GO(XSetTile, iFppL) +//GO(XSetTransientForHint, iFpLL) +//GO(XSetTSOrigin, iFppii) +//GO(XSetWindowBackground, iFpLL) +//GO(XSetWindowBackgroundPixmap, iFpLL) +//GO(XSetWindowBorder, iFpLL) +//GO(XSetWindowBorderPixmap, iFpLL) +//GO(XSetWindowBorderWidth, iFpLu) +//GO(XSetWindowColormap, iFpLL) +//GO(XSetWMClientMachine, vFpLp) +//GO(XSetWMColormapWindows, iFpLpi) +//GO(XSetWMHints, iFpLp) +//GO(XSetWMIconName, vFpLp) +//GO(XSetWMName, vFpLp) +//GO(XSetWMNormalHints, vFpLp) +//GO(XSetWMProperties, vFpLpppippp) +//GO(XSetWMProtocols, iFpLpi) +//GO(XSetWMSizeHints, vFpLpL) +//GO(XSetZoomHints, iFpLp) +//GO(XShrinkRegion, iFpii) +//GO(XStoreBuffer, iFppii) +//GO(XStoreBytes, iFppi) +//GO(XStoreColor, iFpLp) +//GO(XStoreColors, iFpLpi) +//GO(_XStoreEventCookie, vFpp) +GO(XStoreName, iFXLp) +//GO(XStoreNamedColor, iFpLpLi) +//GO(XStringListToTextProperty, iFpip) +//GO(XStringToKeysym, LFp) +GOM(XSubImage, pFEpiiuu) // need unbridging +GO(dummy_XSubImage, pFpiiuu) // for the wrapper +//GO(XSubtractRegion, iFppp) +//GO(XSupportsLocale, iFv) +//GO(XSync, iFpi) +//GOM(XSynchronize, pFEpi) +//GO(XTextExtents, iFppipppp) +//GO(XTextExtents16, iFppipppp) +//GO(_XTextHeight, iFppi) +//GO(_XTextHeight16, iFppi) +//GO(XTextPropertyToStringList, iFppp) +//GO(XTextWidth, iFppi) +//GO(XTextWidth16, iFppi) +//DATAB(_Xthread_self_fn, 4) +//GO(XTranslateCoordinates, iFpLLiippp) +//GO(_XTranslateKey, +//GO(_XTranslateKeySym, +//GO(_XTryShapeBitmapCursor, +GO(XUndefineCursor, iFXL) +//GO(XUngrabButton, iFpuuL) +//GO(XUngrabKey, iFpiuL) +//GO(XUngrabKeyboard, iFpL) +//GO(XUngrabPointer, iFpL) +//GO(XUngrabServer, iFp) +//GO(XUninstallColormap, iFpL) +//GO(XUnionRectWithRegion, iFppp) +//GO(XUnionRegion, iFppp) +//GO(_XUnknownCopyEventCookie, iFppp) +//GO(_XUnknownNativeEvent, iFppp) +//GO(_XUnknownWireEvent, iFppp) +//GO(_XUnknownWireEventCookie, iFppp) +//GO(XUnloadFont, iFpL) +GO(XUnlockDisplay, vFX) +DATAM(_XUnlockMutex_fn, 4) +//GO(XUnmapSubwindows, iFpL) +//GO(XUnmapWindow, iFpL) +//GO(_XUnregisterFilter, +//GOM(XUnregisterIMInstantiateCallback, iFEpppppp) +//GO(_XUnregisterInternalConnection, vFpi) +//GO(_XUnresolveColor, +//GO(XUnsetICFocus, vFp) +//GO(_XUpdateAtomCache, +//GO(_XUpdateGCCache, +//GO(_Xutf8DefaultDrawImageString, +//GO(_Xutf8DefaultDrawString, +//GO(_Xutf8DefaultTextEscapement, +//GO(_Xutf8DefaultTextExtents, +//GO(_Xutf8DefaultTextPerCharExtents, +//GO(Xutf8DrawImageString, vFpLppiipi) +//GO(Xutf8DrawString, vFpLppiipi) +//GO(Xutf8DrawText, vFpLpiipi) +//GO(_Xutf8GenericDrawImageString, +//GO(_Xutf8GenericDrawString, +//GO(_Xutf8GenericTextEscapement, +//GO(_Xutf8GenericTextExtents, +//GO(_Xutf8GenericTextPerCharExtents, +//GO(Xutf8LookupString, iFpppipp) +//GO(Xutf8ResetIC, pFp) +//GO(Xutf8SetWMProperties, vFpLpppippp) +//GO(Xutf8TextEscapement, iFppi) +//GO(Xutf8TextExtents, iFppipp) +//GO(_Xutf8TextListToTextProperty, +//GO(Xutf8TextListToTextProperty, iFppiup) +//GO(Xutf8TextPerCharExtents, iFppippippp) +//GO(_Xutf8TextPropertyToTextList, +//GO(Xutf8TextPropertyToTextList, iFpppp) +//GOM(XVaCreateNestedList, pFEiV) +//GO(XVendorRelease, iFp) +//GO(_XVIDtoVisual, pFpL) +//GO(XVisualIDFromVisual, LFp) +//GO(XWarpPointer, iFpLLiiuuii) +//GO(_XwcDefaultDrawImageString, +//GO(_XwcDefaultDrawString, +//GO(_XwcDefaultTextEscapement, +//GO(_XwcDefaultTextExtents, +//GO(_XwcDefaultTextPerCharExtents, +//GO(XwcDrawImageString, vFpLppiipi) +//GO(XwcDrawString, vFpLppiipi) +//GO(XwcDrawText, vFpLpiipi) +//GO(_XwcFreeStringList, +//GO(XwcFreeStringList, vFp) +//GO(_XwcGenericDrawImageString, +//GO(_XwcGenericDrawString, +//GO(_XwcGenericTextEscapement, +//GO(_XwcGenericTextExtents, +//GO(_XwcGenericTextPerCharExtents, +//GO(XwcLookupString, iFpppipp) +//GO(XwcResetIC, pFp) +//GO(_Xwcscmp, +//GO(_Xwcscpy, +//GO(_Xwcslen, +//GO(_Xwcsncmp, +//GO(_Xwcsncpy, +//GO(_Xwcstombs, +//GO(XwcTextEscapement, iFppi) +//GO(XwcTextExtents, iFppipp) +//GO(_XwcTextListToTextProperty, +//GO(XwcTextListToTextProperty, iFppiup) +//GO(XwcTextPerCharExtents, iFppippippp) +//GO(_XwcTextPropertyToTextList, +//GO(XwcTextPropertyToTextList, iFpppp) +//GO(_Xwctomb, iFpi) +//GO(XWhitePixel, LFpi) +//GO(XWhitePixelOfScreen, LFp) +//GO(XWidthMMOfScreen, iFp) +//GO(XWidthOfScreen, iFp) +//GO(XWindowEvent, iFpLlp) +//GO(_XWireToEvent, iFppp) +//GO(XWithdrawWindow, iFpLi) +//GO(XWMGeometry, iFpippupppppp) +//GO(XWriteBitmapFile, iFppLuuii) +//GO(XXorRegion, iFppp) + +//GO(_XData32, iFppu) +//GO(_XRead32, vFppl) + +GO(dummy_putpixel, iFpiiL) +GO(dummy_addpixel, iFpl) +GO(dummy_vFp, vFp) \ No newline at end of file |