| File: | modules/im/ximcp/imExten.c |
| Location: | line 479, column 28 |
| Description: | The left operand of '==' is a garbage value |
| 1 | /****************************************************************** | |||
| 2 | ||||
| 3 | Copyright 1992, 1993, 1994 by FUJITSU LIMITED | |||
| 4 | ||||
| 5 | Permission to use, copy, modify, distribute, and sell this software | |||
| 6 | and its documentation for any purpose is hereby granted without fee, | |||
| 7 | provided that the above copyright notice appear in all copies and | |||
| 8 | that both that copyright notice and this permission notice appear | |||
| 9 | in supporting documentation, and that the name of FUJITSU LIMITED | |||
| 10 | not be used in advertising or publicity pertaining to distribution | |||
| 11 | of the software without specific, written prior permission. | |||
| 12 | FUJITSU LIMITED makes no representations about the suitability of | |||
| 13 | this software for any purpose. | |||
| 14 | It is provided "as is" without express or implied warranty. | |||
| 15 | ||||
| 16 | FUJITSU LIMITED DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, | |||
| 17 | INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO | |||
| 18 | EVENT SHALL FUJITSU LIMITED BE LIABLE FOR ANY SPECIAL, INDIRECT OR | |||
| 19 | CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF | |||
| 20 | USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR | |||
| 21 | OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR | |||
| 22 | PERFORMANCE OF THIS SOFTWARE. | |||
| 23 | ||||
| 24 | Author: Takashi Fujiwara FUJITSU LIMITED | |||
| 25 | fujiwara@a80.tech.yk.fujitsu.co.jp | |||
| 26 | ||||
| 27 | ******************************************************************/ | |||
| 28 | ||||
| 29 | #ifdef HAVE_CONFIG_H1 | |||
| 30 | #include <config.h> | |||
| 31 | #endif | |||
| 32 | #include <X11/Xatom.h> | |||
| 33 | #include "Xlibint.h" | |||
| 34 | #include "Xlcint.h" | |||
| 35 | #include "Ximint.h" | |||
| 36 | ||||
| 37 | /* | |||
| 38 | * index of extensions | |||
| 39 | */ | |||
| 40 | ||||
| 41 | #define XIM_EXT_SET_EVENT_MASK_IDX0 0 | |||
| 42 | #ifdef EXT_FORWARD | |||
| 43 | #define XIM_EXT_FORWARD_KEYEVENT_IDX 1 | |||
| 44 | #endif | |||
| 45 | #ifdef EXT_MOVE | |||
| 46 | #define XIM_EXT_MOVE_IDX 2 | |||
| 47 | #endif | |||
| 48 | ||||
| 49 | typedef struct _XIM_QueryExtRec { | |||
| 50 | Boolint is_support; | |||
| 51 | const char *name; | |||
| 52 | int name_len; | |||
| 53 | CARD16 major_opcode; | |||
| 54 | CARD16 minor_opcode; | |||
| 55 | int idx; | |||
| 56 | } XIM_QueryExtRec; | |||
| 57 | ||||
| 58 | static XIM_QueryExtRec extensions[] = { | |||
| 59 | {False0, "XIM_EXT_SET_EVENT_MASK", 0, 0, 0, | |||
| 60 | XIM_EXT_SET_EVENT_MASK_IDX0}, | |||
| 61 | #ifdef EXT_FORWARD | |||
| 62 | {False0, "XIM_EXT_FORWARD_KEYEVENT", 0, 0, 0, | |||
| 63 | XIM_EXT_FORWARD_KEYEVENT_IDX}, | |||
| 64 | #endif | |||
| 65 | #ifdef EXT_MOVE | |||
| 66 | {False0, "XIM_EXT_MOVE", 0, 0, 0, XIM_EXT_MOVE_IDX}, | |||
| 67 | #endif | |||
| 68 | {False0, NULL((void*)0), 0, 0, 0, 0} /* dummy */ | |||
| 69 | }; | |||
| 70 | ||||
| 71 | static int | |||
| 72 | _XimIsSupportExt( | |||
| 73 | int idx) | |||
| 74 | { | |||
| 75 | register int i; | |||
| 76 | int n = XIMNumber(extensions)((unsigned int) (sizeof(extensions) / sizeof(extensions[0]))) - 1; | |||
| 77 | ||||
| 78 | for (i = 0; i < n; i++) { | |||
| 79 | if (extensions[i].idx == idx) { | |||
| 80 | if (extensions[i].is_support) | |||
| 81 | return i; | |||
| 82 | else | |||
| 83 | break; | |||
| 84 | } | |||
| 85 | } | |||
| 86 | return -1; | |||
| 87 | } | |||
| 88 | ||||
| 89 | static Boolint | |||
| 90 | _XimProcExtSetEventMask( | |||
| 91 | Xim im, | |||
| 92 | Xic ic, | |||
| 93 | XPointer buf) | |||
| 94 | { | |||
| 95 | EVENTMASK *buf_l = (EVENTMASK *)buf; | |||
| 96 | EVENTMASK select_mask = _XimGetWindowEventmask(ic); | |||
| 97 | ||||
| 98 | ic->private.proto.filter_event_mask = buf_l[0]; | |||
| 99 | ic->private.proto.intercept_event_mask = buf_l[1]; | |||
| 100 | ic->private.proto.select_event_mask = buf_l[2]; | |||
| 101 | ic->private.proto.forward_event_mask = buf_l[3]; | |||
| 102 | ic->private.proto.synchronous_event_mask = buf_l[4]; | |||
| 103 | ||||
| 104 | select_mask &= ~ic->private.proto.intercept_event_mask; | |||
| 105 | /* deselected event mask */ | |||
| 106 | select_mask |= ic->private.proto.select_event_mask; | |||
| 107 | /* selected event mask */ | |||
| 108 | XSelectInput(im->core.display, ic->core.focus_window, select_mask); | |||
| 109 | _XimReregisterFilter(ic); | |||
| 110 | ||||
| 111 | if (!(_XimProcSyncReply(im, ic))) | |||
| 112 | return False0; | |||
| 113 | return True1; | |||
| 114 | } | |||
| 115 | ||||
| 116 | static Boolint | |||
| 117 | _XimExtSetEventMaskCallback( | |||
| 118 | Xim xim, | |||
| 119 | INT16 len, | |||
| 120 | XPointer data, | |||
| 121 | XPointer call_data) | |||
| 122 | { | |||
| 123 | CARD16 *buf_s = (CARD16 *)((CARD8 *)data + XIM_HEADER_SIZEsizeof(CARD8) + sizeof(CARD8) + sizeof(INT16)); | |||
| 124 | XIMID imid = buf_s[0]; | |||
| 125 | XICID icid = buf_s[1]; | |||
| 126 | Xim im = (Xim)call_data; | |||
| 127 | Xic ic; | |||
| 128 | ||||
| 129 | if ((imid == im->private.proto.imid) | |||
| 130 | && (ic = _XimICOfXICID(im, icid))) { | |||
| 131 | (void)_XimProcExtSetEventMask(im, ic, (XPointer)&buf_s[2]); | |||
| 132 | return True1; | |||
| 133 | } | |||
| 134 | return False0; | |||
| 135 | } | |||
| 136 | ||||
| 137 | #ifdef EXT_FORWARD | |||
| 138 | static Boolint | |||
| 139 | _XimProcExtForwardKeyEvent( | |||
| 140 | Xim im, | |||
| 141 | Xic ic, | |||
| 142 | XPointer buf) | |||
| 143 | { | |||
| 144 | CARD8 *buf_b = (CARD8 *)buf; | |||
| 145 | CARD16 *buf_s = (CARD16 *)buf; | |||
| 146 | CARD32 *buf_l = (CARD32 *)buf; | |||
| 147 | XEvent ev; | |||
| 148 | XKeyEvent *kev = (XKeyEvent *)&ev; | |||
| 149 | ||||
| 150 | bzero(&ev, sizeof(XEvent))__builtin___memset_chk (&ev, 0, sizeof(XEvent), __builtin_object_size (&ev, 0)); | |||
| 151 | kev->send_event = False0; | |||
| 152 | kev->display = im->core.display; | |||
| 153 | kev->serial = buf_s[1]; /* sequence number */ | |||
| 154 | kev->type = buf_b[4] & 0x7f; /* xEvent.u.u.type */ | |||
| 155 | kev->keycode = buf_b[5]; /* Keycode */ | |||
| 156 | kev->state = buf_s[3]; /* state */ | |||
| 157 | kev->time = buf_l[2]; /* time */ | |||
| 158 | ||||
| 159 | XPutBackEvent(im->core.display, &ev); | |||
| 160 | ||||
| 161 | _XimRespSyncReply(ic, buf_s[0]); | |||
| 162 | MARK_FABRICATED(im)(((Xim)im)->private.proto.flag |= (1L << 5)); | |||
| 163 | ||||
| 164 | return True1; | |||
| 165 | } | |||
| 166 | ||||
| 167 | static Boolint | |||
| 168 | _XimExtForwardKeyEventCallback( | |||
| 169 | Xim xim, | |||
| 170 | INT16 len, | |||
| 171 | XPointer data, | |||
| 172 | XPointer call_data) | |||
| 173 | { | |||
| 174 | CARD16 *buf_s = (CARD16 *)((CARD8 *)data + XIM_HEADER_SIZEsizeof(CARD8) + sizeof(CARD8) + sizeof(INT16)); | |||
| 175 | XIMID imid = buf_s[0]; | |||
| 176 | XICID icid = buf_s[1]; | |||
| 177 | Xim im = (Xim)call_data; | |||
| 178 | Xic ic; | |||
| 179 | ||||
| 180 | if ((imid == im->private.proto.imid) | |||
| 181 | && (ic = _XimICOfXICID(im, icid))) { | |||
| 182 | (void)_XimProcExtForwardKeyEvent(im, ic, (XPointer)&buf_s[2]); | |||
| 183 | return True1; | |||
| 184 | } | |||
| 185 | return False0; | |||
| 186 | } | |||
| 187 | ||||
| 188 | static Boolint | |||
| 189 | _XimExtForwardKeyEventCheck( | |||
| 190 | Xim im, | |||
| 191 | INT16 len, | |||
| 192 | XPointer data, | |||
| 193 | XPointer arg) | |||
| 194 | { | |||
| 195 | Xic ic = (Xic)arg; | |||
| 196 | CARD16 *buf_s = (CARD16 *)((CARD8 *)data + XIM_HEADER_SIZEsizeof(CARD8) + sizeof(CARD8) + sizeof(INT16)); | |||
| 197 | CARD8 major_opcode = *((CARD8 *)data); | |||
| 198 | CARD8 minor_opcode = *((CARD8 *)data + 1); | |||
| 199 | XIMID imid = buf_s[0]; | |||
| 200 | XICID icid = buf_s[1]; | |||
| 201 | ||||
| 202 | if ((major_opcode == XIM_SYNC_REPLY62) | |||
| 203 | && (minor_opcode == 0) | |||
| 204 | && (imid == im->private.proto.imid) | |||
| 205 | && (icid == ic->private.proto.icid)) | |||
| 206 | if ((major_opcode == XIM_ERROR20) | |||
| 207 | && (minor_opcode == 0) | |||
| 208 | && (buf_s[2] & XIM_IMID_VALID0x0001) | |||
| 209 | && (imid == im->private.proto.imid) | |||
| 210 | && (buf_s[2] & XIM_ICID_VALID0x0002) | |||
| 211 | && (icid == ic->private.proto.icid)) | |||
| 212 | return True1; | |||
| 213 | return False0; | |||
| 214 | } | |||
| 215 | ||||
| 216 | Boolint | |||
| 217 | _XimExtForwardKeyEvent( | |||
| 218 | Xic ic, | |||
| 219 | XKeyEvent *ev, | |||
| 220 | Boolint sync) | |||
| 221 | { | |||
| 222 | Xim im = (Xim) ic->core.im; | |||
| 223 | CARD32 buf32[BUFSIZE2048/4]; | |||
| 224 | CARD8 *buf = (CARD8 *)buf32; | |||
| 225 | CARD8 *buf_b = &buf[XIM_HEADER_SIZEsizeof(CARD8) + sizeof(CARD8) + sizeof(INT16)]; | |||
| 226 | CARD16 *buf_s = (CARD16 *)buf_b; | |||
| 227 | CARD32 *buf_l = (CARD32 *)buf_b; | |||
| 228 | CARD32 reply32[BUFSIZE2048/4]; | |||
| 229 | char *reply = (char *)reply32; | |||
| 230 | XPointer preply; | |||
| 231 | int buf_size; | |||
| 232 | int ret_code; | |||
| 233 | INT16 len; | |||
| 234 | int idx; | |||
| 235 | ||||
| 236 | if ((idx = _XimIsSupportExt(XIM_EXT_FORWARD_KEYEVENT_IDX)) < 0) | |||
| 237 | return False0; | |||
| 238 | ||||
| 239 | buf_s[0] = im->private.proto.imid; /* imid */ | |||
| 240 | buf_s[1] = ic->private.proto.icid; /* icid */ | |||
| 241 | buf_s[2] = sync ? XimSYNCHRONUS0x0001 : 0; /* flag */ | |||
| 242 | buf_s[3] = (CARD16)(((XAnyEvent *)ev)->serial & ((unsigned long) 0xffff)); | |||
| 243 | /* sequence number */ | |||
| 244 | buf_b[8] = ev->type; /* xEvent.u.u.type */ | |||
| 245 | buf_b[9] = ev->keycode; /* keycode */ | |||
| 246 | buf_s[5] = ev->state; /* state */ | |||
| 247 | buf_l[3] = ev->time; /* time */ | |||
| 248 | len = sizeof(CARD16) /* sizeof imid */ | |||
| 249 | + sizeof(CARD16) /* sizeof icid */ | |||
| 250 | + sizeof(BITMASK16) /* sizeof flag */ | |||
| 251 | + sizeof(CARD16) /* sizeof sequence number */ | |||
| 252 | + sizeof(BYTE) /* sizeof xEvent.u.u.type */ | |||
| 253 | + sizeof(BYTE) /* sizeof keycode */ | |||
| 254 | + sizeof(CARD16) /* sizeof state */ | |||
| 255 | + sizeof(CARD32); /* sizeof time */ | |||
| 256 | ||||
| 257 | _XimSetHeader((XPointer)buf, | |||
| 258 | extensions[idx].major_opcode, | |||
| 259 | extensions[idx].minor_opcode, &len); | |||
| 260 | if (!(_XimWrite(im, len, (XPointer)buf))) | |||
| 261 | return False0; | |||
| 262 | _XimFlush(im); | |||
| 263 | if (sync) { | |||
| 264 | buf_size = BUFSIZE2048; | |||
| 265 | ret_code = _XimRead(im, &len, (XPointer)reply, buf_size, | |||
| 266 | _XimExtForwardKeyEventCheck, (XPointer)ic); | |||
| 267 | if(ret_code == XIM_TRUE1) { | |||
| 268 | preply = reply; | |||
| 269 | } else if(ret_code == XIM_OVERFLOW(-1)) { | |||
| 270 | if(len <= 0) { | |||
| 271 | preply = reply; | |||
| 272 | } else { | |||
| 273 | buf_sizex = len; | |||
| 274 | preply = Xmalloc(buf_size)malloc(((buf_size) == 0 ? 1 : (buf_size))); | |||
| 275 | ret_code = _XimRead(im, &len, preply, buf_size, | |||
| 276 | _XimExtForwardKeyEventCheck, (XPointer)ic); | |||
| 277 | if(ret_code != XIM_TRUE1) { | |||
| 278 | Xfree(preply)free((preply)); | |||
| 279 | return False0; | |||
| 280 | } | |||
| 281 | } | |||
| 282 | } else | |||
| 283 | return False0; | |||
| 284 | buf_s = (CARD16 *)((char *)preply + XIM_HEADER_SIZEsizeof(CARD8) + sizeof(CARD8) + sizeof(INT16)); | |||
| 285 | if (*((CARD8 *)preply) == XIM_ERROR20) { | |||
| 286 | _XimProcError(im, 0, (XPointer)&buf_s[3]); | |||
| 287 | if(reply != preply) | |||
| 288 | Xfree(preply)free((preply)); | |||
| 289 | return False0; | |||
| 290 | } | |||
| 291 | if(reply != preply) | |||
| 292 | Xfree(preply)free((preply)); | |||
| 293 | } | |||
| 294 | return True1; | |||
| 295 | } | |||
| 296 | #endif /* EXT_FORWARD */ | |||
| 297 | ||||
| 298 | static int | |||
| 299 | _XimCheckExtensionListSize(void) | |||
| 300 | { | |||
| 301 | register int i; | |||
| 302 | int len; | |||
| 303 | int total = 0; | |||
| 304 | int n = XIMNumber(extensions)((unsigned int) (sizeof(extensions) / sizeof(extensions[0]))) - 1; | |||
| 305 | ||||
| 306 | for (i = 0; i < n; i++) { | |||
| 307 | len = strlen(extensions[i].name); | |||
| 308 | extensions[i].name_len = len; | |||
| 309 | len += sizeof(BYTE); | |||
| 310 | total += len; | |||
| 311 | } | |||
| 312 | return total; | |||
| 313 | } | |||
| 314 | ||||
| 315 | static void | |||
| 316 | _XimSetExtensionList( | |||
| 317 | CARD8 *buf) | |||
| 318 | { | |||
| 319 | register int i; | |||
| 320 | int len; | |||
| 321 | int n = XIMNumber(extensions)((unsigned int) (sizeof(extensions) / sizeof(extensions[0]))) - 1; | |||
| 322 | ||||
| 323 | for (i = 0; i < n; i++) { | |||
| 324 | len = extensions[i].name_len; | |||
| 325 | buf[0] = (BYTE)len; | |||
| 326 | (void)strcpy((char *)&buf[1], extensions[i].name)__builtin___strcpy_chk ((char *)&buf[1], extensions[i].name , __builtin_object_size ((char *)&buf[1], 2 > 1 ? 1 : 0 )); | |||
| 327 | len += sizeof(BYTE); | |||
| 328 | buf += len; | |||
| 329 | } | |||
| 330 | return; | |||
| 331 | } | |||
| 332 | ||||
| 333 | static unsigned int | |||
| 334 | _XimCountNumberOfExtension( | |||
| 335 | INT16 total, | |||
| 336 | CARD8 *ext) | |||
| 337 | { | |||
| 338 | unsigned int n; | |||
| 339 | INT16 len; | |||
| 340 | INT16 min_len = sizeof(CARD8) | |||
| 341 | + sizeof(CARD8) | |||
| 342 | + sizeof(INT16); | |||
| 343 | ||||
| 344 | n = 0; | |||
| 345 | while (total > min_len) { | |||
| 346 | len = *((INT16 *)(&ext[2])); | |||
| 347 | len += (min_len + XIM_PAD(len)((4 - ((len) % 4)) % 4)); | |||
| 348 | total -= len; | |||
| 349 | ext += len; | |||
| 350 | n++; | |||
| 351 | } | |||
| 352 | return n; | |||
| 353 | } | |||
| 354 | ||||
| 355 | static Boolint | |||
| 356 | _XimParseExtensionList( | |||
| 357 | Xim im, | |||
| 358 | CARD16 *data) | |||
| 359 | { | |||
| 360 | int num = XIMNumber(extensions)((unsigned int) (sizeof(extensions) / sizeof(extensions[0]))) - 1; | |||
| 361 | unsigned int n; | |||
| 362 | CARD8 *buf; | |||
| 363 | register int i; | |||
| 364 | register int j; | |||
| 365 | INT16 len; | |||
| 366 | ||||
| 367 | if (!(n = _XimCountNumberOfExtension(data[0], (CARD8 *)&data[1]))) | |||
| 368 | return True1; | |||
| 369 | ||||
| 370 | buf = (CARD8 *)&data[1]; | |||
| 371 | for (i = 0; i < n; i++) { | |||
| 372 | len = *((INT16 *)(&buf[2])); | |||
| 373 | for (j = 0; j < num; j++) { | |||
| 374 | if (!(strncmp(extensions[j].name, (char *)&buf[4], len))) { | |||
| 375 | extensions[j].major_opcode = buf[0]; | |||
| 376 | extensions[j].minor_opcode = buf[1]; | |||
| 377 | extensions[j].is_support = True1; | |||
| 378 | break; | |||
| 379 | } | |||
| 380 | } | |||
| 381 | len += sizeof(CARD8) /* sizeof major_opcode */ | |||
| 382 | + sizeof(CARD8) /* sizeof minor_opcode */ | |||
| 383 | + sizeof(INT16) /* sizeof length */ | |||
| 384 | + XIM_PAD(len)((4 - ((len) % 4)) % 4); /* sizeof pad */ | |||
| 385 | buf += len; | |||
| 386 | } | |||
| 387 | ||||
| 388 | return True1; | |||
| 389 | } | |||
| 390 | ||||
| 391 | static Boolint | |||
| 392 | _XimQueryExtensionCheck( | |||
| 393 | Xim im, | |||
| 394 | INT16 len, | |||
| 395 | XPointer data, | |||
| 396 | XPointer arg) | |||
| 397 | { | |||
| 398 | CARD16 *buf_s = (CARD16 *)((CARD8 *)data + XIM_HEADER_SIZEsizeof(CARD8) + sizeof(CARD8) + sizeof(INT16)); | |||
| 399 | CARD8 major_opcode = *((CARD8 *)data); | |||
| 400 | CARD8 minor_opcode = *((CARD8 *)data + 1); | |||
| 401 | XIMID imid = buf_s[0]; | |||
| 402 | ||||
| 403 | if ((major_opcode == XIM_QUERY_EXTENSION_REPLY41) | |||
| 404 | && (minor_opcode == 0) | |||
| 405 | && (imid == im->private.proto.imid)) | |||
| 406 | return True1; | |||
| 407 | if ((major_opcode == XIM_ERROR20) | |||
| 408 | && (minor_opcode == 0) | |||
| 409 | && (buf_s[2] & XIM_IMID_VALID0x0001) | |||
| 410 | && (imid == im->private.proto.imid)) | |||
| 411 | return True1; | |||
| 412 | return False0; | |||
| 413 | } | |||
| 414 | ||||
| 415 | Boolint | |||
| 416 | _XimExtension( | |||
| 417 | Xim im) | |||
| 418 | { | |||
| 419 | CARD8 *buf; | |||
| 420 | CARD16 *buf_s; | |||
| 421 | int buf_len; | |||
| 422 | INT16 len; | |||
| 423 | CARD32 reply32[BUFSIZE2048/4]; | |||
| 424 | char *reply = (char *)reply32; | |||
| 425 | XPointer preply; | |||
| 426 | int buf_size; | |||
| 427 | int ret_code; | |||
| 428 | int idx; | |||
| 429 | ||||
| 430 | if (!(len = _XimCheckExtensionListSize())) | |||
| ||||
| 431 | return True1; | |||
| 432 | ||||
| 433 | buf_len = XIM_HEADER_SIZEsizeof(CARD8) + sizeof(CARD8) + sizeof(INT16) | |||
| 434 | + sizeof(CARD16) | |||
| 435 | + sizeof(INT16) | |||
| 436 | + len | |||
| 437 | + XIM_PAD(len)((4 - ((len) % 4)) % 4); | |||
| 438 | ||||
| 439 | if (!(buf = Xmalloc(buf_len)malloc(((buf_len) == 0 ? 1 : (buf_len))))) | |||
| 440 | return False0; | |||
| 441 | buf_s = (CARD16 *)&buf[XIM_HEADER_SIZEsizeof(CARD8) + sizeof(CARD8) + sizeof(INT16)]; | |||
| 442 | ||||
| 443 | buf_s[0] = im->private.proto.imid; /* imid */ | |||
| 444 | buf_s[1] = len; /* length of Extensions */ | |||
| 445 | _XimSetExtensionList((CARD8 *)&buf_s[2]); | |||
| 446 | /* extensions supported */ | |||
| 447 | XIM_SET_PAD(&buf_s[2], len){ register int Counter = ((4 - (((int)len) % 4)) % 4); if (Counter ) { register char *Ptr = (char *)(&buf_s[2]) + (len); len += Counter; for (; Counter; --Counter, ++Ptr) *Ptr = '\0'; } }; /* pad */ | |||
| 448 | len += sizeof(CARD16) /* sizeof imid */ | |||
| 449 | + sizeof(INT16); /* sizeof length of extensions */ | |||
| 450 | ||||
| 451 | _XimSetHeader((XPointer)buf, XIM_QUERY_EXTENSION40, 0, &len); | |||
| 452 | if (!(_XimWrite(im, len, (XPointer)buf))) { | |||
| 453 | XFree(buf); | |||
| 454 | return False0; | |||
| 455 | } | |||
| 456 | XFree(buf); | |||
| 457 | _XimFlush(im); | |||
| 458 | buf_size = BUFSIZE2048; | |||
| 459 | ret_code = _XimRead(im, &len, (XPointer)reply, buf_size, | |||
| 460 | _XimQueryExtensionCheck, 0); | |||
| 461 | if(ret_code == XIM_TRUE1) { | |||
| 462 | preply = reply; | |||
| 463 | } else if(ret_code == XIM_OVERFLOW(-1)) { | |||
| 464 | if(len <= 0) { | |||
| 465 | preply = reply; | |||
| 466 | } else { | |||
| 467 | buf_size = len; | |||
| 468 | preply = Xmalloc(buf_size)malloc(((buf_size) == 0 ? 1 : (buf_size))); | |||
| 469 | ret_code = _XimRead(im, &len, reply, buf_size, | |||
| 470 | _XimQueryExtensionCheck, 0); | |||
| 471 | if(ret_code != XIM_TRUE1) { | |||
| 472 | Xfree(preply)free((preply)); | |||
| 473 | return False0; | |||
| 474 | } | |||
| 475 | } | |||
| 476 | } else | |||
| 477 | return False0; | |||
| 478 | buf_s = (CARD16 *)((char *)preply + XIM_HEADER_SIZEsizeof(CARD8) + sizeof(CARD8) + sizeof(INT16)); | |||
| 479 | if (*((CARD8 *)preply) == XIM_ERROR20) { | |||
| ||||
| 480 | _XimProcError(im, 0, (XPointer)&buf_s[3]); | |||
| 481 | if(reply != preply) | |||
| 482 | Xfree(preply)free((preply)); | |||
| 483 | return False0; | |||
| 484 | } | |||
| 485 | ||||
| 486 | if (!(_XimParseExtensionList(im, &buf_s[1]))) { | |||
| 487 | if(reply != preply) | |||
| 488 | Xfree(preply)free((preply)); | |||
| 489 | return False0; | |||
| 490 | } | |||
| 491 | if(reply != preply) | |||
| 492 | Xfree(preply)free((preply)); | |||
| 493 | ||||
| 494 | if ((idx = _XimIsSupportExt(XIM_EXT_SET_EVENT_MASK_IDX0)) >= 0) | |||
| 495 | _XimRegProtoIntrCallback(im, | |||
| 496 | extensions[idx].major_opcode, | |||
| 497 | extensions[idx].minor_opcode, | |||
| 498 | _XimExtSetEventMaskCallback, (XPointer)im); | |||
| 499 | #ifdef EXT_FORWARD | |||
| 500 | if ((idx = _XimIsSupportExt(XIM_EXT_FORWARD_KEYEVENT_IDX)) >= 0) | |||
| 501 | _XimRegProtoIntrCallback(im, | |||
| 502 | extensions[idx].major_opcode, | |||
| 503 | extensions[idx].minor_opcode, | |||
| 504 | _XimExtForwardKeyEventCallback, (XPointer)im); | |||
| 505 | #endif | |||
| 506 | ||||
| 507 | return True1; | |||
| 508 | } | |||
| 509 | ||||
| 510 | #ifdef EXT_MOVE | |||
| 511 | /* flag of ExtenArgCheck */ | |||
| 512 | #define EXT_XNSPOTLOCATION (1L<<0) | |||
| 513 | ||||
| 514 | /* macro for ExtenArgCheck */ | |||
| 515 | #define SET_EXT_XNSPOTLOCATION(flag) (flag |= EXT_XNSPOTLOCATION) | |||
| 516 | #define IS_EXT_XNSPOTLOCATION(flag) (flag & EXT_XNSPOTLOCATION) | |||
| 517 | ||||
| 518 | /* length of XPoint attribute */ | |||
| 519 | #define XIM_Xpoint_length 12 | |||
| 520 | ||||
| 521 | static Boolint | |||
| 522 | _XimExtMove( | |||
| 523 | Xim im, | |||
| 524 | Xic ic, | |||
| 525 | CARD16 x, | |||
| 526 | CARD16 y) | |||
| 527 | { | |||
| 528 | CARD32 buf32[BUFSIZE2048/4]; | |||
| 529 | CARD8 *buf = (CARD8 *)buf32; | |||
| 530 | CARD16 *buf_s = (CARD16 *)&buf[XIM_HEADER_SIZEsizeof(CARD8) + sizeof(CARD8) + sizeof(INT16)]; | |||
| 531 | INT16 len; | |||
| 532 | int idx; | |||
| 533 | ||||
| 534 | if ((idx = _XimIsSupportExt(XIM_EXT_MOVE_IDX)) < 0) | |||
| 535 | return False0; | |||
| 536 | ||||
| 537 | buf_s[0] = im->private.proto.imid; /* imid */ | |||
| 538 | buf_s[1] = ic->private.proto.icid; /* icid */ | |||
| 539 | buf_s[2] = x; /* X */ | |||
| 540 | buf_s[3] = y; /* Y */ | |||
| 541 | len = sizeof(CARD16) /* sizeof imid */ | |||
| 542 | + sizeof(CARD16) /* sizeof icid */ | |||
| 543 | + sizeof(INT16) /* sizeof X */ | |||
| 544 | + sizeof(INT16); /* sizeof Y */ | |||
| 545 | ||||
| 546 | _XimSetHeader((XPointer)buf, extensions[idx].major_opcode, | |||
| 547 | extensions[idx].minor_opcode, &len); | |||
| 548 | if (!(_XimWrite(im, len, (XPointer)buf))) | |||
| 549 | return False0; | |||
| 550 | _XimFlush(im); | |||
| 551 | return True1; | |||
| 552 | } | |||
| 553 | ||||
| 554 | BITMASK32 | |||
| 555 | _XimExtenArgCheck( | |||
| 556 | XIMArg *arg) | |||
| 557 | { | |||
| 558 | CARD32 flag = 0L; | |||
| 559 | if (!strcmp(arg->name, XNSpotLocation"spotLocation")) | |||
| 560 | SET_EXT_XNSPOTLOCATION(flag); | |||
| 561 | return flag; | |||
| 562 | } | |||
| 563 | ||||
| 564 | Boolint | |||
| 565 | _XimExtenMove( | |||
| 566 | Xim im, | |||
| 567 | Xic ic, | |||
| 568 | CARD32 flag, | |||
| 569 | CARD16 *buf, | |||
| 570 | INT16 length) | |||
| 571 | { | |||
| 572 | if ((IS_EXT_XNSPOTLOCATION(flag)) && (length == XIM_Xpoint_length)) | |||
| 573 | return _XimExtMove(im, ic, buf[4], buf[5]); | |||
| 574 | return False0; | |||
| 575 | } | |||
| 576 | #endif /* EXT_MOVE */ |