suwako / ShaderPlayground

master
ブランチ master
ShaderPlayground / deps / xlibre / include / X11 / Xlibint.h
39.6 KB、1444行 生 Blame 履歴
1
2/*
3
4Copyright 1984, 1985, 1987, 1989, 1998 The Open Group
5
6Permission to use, copy, modify, distribute, and sell this software and its
7documentation for any purpose is hereby granted without fee, provided that
8the above copyright notice appear in all copies and that both that
9copyright notice and this permission notice appear in supporting
10documentation.
11
12The above copyright notice and this permission notice shall be included
13in all copies or substantial portions of the Software.
14
15THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
16OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
17MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
18IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR
19OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
20ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
21OTHER DEALINGS IN THE SOFTWARE.
22
23Except as contained in this notice, the name of The Open Group shall
24not be used in advertising or otherwise to promote the sale, use or
25other dealings in this Software without prior written authorization
26from The Open Group.
27
28*/
29
30#ifndef _X11_XLIBINT_H_
31#define _X11_XLIBINT_H_ 1
32
33/*
34 * Xlibint.h - Header definition and support file for the internal
35 * support routines used by the C subroutine interface
36 * library (Xlib) to the X Window System.
37 *
38 * Warning, there be dragons here....
39 */
40
41#include <stdint.h>
42#include <X11/Xlib.h>
43#include <X11/Xproto.h> /* to declare xEvent */
44#include <X11/XlibConf.h> /* for configured options like XTHREADS */
45
46#ifdef XTHREADS
47#include <X11/Xthreads.h>
48#endif
49
50/* The Xlib structs are full of implicit padding to properly align members.
51 We can't clean that up without breaking ABI, so tell clang not to bother
52 complaining about it. */
53#ifdef __clang__
54#pragma clang diagnostic push
55#pragma clang diagnostic ignored "-Wpadded"
56#endif
57
58#ifdef WIN32
59#define _XFlush _XFlushIt
60#endif
61
62struct _XGC
63{
64 XExtData *ext_data; /* hook for extension to hang data */
65 GContext gid; /* protocol ID for graphics context */
66 Bool rects; /* boolean: TRUE if clipmask is list of rectangles */
67 Bool dashes; /* boolean: TRUE if dash-list is really a list */
68 unsigned long dirty;/* cache dirty bits */
69 XGCValues values; /* shadow structure of values */
70};
71
72struct _XDisplay
73{
74 XExtData *ext_data; /* hook for extension to hang data */
75 struct _XFreeFuncs *free_funcs; /* internal free functions */
76 int fd; /* Network socket. */
77 int conn_checker; /* ugly thing used by _XEventsQueued */
78 int proto_major_version;/* maj. version of server's X protocol */
79 int proto_minor_version;/* minor version of server's X protocol */
80 char *vendor; /* vendor of the server hardware */
81 XID resource_base; /* resource ID base */
82 XID resource_mask; /* resource ID mask bits */
83 XID resource_id; /* allocator current ID */
84 int resource_shift; /* allocator shift to correct bits */
85 XID (*resource_alloc)( /* allocator function */
86 struct _XDisplay*
87 );
88 int byte_order; /* screen byte order, LSBFirst, MSBFirst */
89 int bitmap_unit; /* padding and data requirements */
90 int bitmap_pad; /* padding requirements on bitmaps */
91 int bitmap_bit_order; /* LeastSignificant or MostSignificant */
92 int nformats; /* number of pixmap formats in list */
93 ScreenFormat *pixmap_format; /* pixmap format list */
94 int vnumber; /* Xlib's X protocol version number. */
95 int release; /* release of the server */
96 struct _XSQEvent *head, *tail; /* Input event queue. */
97 int qlen; /* Length of input event queue */
98 unsigned long last_request_read; /* seq number of last event read */
99 unsigned long request; /* sequence number of last request. */
100 char *last_req; /* beginning of last request, or dummy */
101 char *buffer; /* Output buffer starting address. */
102 char *bufptr; /* Output buffer index pointer. */
103 char *bufmax; /* Output buffer maximum+1 address. */
104 unsigned max_request_size; /* maximum number 32 bit words in request*/
105 struct _XrmHashBucketRec *db;
106 int (*synchandler)( /* Synchronization handler */
107 struct _XDisplay*
108 );
109 char *display_name; /* "host:display" string used on this connect*/
110 int default_screen; /* default screen for operations */
111 int nscreens; /* number of screens on this server*/
112 Screen *screens; /* pointer to list of screens */
113 unsigned long motion_buffer; /* size of motion buffer */
114 volatile unsigned long flags; /* internal connection flags */
115 int min_keycode; /* minimum defined keycode */
116 int max_keycode; /* maximum defined keycode */
117 KeySym *keysyms; /* This server's keysyms */
118 XModifierKeymap *modifiermap; /* This server's modifier keymap */
119 int keysyms_per_keycode;/* number of rows */
120 char *xdefaults; /* contents of defaults from server */
121 char *scratch_buffer; /* place to hang scratch buffer */
122 unsigned long scratch_length; /* length of scratch buffer */
123 int ext_number; /* extension number on this display */
124 struct _XExten *ext_procs; /* extensions initialized on this display */
125 /*
126 * the following can be fixed size, as the protocol defines how
127 * much address space is available.
128 * While this could be done using the extension vector, there
129 * may be MANY events processed, so a search through the extension
130 * list to find the right procedure for each event might be
131 * expensive if many extensions are being used.
132 */
133 Bool (*event_vec[128])( /* vector for wire to event */
134 Display * /* dpy */,
135 XEvent * /* re */,
136 xEvent * /* event */
137 );
138 Status (*wire_vec[128])( /* vector for event to wire */
139 Display * /* dpy */,
140 XEvent * /* re */,
141 xEvent * /* event */
142 );
143 KeySym lock_meaning; /* for XLookupString */
144 struct _XLockInfo *lock; /* multi-thread state, display lock */
145 struct _XInternalAsync *async_handlers; /* for internal async */
146 unsigned long bigreq_size; /* max size of big requests */
147 struct _XLockPtrs *lock_fns; /* pointers to threads functions */
148 void (*idlist_alloc)( /* XID list allocator function */
149 Display * /* dpy */,
150 XID * /* ids */,
151 int /* count */
152 );
153 /* things above this line should not move, for binary compatibility */
154 struct _XKeytrans *key_bindings; /* for XLookupString */
155 Font cursor_font; /* for XCreateFontCursor */
156 struct _XDisplayAtoms *atoms; /* for XInternAtom */
157 unsigned int mode_switch; /* keyboard group modifiers */
158 unsigned int num_lock; /* keyboard numlock modifiers */
159 struct _XContextDB *context_db; /* context database */
160 Bool (**error_vec)( /* vector for wire to error */
161 Display * /* display */,
162 XErrorEvent * /* he */,
163 xError * /* we */
164 );
165 /*
166 * Xcms information
167 */
168 struct {
169 XPointer defaultCCCs; /* pointer to an array of default XcmsCCC */
170 XPointer clientCmaps; /* pointer to linked list of XcmsCmapRec */
171 XPointer perVisualIntensityMaps;
172 /* linked list of XcmsIntensityMap */
173 } cms;
174 struct _XIMFilter *im_filters;
175 struct _XSQEvent *qfree; /* unallocated event queue elements */
176 unsigned long next_event_serial_num; /* inserted into next queue elt */
177 struct _XExten *flushes; /* Flush hooks */
178 struct _XConnectionInfo *im_fd_info; /* _XRegisterInternalConnection */
179 int im_fd_length; /* number of im_fd_info */
180 struct _XConnWatchInfo *conn_watchers; /* XAddConnectionWatch */
181 int watcher_count; /* number of conn_watchers */
182 XPointer filedes; /* struct pollfd cache for _XWaitForReadable */
183 int (*savedsynchandler)( /* user synchandler when Xlib usurps */
184 Display * /* dpy */
185 );
186 XID resource_max; /* allocator max ID */
187 int xcmisc_opcode; /* major opcode for XC-MISC */
188 struct _XkbInfoRec *xkb_info; /* XKB info */
189 struct _XtransConnInfo *trans_conn; /* transport connection object */
190 struct _X11XCBPrivate *xcb; /* XCB glue private data */
191
192 /* Generic event cookie handling */
193 unsigned int next_cookie; /* next event cookie */
194 /* vector for wire to generic event, index is (extension - 128) */
195 Bool (*generic_event_vec[128])(
196 Display * /* dpy */,
197 XGenericEventCookie * /* Xlib event */,
198 xEvent * /* wire event */);
199 /* vector for event copy, index is (extension - 128) */
200 Bool (*generic_event_copy_vec[128])(
201 Display * /* dpy */,
202 XGenericEventCookie * /* in */,
203 XGenericEventCookie * /* out*/);
204 void *cookiejar; /* cookie events returned but not claimed */
205#ifndef LONG64
206 unsigned long last_request_read_upper32bit;
207 unsigned long request_upper32bit;
208#endif
209
210 struct _XErrorThreadInfo *error_threads;
211
212 XIOErrorExitHandler exit_handler;
213 void *exit_handler_data;
214 CARD32 in_ifevent;
215#ifdef XTHREADS
216 xthread_t ifevent_thread;
217#endif
218};
219
220#define XAllocIDs(dpy,ids,n) (*(dpy)->idlist_alloc)(dpy,ids,n)
221
222/*
223 * access "last_request_read" and "request" with 64bit
224 * warning: the value argument of the SET-macros must not
225 * have any side-effects because it may get called twice.
226 */
227#ifndef LONG64
228/* accessors for 32-bit unsigned long */
229
230#define X_DPY_GET_REQUEST(dpy) \
231 ( \
232 ((uint64_t)(((struct _XDisplay*)dpy)->request)) \
233 + (((uint64_t)(((struct _XDisplay*)dpy)->request_upper32bit)) << 32) \
234 )
235
236#define X_DPY_SET_REQUEST(dpy, value) \
237 ( \
238 (((struct _XDisplay*)dpy)->request = \
239 (value) & 0xFFFFFFFFUL), \
240 (((struct _XDisplay*)dpy)->request_upper32bit = \
241 ((uint64_t)(value)) >> 32), \
242 (void)0 /* don't use the result */ \
243 )
244
245#define X_DPY_GET_LAST_REQUEST_READ(dpy) \
246 ( \
247 ((uint64_t)(((struct _XDisplay*)dpy)->last_request_read)) \
248 + ( \
249 ((uint64_t)( \
250 ((struct _XDisplay*)dpy)->last_request_read_upper32bit \
251 )) << 32 \
252 ) \
253 )
254
255#define X_DPY_SET_LAST_REQUEST_READ(dpy, value) \
256 ( \
257 (((struct _XDisplay*)dpy)->last_request_read = \
258 (value) & 0xFFFFFFFFUL), \
259 (((struct _XDisplay*)dpy)->last_request_read_upper32bit = \
260 ((uint64_t)(value)) >> 32), \
261 (void)0 /* don't use the result */ \
262 )
263
264/*
265 * widen a 32-bit sequence number to a 64 sequence number.
266 * This macro makes the following assumptions:
267 * - ulseq refers to a sequence that has already been sent
268 * - ulseq means the most recent possible sequence number
269 * with these lower 32 bits.
270 *
271 * The following optimization is used:
272 * The comparison result is taken a 0 or 1 to avoid a branch.
273 */
274#define X_DPY_WIDEN_UNSIGNED_LONG_SEQ(dpy, ulseq) \
275 ( \
276 ((uint64_t)ulseq) \
277 + \
278 (( \
279 ((uint64_t)(((struct _XDisplay*)dpy)->request_upper32bit)) \
280 - (uint64_t)( \
281 (ulseq) > (((struct _XDisplay*)dpy)->request) \
282 ) \
283 ) << 32) \
284 )
285
286#define X_DPY_REQUEST_INCREMENT(dpy) \
287 ( \
288 ((struct _XDisplay*)dpy)->request++, \
289 ( \
290 (((struct _XDisplay*)dpy)->request == 0) ? ( \
291 ((struct _XDisplay*)dpy)->request_upper32bit++ \
292 ) : 0 \
293 ), \
294 (void)0 /* don't use the result */ \
295 )
296
297
298#define X_DPY_REQUEST_DECREMENT(dpy) \
299 ( \
300 ( \
301 (((struct _XDisplay*)dpy)->request == 0) ? (\
302 ((struct _XDisplay*)dpy)->request--, /* wrap */ \
303 ((struct _XDisplay*)dpy)->request_upper32bit-- \
304 ) : ( \
305 ((struct _XDisplay*)dpy)->request-- \
306 ) \
307 ), \
308 (void)0 /* don't use the result */ \
309 )
310
311#else
312/* accessors for 64-bit unsigned long */
313#define X_DPY_GET_REQUEST(dpy) \
314 (((struct _XDisplay*)dpy)->request)
315#define X_DPY_SET_REQUEST(dpy, value) \
316 ((struct _XDisplay*)dpy)->request = (value)
317
318#define X_DPY_GET_LAST_REQUEST_READ(dpy) \
319 (((struct _XDisplay*)dpy)->last_request_read)
320#define X_DPY_SET_LAST_REQUEST_READ(dpy, value) \
321 ((struct _XDisplay*)dpy)->last_request_read = (value)
322
323#define X_DPY_WIDEN_UNSIGNED_LONG_SEQ(dpy, ulseq) ulseq
324
325#define X_DPY_REQUEST_INCREMENT(dpy) ((struct _XDisplay*)dpy)->request++
326#define X_DPY_REQUEST_DECREMENT(dpy) ((struct _XDisplay*)dpy)->request--
327#endif
328
329
330#ifndef _XEVENT_
331/*
332 * _QEvent datatype for use in input queueing.
333 */
334typedef struct _XSQEvent
335{
336 struct _XSQEvent *next;
337 XEvent event;
338 unsigned long qserial_num; /* so multi-threaded code can find new ones */
339} _XQEvent;
340#endif
341
342#include <X11/Xproto.h>
343#include <errno.h>
344#define _XBCOPYFUNC _Xbcopy
345#include <X11/Xfuncs.h>
346#include <X11/Xosdefs.h>
347
348/* Utek leaves kernel macros around in include files (bleah) */
349#ifdef dirty
350#undef dirty
351#endif
352
353#include <stdlib.h>
354#include <string.h>
355
356#include <X11/Xfuncproto.h>
357
358_XFUNCPROTOBEGIN
359
360/*
361 * The following definitions can be used for locking requests in multi-threaded
362 * address spaces.
363 */
364#ifdef XTHREADS
365/* Author: Stephen Gildea, MIT X Consortium
366 *
367 * declarations for C Threads locking
368 */
369
370typedef struct _LockInfoRec *LockInfoPtr;
371
372/* interfaces for locking.c */
373struct _XLockPtrs {
374 /* used by all, including extensions; do not move */
375 void (*lock_display)(
376 Display *dpy
377#if defined(XTHREADS_WARN) || defined(XTHREADS_FILE_LINE)
378 , char *file
379 , int line
380#endif
381 );
382 void (*unlock_display)(
383 Display *dpy
384#if defined(XTHREADS_WARN) || defined(XTHREADS_FILE_LINE)
385 , char *file
386 , int line
387#endif
388 );
389};
390
391#if defined(WIN32) && !defined(_XLIBINT_)
392#define _XCreateMutex_fn (*_XCreateMutex_fn_p)
393#define _XFreeMutex_fn (*_XFreeMutex_fn_p)
394#define _XLockMutex_fn (*_XLockMutex_fn_p)
395#define _XUnlockMutex_fn (*_XUnlockMutex_fn_p)
396#define _Xglobal_lock (*_Xglobal_lock_p)
397#endif
398
399/* in XlibInt.c */
400extern void (*_XCreateMutex_fn)(
401 LockInfoPtr /* lock */
402);
403extern void (*_XFreeMutex_fn)(
404 LockInfoPtr /* lock */
405);
406extern void (*_XLockMutex_fn)(
407 LockInfoPtr /* lock */
408#if defined(XTHREADS_WARN) || defined(XTHREADS_FILE_LINE)
409 , char * /* file */
410 , int /* line */
411#endif
412);
413extern void (*_XUnlockMutex_fn)(
414 LockInfoPtr /* lock */
415#if defined(XTHREADS_WARN) || defined(XTHREADS_FILE_LINE)
416 , char * /* file */
417 , int /* line */
418#endif
419);
420
421extern LockInfoPtr _Xglobal_lock;
422
423#if defined(XTHREADS_WARN) || defined(XTHREADS_FILE_LINE)
424#define LockDisplay(d) if ((d)->lock_fns) (*(d)->lock_fns->lock_display)((d),__FILE__,__LINE__)
425#define UnlockDisplay(d) if ((d)->lock_fns) (*(d)->lock_fns->unlock_display)((d),__FILE__,__LINE__)
426#define _XLockMutex(lock) if (_XLockMutex_fn) (*_XLockMutex_fn)(lock,__FILE__,__LINE__)
427#define _XUnlockMutex(lock) if (_XUnlockMutex_fn) (*_XUnlockMutex_fn)(lock,__FILE__,__LINE__)
428#else
429/* used everywhere, so must be fast if not using threads */
430#define LockDisplay(d) if ((d)->lock_fns) (*(d)->lock_fns->lock_display)(d)
431#define UnlockDisplay(d) if ((d)->lock_fns) (*(d)->lock_fns->unlock_display)(d)
432#define _XLockMutex(lock) if (_XLockMutex_fn) (*_XLockMutex_fn)(lock)
433#define _XUnlockMutex(lock) if (_XUnlockMutex_fn) (*_XUnlockMutex_fn)(lock)
434#endif
435#define _XCreateMutex(lock) if (_XCreateMutex_fn) (*_XCreateMutex_fn)(lock)
436#define _XFreeMutex(lock) if (_XFreeMutex_fn) (*_XFreeMutex_fn)(lock)
437
438#else /* XTHREADS */
439#define LockDisplay(dis)
440#define _XLockMutex(lock)
441#define _XUnlockMutex(lock)
442#define UnlockDisplay(dis)
443#define _XCreateMutex(lock)
444#define _XFreeMutex(lock)
445#endif
446
447#define Xfree(ptr) free((ptr))
448
449/*
450 * Note that some machines do not return a valid pointer for malloc(0), in
451 * which case we provide an alternate under the control of the
452 * define MALLOC_0_RETURNS_NULL. This is necessary because some
453 * Xlib code expects malloc(0) to return a valid pointer to storage.
454 */
455#if defined(MALLOC_0_RETURNS_NULL) || defined(__clang_analyzer__)
456
457# define Xmalloc(size) malloc((size_t)((size) == 0 ? 1 : (size)))
458# define Xrealloc(ptr, size) realloc((ptr), (size_t)((size) == 0 ? 1 : (size)))
459# define Xcalloc(nelem, elsize) calloc((size_t)((nelem) == 0 ? 1 : (nelem)), (size_t)(elsize))
460
461#else
462
463# define Xmalloc(size) malloc((size_t)(size))
464# define Xrealloc(ptr, size) realloc((ptr), (size_t)(size))
465# define Xcalloc(nelem, elsize) calloc((size_t)(nelem), (size_t)(elsize))
466
467#endif
468
469#include <stddef.h>
470
471#define LOCKED 1
472#define UNLOCKED 0
473
474#ifndef BUFSIZE
475#define BUFSIZE 2048 /* X output buffer size. */
476#endif
477#ifndef PTSPERBATCH
478#define PTSPERBATCH 1024 /* point batching */
479#endif
480#ifndef WLNSPERBATCH
481#define WLNSPERBATCH 50 /* wide line batching */
482#endif
483#ifndef ZLNSPERBATCH
484#define ZLNSPERBATCH 1024 /* thin line batching */
485#endif
486#ifndef WRCTSPERBATCH
487#define WRCTSPERBATCH 10 /* wide line rectangle batching */
488#endif
489#ifndef ZRCTSPERBATCH
490#define ZRCTSPERBATCH 256 /* thin line rectangle batching */
491#endif
492#ifndef FRCTSPERBATCH
493#define FRCTSPERBATCH 256 /* filled rectangle batching */
494#endif
495#ifndef FARCSPERBATCH
496#define FARCSPERBATCH 256 /* filled arc batching */
497#endif
498#ifndef CURSORFONT
499#define CURSORFONT "cursor" /* standard cursor fonts */
500#endif
501
502/*
503 * Display flags
504 */
505#define XlibDisplayIOError (1L << 0)
506#define XlibDisplayClosing (1L << 1)
507#define XlibDisplayNoXkb (1L << 2)
508#define XlibDisplayPrivSync (1L << 3)
509#define XlibDisplayProcConni (1L << 4) /* in _XProcessInternalConnection */
510#define XlibDisplayReadEvents (1L << 5) /* in _XReadEvents */
511#define XlibDisplayReply (1L << 5) /* in _XReply */
512#define XlibDisplayWriting (1L << 6) /* in _XFlushInt, _XSend */
513#define XlibDisplayDfltRMDB (1L << 7) /* mark if RM db from XGetDefault */
514
515/*
516 * X Protocol packetizing macros.
517 */
518
519/* Leftover from CRAY support - was defined empty on all non-Cray systems */
520#define WORD64ALIGN
521
522/**
523 * Return a len-sized request buffer for the request type. This function may
524 * flush the output queue.
525 *
526 * @param dpy The display connection
527 * @param type The request type
528 * @param len Length of the request in bytes
529 *
530 * @returns A pointer to the request buffer with a few default values
531 * initialized.
532 */
533extern void *_XGetRequest(Display *dpy, CARD8 type, size_t len);
534
535/* GetReqSized is the same as GetReq but allows the caller to specify the
536 * size in bytes. 'sz' must be a multiple of 4! */
537
538#define GetReqSized(name, sz, req) \
539 req = (x##name##Req *) _XGetRequest(dpy, X_##name, sz)
540
541/*
542 * GetReq - Get the next available X request packet in the buffer and
543 * return it.
544 *
545 * "name" is the name of the request, e.g. CreatePixmap, OpenFont, etc.
546 * "req" is the name of the request pointer.
547 *
548 */
549
550#define GetReq(name, req) \
551 GetReqSized(name, SIZEOF(x##name##Req), req)
552
553/* GetReqExtra is the same as GetReq, but allocates "n" additional
554 bytes after the request. "n" must be a multiple of 4! */
555
556#define GetReqExtra(name, n, req) \
557 GetReqSized(name, SIZEOF(x##name##Req) + n, req)
558
559/*
560 * GetResReq is for those requests that have a resource ID
561 * (Window, Pixmap, GContext, etc.) as their single argument.
562 * "rid" is the name of the resource.
563 */
564
565#define GetResReq(name, rid, req) \
566 req = (xResourceReq *) _XGetRequest(dpy, X_##name, SIZEOF(xResourceReq)); \
567 if (req) req->id = (rid)
568
569/*
570 * GetEmptyReq is for those requests that have no arguments
571 * at all.
572 */
573
574#define GetEmptyReq(name, req) \
575 req = (xReq *) _XGetRequest(dpy, X_##name, SIZEOF(xReq))
576
577/*
578 * MakeBigReq sets the CARD16 "req->length" to 0 and inserts a new CARD32
579 * length, after req->length, before the data in the request. The new length
580 * includes the "n" extra 32-bit words.
581 *
582 * Do not use MakeBigReq if there is no data already in the request.
583 * req->length must already be >= 2.
584 */
585#ifdef LONG64
586#define MakeBigReq(req,n) \
587 { \
588 CARD64 _BRdat; \
589 CARD32 _BRlen = (CARD32) (req->length - 1); \
590 req->length = 0; \
591 _BRdat = ((CARD32 *)req)[_BRlen]; \
592 memmove(((char *)req) + 8, ((char *)req) + 4, (_BRlen - 1) << 2); \
593 ((CARD32 *)req)[1] = _BRlen + (CARD32) (n) + 2; \
594 Data32(dpy, &_BRdat, 4); \
595 }
596#else
597#define MakeBigReq(req,n) \
598 { \
599 CARD32 _BRdat; \
600 CARD32 _BRlen = req->length - 1; \
601 req->length = 0; \
602 _BRdat = ((CARD32 *)req)[_BRlen]; \
603 memmove(((char *)req) + 8, ((char *)req) + 4, (_BRlen - 1) << 2); \
604 ((CARD32 *)req)[1] = _BRlen + (CARD32) (n) + 2; \
605 Data32(dpy, &_BRdat, 4); \
606 }
607#endif
608
609/*
610 * SetReqLen increases the count of 32-bit words in the request by "n",
611 * or by "badlen" if "n" is too large.
612 *
613 * Do not use SetReqLen if "req" does not already have data after the
614 * xReq header. req->length must already be >= 2.
615 */
616#ifndef __clang_analyzer__
617#define SetReqLen(req,n,badlen) \
618 if ((req->length + n) > (unsigned)65535) { \
619 if (dpy->bigreq_size) { \
620 MakeBigReq(req,n) \
621 } else { \
622 n = badlen; \
623 req->length = (CARD16) (req->length + n); \
624 } \
625 } else \
626 req->length = (CARD16) (req->length + n)
627#else
628#define SetReqLen(req,n,badlen) \
629 req->length += n
630#endif
631
632#define SyncHandle() \
633 if (dpy->synchandler) (*dpy->synchandler)(dpy)
634
635extern void _XFlushGCCache(Display *dpy, GC gc);
636#define FlushGC(dpy, gc) \
637 if ((gc)->dirty) _XFlushGCCache((dpy), (gc))
638/*
639 * Data - Place data in the buffer and pad the end to provide
640 * 32 bit word alignment. Transmit if the buffer fills.
641 *
642 * "dpy" is a pointer to a Display.
643 * "data" is a pointer to a data buffer.
644 * "len" is the length of the data buffer.
645 */
646#ifndef DataRoutineIsProcedure
647#define Data(dpy, data, len) do {\
648 if (dpy->bufptr + (len) <= dpy->bufmax) {\
649 memcpy(dpy->bufptr, data, (size_t)(len));\
650 dpy->bufptr += ((size_t)((len) + 3) & (size_t)~3);\
651 } else\
652 _XSend(dpy, (_Xconst char*)(data), (long)(len));\
653} while (0)
654#endif /* DataRoutineIsProcedure */
655
656
657/* Allocate bytes from the buffer. No padding is done, so if
658 * the length is not a multiple of 4, the caller must be
659 * careful to leave the buffer aligned after sending the
660 * current request.
661 *
662 * "type" is the type of the pointer being assigned to.
663 * "ptr" is the pointer being assigned to.
664 * "n" is the number of bytes to allocate.
665 *
666 * Example:
667 * xTextElt *elt;
668 * BufAlloc (xTextElt *, elt, nbytes)
669 */
670
671#define BufAlloc(type, ptr, n) do { \
672 if (dpy->bufptr + (n) > dpy->bufmax) \
673 _XFlush (dpy); \
674 ptr = (type) dpy->bufptr; \
675 memset(ptr, '\0', (size_t)(n)); \
676 dpy->bufptr += (n); \
677} while (0)
678
679#define Data16(dpy, data, len) Data((dpy), (_Xconst char *)(data), (len))
680#define _XRead16Pad(dpy, data, len) _XReadPad((dpy), (char *)(data), (len))
681#define _XRead16(dpy, data, len) _XRead((dpy), (char *)(data), (len))
682#ifdef LONG64
683#define Data32(dpy, data, len) _XData32(dpy, (_Xconst long *)(data), (unsigned)(len))
684extern int _XData32(
685 Display *dpy,
686 _Xconst long *data,
687 unsigned len
688);
689extern void _XRead32(
690 Display *dpy,
691 long *data,
692 long len
693);
694#else
695#define Data32(dpy, data, len) Data((dpy), (_Xconst char *)(data), (long)(len))
696#define _XRead32(dpy, data, len) _XRead((dpy), (char *)(data), (len))
697#endif
698
699#define PackData16(dpy,data,len) Data16 (dpy, data, len)
700#define PackData32(dpy,data,len) Data32 (dpy, data, len)
701
702/* Xlib manual is bogus */
703#define PackData(dpy,data,len) PackData16 (dpy, data, len)
704
705#define min(a,b) (((a) < (b)) ? (a) : (b))
706#define max(a,b) (((a) > (b)) ? (a) : (b))
707
708#define CI_NONEXISTCHAR(cs) (((cs)->width == 0) && \
709 (((cs)->rbearing|(cs)->lbearing| \
710 (cs)->ascent|(cs)->descent) == 0))
711
712/*
713 * CI_GET_CHAR_INFO_1D - return the charinfo struct for the indicated 8bit
714 * character. If the character is in the column and exists, then return the
715 * appropriate metrics (note that fonts with common per-character metrics will
716 * return min_bounds). If none of these hold true, try again with the default
717 * char.
718 */
719#define CI_GET_CHAR_INFO_1D(fs,col,def,cs) \
720do { \
721 cs = def; \
722 if (col >= fs->min_char_or_byte2 && col <= fs->max_char_or_byte2) { \
723 if (fs->per_char == NULL) { \
724 cs = &fs->min_bounds; \
725 } else { \
726 cs = &fs->per_char[(col - fs->min_char_or_byte2)]; \
727 if (CI_NONEXISTCHAR(cs)) cs = def; \
728 } \
729 } \
730} while (0)
731
732#define CI_GET_DEFAULT_INFO_1D(fs,cs) \
733 CI_GET_CHAR_INFO_1D (fs, fs->default_char, NULL, cs)
734
735
736
737/*
738 * CI_GET_CHAR_INFO_2D - return the charinfo struct for the indicated row and
739 * column. This is used for fonts that have more than row zero.
740 */
741#define CI_GET_CHAR_INFO_2D(fs,row,col,def,cs) \
742do { \
743 cs = def; \
744 if (row >= fs->min_byte1 && row <= fs->max_byte1 && \
745 col >= fs->min_char_or_byte2 && col <= fs->max_char_or_byte2) { \
746 if (fs->per_char == NULL) { \
747 cs = &fs->min_bounds; \
748 } else { \
749 cs = &fs->per_char[((row - fs->min_byte1) * \
750 (fs->max_char_or_byte2 - \
751 fs->min_char_or_byte2 + 1)) + \
752 (col - fs->min_char_or_byte2)]; \
753 if (CI_NONEXISTCHAR(cs)) cs = def; \
754 } \
755 } \
756} while (0)
757
758#define CI_GET_DEFAULT_INFO_2D(fs,cs) \
759do { \
760 unsigned int r = (fs->default_char >> 8); \
761 unsigned int c = (fs->default_char & 0xff); \
762 CI_GET_CHAR_INFO_2D (fs, r, c, NULL, cs); \
763} while (0)
764
765
766/* srcvar must be a variable for large architecture version */
767#define OneDataCard32(dpy,dstaddr,srcvar) \
768 do { *(CARD32 *)(dstaddr) = (srcvar); } while (0)
769
770
771typedef struct _XInternalAsync {
772 struct _XInternalAsync *next;
773 /*
774 * handler arguments:
775 * rep is the generic reply that caused this handler
776 * to be invoked. It must also be passed to _XGetAsyncReply.
777 * buf and len are opaque values that must be passed to
778 * _XGetAsyncReply or _XGetAsyncData.
779 * data is the closure stored in this struct.
780 * The handler returns True iff it handled this reply.
781 */
782 Bool (*handler)(
783 Display* /* dpy */,
784 xReply* /* rep */,
785 char* /* buf */,
786 int /* len */,
787 XPointer /* data */
788 );
789 XPointer data;
790} _XAsyncHandler;
791
792/*
793 * This struct is part of the ABI and is defined by value
794 * in user-code. This means that we cannot make
795 * the sequence-numbers 64bit.
796 */
797typedef struct _XAsyncEState {
798 unsigned long min_sequence_number;
799 unsigned long max_sequence_number;
800 unsigned char error_code;
801 unsigned char major_opcode;
802 unsigned short minor_opcode;
803 unsigned char last_error_received;
804 int error_count;
805} _XAsyncErrorState;
806
807extern void _XDeqAsyncHandler(Display *dpy, _XAsyncHandler *handler);
808#define DeqAsyncHandler(dpy,handler) do { \
809 if (dpy->async_handlers == (handler)) \
810 dpy->async_handlers = (handler)->next; \
811 else \
812 _XDeqAsyncHandler(dpy, handler); \
813 } while (0)
814
815typedef void (*FreeFuncType) (
816 Display* /* display */
817);
818
819typedef int (*FreeModmapType) (
820 XModifierKeymap* /* modmap */
821);
822
823/*
824 * This structure is private to the library.
825 */
826typedef struct _XFreeFuncs {
827 FreeFuncType atoms; /* _XFreeAtomTable */
828 FreeModmapType modifiermap; /* XFreeModifiermap */
829 FreeFuncType key_bindings; /* _XFreeKeyBindings */
830 FreeFuncType context_db; /* _XFreeContextDB */
831 FreeFuncType defaultCCCs; /* _XcmsFreeDefaultCCCs */
832 FreeFuncType clientCmaps; /* _XcmsFreeClientCmaps */
833 FreeFuncType intensityMaps; /* _XcmsFreeIntensityMaps */
834 FreeFuncType im_filters; /* _XFreeIMFilters */
835 FreeFuncType xkb; /* _XkbFreeInfo */
836} _XFreeFuncRec;
837
838/* types for InitExt.c */
839typedef int (*CreateGCType) (
840 Display* /* display */,
841 GC /* gc */,
842 XExtCodes* /* codes */
843);
844
845typedef int (*CopyGCType)(
846 Display* /* display */,
847 GC /* gc */,
848 XExtCodes* /* codes */
849);
850
851typedef int (*FlushGCType) (
852 Display* /* display */,
853 GC /* gc */,
854 XExtCodes* /* codes */
855);
856
857typedef int (*FreeGCType) (
858 Display* /* display */,
859 GC /* gc */,
860 XExtCodes* /* codes */
861);
862
863typedef int (*CreateFontType) (
864 Display* /* display */,
865 XFontStruct* /* fs */,
866 XExtCodes* /* codes */
867);
868
869typedef int (*FreeFontType) (
870 Display* /* display */,
871 XFontStruct* /* fs */,
872 XExtCodes* /* codes */
873);
874
875typedef int (*CloseDisplayType) (
876 Display* /* display */,
877 XExtCodes* /* codes */
878);
879
880typedef int (*ErrorType) (
881 Display* /* display */,
882 xError* /* err */,
883 XExtCodes* /* codes */,
884 int* /* ret_code */
885);
886
887typedef char* (*ErrorStringType) (
888 Display* /* display */,
889 int /* code */,
890 XExtCodes* /* codes */,
891 char* /* buffer */,
892 int /* nbytes */
893);
894
895typedef void (*PrintErrorType)(
896 Display* /* display */,
897 XErrorEvent* /* ev */,
898 void* /* fp */
899);
900
901typedef void (*BeforeFlushType)(
902 Display* /* display */,
903 XExtCodes* /* codes */,
904 _Xconst char* /* data */,
905 long /* len */
906);
907
908/*
909 * This structure is private to the library.
910 */
911typedef struct _XExten { /* private to extension mechanism */
912 struct _XExten *next; /* next in list */
913 XExtCodes codes; /* public information, all extension told */
914 CreateGCType create_GC; /* routine to call when GC created */
915 CopyGCType copy_GC; /* routine to call when GC copied */
916 FlushGCType flush_GC; /* routine to call when GC flushed */
917 FreeGCType free_GC; /* routine to call when GC freed */
918 CreateFontType create_Font; /* routine to call when Font created */
919 FreeFontType free_Font; /* routine to call when Font freed */
920 CloseDisplayType close_display; /* routine to call when connection closed */
921 ErrorType error; /* who to call when an error occurs */
922 ErrorStringType error_string; /* routine to supply error string */
923 char *name; /* name of this extension */
924 PrintErrorType error_values; /* routine to supply error values */
925 BeforeFlushType before_flush; /* routine to call when sending data */
926 struct _XExten *next_flush; /* next in list of those with flushes */
927} _XExtension;
928
929/* extension hooks */
930
931#ifdef DataRoutineIsProcedure
932extern void Data(Display *dpy, char *data, long len);
933#endif
934extern int _XError(
935 Display* /* dpy */,
936 xError* /* rep */
937);
938extern int _XIOError(
939 Display* /* dpy */
940);
941extern int (*_XIOErrorFunction)(
942 Display* /* dpy */
943);
944extern int (*_XErrorFunction)(
945 Display* /* dpy */,
946 XErrorEvent* /* error_event */
947);
948extern void _XEatData(
949 Display* /* dpy */,
950 unsigned long /* n */
951) _X_COLD;
952extern void _XEatDataWords(
953 Display* /* dpy */,
954 unsigned long /* n */
955) _X_COLD;
956#if defined(__SUNPRO_C) /* Studio compiler alternative to "cold" attribute */
957# pragma rarely_called(_XEatData, _XEatDataWords)
958#endif
959extern char *_XAllocScratch(
960 Display* /* dpy */,
961 unsigned long /* nbytes */
962);
963extern char *_XAllocTemp(
964 Display* /* dpy */,
965 unsigned long /* nbytes */
966);
967extern void _XFreeTemp(
968 Display* /* dpy */,
969 char* /* buf */,
970 unsigned long /* nbytes */
971);
972extern Visual *_XVIDtoVisual(
973 Display* /* dpy */,
974 VisualID /* id */
975);
976extern unsigned long _XSetLastRequestRead(
977 Display* /* dpy */,
978 xGenericReply* /* rep */
979);
980extern int _XGetHostname(
981 char* /* buf */,
982 int /* maxlen */
983);
984extern Screen *_XScreenOfWindow(
985 Display* /* dpy */,
986 Window /* w */
987);
988extern Bool _XAsyncErrorHandler(
989 Display* /* dpy */,
990 xReply* /* rep */,
991 char* /* buf */,
992 int /* len */,
993 XPointer /* data */
994);
995extern char *_XGetAsyncReply(
996 Display* /* dpy */,
997 char* /* replbuf */,
998 xReply* /* rep */,
999 char* /* buf */,
1000 int /* len */,
1001 int /* extra */,
1002 Bool /* discard */
1003);
1004extern void _XGetAsyncData(
1005 Display* /* dpy */,
1006 char * /* data */,
1007 char * /* buf */,
1008 int /* len */,
1009 int /* skip */,
1010 int /* datalen */,
1011 int /* discardtotal */
1012);
1013extern void _XFlush(
1014 Display* /* dpy */
1015);
1016extern int _XEventsQueued(
1017 Display* /* dpy */,
1018 int /* mode */
1019);
1020extern void _XReadEvents(
1021 Display* /* dpy */
1022);
1023extern int _XRead(
1024 Display* /* dpy */,
1025 char* /* data */,
1026 long /* size */
1027);
1028extern void _XReadPad(
1029 Display* /* dpy */,
1030 char* /* data */,
1031 long /* size */
1032);
1033extern void _XSend(
1034 Display* /* dpy */,
1035 _Xconst char* /* data */,
1036 long /* size */
1037);
1038extern Status _XReply(
1039 Display* /* dpy */,
1040 xReply* /* rep */,
1041 int /* extra */,
1042 Bool /* discard */
1043);
1044extern void _XEnq(
1045 Display* /* dpy */,
1046 xEvent* /* event */
1047);
1048extern void _XDeq(
1049 Display* /* dpy */,
1050 _XQEvent* /* prev */,
1051 _XQEvent* /* qelt */
1052);
1053
1054extern Bool _XUnknownWireEvent(
1055 Display* /* dpy */,
1056 XEvent* /* re */,
1057 xEvent* /* event */
1058);
1059
1060extern Bool _XUnknownWireEventCookie(
1061 Display* /* dpy */,
1062 XGenericEventCookie* /* re */,
1063 xEvent* /* event */
1064);
1065
1066extern Bool _XUnknownCopyEventCookie(
1067 Display* /* dpy */,
1068 XGenericEventCookie* /* in */,
1069 XGenericEventCookie* /* out */
1070);
1071
1072extern Status _XUnknownNativeEvent(
1073 Display* /* dpy */,
1074 XEvent* /* re */,
1075 xEvent* /* event */
1076);
1077
1078extern Bool _XWireToEvent(Display *dpy, XEvent *re, xEvent *event);
1079extern Bool _XDefaultWireError(Display *display, XErrorEvent *he, xError *we);
1080extern Bool _XPollfdCacheInit(Display *dpy);
1081extern void _XPollfdCacheAdd(Display *dpy, int fd);
1082extern void _XPollfdCacheDel(Display *dpy, int fd);
1083extern XID _XAllocID(Display *dpy);
1084extern void _XAllocIDs(Display *dpy, XID *ids, int count);
1085
1086extern int _XFreeExtData(
1087 XExtData* /* extension */
1088);
1089
1090extern int (*XESetCreateGC(
1091 Display* /* display */,
1092 int /* extension */,
1093 int (*) (
1094 Display* /* display */,
1095 GC /* gc */,
1096 XExtCodes* /* codes */
1097 ) /* proc */
1098))(
1099 Display*, GC, XExtCodes*
1100);
1101
1102extern int (*XESetCopyGC(
1103 Display* /* display */,
1104 int /* extension */,
1105 int (*) (
1106 Display* /* display */,
1107 GC /* gc */,
1108 XExtCodes* /* codes */
1109 ) /* proc */
1110))(
1111 Display*, GC, XExtCodes*
1112);
1113
1114extern int (*XESetFlushGC(
1115 Display* /* display */,
1116 int /* extension */,
1117 int (*) (
1118 Display* /* display */,
1119 GC /* gc */,
1120 XExtCodes* /* codes */
1121 ) /* proc */
1122))(
1123 Display*, GC, XExtCodes*
1124);
1125
1126extern int (*XESetFreeGC(
1127 Display* /* display */,
1128 int /* extension */,
1129 int (*) (
1130 Display* /* display */,
1131 GC /* gc */,
1132 XExtCodes* /* codes */
1133 ) /* proc */
1134))(
1135 Display*, GC, XExtCodes*
1136);
1137
1138extern int (*XESetCreateFont(
1139 Display* /* display */,
1140 int /* extension */,
1141 int (*) (
1142 Display* /* display */,
1143 XFontStruct* /* fs */,
1144 XExtCodes* /* codes */
1145 ) /* proc */
1146))(
1147 Display*, XFontStruct*, XExtCodes*
1148);
1149
1150extern int (*XESetFreeFont(
1151 Display* /* display */,
1152 int /* extension */,
1153 int (*) (
1154 Display* /* display */,
1155 XFontStruct* /* fs */,
1156 XExtCodes* /* codes */
1157 ) /* proc */
1158))(
1159 Display*, XFontStruct*, XExtCodes*
1160);
1161
1162extern int (*XESetCloseDisplay(
1163 Display* /* display */,
1164 int /* extension */,
1165 int (*) (
1166 Display* /* display */,
1167 XExtCodes* /* codes */
1168 ) /* proc */
1169))(
1170 Display*, XExtCodes*
1171);
1172
1173extern int (*XESetError(
1174 Display* /* display */,
1175 int /* extension */,
1176 int (*) (
1177 Display* /* display */,
1178 xError* /* err */,
1179 XExtCodes* /* codes */,
1180 int* /* ret_code */
1181 ) /* proc */
1182))(
1183 Display*, xError*, XExtCodes*, int*
1184);
1185
1186extern char* (*XESetErrorString(
1187 Display* /* display */,
1188 int /* extension */,
1189 char* (*) (
1190 Display* /* display */,
1191 int /* code */,
1192 XExtCodes* /* codes */,
1193 char* /* buffer */,
1194 int /* nbytes */
1195 ) /* proc */
1196))(
1197 Display*, int, XExtCodes*, char*, int
1198);
1199
1200extern void (*XESetPrintErrorValues (
1201 Display* /* display */,
1202 int /* extension */,
1203 void (*)(
1204 Display* /* display */,
1205 XErrorEvent* /* ev */,
1206 void* /* fp */
1207 ) /* proc */
1208))(
1209 Display*, XErrorEvent*, void*
1210);
1211
1212extern Bool (*XESetWireToEvent(
1213 Display* /* display */,
1214 int /* event_number */,
1215 Bool (*) (
1216 Display* /* display */,
1217 XEvent* /* re */,
1218 xEvent* /* event */
1219 ) /* proc */
1220))(
1221 Display*, XEvent*, xEvent*
1222);
1223
1224extern Bool (*XESetWireToEventCookie(
1225 Display* /* display */,
1226 int /* extension */,
1227 Bool (*) (
1228 Display* /* display */,
1229 XGenericEventCookie* /* re */,
1230 xEvent* /* event */
1231 ) /* proc */
1232))(
1233 Display*, XGenericEventCookie*, xEvent*
1234);
1235
1236extern Bool (*XESetCopyEventCookie(
1237 Display* /* display */,
1238 int /* extension */,
1239 Bool (*) (
1240 Display* /* display */,
1241 XGenericEventCookie* /* in */,
1242 XGenericEventCookie* /* out */
1243 ) /* proc */
1244))(
1245 Display*, XGenericEventCookie*, XGenericEventCookie*
1246);
1247
1248
1249extern Status (*XESetEventToWire(
1250 Display* /* display */,
1251 int /* event_number */,
1252 Status (*) (
1253 Display* /* display */,
1254 XEvent* /* re */,
1255 xEvent* /* event */
1256 ) /* proc */
1257))(
1258 Display*, XEvent*, xEvent*
1259);
1260
1261extern Bool (*XESetWireToError(
1262 Display* /* display */,
1263 int /* error_number */,
1264 Bool (*) (
1265 Display* /* display */,
1266 XErrorEvent* /* he */,
1267 xError* /* we */
1268 ) /* proc */
1269))(
1270 Display*, XErrorEvent*, xError*
1271);
1272
1273extern void (*XESetBeforeFlush(
1274 Display* /* display */,
1275 int /* error_number */,
1276 void (*) (
1277 Display* /* display */,
1278 XExtCodes* /* codes */,
1279 _Xconst char* /* data */,
1280 long /* len */
1281 ) /* proc */
1282))(
1283 Display*, XExtCodes*, _Xconst char*, long
1284);
1285
1286/* internal connections for IMs */
1287
1288typedef void (*_XInternalConnectionProc)(
1289 Display* /* dpy */,
1290 int /* fd */,
1291 XPointer /* call_data */
1292);
1293
1294
1295extern Status _XRegisterInternalConnection(
1296 Display* /* dpy */,
1297 int /* fd */,
1298 _XInternalConnectionProc /* callback */,
1299 XPointer /* call_data */
1300);
1301
1302extern void _XUnregisterInternalConnection(
1303 Display* /* dpy */,
1304 int /* fd */
1305);
1306
1307extern void _XProcessInternalConnection(
1308 Display* /* dpy */,
1309 struct _XConnectionInfo* /* conn_info */
1310);
1311
1312/* Display structure has pointers to these */
1313
1314struct _XConnectionInfo { /* info from _XRegisterInternalConnection */
1315 int fd;
1316 _XInternalConnectionProc read_callback;
1317 XPointer call_data;
1318 XPointer *watch_data; /* set/used by XConnectionWatchProc */
1319 struct _XConnectionInfo *next;
1320};
1321
1322struct _XConnWatchInfo { /* info from XAddConnectionWatch */
1323 XConnectionWatchProc fn;
1324 XPointer client_data;
1325 struct _XConnWatchInfo *next;
1326};
1327
1328extern int _XTextHeight(
1329 XFontStruct* /* font_struct */,
1330 _Xconst char* /* string */,
1331 int /* count */
1332);
1333
1334extern int _XTextHeight16(
1335 XFontStruct* /* font_struct */,
1336 _Xconst XChar2b* /* string */,
1337 int /* count */
1338);
1339
1340#if defined(WIN32)
1341
1342extern int _XOpenFile(
1343 _Xconst char* /* path */,
1344 int /* flags */
1345);
1346
1347extern int _XOpenFileMode(
1348 _Xconst char* /* path */,
1349 int /* flags */,
1350 mode_t /* mode */
1351);
1352
1353extern void* _XFopenFile(
1354 _Xconst char* /* path */,
1355 _Xconst char* /* mode */
1356);
1357
1358extern int _XAccessFile(
1359 _Xconst char* /* path */
1360);
1361#else
1362#define _XOpenFile(path,flags) open(path,flags)
1363#define _XOpenFileMode(path,flags,mode) open(path,flags,mode)
1364#define _XFopenFile(path,mode) fopen(path,mode)
1365#endif
1366
1367/* EvToWire.c */
1368extern Status _XEventToWire(Display *dpy, XEvent *re, xEvent *event);
1369
1370extern int _XF86LoadQueryLocaleFont(
1371 Display* /* dpy */,
1372 _Xconst char* /* name*/,
1373 XFontStruct** /* xfp*/,
1374 Font* /* fidp */
1375);
1376
1377extern void _XProcessWindowAttributes (
1378 Display *dpy,
1379 xChangeWindowAttributesReq *req,
1380 unsigned long valuemask,
1381 XSetWindowAttributes *attributes);
1382
1383extern int _XDefaultError(
1384 Display *dpy,
1385 XErrorEvent *event);
1386
1387extern int _XDefaultIOError(
1388 Display *dpy);
1389
1390extern void _XDefaultIOErrorExit(
1391 Display *dpy,
1392 void *user_data);
1393
1394extern void _XSetClipRectangles (
1395 Display *dpy,
1396 GC gc,
1397 int clip_x_origin, int clip_y_origin,
1398 XRectangle *rectangles,
1399 int n,
1400 int ordering);
1401
1402Status _XGetWindowAttributes(
1403 Display *dpy,
1404 Window w,
1405 XWindowAttributes *attr);
1406
1407int _XPutBackEvent (
1408 Display *dpy,
1409 XEvent *event);
1410
1411extern Bool _XIsEventCookie(
1412 Display *dpy,
1413 XEvent *ev);
1414
1415extern void _XFreeEventCookies(
1416 Display *dpy);
1417
1418extern void _XStoreEventCookie(
1419 Display *dpy,
1420 XEvent *ev);
1421
1422extern Bool _XFetchEventCookie(
1423 Display *dpy,
1424 XGenericEventCookie *ev);
1425
1426extern Bool _XCopyEventCookie(
1427 Display *dpy,
1428 XGenericEventCookie *in,
1429 XGenericEventCookie *out);
1430
1431/* lcFile.c */
1432
1433extern void xlocaledir(
1434 char *buf,
1435 int buf_len
1436);
1437
1438#ifdef __clang__
1439#pragma clang diagnostic pop
1440#endif
1441
1442_XFUNCPROTOEND
1443
1444#endif /* _X11_XLIBINT_H_ */