121 lines
6.1 KiB
C
121 lines
6.1 KiB
C
#include "x11m4.h"
|
|
|
|
/*
|
|
* Byte offsets are C offsets; the TMS34010 ROM's indirect displacements are
|
|
* bit offsets, so every layout_* function below returns offset * 8. The one
|
|
* exception is layout_event_size(), which reports sizeof(XEvent) in bytes
|
|
* because the termtris buffer is sized in bytes (vt_u32 evbuf[24]).
|
|
*/
|
|
_Static_assert(sizeof(void *) == 4, "the VT1200 X11 ABI is 32-bit");
|
|
_Static_assert(sizeof(long) == 4, "the VT1200 X11 ABI is 32-bit");
|
|
_Static_assert(sizeof(XID) == 4, "XID must be 32-bit");
|
|
_Static_assert(sizeof(Time) == 4, "Time must be 32-bit");
|
|
|
|
_Static_assert(__builtin_offsetof(Display, screens) == 0x90,
|
|
"Display.screens must be at byte 0x90 (bit 0x480)");
|
|
_Static_assert(__builtin_offsetof(Screen, root) == 0x8,
|
|
"Screen.root must be at byte 0x8 (bit 0x40)");
|
|
|
|
/* 32-bit X11R4 XImage: data 16, byte_order 20, bytes_per_line 40. */
|
|
_Static_assert(__builtin_offsetof(XImage, width) == 0, "XImage.width");
|
|
_Static_assert(__builtin_offsetof(XImage, height) == 4, "XImage.height");
|
|
_Static_assert(__builtin_offsetof(XImage, xoffset) == 8, "XImage.xoffset");
|
|
_Static_assert(__builtin_offsetof(XImage, format) == 12, "XImage.format");
|
|
_Static_assert(__builtin_offsetof(XImage, data) == 16,
|
|
"XImage.data must be at byte 16 (bit 0x80)");
|
|
_Static_assert(__builtin_offsetof(XImage, byte_order) == 20,
|
|
"XImage.byte_order must be at byte 20 (bit 0xA0)");
|
|
_Static_assert(__builtin_offsetof(XImage, bitmap_unit) == 24, "XImage.bitmap_unit");
|
|
_Static_assert(__builtin_offsetof(XImage, bitmap_bit_order) == 28,
|
|
"XImage.bitmap_bit_order");
|
|
_Static_assert(__builtin_offsetof(XImage, bitmap_pad) == 32, "XImage.bitmap_pad");
|
|
_Static_assert(__builtin_offsetof(XImage, depth) == 36, "XImage.depth");
|
|
_Static_assert(__builtin_offsetof(XImage, bytes_per_line) == 40,
|
|
"XImage.bytes_per_line must be at byte 40 (bit 0x140)");
|
|
_Static_assert(__builtin_offsetof(XImage, bits_per_pixel) == 44,
|
|
"XImage.bits_per_pixel must be at byte 44 (bit 0x160)");
|
|
_Static_assert(__builtin_offsetof(XImage, red_mask) == 48, "XImage.red_mask");
|
|
_Static_assert(__builtin_offsetof(XImage, green_mask) == 52, "XImage.green_mask");
|
|
_Static_assert(__builtin_offsetof(XImage, blue_mask) == 56, "XImage.blue_mask");
|
|
_Static_assert(__builtin_offsetof(XImage, obdata) == 60, "XImage.obdata");
|
|
_Static_assert(__builtin_offsetof(XImage, f) == 64,
|
|
"XImage.f must be at byte 64 (bit 0x200)");
|
|
_Static_assert(__builtin_offsetof(struct funcs, destroy_image) == 4,
|
|
"XImage.f.destroy_image must be 4 bytes into the inline funcs");
|
|
_Static_assert(__builtin_offsetof(XImage, f.destroy_image) == 68,
|
|
"XImage.f.destroy_image must be at byte 68 (bit 0x220)");
|
|
_Static_assert(sizeof(struct funcs) == 24, "the X11R4 funcs tail is six pointers");
|
|
_Static_assert(sizeof(XImage) == 88,
|
|
"sizeof(XImage) must cover the ROM's full inline-funcs object");
|
|
|
|
/* 32-bit X11R4 XErrorEvent: error_code 16, request_code 17, minor_code 18. */
|
|
_Static_assert(__builtin_offsetof(XErrorEvent, type) == 0, "XErrorEvent.type");
|
|
_Static_assert(__builtin_offsetof(XErrorEvent, display) == 4, "XErrorEvent.display");
|
|
_Static_assert(__builtin_offsetof(XErrorEvent, resourceid) == 8,
|
|
"XErrorEvent.resourceid");
|
|
_Static_assert(__builtin_offsetof(XErrorEvent, serial) == 12, "XErrorEvent.serial");
|
|
_Static_assert(__builtin_offsetof(XErrorEvent, error_code) == 16,
|
|
"XErrorEvent.error_code must be at byte 16 (bit 0x80)");
|
|
_Static_assert(__builtin_offsetof(XErrorEvent, request_code) == 17,
|
|
"XErrorEvent.request_code");
|
|
_Static_assert(__builtin_offsetof(XErrorEvent, minor_code) == 18,
|
|
"XErrorEvent.minor_code");
|
|
/* The packed object would be 19 bytes; one X11R4 object-size compatibility
|
|
* pad byte keeps the 32-bit object at 20. The client reads only the
|
|
* handler-passed fields. */
|
|
_Static_assert(sizeof(XErrorEvent) == 20, "sizeof(XErrorEvent) must be 20");
|
|
|
|
/* XEvent: type 0, xkey.window 16, xkey.keycode 52, xexpose.window 16, x 20. */
|
|
_Static_assert(__builtin_offsetof(XEvent, type) == 0, "XEvent.type");
|
|
_Static_assert(__builtin_offsetof(XEvent, xkey.window) == 16, "XEvent.xkey.window");
|
|
_Static_assert(__builtin_offsetof(XEvent, xkey.keycode) == 52,
|
|
"XEvent.xkey.keycode must be at byte 52 (bit 0x1A0)");
|
|
_Static_assert(__builtin_offsetof(XEvent, xexpose.window) == 16,
|
|
"XEvent.xexpose.window");
|
|
_Static_assert(__builtin_offsetof(XEvent, xexpose.x) == 20, "XEvent.xexpose.x");
|
|
_Static_assert(__builtin_offsetof(XEvent, xfocus.window) == 16,
|
|
"XEvent.xfocus.window");
|
|
_Static_assert(__builtin_offsetof(XEvent, xbutton.window) == 16,
|
|
"XEvent.xbutton.window");
|
|
_Static_assert(__builtin_offsetof(XEvent, xconfigure.window) == 20,
|
|
"XEvent.xconfigure.window");
|
|
_Static_assert(__builtin_offsetof(XEvent, xclient.window) == 16,
|
|
"XEvent.xclient.window");
|
|
_Static_assert(sizeof(XEvent) >= 96,
|
|
"XEvent must cover the termtris 96-byte vt_u32 evbuf[24]");
|
|
_Static_assert(sizeof(XEvent) == 96, "the X11R4 XEvent union is 96 bytes");
|
|
|
|
int layout_display_screens(void) {
|
|
return (int)__builtin_offsetof(Display, screens) * 8;
|
|
}
|
|
int layout_screen_root(void) {
|
|
return (int)__builtin_offsetof(Screen, root) * 8;
|
|
}
|
|
int layout_image_data(void) {
|
|
return (int)__builtin_offsetof(XImage, data) * 8;
|
|
}
|
|
int layout_image_byte_order(void) {
|
|
return (int)__builtin_offsetof(XImage, byte_order) * 8;
|
|
}
|
|
int layout_image_bytes_per_line(void) {
|
|
return (int)__builtin_offsetof(XImage, bytes_per_line) * 8;
|
|
}
|
|
int layout_image_bits_per_pixel(void) {
|
|
return (int)__builtin_offsetof(XImage, bits_per_pixel) * 8;
|
|
}
|
|
int layout_image_f(void) {
|
|
return (int)__builtin_offsetof(XImage, f) * 8;
|
|
}
|
|
int layout_error_error_code(void) {
|
|
return (int)__builtin_offsetof(XErrorEvent, error_code) * 8;
|
|
}
|
|
int layout_event_xkey_keycode(void) {
|
|
return (int)__builtin_offsetof(XEvent, xkey.keycode) * 8;
|
|
}
|
|
int layout_event_size(void) {
|
|
return (int)sizeof(XEvent);
|
|
}
|
|
|
|
/* Exercise the real access path: follows Display.screens and reads Screen.root. */
|
|
unsigned int root_probe(Display *d) { return vt_root(d); }
|