(file) Return to swapreq.c CVS log (file) (dir) Up to [XFree86 CVS] / xc / programs / Xserver / dix

Diff for /xc/programs/Xserver/dix/swapreq.c between version 3.5 and 3.6

version 3.5, 2002/02/19 11:09:22 version 3.6, 2005/03/28 02:51:05
Line 1 
Line 1 
 /* $XFree86: xc/programs/Xserver/dix/swapreq.c,v 3.4 2001/12/14 19:59:33 dawes Exp $ */  /* $XFree86: xc/programs/Xserver/dix/swapreq.c,v 3.5 2002/02/19 11:09:22 alanh Exp $ */
 /************************************************************ /************************************************************
  
 Copyright 1987, 1998  The Open Group Copyright 1987, 1998  The Open Group
Line 46 
Line 46 
  
 ********************************************************/ ********************************************************/
  
 /* $Xorg: swapreq.c,v 1.4 2001/02/09 02:04:41 xorgcvs Exp $ */  
   
 #include "X.h" #include "X.h"
 #define NEED_EVENTS #define NEED_EVENTS
 #include "Xproto.h" #include "Xproto.h"
Line 62 
Line 60 
 /* Byte swap a list of longs */ /* Byte swap a list of longs */
  
 void void
 SwapLongs (list, count)  SwapLongs(CARD32 *list, unsigned long count)
         register CARD32 *list;  
         register unsigned long count;  
 { {
         register char n;          char n;
  
         while (count >= 8) {         while (count >= 8) {
             swapl(list+0, n);             swapl(list+0, n);
Line 91 
Line 87 
 /* Byte swap a list of shorts */ /* Byte swap a list of shorts */
  
 void void
 SwapShorts (list, count)  SwapShorts(short *list, unsigned long count)
         register short *list;  
         register unsigned long count;  
 { {
         register char n;          char n;
  
         while (count >= 16) {         while (count >= 16) {
             swaps(list+0, n);             swaps(list+0, n);
Line 128 
Line 122 
 /* The following is used for all requests that have /* The following is used for all requests that have
    no fields to be swapped (except "length") */    no fields to be swapped (except "length") */
 int int
 SProcSimpleReq(client)  SProcSimpleReq(ClientPtr client)
         register ClientPtr client;  
 { {
     register char n;      char n;
  
     REQUEST(xReq);     REQUEST(xReq);
     swaps(&stuff->length, n);     swaps(&stuff->length, n);
Line 142 
Line 135 
    only a single 32-bit field to be swapped, coming    only a single 32-bit field to be swapped, coming
    right after the "length" field */    right after the "length" field */
 int int
 SProcResourceReq(client)  SProcResourceReq(ClientPtr client)
         register ClientPtr client;  
 { {
     register char n;      char n;
  
     REQUEST(xResourceReq);     REQUEST(xResourceReq);
     swaps(&stuff->length, n);     swaps(&stuff->length, n);
Line 155 
Line 147 
 } }
  
 int int
 SProcCreateWindow(client)  SProcCreateWindow(ClientPtr client)
     register ClientPtr client;  
 { {
     register char n;      char n;
  
     REQUEST(xCreateWindowReq);     REQUEST(xCreateWindowReq);
     swaps(&stuff->length, n);     swaps(&stuff->length, n);
Line 178 
Line 169 
 } }
  
 int int
 SProcChangeWindowAttributes(client)  SProcChangeWindowAttributes(ClientPtr client)
     register ClientPtr client;  
 { {
     register char n;      char n;
  
     REQUEST(xChangeWindowAttributesReq);     REQUEST(xChangeWindowAttributesReq);
     swaps(&stuff->length, n);     swaps(&stuff->length, n);
Line 193 
Line 183 
 } }
  
 int int
 SProcReparentWindow(client)  SProcReparentWindow(ClientPtr client)
     register ClientPtr client;  
 { {
     register char n;      char n;
     REQUEST(xReparentWindowReq);     REQUEST(xReparentWindowReq);
     swaps(&stuff->length, n);     swaps(&stuff->length, n);
     REQUEST_SIZE_MATCH(xReparentWindowReq);     REQUEST_SIZE_MATCH(xReparentWindowReq);
Line 208 
Line 197 
 } }
  
 int int
 SProcConfigureWindow(client)  SProcConfigureWindow(ClientPtr client)
     register ClientPtr client;  
 { {
     register char n;      char n;
     REQUEST(xConfigureWindowReq);     REQUEST(xConfigureWindowReq);
     swaps(&stuff->length, n);     swaps(&stuff->length, n);
     REQUEST_AT_LEAST_SIZE(xConfigureWindowReq);     REQUEST_AT_LEAST_SIZE(xConfigureWindowReq);
Line 224 
Line 212 
  
  
 int int
 SProcInternAtom(client)  SProcInternAtom(ClientPtr client)
     register ClientPtr client;  
 { {
     register char n;      char n;
     REQUEST(xInternAtomReq);     REQUEST(xInternAtomReq);
     swaps(&stuff->length, n);     swaps(&stuff->length, n);
     REQUEST_AT_LEAST_SIZE(xInternAtomReq);     REQUEST_AT_LEAST_SIZE(xInternAtomReq);
Line 236 
Line 223 
 } }
  
 int int
 SProcChangeProperty(client)  SProcChangeProperty(ClientPtr client)
     register ClientPtr client;  
 { {
     register char n;      char n;
     REQUEST(xChangePropertyReq);     REQUEST(xChangePropertyReq);
     swaps(&stuff->length, n);     swaps(&stuff->length, n);
     REQUEST_AT_LEAST_SIZE(xChangePropertyReq);     REQUEST_AT_LEAST_SIZE(xChangePropertyReq);
Line 261 
Line 247 
 } }
  
 int int
 SProcDeleteProperty(client)  SProcDeleteProperty(ClientPtr client)
     register ClientPtr client;  
 { {
     register char n;      char n;
     REQUEST(xDeletePropertyReq);     REQUEST(xDeletePropertyReq);
     swaps(&stuff->length, n);     swaps(&stuff->length, n);
     REQUEST_SIZE_MATCH(xDeletePropertyReq);     REQUEST_SIZE_MATCH(xDeletePropertyReq);
Line 275 
Line 260 
 } }
  
 int int
 SProcGetProperty(client)  SProcGetProperty(ClientPtr client)
     register ClientPtr client;  
 { {
     register char n;      char n;
     REQUEST(xGetPropertyReq);     REQUEST(xGetPropertyReq);
     swaps(&stuff->length, n);     swaps(&stuff->length, n);
     REQUEST_SIZE_MATCH(xGetPropertyReq);     REQUEST_SIZE_MATCH(xGetPropertyReq);
Line 291 
Line 275 
 } }
  
 int int
 SProcSetSelectionOwner(client)  SProcSetSelectionOwner(ClientPtr client)
     register ClientPtr client;  
 { {
     register char n;      char n;
     REQUEST(xSetSelectionOwnerReq);     REQUEST(xSetSelectionOwnerReq);
     swaps(&stuff->length, n);     swaps(&stuff->length, n);
     REQUEST_SIZE_MATCH(xSetSelectionOwnerReq);     REQUEST_SIZE_MATCH(xSetSelectionOwnerReq);
Line 305 
Line 288 
 } }
  
 int int
 SProcConvertSelection(client)  SProcConvertSelection(ClientPtr client)
     register ClientPtr client;  
 { {
     register char n;      char n;
     REQUEST(xConvertSelectionReq);     REQUEST(xConvertSelectionReq);
     swaps(&stuff->length, n);     swaps(&stuff->length, n);
     REQUEST_SIZE_MATCH(xConvertSelectionReq);     REQUEST_SIZE_MATCH(xConvertSelectionReq);
Line 321 
Line 303 
 } }
  
 int int
 SProcSendEvent(client)  SProcSendEvent(ClientPtr client)
     register ClientPtr client;  
 { {
     register char n;      char n;
     xEvent eventT;     xEvent eventT;
     EventSwapPtr proc;     EventSwapPtr proc;
     REQUEST(xSendEventReq);     REQUEST(xSendEventReq);
Line 344 
Line 325 
 } }
  
 int int
 SProcGrabPointer(client)  SProcGrabPointer(ClientPtr client)
     register ClientPtr client;  
 { {
     register char n;      char n;
     REQUEST(xGrabPointerReq);     REQUEST(xGrabPointerReq);
     swaps(&stuff->length, n);     swaps(&stuff->length, n);
     REQUEST_SIZE_MATCH(xGrabPointerReq);     REQUEST_SIZE_MATCH(xGrabPointerReq);
Line 360 
Line 340 
 } }
  
 int int
 SProcGrabButton(client)  SProcGrabButton(ClientPtr client)
     register ClientPtr client;  
 { {
     register char n;      char n;
     REQUEST(xGrabButtonReq);     REQUEST(xGrabButtonReq);
     swaps(&stuff->length, n);     swaps(&stuff->length, n);
     REQUEST_SIZE_MATCH(xGrabButtonReq);     REQUEST_SIZE_MATCH(xGrabButtonReq);
Line 376 
Line 355 
 } }
  
 int int
 SProcUngrabButton(client)  SProcUngrabButton(ClientPtr client)
     register ClientPtr client;  
 { {
     register char n;      char n;
     REQUEST(xUngrabButtonReq);     REQUEST(xUngrabButtonReq);
     swaps(&stuff->length, n);     swaps(&stuff->length, n);
     REQUEST_SIZE_MATCH(xUngrabButtonReq);     REQUEST_SIZE_MATCH(xUngrabButtonReq);
Line 389 
Line 367 
 } }
  
 int int
 SProcChangeActivePointerGrab(client)  SProcChangeActivePointerGrab(ClientPtr client)
     register ClientPtr client;  
 { {
     register char n;      char n;
     REQUEST(xChangeActivePointerGrabReq);     REQUEST(xChangeActivePointerGrabReq);
     swaps(&stuff->length, n);     swaps(&stuff->length, n);
     REQUEST_SIZE_MATCH(xChangeActivePointerGrabReq);     REQUEST_SIZE_MATCH(xChangeActivePointerGrabReq);
Line 403 
Line 380 
 } }
  
 int int
 SProcGrabKeyboard(client)  SProcGrabKeyboard(ClientPtr client)
     register ClientPtr client;  
 { {
     register char n;      char n;
     REQUEST(xGrabKeyboardReq);     REQUEST(xGrabKeyboardReq);
     swaps(&stuff->length, n);     swaps(&stuff->length, n);
     REQUEST_SIZE_MATCH(xGrabKeyboardReq);     REQUEST_SIZE_MATCH(xGrabKeyboardReq);
Line 416 
Line 392 
 } }
  
 int int
 SProcGrabKey(client)  SProcGrabKey(ClientPtr client)
     register ClientPtr client;  
 { {
     register char n;      char n;
     REQUEST(xGrabKeyReq);     REQUEST(xGrabKeyReq);
     swaps(&stuff->length, n);     swaps(&stuff->length, n);
     REQUEST_SIZE_MATCH(xGrabKeyReq);     REQUEST_SIZE_MATCH(xGrabKeyReq);
Line 429 
Line 404 
 } }
  
 int int
 SProcUngrabKey(client)  SProcUngrabKey(ClientPtr client)
     register ClientPtr client;  
 { {
     register char n;      char n;
     REQUEST(xUngrabKeyReq);     REQUEST(xUngrabKeyReq);
     swaps(&stuff->length, n);     swaps(&stuff->length, n);
     REQUEST_SIZE_MATCH(xUngrabKeyReq);     REQUEST_SIZE_MATCH(xUngrabKeyReq);
Line 442 
Line 416 
 } }
  
 int int
 SProcGetMotionEvents(client)  SProcGetMotionEvents(ClientPtr client)
     register ClientPtr client;  
 { {
     register char n;      char n;
     REQUEST(xGetMotionEventsReq);     REQUEST(xGetMotionEventsReq);
     swaps(&stuff->length, n);     swaps(&stuff->length, n);
     REQUEST_SIZE_MATCH(xGetMotionEventsReq);     REQUEST_SIZE_MATCH(xGetMotionEventsReq);
Line 456 
Line 429 
 } }
  
 int int
 SProcTranslateCoords(client)  SProcTranslateCoords(ClientPtr client)
     register ClientPtr client;  
 { {
     register char n;      char n;
     REQUEST(xTranslateCoordsReq);     REQUEST(xTranslateCoordsReq);
     swaps(&stuff->length, n);     swaps(&stuff->length, n);
     REQUEST_SIZE_MATCH(xTranslateCoordsReq);     REQUEST_SIZE_MATCH(xTranslateCoordsReq);
Line 471 
Line 443 
 } }
  
 int int
 SProcWarpPointer(client)  SProcWarpPointer(ClientPtr client)
     register ClientPtr client;  
 { {
     register char n;      char n;
     REQUEST(xWarpPointerReq);     REQUEST(xWarpPointerReq);
     swaps(&stuff->length, n);     swaps(&stuff->length, n);
     REQUEST_SIZE_MATCH(xWarpPointerReq);     REQUEST_SIZE_MATCH(xWarpPointerReq);
Line 490 
Line 461 
 } }
  
 int int
 SProcSetInputFocus(client)  SProcSetInputFocus(ClientPtr client)
     register ClientPtr client;  
 { {
     register char n;      char n;
     REQUEST(xSetInputFocusReq);     REQUEST(xSetInputFocusReq);
     swaps(&stuff->length, n);     swaps(&stuff->length, n);
     REQUEST_SIZE_MATCH(xSetInputFocusReq);     REQUEST_SIZE_MATCH(xSetInputFocusReq);
Line 503 
Line 473 
 } }
  
 int int
 SProcOpenFont(client)  SProcOpenFont(ClientPtr client)
     register ClientPtr client;  
 { {
     register char n;      char n;
     REQUEST(xOpenFontReq);     REQUEST(xOpenFontReq);
     swaps(&stuff->length, n);     swaps(&stuff->length, n);
     REQUEST_AT_LEAST_SIZE(xOpenFontReq);     REQUEST_AT_LEAST_SIZE(xOpenFontReq);
Line 516 
Line 485 
 } }
  
 int int
 SProcListFonts(client)  SProcListFonts(ClientPtr client)
     register ClientPtr client;  
 { {
     register char n;      char n;
     REQUEST(xListFontsReq);     REQUEST(xListFontsReq);
     swaps(&stuff->length, n);     swaps(&stuff->length, n);
     REQUEST_AT_LEAST_SIZE(xListFontsReq);     REQUEST_AT_LEAST_SIZE(xListFontsReq);
Line 529 
Line 497 
 } }
  
 int int
 SProcListFontsWithInfo(client)  SProcListFontsWithInfo(ClientPtr client)
     register ClientPtr client;  
 { {
     register char n;      char n;
     REQUEST(xListFontsWithInfoReq);     REQUEST(xListFontsWithInfoReq);
     swaps(&stuff->length, n);     swaps(&stuff->length, n);
     REQUEST_AT_LEAST_SIZE(xListFontsWithInfoReq);     REQUEST_AT_LEAST_SIZE(xListFontsWithInfoReq);
Line 542 
Line 509 
 } }
  
 int int
 SProcSetFontPath(client)  SProcSetFontPath(ClientPtr client)
     register ClientPtr client;  
 { {
     register char n;      char n;
     REQUEST(xSetFontPathReq);     REQUEST(xSetFontPathReq);
     swaps(&stuff->length, n);     swaps(&stuff->length, n);
     REQUEST_AT_LEAST_SIZE(xSetFontPathReq);     REQUEST_AT_LEAST_SIZE(xSetFontPathReq);
Line 554 
Line 520 
 } }
  
 int int
 SProcCreatePixmap(client)  SProcCreatePixmap(ClientPtr client)
     register ClientPtr client;  
 { {
     register char n;      char n;
     REQUEST(xCreatePixmapReq);     REQUEST(xCreatePixmapReq);
  
     swaps(&stuff->length, n);     swaps(&stuff->length, n);
Line 570 
Line 535 
 } }
  
 int int
 SProcCreateGC(client)  SProcCreateGC(ClientPtr client)
     register ClientPtr client;  
 { {
     register char n;      char n;
     REQUEST(xCreateGCReq);     REQUEST(xCreateGCReq);
     swaps(&stuff->length, n);     swaps(&stuff->length, n);
     REQUEST_AT_LEAST_SIZE(xCreateGCReq);     REQUEST_AT_LEAST_SIZE(xCreateGCReq);
Line 585 
Line 549 
 } }
  
 int int
 SProcChangeGC(client)  SProcChangeGC(ClientPtr client)
     register ClientPtr client;  
 { {
     register char n;      char n;
     REQUEST(xChangeGCReq);     REQUEST(xChangeGCReq);
     swaps(&stuff->length, n);     swaps(&stuff->length, n);
     REQUEST_AT_LEAST_SIZE(xChangeGCReq);     REQUEST_AT_LEAST_SIZE(xChangeGCReq);
Line 599 
Line 562 
 } }
  
 int int
 SProcCopyGC(client)  SProcCopyGC(ClientPtr client)
     register ClientPtr client;  
 { {
     register char n;      char n;
     REQUEST(xCopyGCReq);     REQUEST(xCopyGCReq);
     swaps(&stuff->length, n);     swaps(&stuff->length, n);
     REQUEST_SIZE_MATCH(xCopyGCReq);     REQUEST_SIZE_MATCH(xCopyGCReq);
Line 613 
Line 575 
 } }
  
 int int
 SProcSetDashes(client)  SProcSetDashes(ClientPtr client)
     register ClientPtr client;  
 { {
     register char n;      char n;
     REQUEST(xSetDashesReq);     REQUEST(xSetDashesReq);
     swaps(&stuff->length, n);     swaps(&stuff->length, n);
     REQUEST_AT_LEAST_SIZE(xSetDashesReq);     REQUEST_AT_LEAST_SIZE(xSetDashesReq);
Line 628 
Line 589 
 } }
  
 int int
 SProcSetClipRectangles(client)  SProcSetClipRectangles(ClientPtr client)
     register ClientPtr client;  
 { {
     register char n;      char n;
     REQUEST(xSetClipRectanglesReq);     REQUEST(xSetClipRectanglesReq);
     swaps(&stuff->length, n);     swaps(&stuff->length, n);
     REQUEST_AT_LEAST_SIZE(xSetClipRectanglesReq);     REQUEST_AT_LEAST_SIZE(xSetClipRectanglesReq);
Line 643 
Line 603 
 } }
  
 int int
 SProcClearToBackground(client)  SProcClearToBackground(ClientPtr client)
     register ClientPtr client;  
 { {
     register char n;      char n;
     REQUEST(xClearAreaReq);     REQUEST(xClearAreaReq);
     swaps(&stuff->length, n);     swaps(&stuff->length, n);
     REQUEST_SIZE_MATCH(xClearAreaReq);     REQUEST_SIZE_MATCH(xClearAreaReq);
Line 659 
Line 618 
 } }
  
 int int
 SProcCopyArea(client)  SProcCopyArea(ClientPtr client)
     register ClientPtr client;  
 { {
     register char n;      char n;
     REQUEST(xCopyAreaReq);     REQUEST(xCopyAreaReq);
     swaps(&stuff->length, n);     swaps(&stuff->length, n);
     REQUEST_SIZE_MATCH(xCopyAreaReq);     REQUEST_SIZE_MATCH(xCopyAreaReq);
Line 679 
Line 637 
 } }
  
 int int
 SProcCopyPlane(client)  SProcCopyPlane(ClientPtr client)
     register ClientPtr client;  
 { {
     register char n;      char n;
     REQUEST(xCopyPlaneReq);     REQUEST(xCopyPlaneReq);
     swaps(&stuff->length, n);     swaps(&stuff->length, n);
     REQUEST_SIZE_MATCH(xCopyPlaneReq);     REQUEST_SIZE_MATCH(xCopyPlaneReq);
Line 702 
Line 659 
 /* The following routine is used for all Poly drawing requests /* The following routine is used for all Poly drawing requests
    (except FillPoly, which uses a different request format) */    (except FillPoly, which uses a different request format) */
 int int
 SProcPoly(client)  SProcPoly(ClientPtr client)
     register ClientPtr client;  
 { {
     register char n;      char n;
  
     REQUEST(xPolyPointReq);     REQUEST(xPolyPointReq);
     swaps(&stuff->length, n);     swaps(&stuff->length, n);
Line 720 
Line 676 
    is longer than xPolyPointReq, and we don't want to swap    is longer than xPolyPointReq, and we don't want to swap
    the difference as shorts! */    the difference as shorts! */
 int int
 SProcFillPoly(client)  SProcFillPoly(ClientPtr client)
     register ClientPtr client;  
 { {
     register char n;      char n;
  
     REQUEST(xFillPolyReq);     REQUEST(xFillPolyReq);
     swaps(&stuff->length, n);     swaps(&stuff->length, n);
Line 735 
Line 690 
 } }
  
 int int
 SProcPutImage(client)  SProcPutImage(ClientPtr client)
     register ClientPtr client;  
 { {
     register char n;      char n;
     REQUEST(xPutImageReq);     REQUEST(xPutImageReq);
     swaps(&stuff->length, n);     swaps(&stuff->length, n);
     REQUEST_AT_LEAST_SIZE(xPutImageReq);     REQUEST_AT_LEAST_SIZE(xPutImageReq);
Line 754 
Line 708 
 } }
  
 int int
 SProcGetImage(client)  SProcGetImage(ClientPtr client)
     register ClientPtr  client;  
 { {
     register char n;      char n;
     REQUEST(xGetImageReq);     REQUEST(xGetImageReq);
     swaps(&stuff->length, n);     swaps(&stuff->length, n);
     REQUEST_SIZE_MATCH(xGetImageReq);     REQUEST_SIZE_MATCH(xGetImageReq);
Line 773 
Line 726 
 /* ProcPolyText used for both PolyText8 and PolyText16 */ /* ProcPolyText used for both PolyText8 and PolyText16 */
  
 int int
 SProcPolyText(client)  SProcPolyText(ClientPtr client)
     register ClientPtr client;  
 { {
     register char n;      char n;
     REQUEST(xPolyTextReq);     REQUEST(xPolyTextReq);
     swaps(&stuff->length, n);     swaps(&stuff->length, n);
     REQUEST_AT_LEAST_SIZE(xPolyTextReq);     REQUEST_AT_LEAST_SIZE(xPolyTextReq);
Line 790 
Line 742 
 /* ProcImageText used for both ImageText8 and ImageText16 */ /* ProcImageText used for both ImageText8 and ImageText16 */
  
 int int
 SProcImageText(client)  SProcImageText(ClientPtr client)
     register ClientPtr client;  
 { {
     register char n;      char n;
     REQUEST(xImageTextReq);     REQUEST(xImageTextReq);
     swaps(&stuff->length, n);     swaps(&stuff->length, n);
     REQUEST_AT_LEAST_SIZE(xImageTextReq);     REQUEST_AT_LEAST_SIZE(xImageTextReq);
Line 805 
Line 756 
 } }
  
 int int
 SProcCreateColormap(client)  SProcCreateColormap(ClientPtr client)
     register ClientPtr client;  
 { {
     register char n;      char n;
     REQUEST(xCreateColormapReq);     REQUEST(xCreateColormapReq);
     swaps(&stuff->length, n);     swaps(&stuff->length, n);
     REQUEST_SIZE_MATCH(xCreateColormapReq);     REQUEST_SIZE_MATCH(xCreateColormapReq);
Line 820 
Line 770 
  
  
 int int
 SProcCopyColormapAndFree(client)  SProcCopyColormapAndFree(ClientPtr client)
     register ClientPtr client;  
 { {
     register char n;      char n;
     REQUEST(xCopyColormapAndFreeReq);     REQUEST(xCopyColormapAndFreeReq);
     swaps(&stuff->length, n);     swaps(&stuff->length, n);
     REQUEST_SIZE_MATCH(xCopyColormapAndFreeReq);     REQUEST_SIZE_MATCH(xCopyColormapAndFreeReq);
Line 834 
Line 783 
 } }
  
 int int
 SProcAllocColor                (client)  SProcAllocColor(ClientPtr client)
     register ClientPtr client;  
 { {
     register char n;      char n;
     REQUEST(xAllocColorReq);     REQUEST(xAllocColorReq);
     swaps(&stuff->length, n);     swaps(&stuff->length, n);
     REQUEST_SIZE_MATCH(xAllocColorReq);     REQUEST_SIZE_MATCH(xAllocColorReq);
Line 849 
Line 797 
 } }
  
 int int
 SProcAllocNamedColor           (client)  SProcAllocNamedColor(ClientPtr client)
     register ClientPtr client;  
 { {
     register char n;      char n;
  
     REQUEST(xAllocNamedColorReq);     REQUEST(xAllocNamedColorReq);
     swaps(&stuff->length, n);     swaps(&stuff->length, n);
Line 863 
Line 810 
 } }
  
 int int
 SProcAllocColorCells           (client)  SProcAllocColorCells(ClientPtr client)
     register ClientPtr client;  
 { {
     register char n;      char n;
     REQUEST(xAllocColorCellsReq);     REQUEST(xAllocColorCellsReq);
     swaps(&stuff->length, n);     swaps(&stuff->length, n);
     REQUEST_SIZE_MATCH(xAllocColorCellsReq);     REQUEST_SIZE_MATCH(xAllocColorCellsReq);
Line 877 
Line 823 
 } }
  
 int int
 SProcAllocColorPlanes(client)  SProcAllocColorPlanes(ClientPtr client)
     register ClientPtr client;  
 { {
     register char n;      char n;
     REQUEST(xAllocColorPlanesReq);     REQUEST(xAllocColorPlanesReq);
     swaps(&stuff->length, n);     swaps(&stuff->length, n);
     REQUEST_SIZE_MATCH(xAllocColorPlanesReq);     REQUEST_SIZE_MATCH(xAllocColorPlanesReq);
Line 893 
Line 838 
 } }
  
 int int
 SProcFreeColors          (client)  SProcFreeColors(ClientPtr client)
     register ClientPtr client;  
 { {
     register char n;      char n;
     REQUEST(xFreeColorsReq);     REQUEST(xFreeColorsReq);
     swaps(&stuff->length, n);     swaps(&stuff->length, n);
     REQUEST_AT_LEAST_SIZE(xFreeColorsReq);     REQUEST_AT_LEAST_SIZE(xFreeColorsReq);
Line 908 
Line 852 
 } }
  
 void void
 SwapColorItem(pItem)  SwapColorItem(xColorItem *pItem)
     xColorItem  *pItem;  
 { {
     register char n;      char n;
  
     swapl(&pItem->pixel, n);     swapl(&pItem->pixel, n);
     swaps(&pItem->red, n);     swaps(&pItem->red, n);
Line 920 
Line 863 
 } }
  
 int int
 SProcStoreColors               (client)  SProcStoreColors(ClientPtr client)
     register ClientPtr client;  
 { {
     register char n;      char n;
     long count;     long count;
     xColorItem  *pItem;     xColorItem  *pItem;
  
Line 938 
Line 880 
 } }
  
 int int
 SProcStoreNamedColor           (client)  SProcStoreNamedColor(ClientPtr client)
     register ClientPtr client;  
 { {
     register char n;      char n;
     REQUEST(xStoreNamedColorReq);     REQUEST(xStoreNamedColorReq);
     swaps(&stuff->length, n);     swaps(&stuff->length, n);
     REQUEST_AT_LEAST_SIZE(xStoreNamedColorReq);     REQUEST_AT_LEAST_SIZE(xStoreNamedColorReq);
Line 952 
Line 893 
 } }
  
 int int
 SProcQueryColors(client)  SProcQueryColors(ClientPtr client)
     register ClientPtr client;  
 { {
     register char n;      char n;
     REQUEST(xQueryColorsReq);     REQUEST(xQueryColorsReq);
     swaps(&stuff->length, n);     swaps(&stuff->length, n);
     REQUEST_AT_LEAST_SIZE(xQueryColorsReq);     REQUEST_AT_LEAST_SIZE(xQueryColorsReq);
Line 965 
Line 905 
 } }
  
 int int
 SProcLookupColor(client)  SProcLookupColor(ClientPtr client)
     register ClientPtr client;  
 { {
     register char n;      char n;
     REQUEST(xLookupColorReq);     REQUEST(xLookupColorReq);
     swaps(&stuff->length, n);     swaps(&stuff->length, n);
     REQUEST_AT_LEAST_SIZE(xLookupColorReq);     REQUEST_AT_LEAST_SIZE(xLookupColorReq);
Line 978 
Line 917 
 } }
  
 int int
 SProcCreateCursor( client)  SProcCreateCursor(ClientPtr client)
     register ClientPtr client;  
 { {
     register char n;      char n;
     REQUEST(xCreateCursorReq);     REQUEST(xCreateCursorReq);
     swaps(&stuff->length, n);     swaps(&stuff->length, n);
     REQUEST_SIZE_MATCH(xCreateCursorReq);     REQUEST_SIZE_MATCH(xCreateCursorReq);
Line 1000 
Line 938 
 } }
  
 int int
 SProcCreateGlyphCursor( client)  SProcCreateGlyphCursor(ClientPtr client)
     register ClientPtr client;  
 { {
     register char n;      char n;
     REQUEST(xCreateGlyphCursorReq);     REQUEST(xCreateGlyphCursorReq);
     swaps(&stuff->length, n);     swaps(&stuff->length, n);
     REQUEST_SIZE_MATCH(xCreateGlyphCursorReq);     REQUEST_SIZE_MATCH(xCreateGlyphCursorReq);
Line 1023 
Line 960 
  
  
 int int
 SProcRecolorCursor(client)  SProcRecolorCursor(ClientPtr client)
     register ClientPtr client;  
 { {
     register char n;      char n;
     REQUEST(xRecolorCursorReq);     REQUEST(xRecolorCursorReq);
     swaps(&stuff->length, n);     swaps(&stuff->length, n);
     REQUEST_SIZE_MATCH(xRecolorCursorReq);     REQUEST_SIZE_MATCH(xRecolorCursorReq);
Line 1041 
Line 977 
 } }
  
 int int
 SProcQueryBestSize   (client)  SProcQueryBestSize(ClientPtr client)
     register ClientPtr client;  
 { {
     register char n;      char n;
     REQUEST(xQueryBestSizeReq);     REQUEST(xQueryBestSizeReq);
     swaps(&stuff->length, n);     swaps(&stuff->length, n);
     REQUEST_SIZE_MATCH(xQueryBestSizeReq);     REQUEST_SIZE_MATCH(xQueryBestSizeReq);
Line 1056 
Line 991 
 } }
  
 int int
 SProcQueryExtension   (client)  SProcQueryExtension(ClientPtr client)
     register ClientPtr client;  
 { {
     register char n;      char n;
     REQUEST(xQueryExtensionReq);     REQUEST(xQueryExtensionReq);
     swaps(&stuff->length, n);     swaps(&stuff->length, n);
     REQUEST_AT_LEAST_SIZE(xQueryExtensionReq);     REQUEST_AT_LEAST_SIZE(xQueryExtensionReq);
Line 1068 
Line 1002 
 } }
  
 int int
 SProcChangeKeyboardMapping   (client)  SProcChangeKeyboardMapping(ClientPtr client)
     register ClientPtr client;  
 { {
     register char n;      char n;
     REQUEST(xChangeKeyboardMappingReq);     REQUEST(xChangeKeyboardMappingReq);
     swaps(&stuff->length, n);     swaps(&stuff->length, n);
     REQUEST_AT_LEAST_SIZE(xChangeKeyboardMappingReq);     REQUEST_AT_LEAST_SIZE(xChangeKeyboardMappingReq);
Line 1081 
Line 1014 
  
  
 int int
 SProcChangeKeyboardControl   (client)  SProcChangeKeyboardControl(ClientPtr client)
     register ClientPtr client;  
 { {
     register char n;      char n;
     REQUEST(xChangeKeyboardControlReq);     REQUEST(xChangeKeyboardControlReq);
     swaps(&stuff->length, n);     swaps(&stuff->length, n);
     REQUEST_AT_LEAST_SIZE(xChangeKeyboardControlReq);     REQUEST_AT_LEAST_SIZE(xChangeKeyboardControlReq);
Line 1094 
Line 1026 
 } }
  
 int int
 SProcChangePointerControl   (client)  SProcChangePointerControl(ClientPtr client)
     register ClientPtr client;  
 { {
     register char n;      char n;
     REQUEST(xChangePointerControlReq);     REQUEST(xChangePointerControlReq);
     swaps(&stuff->length, n);     swaps(&stuff->length, n);
     REQUEST_SIZE_MATCH(xChangePointerControlReq);     REQUEST_SIZE_MATCH(xChangePointerControlReq);
Line 1109 
Line 1040 
  
  
 int int
 SProcSetScreenSaver            (client)  SProcSetScreenSaver(ClientPtr client)
     register ClientPtr client;  
 { {
     register char n;      char n;
     REQUEST(xSetScreenSaverReq);     REQUEST(xSetScreenSaverReq);
     swaps(&stuff->length, n);     swaps(&stuff->length, n);
     REQUEST_SIZE_MATCH(xSetScreenSaverReq);     REQUEST_SIZE_MATCH(xSetScreenSaverReq);
Line 1122 
Line 1052 
 } }
  
 int int
 SProcChangeHosts(client)  SProcChangeHosts(ClientPtr client)
     register ClientPtr client;  
 { {
     register char n;      char n;
  
     REQUEST(xChangeHostsReq);     REQUEST(xChangeHostsReq);
     swaps(&stuff->length, n);     swaps(&stuff->length, n);
Line 1135 
Line 1064 
  
 } }
  
 int SProcRotateProperties(client)  int SProcRotateProperties(ClientPtr client)
     register ClientPtr client;  
 { {
     register char n;      char n;
     REQUEST(xRotatePropertiesReq);     REQUEST(xRotatePropertiesReq);
     swaps(&stuff->length, n);     swaps(&stuff->length, n);
     REQUEST_AT_LEAST_SIZE(xRotatePropertiesReq);     REQUEST_AT_LEAST_SIZE(xRotatePropertiesReq);
Line 1151 
Line 1079 
  
 /*ARGSUSED*/ /*ARGSUSED*/
 int int
 SProcNoOperation(client)  SProcNoOperation(ClientPtr client)
     ClientPtr client;  
 { {
     register char n;      char n;
     REQUEST(xReq);     REQUEST(xReq);
     swaps(&stuff->length, n);     swaps(&stuff->length, n);
     return ((* ProcVector[X_NoOperation])(client));     return ((* ProcVector[X_NoOperation])(client));
 } }
  
 void void
 SwapConnClientPrefix(pCCP)  SwapConnClientPrefix(xConnClientPrefix *pCCP)
     xConnClientPrefix   *pCCP;  
 { {
     register char n;      char n;
  
     swaps(&pCCP->majorVersion, n);     swaps(&pCCP->majorVersion, n);
     swaps(&pCCP->minorVersion, n);     swaps(&pCCP->minorVersion, n);

Legend:
Removed from v.3.5  
changed lines
  Added in v.3.6
Powered by
ViewCVS 0.9.2