![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to swapreq.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / X11 / src / X.V11R1 / server / dix|
Return to swapreq.c CVS log | Up to [Research Unix] / researchv9 / X11 / src / X.V11R1 / server / dix |
1.1 ! root 1: /************************************************************ ! 2: Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts, ! 3: and the Massachusetts Institute of Technology, Cambridge, Massachusetts. ! 4: ! 5: All Rights Reserved ! 6: ! 7: Permission to use, copy, modify, and distribute this software and its ! 8: documentation for any purpose and without fee is hereby granted, ! 9: provided that the above copyright notice appear in all copies and that ! 10: both that copyright notice and this permission notice appear in ! 11: supporting documentation, and that the names of Digital or MIT not be ! 12: used in advertising or publicity pertaining to distribution of the ! 13: software without specific, written prior permission. ! 14: ! 15: DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ! 16: ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL ! 17: DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ! 18: ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, ! 19: WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ! 20: ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS ! 21: SOFTWARE. ! 22: ! 23: ********************************************************/ ! 24: ! 25: /* $Header: swapreq.c,v 1.26 87/08/14 22:40:54 newman Exp $ */ ! 26: ! 27: #include "X.h" ! 28: #define NEED_EVENTS ! 29: #include "Xproto.h" ! 30: #include "Xprotostr.h" ! 31: #include "misc.h" ! 32: #include "dixstruct.h" ! 33: ! 34: extern int (* ProcVector[256]) (); ! 35: extern void (* EventSwapVector[128]) (); /* for SendEvent */ ! 36: ! 37: /* Thanks to Jack Palevich for testing and subsequently rewriting all this */ ! 38: ! 39: #define LengthRestB(stuff) \ ! 40: ((stuff->length << 2) - sizeof(*stuff)) ! 41: ! 42: #define LengthRestS(stuff) \ ! 43: ((stuff->length << 1) - (sizeof(*stuff) >> 1)) ! 44: ! 45: #define LengthRestL(stuff) \ ! 46: (stuff->length - (sizeof(*stuff) >> 2)) ! 47: ! 48: #define SwapRestS(stuff) \ ! 49: SwapShorts(stuff + 1, LengthRestS(stuff)) ! 50: ! 51: #define SwapRestL(stuff) \ ! 52: SwapLongs(stuff + 1, LengthRestL(stuff)) ! 53: ! 54: ! 55: /* The following is used for all requests that have ! 56: no fields to be swapped (except "length") */ ! 57: int ! 58: SProcSimpleReq(client) ! 59: register ClientPtr client; ! 60: { ! 61: register char n; ! 62: ! 63: REQUEST(xReq); ! 64: swaps(&stuff->length, n); ! 65: return(*ProcVector[stuff->reqType])(client); ! 66: } ! 67: ! 68: /* The following is used for all requests that have ! 69: only a single 32-bit field to be swapped, coming ! 70: right after the "length" field */ ! 71: int ! 72: SProcResourceReq(client) ! 73: register ClientPtr client; ! 74: { ! 75: register char n; ! 76: ! 77: REQUEST(xResourceReq); ! 78: swaps(&stuff->length, n); ! 79: swapl(&stuff->id, n); ! 80: return(*ProcVector[stuff->reqType])(client); ! 81: } ! 82: ! 83: int ! 84: SProcCreateWindow(client) ! 85: register ClientPtr client; ! 86: { ! 87: register char n; ! 88: ! 89: REQUEST(xCreateWindowReq); ! 90: swaps(&stuff->length, n); ! 91: swapl(&stuff->wid, n); ! 92: swapl(&stuff->parent, n); ! 93: swaps(&stuff->x, n); ! 94: swaps(&stuff->y, n); ! 95: swaps(&stuff->width, n); ! 96: swaps(&stuff->height, n); ! 97: swaps(&stuff->borderWidth, n); ! 98: swaps(&stuff->class, n); ! 99: swapl(&stuff->visual, n); ! 100: swapl(&stuff->mask, n); ! 101: SwapRestL(stuff); ! 102: return((* ProcVector[X_CreateWindow])(client)); ! 103: } ! 104: ! 105: int ! 106: SProcChangeWindowAttributes(client) ! 107: register ClientPtr client; ! 108: { ! 109: register char n; ! 110: ! 111: REQUEST(xChangeWindowAttributesReq); ! 112: swaps(&stuff->length, n); ! 113: swapl(&stuff->window, n); ! 114: swapl(&stuff->valueMask, n); ! 115: SwapRestL(stuff); ! 116: return((* ProcVector[X_ChangeWindowAttributes])(client)); ! 117: } ! 118: ! 119: int ! 120: SProcReparentWindow(client) ! 121: register ClientPtr client; ! 122: { ! 123: register char n; ! 124: REQUEST(xReparentWindowReq); ! 125: swaps(&stuff->length, n); ! 126: swapl(&stuff->window, n); ! 127: swapl(&stuff->parent, n); ! 128: swaps(&stuff->x, n); ! 129: swaps(&stuff->y, n); ! 130: return((* ProcVector[X_ReparentWindow])(client)); ! 131: } ! 132: ! 133: int ! 134: SProcConfigureWindow(client) ! 135: register ClientPtr client; ! 136: { ! 137: register char n; ! 138: REQUEST(xConfigureWindowReq); ! 139: swaps(&stuff->length, n); ! 140: swapl(&stuff->window, n); ! 141: swaps(&stuff->mask, n); ! 142: SwapRestL(stuff); ! 143: return((* ProcVector[X_ConfigureWindow])(client)); ! 144: ! 145: } ! 146: ! 147: ! 148: int ! 149: SProcInternAtom(client) ! 150: register ClientPtr client; ! 151: { ! 152: register char n; ! 153: REQUEST(xInternAtomReq); ! 154: swaps(&stuff->length, n); ! 155: swaps(&stuff->nbytes, n); ! 156: return((* ProcVector[X_InternAtom])(client)); ! 157: } ! 158: ! 159: int ! 160: SProcChangeProperty(client) ! 161: register ClientPtr client; ! 162: { ! 163: register char n; ! 164: REQUEST(xChangePropertyReq); ! 165: swaps(&stuff->length, n); ! 166: swapl(&stuff->window, n); ! 167: swapl(&stuff->property, n); ! 168: swapl(&stuff->type, n); ! 169: swapl(&stuff->nUnits, n); ! 170: switch ( stuff->format ) { ! 171: case 8 : break; ! 172: case 16: ! 173: SwapShorts(stuff + 1, stuff->nUnits); ! 174: break; ! 175: case 32: ! 176: SwapLongs(stuff + 1, stuff->nUnits); ! 177: break; ! 178: } ! 179: return((* ProcVector[X_ChangeProperty])(client)); ! 180: } ! 181: ! 182: int ! 183: SProcDeleteProperty(client) ! 184: register ClientPtr client; ! 185: { ! 186: register char n; ! 187: REQUEST(xDeletePropertyReq); ! 188: swaps(&stuff->length, n); ! 189: swapl(&stuff->window, n); ! 190: swapl(&stuff->property, n); ! 191: return((* ProcVector[X_DeleteProperty])(client)); ! 192: ! 193: } ! 194: ! 195: int ! 196: SProcGetProperty(client) ! 197: register ClientPtr client; ! 198: { ! 199: register char n; ! 200: REQUEST(xGetPropertyReq); ! 201: swaps(&stuff->length, n); ! 202: swapl(&stuff->window, n); ! 203: swapl(&stuff->property, n); ! 204: swapl(&stuff->type, n); ! 205: swapl(&stuff->longOffset, n); ! 206: swapl(&stuff->longLength, n); ! 207: return((* ProcVector[X_GetProperty])(client)); ! 208: } ! 209: ! 210: int ! 211: SProcSetSelectionOwner(client) ! 212: register ClientPtr client; ! 213: { ! 214: register char n; ! 215: REQUEST(xSetSelectionOwnerReq); ! 216: swaps(&stuff->length, n); ! 217: swapl(&stuff->window, n); ! 218: swapl(&stuff->selection, n); ! 219: swapl(&stuff->time, n); ! 220: return((* ProcVector[X_SetSelectionOwner])(client)); ! 221: } ! 222: ! 223: int ! 224: SProcConvertSelection(client) ! 225: register ClientPtr client; ! 226: { ! 227: register char n; ! 228: REQUEST(xConvertSelectionReq); ! 229: swaps(&stuff->length, n); ! 230: swapl(&stuff->requestor, n); ! 231: swapl(&stuff->selection, n); ! 232: swapl(&stuff->target, n); ! 233: swapl(&stuff->property, n); ! 234: swapl(&stuff->time, n); ! 235: return((* ProcVector[X_ConvertSelection])(client)); ! 236: } ! 237: ! 238: int ! 239: SProcSendEvent(client) ! 240: register ClientPtr client; ! 241: { ! 242: register char n; ! 243: xEvent eventT; ! 244: void (*proc)(); ! 245: REQUEST(xSendEventReq); ! 246: swaps(&stuff->length, n); ! 247: swapl(&stuff->destination, n); ! 248: swapl(&stuff->eventMask, n); ! 249: ! 250: /* Swap event */ ! 251: proc = EventSwapVector[stuff->event.u.u.type & 0177]; ! 252: if (!proc) /* no swapping proc; invalid event type? */ ! 253: return (BadValue); ! 254: (*proc)(&stuff->event, &eventT); ! 255: stuff->event = eventT; ! 256: ! 257: return((* ProcVector[X_SendEvent])(client)); ! 258: } ! 259: ! 260: int ! 261: SProcGrabPointer(client) ! 262: register ClientPtr client; ! 263: { ! 264: register char n; ! 265: REQUEST(xGrabPointerReq); ! 266: swaps(&stuff->length, n); ! 267: swapl(&stuff->grabWindow, n); ! 268: swaps(&stuff->eventMask, n); ! 269: swapl(&stuff->confineTo, n); ! 270: swapl(&stuff->cursor, n); ! 271: swapl(&stuff->time, n); ! 272: return((* ProcVector[X_GrabPointer])(client)); ! 273: } ! 274: ! 275: int ! 276: SProcGrabButton(client) ! 277: register ClientPtr client; ! 278: { ! 279: register char n; ! 280: REQUEST(xGrabButtonReq); ! 281: swaps(&stuff->length, n); ! 282: swapl(&stuff->grabWindow, n); ! 283: swaps(&stuff->eventMask, n); ! 284: swapl(&stuff->confineTo, n); ! 285: swapl(&stuff->cursor, n); ! 286: swaps(&stuff->modifiers, n); ! 287: return((* ProcVector[X_GrabButton])(client)); ! 288: } ! 289: ! 290: int ! 291: SProcUngrabButton(client) ! 292: register ClientPtr client; ! 293: { ! 294: register char n; ! 295: REQUEST(xUngrabButtonReq); ! 296: swaps(&stuff->length, n); ! 297: swapl(&stuff->grabWindow, n); ! 298: swaps(&stuff->modifiers, n); ! 299: return((* ProcVector[X_UngrabButton])(client)); ! 300: } ! 301: ! 302: int ! 303: SProcChangeActivePointerGrab(client) ! 304: register ClientPtr client; ! 305: { ! 306: register char n; ! 307: REQUEST(xChangeActivePointerGrabReq); ! 308: swaps(&stuff->length, n); ! 309: swapl(&stuff->cursor, n); ! 310: swapl(&stuff->time, n); ! 311: swaps(&stuff->eventMask, n); ! 312: return((* ProcVector[X_ChangeActivePointerGrab])(client)); ! 313: } ! 314: ! 315: int ! 316: SProcGrabKeyboard(client) ! 317: register ClientPtr client; ! 318: { ! 319: register char n; ! 320: REQUEST(xGrabKeyboardReq); ! 321: swaps(&stuff->length, n); ! 322: swapl(&stuff->grabWindow, n); ! 323: swapl(&stuff->time, n); ! 324: return((* ProcVector[X_GrabKeyboard])(client)); ! 325: } ! 326: ! 327: int ! 328: SProcGrabKey(client) ! 329: register ClientPtr client; ! 330: { ! 331: register char n; ! 332: REQUEST(xGrabKeyReq); ! 333: swaps(&stuff->length, n); ! 334: swapl(&stuff->grabWindow, n); ! 335: swaps(&stuff->modifiers, n); ! 336: return((* ProcVector[X_GrabKey])(client)); ! 337: } ! 338: ! 339: int ! 340: SProcUngrabKey(client) ! 341: register ClientPtr client; ! 342: { ! 343: register char n; ! 344: REQUEST(xUngrabKeyReq); ! 345: swaps(&stuff->length, n); ! 346: swapl(&stuff->grabWindow, n); ! 347: swaps(&stuff->modifiers, n); ! 348: return((* ProcVector[X_UngrabKey])(client)); ! 349: } ! 350: ! 351: int ! 352: SProcGetMotionEvents(client) ! 353: register ClientPtr client; ! 354: { ! 355: register char n; ! 356: REQUEST(xGetMotionEventsReq); ! 357: swaps(&stuff->length, n); ! 358: swapl(&stuff->window, n); ! 359: swapl(&stuff->start, n); ! 360: swapl(&stuff->stop, n); ! 361: return((* ProcVector[X_GetMotionEvents])(client)); ! 362: } ! 363: ! 364: int ! 365: SProcTranslateCoords(client) ! 366: register ClientPtr client; ! 367: { ! 368: register char n; ! 369: REQUEST(xTranslateCoordsReq); ! 370: swaps(&stuff->length, n); ! 371: swapl(&stuff->srcWid, n); ! 372: swapl(&stuff->dstWid, n); ! 373: swaps(&stuff->srcX, n); ! 374: swaps(&stuff->srcY, n); ! 375: return((* ProcVector[X_TranslateCoords])(client)); ! 376: } ! 377: ! 378: int ! 379: SProcWarpPointer(client) ! 380: register ClientPtr client; ! 381: { ! 382: register char n; ! 383: REQUEST(xWarpPointerReq); ! 384: swaps(&stuff->length, n); ! 385: swapl(&stuff->srcWid, n); ! 386: swapl(&stuff->dstWid, n); ! 387: swaps(&stuff->srcX, n); ! 388: swaps(&stuff->srcY, n); ! 389: swaps(&stuff->srcWidth, n); ! 390: swaps(&stuff->srcHeight, n); ! 391: swaps(&stuff->dstX, n); ! 392: swaps(&stuff->dstY, n); ! 393: return((* ProcVector[X_WarpPointer])(client)); ! 394: } ! 395: ! 396: int ! 397: SProcSetInputFocus(client) ! 398: register ClientPtr client; ! 399: { ! 400: register char n; ! 401: REQUEST(xSetInputFocusReq); ! 402: swaps(&stuff->length, n); ! 403: swapl(&stuff->focus, n); ! 404: swapl(&stuff->time, n); ! 405: return((* ProcVector[X_SetInputFocus])(client)); ! 406: } ! 407: ! 408: ! 409: SProcOpenFont(client) ! 410: register ClientPtr client; ! 411: { ! 412: register char n; ! 413: REQUEST(xOpenFontReq); ! 414: swaps(&stuff->length, n); ! 415: swapl(&stuff->fid, n); ! 416: swaps(&stuff->nbytes, n); ! 417: return((* ProcVector[X_OpenFont])(client)); ! 418: } ! 419: ! 420: int ! 421: SProcListFonts(client) ! 422: register ClientPtr client; ! 423: { ! 424: register char n; ! 425: REQUEST(xListFontsReq); ! 426: swaps(&stuff->length, n); ! 427: swaps(&stuff->maxNames, n); ! 428: swaps(&stuff->nbytes, n); ! 429: return((* ProcVector[X_ListFonts])(client)); ! 430: } ! 431: ! 432: int ! 433: SProcListFontsWithInfo(client) ! 434: register ClientPtr client; ! 435: { ! 436: register char n; ! 437: REQUEST(xListFontsWithInfoReq); ! 438: swaps(&stuff->length, n); ! 439: swaps(&stuff->maxNames, n); ! 440: swaps(&stuff->nbytes, n); ! 441: return((* ProcVector[X_ListFontsWithInfo])(client)); ! 442: } ! 443: ! 444: int ! 445: SProcSetFontPath(client) ! 446: register ClientPtr client; ! 447: { ! 448: register char n; ! 449: REQUEST(xSetFontPathReq); ! 450: swaps(&stuff->length, n); ! 451: swaps(&stuff->nFonts, n); ! 452: return((* ProcVector[X_SetFontPath])(client)); ! 453: } ! 454: ! 455: int ! 456: SProcCreatePixmap(client) ! 457: register ClientPtr client; ! 458: { ! 459: register char n; ! 460: REQUEST(xCreatePixmapReq); ! 461: ! 462: swaps(&stuff->length, n); ! 463: swapl(&stuff->pid, n); ! 464: swapl(&stuff->drawable, n); ! 465: swaps(&stuff->width, n); ! 466: swaps(&stuff->height, n); ! 467: return((* ProcVector[X_CreatePixmap])(client)); ! 468: } ! 469: ! 470: int ! 471: SProcCreateGC(client) ! 472: register ClientPtr client; ! 473: { ! 474: register char n; ! 475: REQUEST(xCreateGCReq); ! 476: swaps(&stuff->length, n); ! 477: swapl(&stuff->gc, n); ! 478: swapl(&stuff->drawable, n); ! 479: swapl(&stuff->mask, n); ! 480: SwapRestL(stuff); ! 481: return((* ProcVector[X_CreateGC])(client)); ! 482: } ! 483: ! 484: int ! 485: SProcChangeGC(client) ! 486: register ClientPtr client; ! 487: { ! 488: register char n; ! 489: REQUEST(xChangeGCReq); ! 490: swaps(&stuff->length, n); ! 491: swapl(&stuff->gc, n); ! 492: swapl(&stuff->mask, n); ! 493: SwapRestL(stuff); ! 494: return((* ProcVector[X_ChangeGC])(client)); ! 495: } ! 496: ! 497: int ! 498: SProcCopyGC(client) ! 499: register ClientPtr client; ! 500: { ! 501: register char n; ! 502: REQUEST(xCopyGCReq); ! 503: swaps(&stuff->length, n); ! 504: swapl(&stuff->srcGC, n); ! 505: swapl(&stuff->dstGC, n); ! 506: swapl(&stuff->mask, n); ! 507: return((* ProcVector[X_CopyGC])(client)); ! 508: } ! 509: ! 510: int ! 511: SProcSetDashes(client) ! 512: register ClientPtr client; ! 513: { ! 514: register char n; ! 515: REQUEST(xSetDashesReq); ! 516: swaps(&stuff->length, n); ! 517: swapl(&stuff->gc, n); ! 518: swaps(&stuff->dashOffset, n); ! 519: swaps(&stuff->nDashes, n); ! 520: return((* ProcVector[X_SetDashes])(client)); ! 521: ! 522: } ! 523: ! 524: int ! 525: SProcSetClipRectangles(client) ! 526: register ClientPtr client; ! 527: { ! 528: register char n; ! 529: REQUEST(xSetClipRectanglesReq); ! 530: swaps(&stuff->length, n); ! 531: swapl(&stuff->gc, n); ! 532: swaps(&stuff->xOrigin, n); ! 533: swaps(&stuff->yOrigin, n); ! 534: SwapRestS(stuff); ! 535: return((* ProcVector[X_SetClipRectangles])(client)); ! 536: } ! 537: ! 538: int ! 539: SProcClearToBackground(client) ! 540: register ClientPtr client; ! 541: { ! 542: register char n; ! 543: REQUEST(xClearAreaReq); ! 544: swaps(&stuff->length, n); ! 545: swapl(&stuff->window, n); ! 546: swaps(&stuff->x, n); ! 547: swaps(&stuff->y, n); ! 548: swaps(&stuff->width, n); ! 549: swaps(&stuff->height, n); ! 550: return((* ProcVector[X_ClearArea])(client)); ! 551: } ! 552: ! 553: int ! 554: SProcCopyArea(client) ! 555: register ClientPtr client; ! 556: { ! 557: register char n; ! 558: REQUEST(xCopyAreaReq); ! 559: swaps(&stuff->length, n); ! 560: swapl(&stuff->srcDrawable, n); ! 561: swapl(&stuff->dstDrawable, n); ! 562: swapl(&stuff->gc, n); ! 563: swaps(&stuff->srcX, n); ! 564: swaps(&stuff->srcY, n); ! 565: swaps(&stuff->dstX, n); ! 566: swaps(&stuff->dstY, n); ! 567: swaps(&stuff->width, n); ! 568: swaps(&stuff->height, n); ! 569: return((* ProcVector[X_CopyArea])(client)); ! 570: } ! 571: ! 572: int ! 573: SProcCopyPlane(client) ! 574: register ClientPtr client; ! 575: { ! 576: register char n; ! 577: REQUEST(xCopyPlaneReq); ! 578: swaps(&stuff->length, n); ! 579: swapl(&stuff->srcDrawable, n); ! 580: swapl(&stuff->dstDrawable, n); ! 581: swapl(&stuff->gc, n); ! 582: swaps(&stuff->srcX, n); ! 583: swaps(&stuff->srcY, n); ! 584: swaps(&stuff->dstX, n); ! 585: swaps(&stuff->dstY, n); ! 586: swaps(&stuff->width, n); ! 587: swaps(&stuff->height, n); ! 588: swapl(&stuff->bitPlane, n); ! 589: return((* ProcVector[X_CopyPlane])(client)); ! 590: } ! 591: ! 592: /* The following routine is used for all Poly drawing requests ! 593: (except FillPoly, which uses a different request format) */ ! 594: int ! 595: SProcPoly(client) ! 596: register ClientPtr client; ! 597: { ! 598: register char n; ! 599: ! 600: REQUEST(xPolyPointReq); ! 601: swaps(&stuff->length, n); ! 602: swapl(&stuff->drawable, n); ! 603: swapl(&stuff->gc, n); ! 604: SwapRestS(stuff); ! 605: return((* ProcVector[stuff->reqType])(client)); ! 606: } ! 607: ! 608: /* cannot use SProcPoly for this one, because xFillPolyReq ! 609: is longer than xPolyPointReq, and we don't want to swap ! 610: the difference as shorts! */ ! 611: int ! 612: SProcFillPoly(client) ! 613: register ClientPtr client; ! 614: { ! 615: register char n; ! 616: ! 617: REQUEST(xFillPolyReq); ! 618: swaps(&stuff->length, n); ! 619: swapl(&stuff->drawable, n); ! 620: swapl(&stuff->gc, n); ! 621: SwapRestS(stuff); ! 622: return((* ProcVector[X_FillPoly])(client)); ! 623: } ! 624: ! 625: int ! 626: SProcPutImage(client) ! 627: register ClientPtr client; ! 628: { ! 629: register char n; ! 630: REQUEST(xPutImageReq); ! 631: swaps(&stuff->length, n); ! 632: swapl(&stuff->drawable, n); ! 633: swapl(&stuff->gc, n); ! 634: swaps(&stuff->width, n); ! 635: swaps(&stuff->height, n); ! 636: swaps(&stuff->dstX, n); ! 637: swaps(&stuff->dstY, n); ! 638: /* Image should already be swapped */ ! 639: return((* ProcVector[X_PutImage])(client)); ! 640: ! 641: } ! 642: ! 643: int ! 644: SProcGetImage(client) ! 645: register ClientPtr client; ! 646: { ! 647: register char n; ! 648: REQUEST(xGetImageReq); ! 649: swaps(&stuff->length, n); ! 650: swapl(&stuff->drawable, n); ! 651: swaps(&stuff->x, n); ! 652: swaps(&stuff->y, n); ! 653: swaps(&stuff->width, n); ! 654: swaps(&stuff->height, n); ! 655: swapl(&stuff->planeMask, n); ! 656: return((* ProcVector[X_GetImage])(client)); ! 657: } ! 658: ! 659: /* ProcPolyText used for both PolyText8 and PolyText16 */ ! 660: ! 661: int ! 662: SProcPolyText(client) ! 663: register ClientPtr client; ! 664: { ! 665: register char n; ! 666: REQUEST(xPolyTextReq); ! 667: swaps(&stuff->length, n); ! 668: swapl(&stuff->drawable, n); ! 669: swapl(&stuff->gc, n); ! 670: swaps(&stuff->x, n); ! 671: swaps(&stuff->y, n); ! 672: return((* ProcVector[stuff->reqType])(client)); ! 673: } ! 674: ! 675: /* ProcImageText used for both ImageText8 and ImageText16 */ ! 676: ! 677: int ! 678: SProcImageText(client) ! 679: register ClientPtr client; ! 680: { ! 681: register char n; ! 682: REQUEST(xImageTextReq); ! 683: swaps(&stuff->length, n); ! 684: swapl(&stuff->drawable, n); ! 685: swapl(&stuff->gc, n); ! 686: swaps(&stuff->x, n); ! 687: swaps(&stuff->y, n); ! 688: return((* ProcVector[stuff->reqType])(client)); ! 689: } ! 690: ! 691: int ! 692: SProcCreateColormap(client) ! 693: register ClientPtr client; ! 694: { ! 695: register char n; ! 696: REQUEST(xCreateColormapReq); ! 697: swaps(&stuff->length, n); ! 698: swapl(&stuff->mid, n); ! 699: swapl(&stuff->window, n); ! 700: swapl(&stuff->visual, n); ! 701: return((* ProcVector[X_CreateColormap])(client)); ! 702: } ! 703: ! 704: ! 705: int ! 706: SProcCopyColormapAndFree(client) ! 707: register ClientPtr client; ! 708: { ! 709: register char n; ! 710: REQUEST(xCopyColormapAndFreeReq); ! 711: swaps(&stuff->length, n); ! 712: swapl(&stuff->mid, n); ! 713: swapl(&stuff->srcCmap, n); ! 714: return((* ProcVector[X_CopyColormapAndFree])(client)); ! 715: ! 716: } ! 717: ! 718: int ! 719: SProcAllocColor (client) ! 720: register ClientPtr client; ! 721: { ! 722: register char n; ! 723: REQUEST(xAllocColorReq); ! 724: swaps(&stuff->length, n); ! 725: swapl(&stuff->cmap, n); ! 726: swaps(&stuff->red, n); ! 727: swaps(&stuff->green, n); ! 728: swaps(&stuff->blue, n); ! 729: return((* ProcVector[X_AllocColor])(client)); ! 730: } ! 731: ! 732: int ! 733: SProcAllocNamedColor (client) ! 734: register ClientPtr client; ! 735: { ! 736: register char n; ! 737: ! 738: REQUEST(xAllocNamedColorReq); ! 739: swaps(&stuff->length, n); ! 740: swapl(&stuff->cmap, n); ! 741: swaps(&stuff->nbytes, n); ! 742: return((* ProcVector[X_AllocNamedColor])(client)); ! 743: } ! 744: ! 745: int ! 746: SProcAllocColorCells (client) ! 747: register ClientPtr client; ! 748: { ! 749: register char n; ! 750: REQUEST(xAllocColorCellsReq); ! 751: swaps(&stuff->length, n); ! 752: swapl(&stuff->cmap, n); ! 753: swaps(&stuff->colors, n); ! 754: swaps(&stuff->planes, n); ! 755: return((* ProcVector[X_AllocColorCells])(client)); ! 756: } ! 757: ! 758: int ! 759: SProcAllocColorPlanes(client) ! 760: register ClientPtr client; ! 761: { ! 762: register char n; ! 763: REQUEST(xAllocColorPlanesReq); ! 764: swaps(&stuff->length, n); ! 765: swapl(&stuff->cmap, n); ! 766: swaps(&stuff->colors, n); ! 767: swaps(&stuff->red, n); ! 768: swaps(&stuff->green, n); ! 769: swaps(&stuff->blue, n); ! 770: return((* ProcVector[X_AllocColorPlanes])(client)); ! 771: } ! 772: ! 773: int ! 774: SProcFreeColors (client) ! 775: register ClientPtr client; ! 776: { ! 777: register char n; ! 778: REQUEST(xFreeColorsReq); ! 779: swaps(&stuff->length, n); ! 780: swapl(&stuff->cmap, n); ! 781: swapl(&stuff->planeMask, n); ! 782: SwapRestL(stuff); ! 783: return((* ProcVector[X_FreeColors])(client)); ! 784: ! 785: } ! 786: ! 787: int ! 788: SProcStoreColors (client) ! 789: register ClientPtr client; ! 790: { ! 791: register char n; ! 792: xColorItem *pItem; ! 793: ! 794: REQUEST(xStoreColorsReq); ! 795: swaps(&stuff->length, n); ! 796: swapl(&stuff->cmap, n); ! 797: pItem = (xColorItem *) &stuff[1]; ! 798: for(n = 0; n < LengthRestB(stuff)/sizeof(xColorItem); n++) ! 799: SwapColorItem(pItem++); ! 800: return((* ProcVector[X_StoreColors])(client)); ! 801: } ! 802: ! 803: int ! 804: SProcStoreNamedColor (client) ! 805: register ClientPtr client; ! 806: { ! 807: register char n; ! 808: REQUEST(xStoreNamedColorReq); ! 809: swaps(&stuff->length, n); ! 810: swapl(&stuff->cmap, n); ! 811: swapl(&stuff->pixel, n); ! 812: swaps(&stuff->nbytes, n); ! 813: return((* ProcVector[X_StoreNamedColor])(client)); ! 814: } ! 815: ! 816: int ! 817: SProcQueryColors(client) ! 818: register ClientPtr client; ! 819: { ! 820: register char n; ! 821: REQUEST(xQueryColorsReq); ! 822: swaps(&stuff->length, n); ! 823: swapl(&stuff->cmap, n); ! 824: SwapRestL(stuff); ! 825: return((* ProcVector[X_QueryColors])(client)); ! 826: } ! 827: ! 828: int ! 829: SProcLookupColor(client) ! 830: register ClientPtr client; ! 831: { ! 832: register char n; ! 833: REQUEST(xLookupColorReq); ! 834: swaps(&stuff->length, n); ! 835: swapl(&stuff->cmap, n); ! 836: swaps(&stuff->nbytes, n); ! 837: return((* ProcVector[X_LookupColor])(client)); ! 838: } ! 839: ! 840: int ! 841: SProcCreateCursor( client) ! 842: register ClientPtr client; ! 843: { ! 844: register char n; ! 845: REQUEST(xCreateCursorReq); ! 846: swaps(&stuff->length, n); ! 847: swapl(&stuff->cid, n); ! 848: swapl(&stuff->source, n); ! 849: swapl(&stuff->mask, n); ! 850: swaps(&stuff->foreRed, n); ! 851: swaps(&stuff->foreGreen, n); ! 852: swaps(&stuff->foreBlue, n); ! 853: swaps(&stuff->backRed, n); ! 854: swaps(&stuff->backGreen, n); ! 855: swaps(&stuff->backBlue, n); ! 856: swaps(&stuff->x, n); ! 857: swaps(&stuff->y, n); ! 858: return((* ProcVector[X_CreateCursor])(client)); ! 859: } ! 860: ! 861: int ! 862: SProcCreateGlyphCursor( client) ! 863: register ClientPtr client; ! 864: { ! 865: register char n; ! 866: REQUEST(xCreateGlyphCursorReq); ! 867: swaps(&stuff->length, n); ! 868: swapl(&stuff->cid, n); ! 869: swapl(&stuff->source, n); ! 870: swapl(&stuff->mask, n); ! 871: swaps(&stuff->sourceChar, n); ! 872: swaps(&stuff->maskChar, n); ! 873: swaps(&stuff->foreRed, n); ! 874: swaps(&stuff->foreGreen, n); ! 875: swaps(&stuff->foreBlue, n); ! 876: swaps(&stuff->backRed, n); ! 877: swaps(&stuff->backGreen, n); ! 878: swaps(&stuff->backBlue, n); ! 879: return((* ProcVector[X_CreateGlyphCursor])(client)); ! 880: } ! 881: ! 882: ! 883: int ! 884: SProcRecolorCursor(client) ! 885: register ClientPtr client; ! 886: { ! 887: register char n; ! 888: REQUEST(xRecolorCursorReq); ! 889: swaps(&stuff->length, n); ! 890: swapl(&stuff->cursor, n); ! 891: swaps(&stuff->foreRed, n); ! 892: swaps(&stuff->foreGreen, n); ! 893: swaps(&stuff->foreBlue, n); ! 894: swaps(&stuff->backRed, n); ! 895: swaps(&stuff->backGreen, n); ! 896: swaps(&stuff->backBlue, n); ! 897: return((* ProcVector[X_RecolorCursor])(client)); ! 898: } ! 899: ! 900: int ! 901: SProcQueryBestSize (client) ! 902: register ClientPtr client; ! 903: { ! 904: register char n; ! 905: REQUEST(xQueryBestSizeReq); ! 906: swaps(&stuff->length, n); ! 907: swapl(&stuff->drawable, n); ! 908: swaps(&stuff->width, n); ! 909: swaps(&stuff->height, n); ! 910: return((* ProcVector[X_QueryBestSize])(client)); ! 911: ! 912: } ! 913: ! 914: int ! 915: SProcQueryExtension (client) ! 916: register ClientPtr client; ! 917: { ! 918: register char n; ! 919: REQUEST(xQueryExtensionReq); ! 920: swaps(&stuff->length, n); ! 921: swaps(&stuff->nbytes, n); ! 922: return((* ProcVector[X_QueryExtension])(client)); ! 923: } ! 924: ! 925: int ! 926: SProcChangeKeyboardMapping (client) ! 927: register ClientPtr client; ! 928: { ! 929: register char n; ! 930: register long *p; ! 931: register int i, count; ! 932: ! 933: REQUEST(xChangeKeyboardMappingReq); ! 934: swaps(&stuff->length, n); ! 935: p = (long *)&stuff[1]; ! 936: count = stuff->keyCodes * stuff->keySymsPerKeyCode; ! 937: for(i = 0; i < count; i++) ! 938: { ! 939: swapl(p, n); ! 940: p++; ! 941: } ! 942: return((* ProcVector[X_ChangeKeyboardMapping])(client)); ! 943: } ! 944: ! 945: ! 946: int ! 947: SProcChangeKeyboardControl (client) ! 948: register ClientPtr client; ! 949: { ! 950: register char n; ! 951: REQUEST(xChangeKeyboardControlReq); ! 952: swaps(&stuff->length, n); ! 953: swapl(&stuff->mask, n); ! 954: SwapRestL(stuff); ! 955: return((* ProcVector[X_ChangeKeyboardControl])(client)); ! 956: } ! 957: ! 958: int ! 959: SProcChangePointerControl (client) ! 960: register ClientPtr client; ! 961: { ! 962: register char n; ! 963: REQUEST(xChangePointerControlReq); ! 964: swaps(&stuff->length, n); ! 965: swaps(&stuff->accelNum, n); ! 966: swaps(&stuff->accelDenum, n); ! 967: swaps(&stuff->threshold, n); ! 968: return((* ProcVector[X_ChangePointerControl])(client)); ! 969: } ! 970: ! 971: ! 972: int ! 973: SProcSetScreenSaver (client) ! 974: register ClientPtr client; ! 975: { ! 976: register char n; ! 977: REQUEST(xSetScreenSaverReq); ! 978: swaps(&stuff->length, n); ! 979: swaps(&stuff->timeout, n); ! 980: swaps(&stuff->interval, n); ! 981: return((* ProcVector[X_SetScreenSaver])(client)); ! 982: } ! 983: ! 984: int ! 985: SProcChangeHosts(client) ! 986: register ClientPtr client; ! 987: { ! 988: register char n; ! 989: ! 990: REQUEST(xChangeHostsReq); ! 991: swaps(&stuff->length, n); ! 992: swaps(&stuff->hostLength, n); ! 993: return((* ProcVector[X_ChangeHosts])(client)); ! 994: ! 995: } ! 996: ! 997: int SProcRotateProperties(client) ! 998: register ClientPtr client; ! 999: { ! 1000: register char n; ! 1001: REQUEST(xRotatePropertiesReq); ! 1002: swaps(&stuff->length, n); ! 1003: swapl(&stuff->window, n); ! 1004: swaps(&stuff->nAtoms, n); ! 1005: swaps(&stuff->nPositions, n); ! 1006: SwapRestL(stuff); ! 1007: return ((* ProcVector[X_RotateProperties])(client)); ! 1008: } ! 1009: ! 1010: int SProcNoOperation(client) ! 1011: register ClientPtr client; ! 1012: { ! 1013: /* noop -- don't do anything */ ! 1014: return(Success); ! 1015: } ! 1016: ! 1017: SwapTimecoord(pCoord) ! 1018: xTimecoord *pCoord; ! 1019: { ! 1020: register char n; ! 1021: ! 1022: swapl(&pCoord->time, n); ! 1023: swaps(&pCoord->x, n); ! 1024: swaps(&pCoord->y, n); ! 1025: } ! 1026: ! 1027: ! 1028: SwapRGB(prgb) ! 1029: xrgb *prgb; ! 1030: { ! 1031: register char n; ! 1032: ! 1033: swaps(&prgb->red, n); ! 1034: swaps(&prgb->green, n); ! 1035: swaps(&prgb->blue, n); ! 1036: } ! 1037: ! 1038: SwapColorItem(pItem) ! 1039: xColorItem *pItem; ! 1040: { ! 1041: register char n; ! 1042: ! 1043: swapl(&pItem->pixel, n); ! 1044: swaps(&pItem->red, n); ! 1045: swaps(&pItem->green, n); ! 1046: swaps(&pItem->blue, n); ! 1047: } ! 1048: ! 1049: SwapConnClientPrefix(pCCP) ! 1050: xConnClientPrefix *pCCP; ! 1051: { ! 1052: register char n; ! 1053: ! 1054: swaps(&pCCP->majorVersion, n); ! 1055: swaps(&pCCP->minorVersion, n); ! 1056: swaps(&pCCP->nbytesAuthProto, n); ! 1057: swaps(&pCCP->nbytesAuthString, n); ! 1058: } ! 1059:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.