frederik
/
xserver
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

xc/programs/Xserver/dix/atom.c 

xc/programs/Xserver/dix/colormap.c
xc/programs/Xserver/dix/cursor.c
xc/programs/Xserver/dix/devices.c
xc/programs/Xserver/dix/dispatch.c
xc/programs/Xserver/dix/dixfonts.c
xc/programs/Xserver/dix/dixutils.c
xc/programs/Xserver/dix/events.c
xc/programs/Xserver/dix/extension.c
xc/programs/Xserver/dix/gc.c
xc/programs/Xserver/dix/glyphcurs.c
xc/programs/Xserver/dix/grabs.c
xc/programs/Xserver/dix/main.c
xc/programs/Xserver/dix/pixmap.c
xc/programs/Xserver/dix/privates.c
xc/programs/Xserver/dix/property.c
xc/programs/Xserver/dix/resource.c
xc/programs/Xserver/dix/swaprep.c
xc/programs/Xserver/dix/swapreq.c
//bugs.freedesktop.org/show_bug.cgi?id=2560) attachment #2037
    (https://bugs.freedesktop.org/attachment.cgi?id=2037) ANSI-fy
    Xserver/dix code. The conversion preserves the comments which annotate
    variables. These have been moved into doxygen(esque?) "stubs" above
    each function. Patch by Mike Owens <etc@filespanker.com>.
This commit is contained in:
Roland Mainz 2005-03-07 23:02:59 +00:00
parent cb0aa2b4d8
commit 8d0e520721
20 changed files with 760 additions and 1700 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
dix/atom.c
View File

@ -71,10 +71,7 @@ static NodePtr *nodeTable;
void FreeAtom(NodePtr patom); void FreeAtom(NodePtr patom);
Atom Atom
MakeAtom(string, len, makeit) MakeAtom(char *string, unsigned len, Bool makeit)
char *string;
unsigned len;
Bool makeit;
{ {
register NodePtr * np; register NodePtr * np;
unsigned i; unsigned i;
@ -151,15 +148,13 @@ MakeAtom(string, len, makeit)
} }
Bool Bool
ValidAtom(atom) ValidAtom(Atom atom)
Atom atom;
{ {
return (atom != None) && (atom <= lastAtom); return (atom != None) && (atom <= lastAtom);
} }
char * char *
NameForAtom(atom) NameForAtom(Atom atom)
Atom atom;
{ {
NodePtr node; NodePtr node;
if (atom > lastAtom) return 0; if (atom > lastAtom) return 0;

239
dix/colormap.c
View File

@ -1,4 +1,4 @@
/* $XdotOrg: xc/programs/Xserver/dix/colormap.c,v 1.4 2004/08/07 00:58:21 keithp Exp $ */ /* $XdotOrg: xc/programs/Xserver/dix/colormap.c,v 1.5 2004/08/13 08:16:14 keithp Exp $ */
/* $XFree86: xc/programs/Xserver/dix/colormap.c,v 3.11 2003/11/03 05:10:59 tsi Exp $ */ /* $XFree86: xc/programs/Xserver/dix/colormap.c,v 3.11 2003/11/03 05:10:59 tsi Exp $ */
/*********************************************************** /***********************************************************
@ -245,15 +245,15 @@ typedef struct _colorResource
*/ */
/* Create and initialize the color map */ /**
* Create and initialize the color map
*
* \param mid resource to use for this colormap
* \param alloc 1 iff all entries are allocated writable
*/
int int
CreateColormap (mid, pScreen, pVisual, ppcmap, alloc, client) CreateColormap (Colormap mid, ScreenPtr pScreen, VisualPtr pVisual,
Colormap mid; /* resource to use for this colormap */ ColormapPtr *ppcmap, int alloc, int client)
ScreenPtr pScreen;
VisualPtr pVisual;
ColormapPtr *ppcmap;
int alloc; /* 1 iff all entries are allocated writeable */
int client;
{ {
int class, size; int class, size;
unsigned long sizebytes; unsigned long sizebytes;
@ -414,10 +414,12 @@ CreateColormap (mid, pScreen, pVisual, ppcmap, alloc, client)
return (Success); return (Success);
} }
/**
*
* \param value must conform to DeleteType
*/
int int
FreeColormap (value, mid) FreeColormap (pointer value, XID mid)
pointer value; /* must conform to DeleteType */
XID mid;
{ {
int i; int i;
register EntryPtr pent; register EntryPtr pent;
@ -474,9 +476,7 @@ FreeColormap (value, mid)
/* Tell window that pmid has disappeared */ /* Tell window that pmid has disappeared */
static int static int
TellNoMap (pwin, pmid) TellNoMap (WindowPtr pwin, Colormap *pmid)
WindowPtr pwin;
Colormap *pmid;
{ {
xEvent xE; xEvent xE;
@ -503,9 +503,7 @@ TellNoMap (pwin, pmid)
/* Tell window that pmid got uninstalled */ /* Tell window that pmid got uninstalled */
int int
TellLostMap (pwin, value) TellLostMap (WindowPtr pwin, pointer value)
WindowPtr pwin;
pointer value;
{ {
Colormap *pmid = (Colormap *)value; Colormap *pmid = (Colormap *)value;
xEvent xE; xEvent xE;
@ -530,9 +528,7 @@ TellLostMap (pwin, value)
/* Tell window that pmid got installed */ /* Tell window that pmid got installed */
int int
TellGainedMap (pwin, value) TellGainedMap (WindowPtr pwin, pointer value)
WindowPtr pwin;
pointer value;
{ {
Colormap *pmid = (Colormap *)value; Colormap *pmid = (Colormap *)value;
xEvent xE; xEvent xE;
@ -557,10 +553,7 @@ TellGainedMap (pwin, value)
int int
CopyColormapAndFree (mid, pSrc, client) CopyColormapAndFree (Colormap mid, ColormapPtr pSrc, int client)
Colormap mid;
ColormapPtr pSrc;
int client;
{ {
ColormapPtr pmap = (ColormapPtr) NULL; ColormapPtr pmap = (ColormapPtr) NULL;
int result, alloc, size; int result, alloc, size;
@ -607,9 +600,7 @@ CopyColormapAndFree (mid, pSrc, client)
/* Helper routine for freeing large numbers of cells from a map */ /* Helper routine for freeing large numbers of cells from a map */
static void static void
CopyFree (channel, client, pmapSrc, pmapDst) CopyFree (int channel, int client, ColormapPtr pmapSrc, ColormapPtr pmapDst)
int channel, client;
ColormapPtr pmapSrc, pmapDst;
{ {
int z, npix; int z, npix;
EntryPtr pentSrcFirst, pentDstFirst; EntryPtr pentSrcFirst, pentDstFirst;
@ -696,10 +687,7 @@ CopyFree (channel, client, pmapSrc, pmapDst)
/* Free the ith entry in a color map. Must handle freeing of /* Free the ith entry in a color map. Must handle freeing of
* colors allocated through AllocColorPlanes */ * colors allocated through AllocColorPlanes */
static void static void
FreeCell (pmap, i, channel) FreeCell (ColormapPtr pmap, Pixel i, int channel)
ColormapPtr pmap;
Pixel i;
int channel;
{ {
EntryPtr pent; EntryPtr pent;
int *pCount; int *pCount;
@ -746,8 +734,7 @@ FreeCell (pmap, i, channel)
} }
static void static void
UpdateColors (pmap) UpdateColors (ColormapPtr pmap)
ColormapPtr pmap;
{ {
xColorItem *defs; xColorItem *defs;
register xColorItem *pdef; register xColorItem *pdef;
@ -814,11 +801,9 @@ UpdateColors (pmap)
* Returns by changing the value in pred, pgreen, pblue and pPix * Returns by changing the value in pred, pgreen, pblue and pPix
*/ */
int int
AllocColor (pmap, pred, pgreen, pblue, pPix, client) AllocColor (ColormapPtr pmap,
ColormapPtr pmap; unsigned short *pred, unsigned short *pgreen, unsigned short *pblue,
unsigned short *pred, *pgreen, *pblue; Pixel *pPix, int client)
Pixel *pPix;
int client;
{ {
Pixel pixR, pixG, pixB; Pixel pixR, pixG, pixB;
int entries; int entries;
@ -1001,9 +986,7 @@ AllocColor (pmap, pred, pgreen, pblue, pPix, client)
*/ */
void void
FakeAllocColor (pmap, item) FakeAllocColor (register ColormapPtr pmap, register xColorItem *item)
register ColormapPtr pmap;
register xColorItem *item;
{ {
Pixel pixR, pixG, pixB; Pixel pixR, pixG, pixB;
Pixel temp; Pixel temp;
@ -1069,9 +1052,7 @@ FakeAllocColor (pmap, item)
/* free a pixel value obtained from FakeAllocColor */ /* free a pixel value obtained from FakeAllocColor */
void void
FakeFreeColor(pmap, pixel) FakeFreeColor(register ColormapPtr pmap, Pixel pixel)
register ColormapPtr pmap;
Pixel pixel;
{ {
register VisualPtr pVisual; register VisualPtr pVisual;
Pixel pixR, pixG, pixB; Pixel pixR, pixG, pixB;
@ -1136,11 +1117,7 @@ BigNumAdd (BigNumPtr x, BigNumPtr y, BigNumPtr r)
} }
static Pixel static Pixel
FindBestPixel(pentFirst, size, prgb, channel) FindBestPixel(EntryPtr pentFirst, int size, xrgb *prgb, int channel)
EntryPtr pentFirst;
int size;
xrgb *prgb;
int channel;
{ {
EntryPtr pent; EntryPtr pent;
Pixel pixel, final; Pixel pixel, final;
@ -1187,14 +1164,9 @@ FindBestPixel(pentFirst, size, prgb, channel)
} }
static void static void
FindColorInRootCmap (pmap, pentFirst, size, prgb, pPixel, channel, comp) FindColorInRootCmap (ColormapPtr pmap, EntryPtr pentFirst, int size,
ColormapPtr pmap; xrgb *prgb, Pixel *pPixel, int channel,
EntryPtr pentFirst; ColorCompareProcPtr comp)
int size;
xrgb* prgb;
Pixel* pPixel;
int channel;
ColorCompareProcPtr comp;
{ {
EntryPtr pent; EntryPtr pent;
Pixel pixel; Pixel pixel;
@ -1231,15 +1203,9 @@ FindColorInRootCmap (pmap, pentFirst, size, prgb, pPixel, channel, comp)
* load *pPixel with that value, otherwise set it to 0 * load *pPixel with that value, otherwise set it to 0
*/ */
int int
FindColor (pmap, pentFirst, size, prgb, pPixel, channel, client, comp) FindColor (ColormapPtr pmap, EntryPtr pentFirst, int size, xrgb *prgb,
ColormapPtr pmap; Pixel *pPixel, int channel, int client,
EntryPtr pentFirst; ColorCompareProcPtr comp)
int size;
xrgb *prgb;
Pixel *pPixel;
int channel;
int client;
ColorCompareProcPtr comp;
{ {
EntryPtr pent; EntryPtr pent;
Bool foundFree; Bool foundFree;
@ -1412,9 +1378,7 @@ gotit:
/* Comparison functions -- passed to FindColor to determine if an /* Comparison functions -- passed to FindColor to determine if an
* entry is already the color we're looking for or not */ * entry is already the color we're looking for or not */
static int static int
AllComp (pent, prgb) AllComp (EntryPtr pent, xrgb *prgb)
EntryPtr pent;
xrgb *prgb;
{ {
if((pent->co.local.red == prgb->red) && if((pent->co.local.red == prgb->red) &&
(pent->co.local.green == prgb->green) && (pent->co.local.green == prgb->green) &&
@ -1424,9 +1388,7 @@ AllComp (pent, prgb)
} }
static int static int
RedComp (pent, prgb) RedComp (EntryPtr pent, xrgb *prgb)
EntryPtr pent;
xrgb *prgb;
{ {
if (pent->co.local.red == prgb->red) if (pent->co.local.red == prgb->red)
return (1); return (1);
@ -1434,9 +1396,7 @@ RedComp (pent, prgb)
} }
static int static int
GreenComp (pent, prgb) GreenComp (EntryPtr pent, xrgb *prgb)
EntryPtr pent;
xrgb *prgb;
{ {
if (pent->co.local.green == prgb->green) if (pent->co.local.green == prgb->green)
return (1); return (1);
@ -1444,9 +1404,7 @@ GreenComp (pent, prgb)
} }
static int static int
BlueComp (pent, prgb) BlueComp (EntryPtr pent, xrgb *prgb)
EntryPtr pent;
xrgb *prgb;
{ {
if (pent->co.local.blue == prgb->blue) if (pent->co.local.blue == prgb->blue)
return (1); return (1);
@ -1457,11 +1415,7 @@ BlueComp (pent, prgb)
/* Read the color value of a cell */ /* Read the color value of a cell */
int int
QueryColors (pmap, count, ppixIn, prgbList) QueryColors (ColormapPtr pmap, int count, Pixel *ppixIn, xrgb *prgbList)
ColormapPtr pmap;
int count;
Pixel *ppixIn;
xrgb *prgbList;
{ {
Pixel *ppix, pixel; Pixel *ppix, pixel;
xrgb *prgb; xrgb *prgb;
@ -1546,9 +1500,7 @@ QueryColors (pmap, count, ppixIn, prgbList)
} }
static void static void
FreePixels(pmap, client) FreePixels(register ColormapPtr pmap, register int client)
register ColormapPtr pmap;
register int client;
{ {
register Pixel *ppix, *ppixStart; register Pixel *ppix, *ppixStart;
register int n; register int n;
@ -1637,12 +1589,14 @@ FreePixels(pmap, client)
} }
} }
/* Free all of a client's colors and cells */ /**
/*ARGSUSED*/ * Frees all of a client's colors and cells.
*
* \param value must conform to DeleteType
* \unused fakeid
*/
int int
FreeClientPixels (value, fakeid) FreeClientPixels (pointer value, XID fakeid)
pointer value; /* must conform to DeleteType */
XID fakeid;
{ {
ColormapPtr pmap; ColormapPtr pmap;
colorResource *pcr = (colorResource *)value; colorResource *pcr = (colorResource *)value;
@ -1655,13 +1609,8 @@ FreeClientPixels (value, fakeid)
} }
int int
AllocColorCells (client, pmap, colors, planes, contig, ppix, masks) AllocColorCells (int client, ColormapPtr pmap, int colors, int planes,
int client; Bool contig, Pixel *ppix, Pixel *masks)
ColormapPtr pmap;
int colors, planes;
Bool contig;
Pixel *ppix;
Pixel *masks;
{ {
Pixel rmask, gmask, bmask, *ppixFirst, r, g, b; Pixel rmask, gmask, bmask, *ppixFirst, r, g, b;
int n, class; int n, class;
@ -1732,14 +1681,9 @@ AllocColorCells (client, pmap, colors, planes, contig, ppix, masks)
int int
AllocColorPlanes (client, pmap, colors, r, g, b, contig, pixels, AllocColorPlanes (int client, ColormapPtr pmap, int colors,
prmask, pgmask, pbmask) int r, int g, int b, Bool contig, Pixel *pixels,
int client; Pixel *prmask, Pixel *pgmask, Pixel *pbmask)
ColormapPtr pmap;
int colors, r, g, b;
Bool contig;
Pixel *pixels;
Pixel *prmask, *pgmask, *pbmask;
{ {
int ok; int ok;
Pixel mask, *ppixFirst; Pixel mask, *ppixFirst;
@ -1827,13 +1771,8 @@ AllocColorPlanes (client, pmap, colors, r, g, b, contig, pixels,
} }
static int static int
AllocDirect (client, pmap, c, r, g, b, contig, pixels, prmask, pgmask, pbmask) AllocDirect (int client, ColormapPtr pmap, int c, int r, int g, int b, Bool contig,
int client; Pixel *pixels, Pixel *prmask, Pixel *pgmask, Pixel *pbmask)
ColormapPtr pmap;
int c, r, g, b;
Bool contig;
Pixel *pixels;
Pixel *prmask, *pgmask, *pbmask;
{ {
Pixel *ppixRed, *ppixGreen, *ppixBlue; Pixel *ppixRed, *ppixGreen, *ppixBlue;
Pixel *ppix, *pDst, *p; Pixel *ppix, *pDst, *p;
@ -1951,14 +1890,8 @@ AllocDirect (client, pmap, c, r, g, b, contig, pixels, prmask, pgmask, pbmask)
} }
static int static int
AllocPseudo (client, pmap, c, r, contig, pixels, pmask, pppixFirst) AllocPseudo (int client, ColormapPtr pmap, int c, int r, Bool contig,
int client; Pixel *pixels, Pixel *pmask, Pixel **pppixFirst)
ColormapPtr pmap;
int c, r;
Bool contig;
Pixel *pixels;
Pixel *pmask;
Pixel **pppixFirst;
{ {
Pixel *ppix, *p, *pDst, *ppixTemp; Pixel *ppix, *p, *pDst, *ppixTemp;
int npix; int npix;
@ -2012,13 +1945,8 @@ AllocPseudo (client, pmap, c, r, contig, pixels, pmask, pppixFirst)
* (see AllocShared for why we care) * (see AllocShared for why we care)
*/ */
static Bool static Bool
AllocCP (pmap, pentFirst, count, planes, contig, pixels, pMask) AllocCP (ColormapPtr pmap, EntryPtr pentFirst, int count, int planes,
ColormapPtr pmap; Bool contig, Pixel *pixels, Pixel *pMask)
EntryPtr pentFirst;
int count, planes;
Bool contig;
Pixel *pixels, *pMask;
{ {
EntryPtr ent; EntryPtr ent;
Pixel pixel, base, entries, maxp, save; Pixel pixel, base, entries, maxp, save;
@ -2187,13 +2115,13 @@ AllocCP (pmap, pentFirst, count, planes, contig, pixels, pMask)
return (FALSE); return (FALSE);
} }
/**
*
* \param ppixFirst First of the client's new pixels
*/
static Bool static Bool
AllocShared (pmap, ppix, c, r, g, b, rmask, gmask, bmask, ppixFirst) AllocShared (ColormapPtr pmap, Pixel *ppix, int c, int r, int g, int b,
ColormapPtr pmap; Pixel rmask, Pixel gmask, Pixel bmask, Pixel *ppixFirst)
Pixel *ppix;
int c, r, g, b;
Pixel rmask, gmask, bmask;
Pixel *ppixFirst; /* First of the client's new pixels */
{ {
Pixel *pptr, *cptr; Pixel *pptr, *cptr;
int npix, z, npixClientNew, npixShared; int npix, z, npixClientNew, npixShared;
@ -2322,14 +2250,11 @@ AllocShared (pmap, ppix, c, r, g, b, rmask, gmask, bmask, ppixFirst)
} }
/* Free colors and/or cells (probably slow for large numbers) */ /** FreeColors
* Free colors and/or cells (probably slow for large numbers)
*/
int int
FreeColors (pmap, client, count, pixels, mask) FreeColors (ColormapPtr pmap, int client, int count, Pixel *pixels, Pixel mask)
ColormapPtr pmap;
int client, count;
Pixel *pixels;
Pixel mask;
{ {
int rval, result, class; int rval, result, class;
Pixel rmask; Pixel rmask;
@ -2367,19 +2292,20 @@ FreeColors (pmap, client, count, pixels, mask)
return (result); return (result);
} }
/* Helper for FreeColors -- frees all combinations of *newpixels and mask bits /**
* Helper for FreeColors -- frees all combinations of *newpixels and mask bits
* which the client has allocated in channel colormap cells of pmap. * which the client has allocated in channel colormap cells of pmap.
* doesn't change newpixels if it doesn't need to */ * doesn't change newpixels if it doesn't need to
*
* \param pmap which colormap head
* \param color which sub-map, eg, RED, BLUE, PSEUDO
* \param npixIn number of pixels passed in
* \param ppixIn number of base pixels
* \param mask mask client gave us
*/
static int static int
FreeCo (pmap, client, color, npixIn, ppixIn, mask) FreeCo (ColormapPtr pmap, int client, int color, int npixIn, Pixel *ppixIn, Pixel mask)
ColormapPtr pmap; /* which colormap head */
int client;
int color; /* which sub-map, eg RED, BLUE, PSEUDO */
int npixIn; /* number of pixels passed in */
Pixel *ppixIn; /* list of base pixels */
Pixel mask; /* mask client gave us */
{ {
Pixel *ppixClient, pixTest; Pixel *ppixClient, pixTest;
int npixClient, npixNew, npix; int npixClient, npixNew, npix;
Pixel bits, base, cmask, rgbbad; Pixel bits, base, cmask, rgbbad;
@ -2572,10 +2498,7 @@ FreeCo (pmap, client, color, npixIn, ppixIn, mask)
/* Redefine color values */ /* Redefine color values */
int int
StoreColors (pmap, count, defs) StoreColors (ColormapPtr pmap, int count, xColorItem *defs)
ColormapPtr pmap;
int count;
xColorItem *defs;
{ {
register Pixel pix; register Pixel pix;
register xColorItem *pdef; register xColorItem *pdef;
@ -2842,9 +2765,7 @@ StoreColors (pmap, count, defs)
} }
int int
IsMapInstalled(map, pWin) IsMapInstalled(Colormap map, WindowPtr pWin)
Colormap map;
WindowPtr pWin;
{ {
Colormap *pmaps; Colormap *pmaps;
int imap, nummaps, found; int imap, nummaps, found;

65
dix/cursor.c
View File

@ -100,14 +100,13 @@ FreeCursorBits(CursorBitsPtr bits)
} }
} }
/* /**
* To be called indirectly by DeleteResource; must use exactly two args * To be called indirectly by DeleteResource; must use exactly two args.
*
* \param value must conform to DeleteType
*/ */
/*ARGSUSED*/
int int
FreeCursor(value, cid) FreeCursor(pointer value, XID cid)
pointer value; /* must conform to DeleteType */
XID cid;
{ {
int nscr; int nscr;
CursorPtr pCurs = (CursorPtr)value; CursorPtr pCurs = (CursorPtr)value;
@ -152,19 +151,19 @@ CheckForEmptyMask(CursorBitsPtr bits)
bits->emptyMask = TRUE; bits->emptyMask = TRUE;
} }
/* /**
* does nothing about the resource table, just creates the data structure. * does nothing about the resource table, just creates the data structure.
* does not copy the src and mask bits * does not copy the src and mask bits
*
* \param psrcbits server-defined padding
* \param pmaskbits server-defined padding
* \param argb no padding
*/ */
CursorPtr CursorPtr
AllocCursorARGB(psrcbits, pmaskbits, argb, cm, AllocCursorARGB(unsigned char *psrcbits, unsigned char *pmaskbits, CARD32 *argb,
foreRed, foreGreen, foreBlue, backRed, backGreen, backBlue) CursorMetricPtr cm,
unsigned char * psrcbits; /* server-defined padding */ unsigned foreRed, unsigned foreGreen, unsigned foreBlue,
unsigned char * pmaskbits; /* server-defined padding */ unsigned backRed, unsigned backGreen, unsigned backBlue)
CARD32 * argb; /* no padding */
CursorMetricPtr cm;
unsigned foreRed, foreGreen, foreBlue;
unsigned backRed, backGreen, backBlue;
{ {
CursorBitsPtr bits; CursorBitsPtr bits;
CursorPtr pCurs; CursorPtr pCurs;
@ -227,14 +226,16 @@ AllocCursorARGB(psrcbits, pmaskbits, argb, cm,
return pCurs; return pCurs;
} }
/**
*
* \param psrcbits server-defined padding
* \param pmaskbits server-defined padding
*/
CursorPtr CursorPtr
AllocCursor(psrcbits, pmaskbits, cm, AllocCursor(unsigned char *psrcbits, unsigned char *pmaskbits,
foreRed, foreGreen, foreBlue, backRed, backGreen, backBlue) CursorMetricPtr cm,
unsigned char * psrcbits; /* server-defined padding */ unsigned foreRed, unsigned foreGreen, unsigned foreBlue,
unsigned char * pmaskbits; /* server-defined padding */ unsigned backRed, unsigned backGreen, unsigned backBlue)
CursorMetricPtr cm;
unsigned foreRed, foreGreen, foreBlue;
unsigned backRed, backGreen, backBlue;
{ {
return AllocCursorARGB (psrcbits, pmaskbits, (CARD32 *) 0, cm, return AllocCursorARGB (psrcbits, pmaskbits, (CARD32 *) 0, cm,
foreRed, foreGreen, foreBlue, foreRed, foreGreen, foreBlue,
@ -242,15 +243,10 @@ AllocCursor(psrcbits, pmaskbits, cm,
} }
int int
AllocGlyphCursor(source, sourceChar, mask, maskChar, AllocGlyphCursor(Font source, unsigned sourceChar, Font mask, unsigned maskChar,
foreRed, foreGreen, foreBlue, backRed, backGreen, backBlue, unsigned foreRed, unsigned foreGreen, unsigned foreBlue,
ppCurs, client) unsigned backRed, unsigned backGreen, unsigned backBlue,
Font source, mask; CursorPtr *ppCurs, ClientPtr client)
unsigned int sourceChar, maskChar;
unsigned foreRed, foreGreen, foreBlue;
unsigned backRed, backGreen, backBlue;
CursorPtr *ppCurs;
ClientPtr client;
{ {
FontPtr sourcefont, maskfont; FontPtr sourcefont, maskfont;
unsigned char *srcbits; unsigned char *srcbits;
@ -422,8 +418,7 @@ AllocGlyphCursor(source, sourceChar, mask, maskChar,
return Success; return Success;
} }
/*********************************************************** /** CreateRootCursor
* CreateRootCursor
* *
* look up the name of a font * look up the name of a font
* open the font * open the font
@ -433,9 +428,7 @@ AllocGlyphCursor(source, sourceChar, mask, maskChar,
*************************************************************/ *************************************************************/
CursorPtr CursorPtr
CreateRootCursor(pfilename, glyph) CreateRootCursor(char *pfilename, unsigned glyph)
char * pfilename;
unsigned int glyph;
{ {
CursorPtr curs; CursorPtr curs;
FontPtr cursorfont; FontPtr cursorfont;

172
dix/devices.c
View File

@ -78,9 +78,7 @@ SOFTWARE.
#include "dixevents.h" #include "dixevents.h"
DeviceIntPtr DeviceIntPtr
_AddInputDevice(deviceProc, autoStart) _AddInputDevice(DeviceProc deviceProc, Bool autoStart)
DeviceProc deviceProc;
Bool autoStart;
{ {
register DeviceIntPtr dev; register DeviceIntPtr dev;
@ -127,8 +125,7 @@ _AddInputDevice(deviceProc, autoStart)
} }
Bool Bool
EnableDevice(dev) EnableDevice(register DeviceIntPtr dev)
register DeviceIntPtr dev;
{ {
register DeviceIntPtr *prev; register DeviceIntPtr *prev;
@ -146,8 +143,7 @@ EnableDevice(dev)
} }
Bool Bool
DisableDevice(dev) DisableDevice(register DeviceIntPtr dev)
register DeviceIntPtr dev;
{ {
register DeviceIntPtr *prev; register DeviceIntPtr *prev;
@ -302,8 +298,7 @@ CloseDownDevices()
} }
void void
RemoveDevice(dev) RemoveDevice(register DeviceIntPtr dev)
register DeviceIntPtr dev;
{ {
register DeviceIntPtr prev,tmp,next; register DeviceIntPtr prev,tmp,next;
@ -353,8 +348,7 @@ NumMotionEvents()
} }
void void
_RegisterPointerDevice(device) _RegisterPointerDevice(DeviceIntPtr device)
DeviceIntPtr device;
{ {
inputInfo.pointer = device; inputInfo.pointer = device;
#ifdef XKB #ifdef XKB
@ -380,8 +374,7 @@ _RegisterPointerDevice(device)
} }
void void
_RegisterKeyboardDevice(device) _RegisterKeyboardDevice(DeviceIntPtr device)
DeviceIntPtr device;
{ {
inputInfo.keyboard = device; inputInfo.keyboard = device;
#ifdef XKB #ifdef XKB
@ -419,8 +412,7 @@ LookupPointerDevice()
} }
DevicePtr DevicePtr
LookupDevice(id) LookupDevice(int id)
int id;
{ {
DeviceIntPtr dev; DeviceIntPtr dev;
@ -436,8 +428,7 @@ LookupDevice(id)
} }
void void
QueryMinMaxKeyCodes(minCode, maxCode) QueryMinMaxKeyCodes(KeyCode *minCode, KeyCode *maxCode)
KeyCode *minCode, *maxCode;
{ {
if (inputInfo.keyboard) { if (inputInfo.keyboard) {
*minCode = inputInfo.keyboard->key->curKeySyms.minKeyCode; *minCode = inputInfo.keyboard->key->curKeySyms.minKeyCode;
@ -446,8 +437,7 @@ QueryMinMaxKeyCodes(minCode, maxCode)
} }
Bool Bool
SetKeySymsMap(dst, src) SetKeySymsMap(register KeySymsPtr dst, register KeySymsPtr src)
register KeySymsPtr dst, src;
{ {
int i, j; int i, j;
int rowDif = src->minKeyCode - dst->minKeyCode; int rowDif = src->minKeyCode - dst->minKeyCode;
@ -538,10 +528,7 @@ InitModMap(register KeyClassPtr keyc)
} }
Bool Bool
InitKeyClassDeviceStruct(dev, pKeySyms, pModifiers) InitKeyClassDeviceStruct(DeviceIntPtr dev, KeySymsPtr pKeySyms, CARD8 pModifiers[])
DeviceIntPtr dev;
KeySymsPtr pKeySyms;
CARD8 pModifiers[];
{ {
int i; int i;
register KeyClassPtr keyc; register KeyClassPtr keyc;
@ -579,10 +566,8 @@ InitKeyClassDeviceStruct(dev, pKeySyms, pModifiers)
} }
Bool Bool
InitButtonClassDeviceStruct(dev, numButtons, map) InitButtonClassDeviceStruct(register DeviceIntPtr dev, int numButtons,
register DeviceIntPtr dev; CARD8 *map)
int numButtons;
CARD8 *map;
{ {
register ButtonClassPtr butc; register ButtonClassPtr butc;
int i; int i;
@ -605,12 +590,9 @@ InitButtonClassDeviceStruct(dev, numButtons, map)
} }
Bool Bool
InitValuatorClassDeviceStruct(dev, numAxes, motionProc, numMotionEvents, mode) InitValuatorClassDeviceStruct(DeviceIntPtr dev, int numAxes,
DeviceIntPtr dev; ValuatorMotionProcPtr motionProc,
ValuatorMotionProcPtr motionProc; int numMotionEvents, int mode)
int numAxes;
int numMotionEvents;
int mode;
{ {
int i; int i;
register ValuatorClassPtr valc; register ValuatorClassPtr valc;
@ -634,8 +616,7 @@ InitValuatorClassDeviceStruct(dev, numAxes, motionProc, numMotionEvents, mode)
} }
Bool Bool
InitFocusClassDeviceStruct(dev) InitFocusClassDeviceStruct(DeviceIntPtr dev)
DeviceIntPtr dev;
{ {
register FocusClassPtr focc; register FocusClassPtr focc;
@ -653,10 +634,8 @@ InitFocusClassDeviceStruct(dev)
} }
Bool Bool
InitKbdFeedbackClassDeviceStruct(dev, bellProc, controlProc) InitKbdFeedbackClassDeviceStruct(DeviceIntPtr dev, BellProcPtr bellProc,
DeviceIntPtr dev; KbdCtrlProcPtr controlProc)
BellProcPtr bellProc;
KbdCtrlProcPtr controlProc;
{ {
register KbdFeedbackPtr feedc; register KbdFeedbackPtr feedc;
@ -683,9 +662,7 @@ InitKbdFeedbackClassDeviceStruct(dev, bellProc, controlProc)
} }
Bool Bool
InitPtrFeedbackClassDeviceStruct(dev, controlProc) InitPtrFeedbackClassDeviceStruct(DeviceIntPtr dev, PtrCtrlProcPtr controlProc)
DeviceIntPtr dev;
PtrCtrlProcPtr controlProc;
{ {
register PtrFeedbackPtr feedc; register PtrFeedbackPtr feedc;
@ -726,13 +703,9 @@ IntegerCtrl defaultIntegerControl = {
0}; 0};
Bool Bool
InitStringFeedbackClassDeviceStruct (dev, controlProc, max_symbols, InitStringFeedbackClassDeviceStruct (
num_symbols_supported, symbols) DeviceIntPtr dev, StringCtrlProcPtr controlProc,
DeviceIntPtr dev; int max_symbols, int num_symbols_supported, KeySym *symbols)
StringCtrlProcPtr controlProc;
int max_symbols;
int num_symbols_supported;
KeySym *symbols;
{ {
int i; int i;
register StringFeedbackPtr feedc; register StringFeedbackPtr feedc;
@ -770,10 +743,8 @@ InitStringFeedbackClassDeviceStruct (dev, controlProc, max_symbols,
} }
Bool Bool
InitBellFeedbackClassDeviceStruct (dev, bellProc, controlProc) InitBellFeedbackClassDeviceStruct (DeviceIntPtr dev, BellProcPtr bellProc,
DeviceIntPtr dev; BellCtrlProcPtr controlProc)
BellProcPtr bellProc;
BellCtrlProcPtr controlProc;
{ {
register BellFeedbackPtr feedc; register BellFeedbackPtr feedc;
@ -792,9 +763,7 @@ InitBellFeedbackClassDeviceStruct (dev, bellProc, controlProc)
} }
Bool Bool
InitLedFeedbackClassDeviceStruct (dev, controlProc) InitLedFeedbackClassDeviceStruct (DeviceIntPtr dev, LedCtrlProcPtr controlProc)
DeviceIntPtr dev;
LedCtrlProcPtr controlProc;
{ {
register LedFeedbackPtr feedc; register LedFeedbackPtr feedc;
@ -815,9 +784,7 @@ InitLedFeedbackClassDeviceStruct (dev, controlProc)
} }
Bool Bool
InitIntegerFeedbackClassDeviceStruct (dev, controlProc) InitIntegerFeedbackClassDeviceStruct (DeviceIntPtr dev, IntegerCtrlProcPtr controlProc)
DeviceIntPtr dev;
IntegerCtrlProcPtr controlProc;
{ {
register IntegerFeedbackPtr feedc; register IntegerFeedbackPtr feedc;
@ -835,14 +802,9 @@ InitIntegerFeedbackClassDeviceStruct (dev, controlProc)
} }
Bool Bool
InitPointerDeviceStruct(device, map, numButtons, motionProc, controlProc, InitPointerDeviceStruct(DevicePtr device, CARD8 *map, int numButtons,
numMotionEvents) ValuatorMotionProcPtr motionProc,
DevicePtr device; PtrCtrlProcPtr controlProc, int numMotionEvents)
CARD8 *map;
int numButtons;
PtrCtrlProcPtr controlProc;
ValuatorMotionProcPtr motionProc;
int numMotionEvents;
{ {
DeviceIntPtr dev = (DeviceIntPtr)device; DeviceIntPtr dev = (DeviceIntPtr)device;
@ -853,12 +815,9 @@ InitPointerDeviceStruct(device, map, numButtons, motionProc, controlProc,
} }
Bool Bool
InitKeyboardDeviceStruct(device, pKeySyms, pModifiers, bellProc, controlProc) InitKeyboardDeviceStruct(DevicePtr device, KeySymsPtr pKeySyms,
DevicePtr device; CARD8 pModifiers[], BellProcPtr bellProc,
KeySymsPtr pKeySyms; KbdCtrlProcPtr controlProc)
CARD8 pModifiers[];
BellProcPtr bellProc;
KbdCtrlProcPtr controlProc;
{ {
DeviceIntPtr dev = (DeviceIntPtr)device; DeviceIntPtr dev = (DeviceIntPtr)device;
@ -868,10 +827,8 @@ InitKeyboardDeviceStruct(device, pKeySyms, pModifiers, bellProc, controlProc)
} }
void void
SendMappingNotify(request, firstKeyCode, count, client) SendMappingNotify(unsigned request, unsigned firstKeyCode, unsigned count,
unsigned int request, count; ClientPtr client)
unsigned int firstKeyCode;
ClientPtr client;
{ {
int i; int i;
xEvent event; xEvent event;
@ -914,11 +871,7 @@ SendMappingNotify(request, firstKeyCode, count, client)
* sort it to do the checking. How often is it called? Just being lazy? * sort it to do the checking. How often is it called? Just being lazy?
*/ */
Bool Bool
BadDeviceMap(buff, length, low, high, errval) BadDeviceMap(register BYTE *buff, int length, unsigned low, unsigned high, XID *errval)
register BYTE *buff;
int length;
unsigned low, high;
XID *errval;
{ {
register int i, j; register int i, j;
@ -966,8 +919,7 @@ AllModifierKeysAreUp(dev, map1, per1, map2, per2)
} }
int int
ProcSetModifierMapping(client) ProcSetModifierMapping(ClientPtr client)
ClientPtr client;
{ {
xSetModifierMappingReply rep; xSetModifierMappingReply rep;
REQUEST(xSetModifierMappingReq); REQUEST(xSetModifierMappingReq);
@ -1078,8 +1030,7 @@ ProcSetModifierMapping(client)
} }
int int
ProcGetModifierMapping(client) ProcGetModifierMapping(ClientPtr client)
ClientPtr client;
{ {
xGetModifierMappingReply rep; xGetModifierMappingReply rep;
register KeyClassPtr keyc = inputInfo.keyboard->key; register KeyClassPtr keyc = inputInfo.keyboard->key;
@ -1100,8 +1051,7 @@ ProcGetModifierMapping(client)
} }
int int
ProcChangeKeyboardMapping(client) ProcChangeKeyboardMapping(ClientPtr client)
ClientPtr client;
{ {
REQUEST(xChangeKeyboardMappingReq); REQUEST(xChangeKeyboardMappingReq);
unsigned len; unsigned len;
@ -1146,8 +1096,7 @@ ProcChangeKeyboardMapping(client)
} }
int int
ProcSetPointerMapping(client) ProcSetPointerMapping(ClientPtr client)
ClientPtr client;
{ {
REQUEST(xSetPointerMappingReq); REQUEST(xSetPointerMappingReq);
BYTE *map; BYTE *map;
@ -1186,8 +1135,7 @@ ProcSetPointerMapping(client)
} }
int int
ProcGetKeyboardMapping(client) ProcGetKeyboardMapping(ClientPtr client)
ClientPtr client;
{ {
xGetKeyboardMappingReply rep; xGetKeyboardMappingReply rep;
REQUEST(xGetKeyboardMappingReq); REQUEST(xGetKeyboardMappingReq);
@ -1225,8 +1173,7 @@ ProcGetKeyboardMapping(client)
} }
int int
ProcGetPointerMapping(client) ProcGetPointerMapping(ClientPtr client)
ClientPtr client;
{ {
xGetPointerMappingReply rep; xGetPointerMappingReply rep;
ButtonClassPtr butc = inputInfo.pointer->button; ButtonClassPtr butc = inputInfo.pointer->button;
@ -1242,10 +1189,7 @@ ProcGetPointerMapping(client)
} }
void void
NoteLedState(keybd, led, on) NoteLedState(DeviceIntPtr keybd, int led, Bool on)
DeviceIntPtr keybd;
int led;
Bool on;
{ {
KeybdCtrl *ctrl = &keybd->kbdfeed->ctrl; KeybdCtrl *ctrl = &keybd->kbdfeed->ctrl;
if (on) if (on)
@ -1255,8 +1199,7 @@ NoteLedState(keybd, led, on)
} }
int int
Ones(mask) /* HACKMEM 169 */ Ones(unsigned long mask) /* HACKMEM 169 */
unsigned long mask;
{ {
register unsigned long y; register unsigned long y;
@ -1266,8 +1209,7 @@ Ones(mask) /* HACKMEM 169 */
} }
int int
ProcChangeKeyboardControl (client) ProcChangeKeyboardControl (ClientPtr client)
ClientPtr client;
{ {
#define DO_ALL (-1) #define DO_ALL (-1)
KeybdCtrl ctrl; KeybdCtrl ctrl;
@ -1457,8 +1399,7 @@ ProcChangeKeyboardControl (client)
} }
int int
ProcGetKeyboardControl (client) ProcGetKeyboardControl (ClientPtr client)
ClientPtr client;
{ {
int i; int i;
register KeybdCtrl *ctrl = &inputInfo.keyboard->kbdfeed->ctrl; register KeybdCtrl *ctrl = &inputInfo.keyboard->kbdfeed->ctrl;
@ -1481,8 +1422,7 @@ ProcGetKeyboardControl (client)
} }
int int
ProcBell(client) ProcBell(ClientPtr client)
ClientPtr client;
{ {
register DeviceIntPtr keybd = inputInfo.keyboard; register DeviceIntPtr keybd = inputInfo.keyboard;
int base = keybd->kbdfeed->ctrl.bell; int base = keybd->kbdfeed->ctrl.bell;
@ -1511,8 +1451,7 @@ ProcBell(client)
} }
int int
ProcChangePointerControl(client) ProcChangePointerControl(ClientPtr client)
ClientPtr client;
{ {
DeviceIntPtr mouse = inputInfo.pointer; DeviceIntPtr mouse = inputInfo.pointer;
PtrCtrl ctrl; /* might get BadValue part way through */ PtrCtrl ctrl; /* might get BadValue part way through */
@ -1566,8 +1505,7 @@ ProcChangePointerControl(client)
} }
int int
ProcGetPointerControl(client) ProcGetPointerControl(ClientPtr client)
ClientPtr client;
{ {
register PtrCtrl *ctrl = &inputInfo.pointer->ptrfeed->ctrl; register PtrCtrl *ctrl = &inputInfo.pointer->ptrfeed->ctrl;
xGetPointerControlReply rep; xGetPointerControlReply rep;
@ -1584,9 +1522,7 @@ ProcGetPointerControl(client)
} }
void void
MaybeStopHint(dev, client) MaybeStopHint(register DeviceIntPtr dev, ClientPtr client)
register DeviceIntPtr dev;
ClientPtr client;
{ {
GrabPtr grab = dev->grab; GrabPtr grab = dev->grab;
@ -1602,8 +1538,7 @@ MaybeStopHint(dev, client)
} }
int int
ProcGetMotionEvents(client) ProcGetMotionEvents(ClientPtr client)
ClientPtr client;
{ {
WindowPtr pWin; WindowPtr pWin;
xTimecoord * coords = (xTimecoord *) NULL; xTimecoord * coords = (xTimecoord *) NULL;
@ -1670,8 +1605,7 @@ ProcGetMotionEvents(client)
} }
int int
ProcQueryKeymap(client) ProcQueryKeymap(ClientPtr client)
ClientPtr client;
{ {
xQueryKeymapReply rep; xQueryKeymapReply rep;
int i; int i;
@ -1703,9 +1637,7 @@ ProcQueryKeymap(client)
#undef AddInputDevice #undef AddInputDevice
DevicePtr DevicePtr
AddInputDevice( AddInputDevice(DeviceProc deviceProc, Bool autoStart)
DeviceProc deviceProc,
Bool autoStart)
{ {
return (DevicePtr)_AddInputDevice(deviceProc, autoStart); return (DevicePtr)_AddInputDevice(deviceProc, autoStart);
} }

334
dix/dispatch.c
View File

@ -1,4 +1,4 @@
/* $XdotOrg: xc/programs/Xserver/dix/dispatch.c,v 1.4 2004/07/29 18:43:58 stukreit Exp $ */ /* $XdotOrg: xc/programs/Xserver/dix/dispatch.c,v 1.6 2004/09/15 09:05:22 eich Exp $ */
/* $Xorg: dispatch.c,v 1.5 2001/02/09 02:04:40 xorgcvs Exp $ */ /* $Xorg: dispatch.c,v 1.5 2001/02/09 02:04:40 xorgcvs Exp $ */
/************************************************************ /************************************************************
@ -144,13 +144,9 @@ CallbackListPtr ServerGrabCallback = NULL;
HWEventQueuePtr checkForInput[2]; HWEventQueuePtr checkForInput[2];
extern int connBlockScreenStart; extern int connBlockScreenStart;
static void KillAllClients( static void KillAllClients(void);
void
);
static void DeleteClientFromAnySelections( static void DeleteClientFromAnySelections(ClientPtr client);
ClientPtr /*client*/
);
static int nextFreeClientID; /* always MIN free client ID */ static int nextFreeClientID; /* always MIN free client ID */
@ -171,8 +167,7 @@ XID clientErrorValue; /* XXX this is a kludge */
(a.pScreen == b.pScreen)) (a.pScreen == b.pScreen))
void void
SetInputCheck(c0, c1) SetInputCheck(HWEventQueuePtr c0, HWEventQueuePtr c1)
HWEventQueuePtr c0, c1;
{ {
checkForInput[0] = c0; checkForInput[0] = c0;
checkForInput[1] = c1; checkForInput[1] = c1;
@ -220,8 +215,7 @@ InitSelections()
} }
void void
FlushClientCaches(id) FlushClientCaches(XID id)
XID id;
{ {
int i; int i;
register ClientPtr client; register ClientPtr client;
@ -488,17 +482,14 @@ Dispatch(void)
#undef MAJOROP #undef MAJOROP
/*ARGSUSED*/
int int
ProcBadRequest(client) ProcBadRequest(ClientPtr client)
ClientPtr client;
{ {
return (BadRequest); return (BadRequest);
} }
int int
ProcCreateWindow(client) ProcCreateWindow(ClientPtr client)
register ClientPtr client;
{ {
register WindowPtr pParent, pWin; register WindowPtr pParent, pWin;
REQUEST(xCreateWindowReq); REQUEST(xCreateWindowReq);
@ -541,8 +532,7 @@ ProcCreateWindow(client)
} }
int int
ProcChangeWindowAttributes(client) ProcChangeWindowAttributes(register ClientPtr client)
register ClientPtr client;
{ {
register WindowPtr pWin; register WindowPtr pWin;
REQUEST(xChangeWindowAttributesReq); REQUEST(xChangeWindowAttributesReq);
@ -568,8 +558,7 @@ ProcChangeWindowAttributes(client)
} }
int int
ProcGetWindowAttributes(client) ProcGetWindowAttributes(register ClientPtr client)
register ClientPtr client;
{ {
register WindowPtr pWin; register WindowPtr pWin;
REQUEST(xResourceReq); REQUEST(xResourceReq);
@ -586,8 +575,7 @@ ProcGetWindowAttributes(client)
} }
int int
ProcDestroyWindow(client) ProcDestroyWindow(register ClientPtr client)
register ClientPtr client;
{ {
register WindowPtr pWin; register WindowPtr pWin;
REQUEST(xResourceReq); REQUEST(xResourceReq);
@ -603,8 +591,7 @@ ProcDestroyWindow(client)
} }
int int
ProcDestroySubwindows(client) ProcDestroySubwindows(register ClientPtr client)
register ClientPtr client;
{ {
register WindowPtr pWin; register WindowPtr pWin;
REQUEST(xResourceReq); REQUEST(xResourceReq);
@ -619,8 +606,7 @@ ProcDestroySubwindows(client)
} }
int int
ProcChangeSaveSet(client) ProcChangeSaveSet(register ClientPtr client)
register ClientPtr client;
{ {
register WindowPtr pWin; register WindowPtr pWin;
REQUEST(xChangeSaveSetReq); REQUEST(xChangeSaveSetReq);
@ -649,8 +635,7 @@ ProcChangeSaveSet(client)
} }
int int
ProcReparentWindow(client) ProcReparentWindow(register ClientPtr client)
register ClientPtr client;
{ {
register WindowPtr pWin, pParent; register WindowPtr pWin, pParent;
REQUEST(xReparentWindowReq); REQUEST(xReparentWindowReq);
@ -685,8 +670,7 @@ ProcReparentWindow(client)
} }
int int
ProcMapWindow(client) ProcMapWindow(register ClientPtr client)
register ClientPtr client;
{ {
register WindowPtr pWin; register WindowPtr pWin;
REQUEST(xResourceReq); REQUEST(xResourceReq);
@ -702,8 +686,7 @@ ProcMapWindow(client)
} }
int int
ProcMapSubwindows(client) ProcMapSubwindows(register ClientPtr client)
register ClientPtr client;
{ {
register WindowPtr pWin; register WindowPtr pWin;
REQUEST(xResourceReq); REQUEST(xResourceReq);
@ -719,8 +702,7 @@ ProcMapSubwindows(client)
} }
int int
ProcUnmapWindow(client) ProcUnmapWindow(register ClientPtr client)
register ClientPtr client;
{ {
register WindowPtr pWin; register WindowPtr pWin;
REQUEST(xResourceReq); REQUEST(xResourceReq);
@ -736,8 +718,7 @@ ProcUnmapWindow(client)
} }
int int
ProcUnmapSubwindows(client) ProcUnmapSubwindows(register ClientPtr client)
register ClientPtr client;
{ {
register WindowPtr pWin; register WindowPtr pWin;
REQUEST(xResourceReq); REQUEST(xResourceReq);
@ -752,8 +733,7 @@ ProcUnmapSubwindows(client)
} }
int int
ProcConfigureWindow(client) ProcConfigureWindow(register ClientPtr client)
register ClientPtr client;
{ {
register WindowPtr pWin; register WindowPtr pWin;
REQUEST(xConfigureWindowReq); REQUEST(xConfigureWindowReq);
@ -777,8 +757,7 @@ ProcConfigureWindow(client)
} }
int int
ProcCirculateWindow(client) ProcCirculateWindow(register ClientPtr client)
register ClientPtr client;
{ {
register WindowPtr pWin; register WindowPtr pWin;
REQUEST(xCirculateWindowReq); REQUEST(xCirculateWindowReq);
@ -799,9 +778,7 @@ ProcCirculateWindow(client)
} }
int int
GetGeometry(client, rep) GetGeometry(register ClientPtr client, xGetGeometryReply *rep)
register ClientPtr client;
xGetGeometryReply *rep;
{ {
register DrawablePtr pDraw; register DrawablePtr pDraw;
REQUEST(xResourceReq); REQUEST(xResourceReq);
@ -842,8 +819,7 @@ GetGeometry(client, rep)
int int
ProcGetGeometry(client) ProcGetGeometry(register ClientPtr client)
register ClientPtr client;
{ {
xGetGeometryReply rep; xGetGeometryReply rep;
int status; int status;
@ -857,8 +833,7 @@ ProcGetGeometry(client)
int int
ProcQueryTree(client) ProcQueryTree(register ClientPtr client)
register ClientPtr client;
{ {
xQueryTreeReply reply; xQueryTreeReply reply;
int numChildren = 0; int numChildren = 0;
@ -907,8 +882,7 @@ ProcQueryTree(client)
} }
int int
ProcInternAtom(client) ProcInternAtom(register ClientPtr client)
register ClientPtr client;
{ {
Atom atom; Atom atom;
char *tchar; char *tchar;
@ -937,8 +911,7 @@ ProcInternAtom(client)
} }
int int
ProcGetAtomName(client) ProcGetAtomName(register ClientPtr client)
register ClientPtr client;
{ {
char *str; char *str;
xGetAtomNameReply reply; xGetAtomNameReply reply;
@ -969,8 +942,7 @@ extern int k5_bad();
#endif #endif
int int
ProcSetSelectionOwner(client) ProcSetSelectionOwner(register ClientPtr client)
register ClientPtr client;
{ {
WindowPtr pWin; WindowPtr pWin;
TimeStamp time; TimeStamp time;
@ -1066,8 +1038,7 @@ ProcSetSelectionOwner(client)
} }
int int
ProcGetSelectionOwner(client) ProcGetSelectionOwner(register ClientPtr client)
register ClientPtr client;
{ {
REQUEST(xResourceReq); REQUEST(xResourceReq);
@ -1098,8 +1069,7 @@ ProcGetSelectionOwner(client)
} }
int int
ProcConvertSelection(client) ProcConvertSelection(register ClientPtr client)
register ClientPtr client;
{ {
Bool paramsOkay; Bool paramsOkay;
xEvent event; xEvent event;
@ -1163,8 +1133,7 @@ ProcConvertSelection(client)
} }
int int
ProcGrabServer(client) ProcGrabServer(register ClientPtr client)
register ClientPtr client;
{ {
REQUEST_SIZE_MATCH(xReq); REQUEST_SIZE_MATCH(xReq);
if (grabState != GrabNone && client != grabClient) if (grabState != GrabNone && client != grabClient)
@ -1218,8 +1187,7 @@ UngrabServer(ClientPtr client)
} }
int int
ProcUngrabServer(client) ProcUngrabServer(register ClientPtr client)
register ClientPtr client;
{ {
REQUEST_SIZE_MATCH(xReq); REQUEST_SIZE_MATCH(xReq);
UngrabServer(client); UngrabServer(client);
@ -1227,8 +1195,7 @@ ProcUngrabServer(client)
} }
int int
ProcTranslateCoords(client) ProcTranslateCoords(register ClientPtr client)
register ClientPtr client;
{ {
REQUEST(xTranslateCoordsReq); REQUEST(xTranslateCoordsReq);
@ -1300,8 +1267,7 @@ ProcTranslateCoords(client)
} }
int int
ProcOpenFont(client) ProcOpenFont(register ClientPtr client)
register ClientPtr client;
{ {
int err; int err;
REQUEST(xOpenFontReq); REQUEST(xOpenFontReq);
@ -1320,8 +1286,7 @@ ProcOpenFont(client)
} }
int int
ProcCloseFont(client) ProcCloseFont(register ClientPtr client)
register ClientPtr client;
{ {
FontPtr pFont; FontPtr pFont;
REQUEST(xResourceReq); REQUEST(xResourceReq);
@ -1342,8 +1307,7 @@ ProcCloseFont(client)
} }
int int
ProcQueryFont(client) ProcQueryFont(register ClientPtr client)
register ClientPtr client;
{ {
xQueryFontReply *reply; xQueryFontReply *reply;
FontPtr pFont; FontPtr pFont;
@ -1402,8 +1366,7 @@ ProcQueryFont(client)
} }
int int
ProcQueryTextExtents(client) ProcQueryTextExtents(register ClientPtr client)
register ClientPtr client;
{ {
REQUEST(xQueryTextExtentsReq); REQUEST(xQueryTextExtentsReq);
xQueryTextExtentsReply reply; xQueryTextExtentsReply reply;
@ -1453,8 +1416,7 @@ ProcQueryTextExtents(client)
} }
int int
ProcListFonts(client) ProcListFonts(register ClientPtr client)
register ClientPtr client;
{ {
REQUEST(xListFontsReq); REQUEST(xListFontsReq);
@ -1465,8 +1427,7 @@ ProcListFonts(client)
} }
int int
ProcListFontsWithInfo(client) ProcListFontsWithInfo(register ClientPtr client)
register ClientPtr client;
{ {
REQUEST(xListFontsWithInfoReq); REQUEST(xListFontsWithInfoReq);
@ -1476,19 +1437,19 @@ ProcListFontsWithInfo(client)
(unsigned char *) &stuff[1], stuff->maxNames); (unsigned char *) &stuff[1], stuff->maxNames);
} }
/*ARGSUSED*/ /**
*
* \param value must conform to DeleteType
*/
int int
dixDestroyPixmap(value, pid) dixDestroyPixmap(pointer value, XID pid)
pointer value; /* must conform to DeleteType */
XID pid;
{ {
PixmapPtr pPixmap = (PixmapPtr)value; PixmapPtr pPixmap = (PixmapPtr)value;
return (*pPixmap->drawable.pScreen->DestroyPixmap)(pPixmap); return (*pPixmap->drawable.pScreen->DestroyPixmap)(pPixmap);
} }
int int
ProcCreatePixmap(client) ProcCreatePixmap(register ClientPtr client)
register ClientPtr client;
{ {
PixmapPtr pMap; PixmapPtr pMap;
register DrawablePtr pDraw; register DrawablePtr pDraw;
@ -1530,8 +1491,7 @@ CreatePmap:
} }
int int
ProcFreePixmap(client) ProcFreePixmap(register ClientPtr client)
register ClientPtr client;
{ {
PixmapPtr pMap; PixmapPtr pMap;
@ -1553,8 +1513,7 @@ ProcFreePixmap(client)
} }
int int
ProcCreateGC(client) ProcCreateGC(register ClientPtr client)
register ClientPtr client;
{ {
int error; int error;
GC *pGC; GC *pGC;
@ -1580,8 +1539,7 @@ ProcCreateGC(client)
} }
int int
ProcChangeGC(client) ProcChangeGC(register ClientPtr client)
register ClientPtr client;
{ {
GC *pGC; GC *pGC;
REQUEST(xChangeGCReq); REQUEST(xChangeGCReq);
@ -1605,8 +1563,7 @@ ProcChangeGC(client)
} }
int int
ProcCopyGC(client) ProcCopyGC(register ClientPtr client)
register ClientPtr client;
{ {
register GC *dstGC; register GC *dstGC;
register GC *pGC; register GC *pGC;
@ -1629,8 +1586,7 @@ ProcCopyGC(client)
} }
int int
ProcSetDashes(client) ProcSetDashes(register ClientPtr client)
register ClientPtr client;
{ {
register GC *pGC; register GC *pGC;
int result; int result;
@ -1657,8 +1613,7 @@ ProcSetDashes(client)
} }
int int
ProcSetClipRectangles(client) ProcSetClipRectangles(register ClientPtr client)
register ClientPtr client;
{ {
int nr; int nr;
int result; int result;
@ -1687,8 +1642,7 @@ ProcSetClipRectangles(client)
} }
int int
ProcFreeGC(client) ProcFreeGC(register ClientPtr client)
register ClientPtr client;
{ {
register GC *pGC; register GC *pGC;
REQUEST(xResourceReq); REQUEST(xResourceReq);
@ -1700,8 +1654,7 @@ ProcFreeGC(client)
} }
int int
ProcClearToBackground(client) ProcClearToBackground(register ClientPtr client)
register ClientPtr client;
{ {
REQUEST(xClearAreaReq); REQUEST(xClearAreaReq);
register WindowPtr pWin; register WindowPtr pWin;
@ -1728,8 +1681,7 @@ ProcClearToBackground(client)
} }
int int
ProcCopyArea(client) ProcCopyArea(register ClientPtr client)
register ClientPtr client;
{ {
register DrawablePtr pDst; register DrawablePtr pDst;
register DrawablePtr pSrc; register DrawablePtr pSrc;
@ -1770,8 +1722,7 @@ ProcCopyArea(client)
} }
int int
ProcCopyPlane(client) ProcCopyPlane(register ClientPtr client)
register ClientPtr client;
{ {
register DrawablePtr psrcDraw, pdstDraw; register DrawablePtr psrcDraw, pdstDraw;
register GC *pGC; register GC *pGC;
@ -1818,8 +1769,7 @@ ProcCopyPlane(client)
} }
int int
ProcPolyPoint(client) ProcPolyPoint(register ClientPtr client)
register ClientPtr client;
{ {
int npoint; int npoint;
register GC *pGC; register GC *pGC;
@ -1842,8 +1792,7 @@ ProcPolyPoint(client)
} }
int int
ProcPolyLine(client) ProcPolyLine(register ClientPtr client)
register ClientPtr client;
{ {
int npoint; int npoint;
register GC *pGC; register GC *pGC;
@ -1866,8 +1815,7 @@ ProcPolyLine(client)
} }
int int
ProcPolySegment(client) ProcPolySegment(register ClientPtr client)
register ClientPtr client;
{ {
int nsegs; int nsegs;
register GC *pGC; register GC *pGC;
@ -1886,8 +1834,7 @@ ProcPolySegment(client)
} }
int int
ProcPolyRectangle (client) ProcPolyRectangle (register ClientPtr client)
register ClientPtr client;
{ {
int nrects; int nrects;
register GC *pGC; register GC *pGC;
@ -1907,8 +1854,7 @@ ProcPolyRectangle (client)
} }
int int
ProcPolyArc(client) ProcPolyArc(register ClientPtr client)
register ClientPtr client;
{ {
int narcs; int narcs;
register GC *pGC; register GC *pGC;
@ -1927,8 +1873,7 @@ ProcPolyArc(client)
} }
int int
ProcFillPoly(client) ProcFillPoly(register ClientPtr client)
register ClientPtr client;
{ {
int things; int things;
register GC *pGC; register GC *pGC;
@ -1959,8 +1904,7 @@ ProcFillPoly(client)
} }
int int
ProcPolyFillRectangle(client) ProcPolyFillRectangle(register ClientPtr client)
register ClientPtr client;
{ {
int things; int things;
register GC *pGC; register GC *pGC;
@ -1981,8 +1925,7 @@ ProcPolyFillRectangle(client)
} }
int int
ProcPolyFillArc(client) ProcPolyFillArc(register ClientPtr client)
register ClientPtr client;
{ {
int narcs; int narcs;
register GC *pGC; register GC *pGC;
@ -2055,8 +1998,7 @@ ReformatImage (char *base, int nbytes, int bpp, int order)
* boundary, even if the scanlines are padded to our satisfaction. * boundary, even if the scanlines are padded to our satisfaction.
*/ */
int int
ProcPutImage(client) ProcPutImage(register ClientPtr client)
register ClientPtr client;
{ {
register GC *pGC; register GC *pGC;
register DrawablePtr pDraw; register DrawablePtr pDraw;
@ -2114,13 +2056,9 @@ ProcPutImage(client)
int int
DoGetImage(client, format, drawable, x, y, width, height, planemask, im_return) DoGetImage(register ClientPtr client, int format, Drawable drawable,
register ClientPtr client; int x, int y, int width, int height,
Drawable drawable; Mask planemask, xGetImageReply **im_return)
int format;
int x, y, width, height;
Mask planemask;
xGetImageReply **im_return;
{ {
register DrawablePtr pDraw; register DrawablePtr pDraw;
int nlines, linesPerBuf; int nlines, linesPerBuf;
@ -2344,8 +2282,7 @@ DoGetImage(client, format, drawable, x, y, width, height, planemask, im_return)
} }
int int
ProcGetImage(client) ProcGetImage(register ClientPtr client)
register ClientPtr client;
{ {
REQUEST(xGetImageReq); REQUEST(xGetImageReq);
@ -2358,8 +2295,7 @@ ProcGetImage(client)
} }
int int
ProcPolyText(client) ProcPolyText(register ClientPtr client)
register ClientPtr client;
{ {
int err; int err;
REQUEST(xPolyTextReq); REQUEST(xPolyTextReq);
@ -2388,8 +2324,7 @@ ProcPolyText(client)
} }
int int
ProcImageText8(client) ProcImageText8(register ClientPtr client)
register ClientPtr client;
{ {
int err; int err;
register DrawablePtr pDraw; register DrawablePtr pDraw;
@ -2419,8 +2354,7 @@ ProcImageText8(client)
} }
int int
ProcImageText16(client) ProcImageText16(register ClientPtr client)
register ClientPtr client;
{ {
int err; int err;
register DrawablePtr pDraw; register DrawablePtr pDraw;
@ -2451,8 +2385,7 @@ ProcImageText16(client)
int int
ProcCreateColormap(client) ProcCreateColormap(register ClientPtr client)
register ClientPtr client;
{ {
VisualPtr pVisual; VisualPtr pVisual;
ColormapPtr pmap; ColormapPtr pmap;
@ -2495,8 +2428,7 @@ ProcCreateColormap(client)
} }
int int
ProcFreeColormap(client) ProcFreeColormap(register ClientPtr client)
register ClientPtr client;
{ {
ColormapPtr pmap; ColormapPtr pmap;
REQUEST(xResourceReq); REQUEST(xResourceReq);
@ -2520,8 +2452,7 @@ ProcFreeColormap(client)
int int
ProcCopyColormapAndFree(client) ProcCopyColormapAndFree(register ClientPtr client)
register ClientPtr client;
{ {
Colormap mid; Colormap mid;
ColormapPtr pSrcMap; ColormapPtr pSrcMap;
@ -2548,8 +2479,7 @@ ProcCopyColormapAndFree(client)
} }
int int
ProcInstallColormap(client) ProcInstallColormap(register ClientPtr client)
register ClientPtr client;
{ {
ColormapPtr pcmp; ColormapPtr pcmp;
REQUEST(xResourceReq); REQUEST(xResourceReq);
@ -2570,8 +2500,7 @@ ProcInstallColormap(client)
} }
int int
ProcUninstallColormap(client) ProcUninstallColormap(register ClientPtr client)
register ClientPtr client;
{ {
ColormapPtr pcmp; ColormapPtr pcmp;
REQUEST(xResourceReq); REQUEST(xResourceReq);
@ -2593,8 +2522,7 @@ ProcUninstallColormap(client)
} }
int int
ProcListInstalledColormaps(client) ProcListInstalledColormaps(register ClientPtr client)
register ClientPtr client;
{ {
xListInstalledColormapsReply *preply; xListInstalledColormapsReply *preply;
int nummaps; int nummaps;
@ -2629,8 +2557,7 @@ ProcListInstalledColormaps(client)
} }
int int
ProcAllocColor(client) ProcAllocColor (register ClientPtr client)
register ClientPtr client;
{ {
ColormapPtr pmap; ColormapPtr pmap;
int retval; int retval;
@ -2681,8 +2608,7 @@ ProcAllocColor(client)
} }
int int
ProcAllocNamedColor (client) ProcAllocNamedColor (register ClientPtr client)
register ClientPtr client;
{ {
ColormapPtr pcmp; ColormapPtr pcmp;
REQUEST(xAllocNamedColorReq); REQUEST(xAllocNamedColorReq);
@ -2743,8 +2669,7 @@ ProcAllocNamedColor (client)
} }
int int
ProcAllocColorCells (client) ProcAllocColorCells (register ClientPtr client)
register ClientPtr client;
{ {
ColormapPtr pcmp; ColormapPtr pcmp;
REQUEST(xAllocColorCellsReq); REQUEST(xAllocColorCellsReq);
@ -2819,8 +2744,7 @@ ProcAllocColorCells (client)
} }
int int
ProcAllocColorPlanes(client) ProcAllocColorPlanes(register ClientPtr client)
register ClientPtr client;
{ {
ColormapPtr pcmp; ColormapPtr pcmp;
REQUEST(xAllocColorPlanesReq); REQUEST(xAllocColorPlanesReq);
@ -2893,8 +2817,7 @@ ProcAllocColorPlanes(client)
} }
int int
ProcFreeColors (client) ProcFreeColors(register ClientPtr client)
register ClientPtr client;
{ {
ColormapPtr pcmp; ColormapPtr pcmp;
REQUEST(xFreeColorsReq); REQUEST(xFreeColorsReq);
@ -2929,8 +2852,7 @@ ProcFreeColors (client)
} }
int int
ProcStoreColors (client) ProcStoreColors (ClientPtr client)
register ClientPtr client;
{ {
ColormapPtr pcmp; ColormapPtr pcmp;
REQUEST(xStoreColorsReq); REQUEST(xStoreColorsReq);
@ -2964,8 +2886,7 @@ ProcStoreColors (client)
} }
int int
ProcStoreNamedColor (client) ProcStoreNamedColor (register ClientPtr client)
register ClientPtr client;
{ {
ColormapPtr pcmp; ColormapPtr pcmp;
REQUEST(xStoreNamedColorReq); REQUEST(xStoreNamedColorReq);
@ -2999,8 +2920,7 @@ ProcStoreNamedColor (client)
} }
int int
ProcQueryColors(client) ProcQueryColors(register ClientPtr client)
register ClientPtr client;
{ {
ColormapPtr pcmp; ColormapPtr pcmp;
REQUEST(xQueryColorsReq); REQUEST(xQueryColorsReq);
@ -3051,8 +2971,7 @@ ProcQueryColors(client)
} }
int int
ProcLookupColor(client) ProcLookupColor(register ClientPtr client)
register ClientPtr client;
{ {
ColormapPtr pcmp; ColormapPtr pcmp;
REQUEST(xLookupColorReq); REQUEST(xLookupColorReq);
@ -3090,8 +3009,7 @@ ProcLookupColor(client)
} }
int int
ProcCreateCursor( client) ProcCreateCursor (register ClientPtr client)
register ClientPtr client;
{ {
CursorPtr pCursor; CursorPtr pCursor;
@ -3181,8 +3099,7 @@ ProcCreateCursor( client)
} }
int int
ProcCreateGlyphCursor( client) ProcCreateGlyphCursor (register ClientPtr client)
register ClientPtr client;
{ {
CursorPtr pCursor; CursorPtr pCursor;
int res; int res;
@ -3206,8 +3123,7 @@ ProcCreateGlyphCursor( client)
int int
ProcFreeCursor(client) ProcFreeCursor (register ClientPtr client)
register ClientPtr client;
{ {
CursorPtr pCursor; CursorPtr pCursor;
REQUEST(xResourceReq); REQUEST(xResourceReq);
@ -3228,8 +3144,7 @@ ProcFreeCursor(client)
} }
int int
ProcQueryBestSize (client) ProcQueryBestSize (register ClientPtr client)
register ClientPtr client;
{ {
xQueryBestSizeReply reply; xQueryBestSizeReply reply;
register DrawablePtr pDraw; register DrawablePtr pDraw;
@ -3262,8 +3177,7 @@ ProcQueryBestSize (client)
int int
ProcSetScreenSaver (client) ProcSetScreenSaver (register ClientPtr client)
register ClientPtr client;
{ {
int blankingOption, exposureOption; int blankingOption, exposureOption;
REQUEST(xSetScreenSaverReq); REQUEST(xSetScreenSaverReq);
@ -3319,8 +3233,7 @@ ProcSetScreenSaver (client)
} }
int int
ProcGetScreenSaver(client) ProcGetScreenSaver(register ClientPtr client)
register ClientPtr client;
{ {
xGetScreenSaverReply rep; xGetScreenSaverReply rep;
@ -3337,8 +3250,7 @@ ProcGetScreenSaver(client)
} }
int int
ProcChangeHosts(client) ProcChangeHosts(register ClientPtr client)
register ClientPtr client;
{ {
REQUEST(xChangeHostsReq); REQUEST(xChangeHostsReq);
int result; int result;
@ -3362,8 +3274,7 @@ ProcChangeHosts(client)
} }
int int
ProcListHosts(client) ProcListHosts(register ClientPtr client)
register ClientPtr client;
{ {
xListHostsReply reply; xListHostsReply reply;
int len, nHosts, result; int len, nHosts, result;
@ -3397,8 +3308,7 @@ ProcListHosts(client)
} }
int int
ProcChangeAccessControl(client) ProcChangeAccessControl(register ClientPtr client)
register ClientPtr client;
{ {
int result; int result;
REQUEST(xSetAccessControlReq); REQUEST(xSetAccessControlReq);
@ -3416,8 +3326,7 @@ ProcChangeAccessControl(client)
} }
int int
ProcKillClient(client) ProcKillClient(register ClientPtr client)
register ClientPtr client;
{ {
REQUEST(xResourceReq); REQUEST(xResourceReq);
ClientPtr killclient; ClientPtr killclient;
@ -3451,8 +3360,7 @@ ProcKillClient(client)
} }
int int
ProcSetFontPath(client) ProcSetFontPath(register ClientPtr client)
register ClientPtr client;
{ {
unsigned char *ptr; unsigned char *ptr;
unsigned long nbytes, total; unsigned long nbytes, total;
@ -3487,8 +3395,7 @@ ProcSetFontPath(client)
} }
int int
ProcGetFontPath(client) ProcGetFontPath(register ClientPtr client)
register ClientPtr client;
{ {
xGetFontPathReply reply; xGetFontPathReply reply;
int stringLens, numpaths; int stringLens, numpaths;
@ -3510,8 +3417,7 @@ ProcGetFontPath(client)
} }
int int
ProcChangeCloseDownMode(client) ProcChangeCloseDownMode(register ClientPtr client)
register ClientPtr client;
{ {
REQUEST(xSetCloseDownModeReq); REQUEST(xSetCloseDownModeReq);
@ -3530,8 +3436,7 @@ ProcChangeCloseDownMode(client)
} }
} }
int ProcForceScreenSaver(client) int ProcForceScreenSaver(register ClientPtr client)
register ClientPtr client;
{ {
REQUEST(xForceScreenSaverReq); REQUEST(xForceScreenSaverReq);
@ -3547,8 +3452,7 @@ int ProcForceScreenSaver(client)
return client->noClientException; return client->noClientException;
} }
int ProcNoOperation(client) int ProcNoOperation(register ClientPtr client)
register ClientPtr client;
{ {
REQUEST_AT_LEAST_SIZE(xReq); REQUEST_AT_LEAST_SIZE(xReq);
@ -3591,8 +3495,7 @@ InitProcVectors(void)
char dispatchExceptionAtReset = DE_RESET; char dispatchExceptionAtReset = DE_RESET;
void void
CloseDownClient(client) CloseDownClient(register ClientPtr client)
register ClientPtr client;
{ {
Bool really_close_down = client->clientGone || Bool really_close_down = client->clientGone ||
client->closeDownMode == DestroyAll; client->closeDownMode == DestroyAll;
@ -3714,10 +3617,7 @@ CloseDownRetainedResources()
} }
} }
void InitClient(client, i, ospriv) void InitClient(ClientPtr client, int i, pointer ospriv)
ClientPtr client;
int i;
pointer ospriv;
{ {
client->index = i; client->index = i;
client->sequence = 0; client->sequence = 0;
@ -3782,8 +3682,7 @@ extern unsigned *clientPrivateSizes;
extern unsigned totalClientSize; extern unsigned totalClientSize;
int int
InitClientPrivates(client) InitClientPrivates(ClientPtr client)
ClientPtr client;
{ {
register char *ptr; register char *ptr;
DevUnion *ppriv; DevUnion *ppriv;
@ -3824,9 +3723,7 @@ InitClientPrivates(client)
* Returns NULL if there are no free clients. * Returns NULL if there are no free clients.
*************************/ *************************/
ClientPtr ClientPtr NextAvailableClient(pointer ospriv)
NextAvailableClient(ospriv)
pointer ospriv;
{ {
register int i; register int i;
register ClientPtr client; register ClientPtr client;
@ -3870,8 +3767,7 @@ NextAvailableClient(ospriv)
} }
int int
ProcInitialConnection(client) ProcInitialConnection(register ClientPtr client)
register ClientPtr client;
{ {
REQUEST(xReq); REQUEST(xReq);
register xConnClientPrefix *prefix; register xConnClientPrefix *prefix;
@ -3906,9 +3802,7 @@ IncrementClientCount()
#endif #endif
int int
SendConnSetup(client, reason) SendConnSetup(register ClientPtr client, char *reason)
register ClientPtr client;
char *reason;
{ {
register xWindowRoot *root; register xWindowRoot *root;
register int i; register int i;
@ -4008,8 +3902,7 @@ SendConnSetup(client, reason)
} }
int int
ProcEstablishConnection(client) ProcEstablishConnection(register ClientPtr client)
register ClientPtr client;
{ {
char *reason, *auth_proto, *auth_string; char *reason, *auth_proto, *auth_string;
register xConnClientPrefix *prefix; register xConnClientPrefix *prefix;
@ -4043,12 +3936,8 @@ ProcEstablishConnection(client)
} }
void void
SendErrorToClient(client, majorCode, minorCode, resId, errorCode) SendErrorToClient(ClientPtr client, unsigned majorCode, unsigned minorCode,
ClientPtr client; XID resId, int errorCode)
unsigned int majorCode;
unsigned int minorCode;
XID resId;
int errorCode;
{ {
xError rep; xError rep;
@ -4063,8 +3952,7 @@ SendErrorToClient(client, majorCode, minorCode, resId, errorCode)
} }
void void
DeleteWindowFromAnySelections(pWin) DeleteWindowFromAnySelections(WindowPtr pWin)
WindowPtr pWin;
{ {
register int i; register int i;
@ -4086,8 +3974,7 @@ DeleteWindowFromAnySelections(pWin)
} }
static void static void
DeleteClientFromAnySelections(client) DeleteClientFromAnySelections(ClientPtr client)
ClientPtr client;
{ {
register int i; register int i;
@ -4109,8 +3996,7 @@ DeleteClientFromAnySelections(client)
} }
void void
MarkClientException(client) MarkClientException(ClientPtr client)
ClientPtr client;
{ {
client->noClientException = -1; client->noClientException = -1;
} }

149
dix/dixfonts.c
View File

@ -1,4 +1,4 @@
/* $XdotOrg$ */ /* $XdotOrg: xc/programs/Xserver/dix/dixfonts.c,v 1.2 2004/04/23 19:04:44 eich Exp $ */
/* $XFree86: xc/programs/Xserver/dix/dixfonts.c,v 3.28 2003/11/08 02:02:03 dawes Exp $ */ /* $XFree86: xc/programs/Xserver/dix/dixfonts.c,v 3.28 2003/11/08 02:02:03 dawes Exp $ */
/************************************************************************ /************************************************************************
Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts. Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
@ -123,8 +123,7 @@ FontToXError(err)
* adding RT_FONT prevents conflict with default cursor font * adding RT_FONT prevents conflict with default cursor font
*/ */
Bool Bool
SetDefaultFont(defaultfontname) SetDefaultFont(char *defaultfontname)
char *defaultfontname;
{ {
int err; int err;
FontPtr pf; FontPtr pf;
@ -152,8 +151,7 @@ SetDefaultFont(defaultfontname)
* freed data. * freed data.
*/ */
void void
QueueFontWakeup(fpe) QueueFontWakeup(FontPathElementPtr fpe)
FontPathElementPtr fpe;
{ {
int i; int i;
FontPathElementPtr *new; FontPathElementPtr *new;
@ -182,8 +180,7 @@ QueueFontWakeup(fpe)
} }
void void
RemoveFontWakeup(fpe) RemoveFontWakeup(FontPathElementPtr fpe)
FontPathElementPtr fpe;
{ {
int i, int i,
j; j;
@ -199,12 +196,8 @@ RemoveFontWakeup(fpe)
} }
} }
/* ARGSUSED */
void void
FontWakeup(data, count, LastSelectMask) FontWakeup(pointer data, int count, pointer LastSelectMask)
pointer data;
int count;
pointer LastSelectMask;
{ {
int i; int i;
FontPathElementPtr fpe; FontPathElementPtr fpe;
@ -381,12 +374,7 @@ bail:
} }
int int
OpenFont(client, fid, flags, lenfname, pfontname) OpenFont(ClientPtr client, XID fid, Mask flags, unsigned lenfname, char *pfontname)
ClientPtr client;
XID fid;
Mask flags;
unsigned lenfname;
char *pfontname;
{ {
OFclosurePtr c; OFclosurePtr c;
int i; int i;
@ -470,14 +458,13 @@ OpenFont(client, fid, flags, lenfname, pfontname)
return Success; return Success;
} }
/* /**
* Decrement font's ref count, and free storage if ref count equals zero * Decrement font's ref count, and free storage if ref count equals zero
*
* \param value must conform to DeleteType
*/ */
/*ARGSUSED*/
int int
CloseFont(value, fid) CloseFont(pointer value, XID fid)
pointer value; /* must conform to DeleteType */
XID fid;
{ {
int nscr; int nscr;
ScreenPtr pscr; ScreenPtr pscr;
@ -516,16 +503,14 @@ CloseFont(value, fid)
/***====================================================================***/ /***====================================================================***/
/* /**
* \ Sets up pReply as the correct QueryFontReply for pFont with the first * Sets up pReply as the correct QueryFontReply for pFont with the first
* nProtoCCIStructs char infos. \ * nProtoCCIStructs char infos.
*
* \param pReply caller must allocate this storage
*/ */
void void
QueryFont(pFont, pReply, nProtoCCIStructs) QueryFont(FontPtr pFont, xQueryFontReply *pReply, int nProtoCCIStructs)
FontPtr pFont;
xQueryFontReply *pReply; /* caller must allocate this storage */
int nProtoCCIStructs;
{ {
FontPropPtr pFP; FontPropPtr pFP;
int r, int r,
@ -843,11 +828,8 @@ bail:
} }
int int
ListFonts(client, pattern, length, max_names) ListFonts(ClientPtr client, unsigned char *pattern, unsigned length,
ClientPtr client; unsigned max_names)
unsigned char *pattern;
unsigned int length;
unsigned int max_names;
{ {
int i; int i;
LFclosurePtr c; LFclosurePtr c;
@ -896,9 +878,7 @@ ListFonts(client, pattern, length, max_names)
} }
int int
doListFontsWithInfo(client, c) doListFontsWithInfo(ClientPtr client, LFWIclosurePtr c)
ClientPtr client;
LFWIclosurePtr c;
{ {
FontPathElementPtr fpe; FontPathElementPtr fpe;
int err = Successful; int err = Successful;
@ -1120,11 +1100,8 @@ bail:
} }
int int
StartListFontsWithInfo(client, length, pattern, max_names) StartListFontsWithInfo(ClientPtr client, int length, unsigned char *pattern,
ClientPtr client; int max_names)
int length;
unsigned char *pattern;
int max_names;
{ {
int i; int i;
LFWIclosurePtr c; LFWIclosurePtr c;
@ -1178,9 +1155,7 @@ static XID clearGC[] = { CT_NONE };
#define clearGCmask (GCClipMask) #define clearGCmask (GCClipMask)
int int
doPolyText(client, c) doPolyText(ClientPtr client, register PTclosurePtr c)
ClientPtr client;
register PTclosurePtr c;
{ {
register FontPtr pFont = c->pGC->font, oldpFont; register FontPtr pFont = c->pGC->font, oldpFont;
Font fid, oldfid; Font fid, oldfid;
@ -1447,16 +1422,8 @@ bail:
} }
int int
PolyText(client, pDraw, pGC, pElt, endReq, xorg, yorg, reqType, did) PolyText(ClientPtr client, DrawablePtr pDraw, GC *pGC, unsigned char *pElt,
ClientPtr client; unsigned char *endReq, int xorg, int yorg, int reqType, XID did)
DrawablePtr pDraw;
GC *pGC;
unsigned char *pElt;
unsigned char *endReq;
int xorg;
int yorg;
int reqType;
XID did;
{ {
PTclosureRec local_closure; PTclosureRec local_closure;
@ -1490,9 +1457,7 @@ PolyText(client, pDraw, pGC, pElt, endReq, xorg, yorg, reqType, did)
#undef FontShiftSize #undef FontShiftSize
int int
doImageText(client, c) doImageText(ClientPtr client, register ITclosurePtr c)
ClientPtr client;
register ITclosurePtr c;
{ {
int err = Success, lgerr; /* err is in X error, not font error, space */ int err = Success, lgerr; /* err is in X error, not font error, space */
FontPathElementPtr fpe; FontPathElementPtr fpe;
@ -1613,16 +1578,8 @@ bail:
} }
int int
ImageText(client, pDraw, pGC, nChars, data, xorg, yorg, reqType, did) ImageText(ClientPtr client, DrawablePtr pDraw, GC *pGC, int nChars,
ClientPtr client; unsigned char *data, int xorg, int yorg, int reqType, XID did)
DrawablePtr pDraw;
GC *pGC;
int nChars;
unsigned char *data;
int xorg;
int yorg;
int reqType;
XID did;
{ {
ITclosureRec local_closure; ITclosureRec local_closure;
@ -1822,11 +1779,7 @@ bail:
/* XXX -- do we need to pass error down to each renderer? */ /* XXX -- do we need to pass error down to each renderer? */
int int
SetFontPath(client, npaths, paths, error) SetFontPath(ClientPtr client, int npaths, unsigned char *paths, int *error)
ClientPtr client;
int npaths;
unsigned char *paths;
int *error;
{ {
int err = Success; int err = Success;
@ -1840,8 +1793,7 @@ SetFontPath(client, npaths, paths, error)
} }
int int
SetDefaultFontPath(path) SetDefaultFontPath(char *path)
char *path;
{ {
unsigned char *cp, unsigned char *cp,
*pp, *pp,
@ -1882,9 +1834,7 @@ SetDefaultFontPath(path)
} }
unsigned char * unsigned char *
GetFontPath(count, length) GetFontPath(int *count, int *length)
int *count;
int *length;
{ {
int i; int i;
unsigned char *c; unsigned char *c;
@ -1914,12 +1864,7 @@ GetFontPath(count, length)
} }
int int
LoadGlyphs(client, pfont, nchars, item_size, data) LoadGlyphs(ClientPtr client, FontPtr pfont, unsigned nchars, int item_size, unsigned char *data)
ClientPtr client;
FontPtr pfont;
unsigned nchars;
int item_size;
unsigned char *data;
{ {
if (fpe_functions[pfont->fpe->type].load_glyphs) if (fpe_functions[pfont->fpe->type].load_glyphs)
return (*fpe_functions[pfont->fpe->type].load_glyphs) return (*fpe_functions[pfont->fpe->type].load_glyphs)
@ -1929,8 +1874,7 @@ LoadGlyphs(client, pfont, nchars, item_size, data)
} }
void void
DeleteClientFontStuff(client) DeleteClientFontStuff(ClientPtr client)
ClientPtr client;
{ {
int i; int i;
FontPathElementPtr fpe; FontPathElementPtr fpe;
@ -1974,8 +1918,7 @@ GetDefaultPointSize ()
FontResolutionPtr FontResolutionPtr
GetClientResolutions (num) GetClientResolutions (int *num)
int *num;
{ {
if (requestingClient && requestingClient->fontResFunc != NULL && if (requestingClient && requestingClient->fontResFunc != NULL &&
!requestingClient->clientGone) !requestingClient->clientGone)
@ -2080,8 +2023,7 @@ FreeFonts()
/* convenience functions for FS interface */ /* convenience functions for FS interface */
FontPtr FontPtr
find_old_font(id) find_old_font(XID id)
XID id;
{ {
return (FontPtr) SecurityLookupIDByType(NullClient, id, RT_NONE, return (FontPtr) SecurityLookupIDByType(NullClient, id, RT_NONE,
SecurityUnknownAccess); SecurityUnknownAccess);
@ -2094,23 +2036,19 @@ GetNewFontClientID()
} }
int int
StoreFontClientFont(pfont, id) StoreFontClientFont(FontPtr pfont, Font id)
FontPtr pfont;
Font id;
{ {
return AddResource(id, RT_NONE, (pointer) pfont); return AddResource(id, RT_NONE, (pointer) pfont);
} }
void void
DeleteFontClientID(id) DeleteFontClientID(Font id)
Font id;
{ {
FreeResource(id, RT_NONE); FreeResource(id, RT_NONE);
} }
int int
client_auth_generation(client) client_auth_generation(ClientPtr client)
ClientPtr client;
{ {
return 0; return 0;
} }
@ -2119,9 +2057,7 @@ static int fs_handlers_installed = 0;
static unsigned int last_server_gen; static unsigned int last_server_gen;
int int
init_fs_handlers(fpe, block_handler) init_fs_handlers(FontPathElementPtr fpe, BlockHandlerProcPtr block_handler)
FontPathElementPtr fpe;
BlockHandlerProcPtr block_handler;
{ {
/* if server has reset, make sure the b&w handlers are reinstalled */ /* if server has reset, make sure the b&w handlers are reinstalled */
if (last_server_gen < serverGeneration) { if (last_server_gen < serverGeneration) {
@ -2144,10 +2080,7 @@ init_fs_handlers(fpe, block_handler)
} }
void void
remove_fs_handlers(fpe, block_handler, all) remove_fs_handlers(FontPathElementPtr fpe, BlockHandlerProcPtr block_handler, Bool all)
FontPathElementPtr fpe;
BlockHandlerProcPtr block_handler;
Bool all;
{ {
if (all) { if (all) {
/* remove the handlers if no one else is using them */ /* remove the handlers if no one else is using them */
@ -2175,8 +2108,8 @@ remove_fs_handlers(fpe, block_handler, all)
#define GLYPH_SIZE(ch, nbytes) \ #define GLYPH_SIZE(ch, nbytes) \
GLWIDTHBYTESPADDED((ch)->metrics.rightSideBearing - \ GLWIDTHBYTESPADDED((ch)->metrics.rightSideBearing - \
(ch)->metrics.leftSideBearing, (nbytes)) (ch)->metrics.leftSideBearing, (nbytes))
dump_char_ascii(cip) void
CharInfoPtr cip; dump_char_ascii(CharInfoPtr cip)
{ {
int r, int r,
l; l;

130
dix/dixutils.c
View File

@ -104,8 +104,7 @@ Author: Adobe Systems Incorporated
*/ */
int int
CompareTimeStamps(a, b) CompareTimeStamps(TimeStamp a, TimeStamp b)
TimeStamp a, b;
{ {
if (a.months < b.months) if (a.months < b.months)
return EARLIER; return EARLIER;
@ -124,8 +123,7 @@ CompareTimeStamps(a, b)
#define HALFMONTH ((unsigned long) 1<<31) #define HALFMONTH ((unsigned long) 1<<31)
TimeStamp TimeStamp
ClientTimeToServerTime(c) ClientTimeToServerTime(CARD32 c)
CARD32 c;
{ {
TimeStamp ts; TimeStamp ts;
if (c == CurrentTime) if (c == CurrentTime)
@ -169,9 +167,7 @@ ISOLatin1ToLower (unsigned char source)
void void
CopyISOLatin1Lowered(dest, source, length) CopyISOLatin1Lowered(unsigned char *dest, unsigned char *source, int length)
register unsigned char *dest, *source;
int length;
{ {
register int i; register int i;
@ -210,10 +206,7 @@ CompareISOLatin1Lowered(unsigned char *s1, int s1len,
*/ */
WindowPtr WindowPtr
SecurityLookupWindow(rid, client, access_mode) SecurityLookupWindow(XID rid, ClientPtr client, Mask access_mode)
XID rid;
ClientPtr client;
Mask access_mode;
{ {
WindowPtr pWin; WindowPtr pWin;
@ -240,10 +233,7 @@ SecurityLookupWindow(rid, client, access_mode)
pointer pointer
SecurityLookupDrawable(rid, client, access_mode) SecurityLookupDrawable(XID rid, ClientPtr client, Mask access_mode)
XID rid;
ClientPtr client;
Mask access_mode;
{ {
register DrawablePtr pDraw; register DrawablePtr pDraw;
@ -266,17 +256,13 @@ SecurityLookupDrawable(rid, client, access_mode)
*/ */
WindowPtr WindowPtr
LookupWindow(rid, client) LookupWindow(XID rid, ClientPtr client)
XID rid;
ClientPtr client;
{ {
return SecurityLookupWindow(rid, client, SecurityUnknownAccess); return SecurityLookupWindow(rid, client, SecurityUnknownAccess);
} }
pointer pointer
LookupDrawable(rid, client) LookupDrawable(XID rid, ClientPtr client)
XID rid;
ClientPtr client;
{ {
return SecurityLookupDrawable(rid, client, SecurityUnknownAccess); return SecurityLookupDrawable(rid, client, SecurityUnknownAccess);
} }
@ -284,9 +270,7 @@ LookupDrawable(rid, client)
#else /* not XCSECURITY */ #else /* not XCSECURITY */
WindowPtr WindowPtr
LookupWindow(rid, client) LookupWindow(XID rid, ClientPtr client)
XID rid;
ClientPtr client;
{ {
WindowPtr pWin; WindowPtr pWin;
@ -311,9 +295,7 @@ LookupWindow(rid, client)
pointer pointer
LookupDrawable(rid, client) LookupDrawable(XID rid, ClientPtr client)
XID rid;
ClientPtr client;
{ {
register DrawablePtr pDraw; register DrawablePtr pDraw;
@ -330,9 +312,7 @@ LookupDrawable(rid, client)
#endif /* XCSECURITY */ #endif /* XCSECURITY */
ClientPtr ClientPtr
LookupClient(rid, client) LookupClient(XID rid, ClientPtr client)
XID rid;
ClientPtr client;
{ {
pointer pRes = (pointer)SecurityLookupIDByClass(client, rid, RC_ANY, pointer pRes = (pointer)SecurityLookupIDByClass(client, rid, RC_ANY,
SecurityReadAccess); SecurityReadAccess);
@ -347,11 +327,8 @@ LookupClient(rid, client)
int int
AlterSaveSetForClient(ClientPtr client, AlterSaveSetForClient(ClientPtr client, WindowPtr pWin, unsigned mode,
WindowPtr pWin, Bool toRoot, Bool remap)
unsigned mode,
Bool toRoot,
Bool remap)
{ {
int numnow; int numnow;
SaveSetElt *pTmp = NULL; SaveSetElt *pTmp = NULL;
@ -406,8 +383,7 @@ AlterSaveSetForClient(ClientPtr client,
} }
void void
DeleteWindowFromAnySaveSet(pWin) DeleteWindowFromAnySaveSet(WindowPtr pWin)
WindowPtr pWin;
{ {
register int i; register int i;
register ClientPtr client; register ClientPtr client;
@ -443,11 +419,13 @@ static int sizeHandlers;
static Bool inHandler; static Bool inHandler;
static Bool handlerDeleted; static Bool handlerDeleted;
/* called from the OS layer */ /**
*
* \param pTimeout DIX doesn't want to know how OS represents time
* \param pReadMask nor how it represents the det of descriptors
*/
void void
BlockHandler(pTimeout, pReadmask) BlockHandler(pointer pTimeout, pointer pReadmask)
pointer pTimeout; /* DIX doesn't want to know how OS represents time */
pointer pReadmask; /* nor how it represents the set of descriptors */
{ {
register int i, j; register int i, j;
@ -475,10 +453,13 @@ pointer pReadmask; /* nor how it represents the set of descriptors */
--inHandler; --inHandler;
} }
/**
*
* \param result 32 bits of undefined result from the wait
* \param pReadmask the resulting descriptor mask
*/
void void
WakeupHandler(result, pReadmask) WakeupHandler(int result, pointer pReadmask)
int result; /* 32 bits of undefined result from the wait */
pointer pReadmask; /* the resulting descriptor mask */
{ {
register int i, j; register int i, j;
@ -506,15 +487,14 @@ pointer pReadmask; /* the resulting descriptor mask */
--inHandler; --inHandler;
} }
/* Reentrant with BlockHandler and WakeupHandler, except wakeup won't /**
* Reentrant with BlockHandler and WakeupHandler, except wakeup won't
* get called until next time * get called until next time
*/ */
Bool Bool
RegisterBlockAndWakeupHandlers (blockHandler, wakeupHandler, blockData) RegisterBlockAndWakeupHandlers (BlockHandlerProcPtr blockHandler,
BlockHandlerProcPtr blockHandler; WakeupHandlerProcPtr wakeupHandler,
WakeupHandlerProcPtr wakeupHandler; pointer blockData)
pointer blockData;
{ {
BlockHandlerPtr new; BlockHandlerPtr new;
@ -536,10 +516,9 @@ RegisterBlockAndWakeupHandlers (blockHandler, wakeupHandler, blockData)
} }
void void
RemoveBlockAndWakeupHandlers (blockHandler, wakeupHandler, blockData) RemoveBlockAndWakeupHandlers (BlockHandlerProcPtr blockHandler,
BlockHandlerProcPtr blockHandler; WakeupHandlerProcPtr wakeupHandler,
WakeupHandlerProcPtr wakeupHandler; pointer blockData)
pointer blockData;
{ {
int i; int i;
@ -633,12 +612,8 @@ ProcessWorkQueueZombies(void)
Bool Bool
QueueWorkProc ( QueueWorkProc (
Bool (*function)( Bool (*function)(ClientPtr /* pClient */, pointer /* closure */),
ClientPtr /* pClient */, ClientPtr client, pointer closure)
pointer /* closure */
),
ClientPtr client,
pointer closure)
{ {
WorkQueuePtr q; WorkQueuePtr q;
@ -672,10 +647,7 @@ typedef struct _SleepQueue {
static SleepQueuePtr sleepQueue = NULL; static SleepQueuePtr sleepQueue = NULL;
Bool Bool
ClientSleep (client, function, closure) ClientSleep (ClientPtr client, ClientSleepProcPtr function, pointer closure)
ClientPtr client;
ClientSleepProcPtr function;
pointer closure;
{ {
SleepQueuePtr q; SleepQueuePtr q;
@ -693,8 +665,7 @@ ClientSleep (client, function, closure)
} }
Bool Bool
ClientSignal (client) ClientSignal (ClientPtr client)
ClientPtr client;
{ {
SleepQueuePtr q; SleepQueuePtr q;
@ -707,8 +678,7 @@ ClientSignal (client)
} }
void void
ClientWakeup (client) ClientWakeup (ClientPtr client)
ClientPtr client;
{ {
SleepQueuePtr q, *prev; SleepQueuePtr q, *prev;
@ -734,8 +704,7 @@ ClientWakeup (client)
} }
Bool Bool
ClientIsAsleep (client) ClientIsAsleep (ClientPtr client)
ClientPtr client;
{ {
SleepQueuePtr q; SleepQueuePtr q;
@ -909,9 +878,7 @@ static CallbackFuncsRec default_cbfuncs =
/* ===== Public Procedures ===== */ /* ===== Public Procedures ===== */
Bool Bool
CreateCallbackList(pcbl, cbfuncs) CreateCallbackList(CallbackListPtr *pcbl, CallbackFuncsPtr cbfuncs)
CallbackListPtr *pcbl;
CallbackFuncsPtr cbfuncs;
{ {
CallbackListPtr cbl; CallbackListPtr cbl;
int i; int i;
@ -943,10 +910,7 @@ CreateCallbackList(pcbl, cbfuncs)
} }
Bool Bool
AddCallback(pcbl, callback, data) AddCallback(CallbackListPtr *pcbl, CallbackProcPtr callback, pointer data)
CallbackListPtr *pcbl;
CallbackProcPtr callback;
pointer data;
{ {
if (!pcbl) return FALSE; if (!pcbl) return FALSE;
if (!*pcbl) if (!*pcbl)
@ -958,27 +922,21 @@ AddCallback(pcbl, callback, data)
} }
Bool Bool
DeleteCallback(pcbl, callback, data) DeleteCallback(CallbackListPtr *pcbl, CallbackProcPtr callback, pointer data)
CallbackListPtr *pcbl;
CallbackProcPtr callback;
pointer data;
{ {
if (!pcbl || !*pcbl) return FALSE; if (!pcbl || !*pcbl) return FALSE;
return ((*(*pcbl)->funcs.DeleteCallback) (pcbl, callback, data)); return ((*(*pcbl)->funcs.DeleteCallback) (pcbl, callback, data));
} }
void void
CallCallbacks(pcbl, call_data) CallCallbacks(CallbackListPtr *pcbl, pointer call_data)
CallbackListPtr *pcbl;
pointer call_data;
{ {
if (!pcbl || !*pcbl) return; if (!pcbl || !*pcbl) return;
(*(*pcbl)->funcs.CallCallbacks) (pcbl, call_data); (*(*pcbl)->funcs.CallCallbacks) (pcbl, call_data);
} }
void void
DeleteCallbackList(pcbl) DeleteCallbackList(CallbackListPtr *pcbl)
CallbackListPtr *pcbl;
{ {
if (!pcbl || !*pcbl) return; if (!pcbl || !*pcbl) return;
(*(*pcbl)->funcs.DeleteCallbackList) (pcbl); (*(*pcbl)->funcs.DeleteCallbackList) (pcbl);

262
dix/events.c
View File

@ -1,4 +1,4 @@
/* $XdotOrg: xc/programs/Xserver/dix/events.c,v 1.5 2004/07/31 01:33:40 stukreit Exp $ */ /* $XdotOrg: xc/programs/Xserver/dix/events.c,v 1.6 2004/08/09 02:08:35 kem Exp $ */
/* $XFree86: xc/programs/Xserver/dix/events.c,v 3.51 2004/01/12 17:04:52 tsi Exp $ */ /* $XFree86: xc/programs/Xserver/dix/events.c,v 3.51 2004/01/12 17:04:52 tsi Exp $ */
/************************************************************ /************************************************************
@ -222,14 +222,14 @@ HotSpot xeviehot;
#endif #endif
static void DoEnterLeaveEvents( static void DoEnterLeaveEvents(
WindowPtr /*fromWin*/, WindowPtr fromWin,
WindowPtr /*toWin*/, WindowPtr toWin,
int /*mode*/ int mode
); );
static WindowPtr XYToWindow( static WindowPtr XYToWindow(
int /*x*/, int x,
int /*y*/ int y
); );
extern int lastEvent; extern int lastEvent;
@ -608,9 +608,7 @@ XineramaChangeToCursor(CursorPtr cursor)
#endif /* PANORAMIX */ #endif /* PANORAMIX */
void void
SetMaskForEvent(mask, event) SetMaskForEvent(Mask mask, int event)
Mask mask;
int event;
{ {
if ((event < LASTEvent) || (event >= 128)) if ((event < LASTEvent) || (event >= 128))
FatalError("SetMaskForEvent: bogus event number"); FatalError("SetMaskForEvent: bogus event number");
@ -618,8 +616,7 @@ SetMaskForEvent(mask, event)
} }
void void
SetCriticalEvent(event) SetCriticalEvent(int event)
int event;
{ {
if (event >= 128) if (event >= 128)
FatalError("SetCriticalEvent: bogus event number"); FatalError("SetCriticalEvent: bogus event number");
@ -843,8 +840,7 @@ ChangeToCursor(CursorPtr cursor)
/* returns true if b is a descendent of a */ /* returns true if b is a descendent of a */
Bool Bool
IsParent(a, b) IsParent(register WindowPtr a, register WindowPtr b)
register WindowPtr a, b;
{ {
for (b = b->parent; b; b = b->parent) for (b = b->parent; b; b = b->parent)
if (b == a) return TRUE; if (b == a) return TRUE;
@ -900,8 +896,7 @@ GetSpriteCursor()
} }
void void
GetSpritePosition(px, py) GetSpritePosition(int *px, int *py)
int *px, *py;
{ {
*px = sprite.hotPhys.x; *px = sprite.hotPhys.x;
*py = sprite.hotPhys.y; *py = sprite.hotPhys.y;
@ -941,8 +936,7 @@ MonthChangedOrBadTime(register xEvent *xE)
lastDeviceEventTime = currentTime; } lastDeviceEventTime = currentTime; }
void void
NoticeEventTime(xE) NoticeEventTime(register xEvent *xE)
register xEvent *xE;
{ {
if (!syncEvents.playingEvents) if (!syncEvents.playingEvents)
NoticeTime(xE); NoticeTime(xE);
@ -953,10 +947,7 @@ NoticeEventTime(xE)
**************************************************************************/ **************************************************************************/
void void
EnqueueEvent(xE, device, count) EnqueueEvent(xEvent *xE, DeviceIntPtr device, int count)
xEvent *xE;
DeviceIntPtr device;
int count;
{ {
register QdEventPtr tail = *syncEvents.pendtail; register QdEventPtr tail = *syncEvents.pendtail;
register QdEventPtr qe; register QdEventPtr qe;
@ -1172,9 +1163,7 @@ ScreenRestructured (ScreenPtr pScreen)
#endif #endif
void void
CheckGrabForSyncs(thisDev, thisMode, otherMode) CheckGrabForSyncs(register DeviceIntPtr thisDev, Bool thisMode, Bool otherMode)
register DeviceIntPtr thisDev;
Bool thisMode, otherMode;
{ {
register GrabPtr grab = thisDev->grab; register GrabPtr grab = thisDev->grab;
register DeviceIntPtr dev; register DeviceIntPtr dev;
@ -1208,11 +1197,8 @@ CheckGrabForSyncs(thisDev, thisMode, otherMode)
} }
void void
ActivatePointerGrab(mouse, grab, time, autoGrab) ActivatePointerGrab(register DeviceIntPtr mouse, register GrabPtr grab,
register GrabPtr grab; TimeStamp time, Bool autoGrab)
register DeviceIntPtr mouse;
TimeStamp time;
Bool autoGrab;
{ {
WindowPtr oldWin = (mouse->grab) ? mouse->grab->window WindowPtr oldWin = (mouse->grab) ? mouse->grab->window
: sprite.win; : sprite.win;
@ -1239,8 +1225,7 @@ ActivatePointerGrab(mouse, grab, time, autoGrab)
} }
void void
DeactivatePointerGrab(mouse) DeactivatePointerGrab(register DeviceIntPtr mouse)
register DeviceIntPtr mouse;
{ {
register GrabPtr grab = mouse->grab; register GrabPtr grab = mouse->grab;
register DeviceIntPtr dev; register DeviceIntPtr dev;
@ -1264,11 +1249,7 @@ DeactivatePointerGrab(mouse)
} }
void void
ActivateKeyboardGrab(keybd, grab, time, passive) ActivateKeyboardGrab(register DeviceIntPtr keybd, GrabPtr grab, TimeStamp time, Bool passive)
register DeviceIntPtr keybd;
GrabPtr grab;
TimeStamp time;
Bool passive;
{ {
WindowPtr oldWin; WindowPtr oldWin;
@ -1294,8 +1275,7 @@ ActivateKeyboardGrab(keybd, grab, time, passive)
} }
void void
DeactivateKeyboardGrab(keybd) DeactivateKeyboardGrab(register DeviceIntPtr keybd)
register DeviceIntPtr keybd;
{ {
register GrabPtr grab = keybd->grab; register GrabPtr grab = keybd->grab;
register DeviceIntPtr dev; register DeviceIntPtr dev;
@ -1319,11 +1299,7 @@ DeactivateKeyboardGrab(keybd)
} }
void void
AllowSome(client, time, thisDev, newState) AllowSome(ClientPtr client, TimeStamp time, DeviceIntPtr thisDev, int newState)
ClientPtr client;
TimeStamp time;
register DeviceIntPtr thisDev;
int newState;
{ {
Bool thisGrabbed, otherGrabbed, othersFrozen, thisSynced; Bool thisGrabbed, otherGrabbed, othersFrozen, thisSynced;
TimeStamp grabTime; TimeStamp grabTime;
@ -1431,8 +1407,7 @@ AllowSome(client, time, thisDev, newState)
} }
int int
ProcAllowEvents(client) ProcAllowEvents(register ClientPtr client)
register ClientPtr client;
{ {
TimeStamp time; TimeStamp time;
DeviceIntPtr mouse = inputInfo.pointer; DeviceIntPtr mouse = inputInfo.pointer;
@ -1475,8 +1450,7 @@ ProcAllowEvents(client)
} }
void void
ReleaseActiveGrabs(client) ReleaseActiveGrabs(ClientPtr client)
ClientPtr client;
{ {
register DeviceIntPtr dev; register DeviceIntPtr dev;
Bool done; Bool done;
@ -1502,12 +1476,8 @@ ReleaseActiveGrabs(client)
**************************************************************************/ **************************************************************************/
int int
TryClientEvents (client, pEvents, count, mask, filter, grab) TryClientEvents (ClientPtr client, xEvent *pEvents, int count, Mask mask,
ClientPtr client; Mask filter, GrabPtr grab)
GrabPtr grab;
xEvent *pEvents;
int count;
Mask mask, filter;
{ {
int i; int i;
int type; int type;
@ -1585,13 +1555,8 @@ TryClientEvents (client, pEvents, count, mask, filter, grab)
} }
int int
DeliverEventsToWindow(pWin, pEvents, count, filter, grab, mskidx) DeliverEventsToWindow(register WindowPtr pWin, xEvent *pEvents, int count,
register WindowPtr pWin; Mask filter, GrabPtr grab, int mskidx)
GrabPtr grab;
xEvent *pEvents;
int count;
Mask filter;
int mskidx;
{ {
int deliveries = 0, nondeliveries = 0; int deliveries = 0, nondeliveries = 0;
int attempt; int attempt;
@ -1709,12 +1674,8 @@ XineramaTryClientEventsResult(
#endif #endif
int int
MaybeDeliverEventsToClient(pWin, pEvents, count, filter, dontClient) MaybeDeliverEventsToClient(register WindowPtr pWin, xEvent *pEvents,
register WindowPtr pWin; int count, Mask filter, ClientPtr dontClient)
xEvent *pEvents;
int count;
Mask filter;
ClientPtr dontClient;
{ {
register OtherClients *other; register OtherClients *other;
@ -1804,12 +1765,8 @@ FixUpEventFromWindow(
} }
int int
DeliverDeviceEvents(pWin, xE, grab, stopAt, dev, count) DeliverDeviceEvents(register WindowPtr pWin, register xEvent *xE, GrabPtr grab,
register WindowPtr pWin, stopAt; register WindowPtr stopAt, DeviceIntPtr dev, int count)
register xEvent *xE;
GrabPtr grab;
DeviceIntPtr dev;
int count;
{ {
Window child = None; Window child = None;
int type = xE->u.u.type; int type = xE->u.u.type;
@ -1872,10 +1829,8 @@ DeliverDeviceEvents(pWin, xE, grab, stopAt, dev, count)
/* not useful for events that propagate up the tree or extension events */ /* not useful for events that propagate up the tree or extension events */
int int
DeliverEvents(pWin, xE, count, otherParent) DeliverEvents(register WindowPtr pWin, register xEvent *xE, int count,
register WindowPtr pWin, otherParent; register WindowPtr otherParent)
register xEvent *xE;
int count;
{ {
Mask filter; Mask filter;
int deliveries; int deliveries;
@ -2091,8 +2046,7 @@ void ReinitializeRootWindow(WindowPtr win, int xoff, int yoff)
#endif #endif
void void
DefineInitialRootWindow(win) DefineInitialRootWindow(register WindowPtr win)
register WindowPtr win;
{ {
register ScreenPtr pScreen = win->drawable.pScreen; register ScreenPtr pScreen = win->drawable.pScreen;
@ -2139,18 +2093,14 @@ DefineInitialRootWindow(win)
* between the one the pointer is in and the one that the last cursor was * between the one the pointer is in and the one that the last cursor was
* instantiated from. * instantiated from.
*/ */
/*ARGSUSED*/
void void
WindowHasNewCursor(pWin) WindowHasNewCursor(WindowPtr pWin)
WindowPtr pWin;
{ {
PostNewCursor(); PostNewCursor();
} }
void void
NewCurrentScreen(newScreen, x, y) NewCurrentScreen(ScreenPtr newScreen, int x, int y)
ScreenPtr newScreen;
int x,y;
{ {
sprite.hotPhys.x = x; sprite.hotPhys.x = x;
sprite.hotPhys.y = y; sprite.hotPhys.y = y;
@ -2293,8 +2243,7 @@ XineramaWarpPointer(ClientPtr client)
int int
ProcWarpPointer(client) ProcWarpPointer(ClientPtr client)
ClientPtr client;
{ {
WindowPtr dest = NULL; WindowPtr dest = NULL;
int x, y; int x, y;
@ -2497,7 +2446,7 @@ CheckPassiveGrabsOnWindow(
return FALSE; return FALSE;
} }
/* /**
"CheckDeviceGrabs" handles both keyboard and pointer events that may cause "CheckDeviceGrabs" handles both keyboard and pointer events that may cause
a passive grab to be activated. If the event is a keyboard event, the a passive grab to be activated. If the event is a keyboard event, the
ancestors of the focus window are traced down and tried to see if they have ancestors of the focus window are traced down and tried to see if they have
@ -2511,11 +2460,8 @@ tried. PRH
*/ */
Bool Bool
CheckDeviceGrabs(device, xE, checkFirst, count) CheckDeviceGrabs(register DeviceIntPtr device, register xEvent *xE,
register DeviceIntPtr device; int checkFirst, int count)
register xEvent *xE;
int checkFirst;
int count;
{ {
register int i; register int i;
register WindowPtr pWin = NULL; register WindowPtr pWin = NULL;
@ -2558,11 +2504,7 @@ CheckDeviceGrabs(device, xE, checkFirst, count)
} }
void void
DeliverFocusedEvent(keybd, xE, window, count) DeliverFocusedEvent(DeviceIntPtr keybd, xEvent *xE, WindowPtr window, int count)
xEvent *xE;
DeviceIntPtr keybd;
WindowPtr window;
int count;
{ {
WindowPtr focus = keybd->focus->win; WindowPtr focus = keybd->focus->win;
int mskidx = 0; int mskidx = 0;
@ -2590,11 +2532,8 @@ DeliverFocusedEvent(keybd, xE, window, count)
} }
void void
DeliverGrabbedEvent(xE, thisDev, deactivateGrab, count) DeliverGrabbedEvent(register xEvent *xE, register DeviceIntPtr thisDev,
register xEvent *xE; Bool deactivateGrab, int count)
register DeviceIntPtr thisDev;
Bool deactivateGrab;
int count;
{ {
register GrabPtr grab = thisDev->grab; register GrabPtr grab = thisDev->grab;
int deliveries = 0; int deliveries = 0;
@ -2676,13 +2615,10 @@ DeliverGrabbedEvent(xE, thisDev, deactivateGrab, count)
void void
#ifdef XKB #ifdef XKB
CoreProcessKeyboardEvent (xE, keybd, count) CoreProcessKeyboardEvent (register xEvent *xE, register DeviceIntPtr keybd, int count)
#else #else
ProcessKeyboardEvent (xE, keybd, count) ProcessKeyboardEvent (register xEvent *xE, register DeviceIntPtr keybd, int count)
#endif #endif
register xEvent *xE;
register DeviceIntPtr keybd;
int count;
{ {
int key, bit; int key, bit;
register BYTE *kptr; register BYTE *kptr;
@ -2835,9 +2771,7 @@ drawable.id:0;
CoreProcessKeyEvent to be called, as in for example Mouse Keys. CoreProcessKeyEvent to be called, as in for example Mouse Keys.
*/ */
void void
FixKeyState (xE, keybd) FixKeyState (register xEvent *xE, register DeviceIntPtr keybd)
register xEvent *xE;
register DeviceIntPtr keybd;
{ {
int key, bit; int key, bit;
register BYTE *kptr; register BYTE *kptr;
@ -2869,13 +2803,10 @@ FixKeyState (xE, keybd)
void void
#ifdef XKB #ifdef XKB
CoreProcessPointerEvent (xE, mouse, count) CoreProcessPointerEvent (register xEvent *xE, register DeviceIntPtr mouse, int count)
#else #else
ProcessPointerEvent (xE, mouse, count) ProcessPointerEvent (register xEvent *xE, register DeviceIntPtr mouse, int count)
#endif #endif
register xEvent *xE;
register DeviceIntPtr mouse;
int count;
{ {
register GrabPtr grab = mouse->grab; register GrabPtr grab = mouse->grab;
Bool deactivateGrab = FALSE; Bool deactivateGrab = FALSE;
@ -3026,10 +2957,12 @@ RecalculateDeliverableEvents(pWin)
} }
} }
/**
*
* \param value must conform to DeleteType
*/
int int
OtherClientGone(value, id) OtherClientGone(pointer value, XID id)
pointer value; /* must conform to DeleteType */
XID id;
{ {
register OtherClientsPtr other, prev; register OtherClientsPtr other, prev;
register WindowPtr pWin = (WindowPtr)value; register WindowPtr pWin = (WindowPtr)value;
@ -3058,10 +2991,7 @@ OtherClientGone(value, id)
} }
int int
EventSelectForWindow(pWin, client, mask) EventSelectForWindow(register WindowPtr pWin, register ClientPtr client, Mask mask)
register WindowPtr pWin;
register ClientPtr client;
Mask mask;
{ {
Mask check; Mask check;
OtherClients * others; OtherClients * others;
@ -3140,13 +3070,9 @@ maskSet:
return Success; return Success;
} }
/*ARGSUSED*/
int int
EventSuppressForWindow(pWin, client, mask, checkOptional) EventSuppressForWindow(register WindowPtr pWin, register ClientPtr client,
register WindowPtr pWin; Mask mask, Bool *checkOptional)
register ClientPtr client;
Mask mask;
Bool *checkOptional;
{ {
register int i, free; register int i, free;
@ -3432,10 +3358,7 @@ FocusOutEvents(
} }
void void
DoFocusEvents(dev, fromWin, toWin, mode) DoFocusEvents(DeviceIntPtr dev, WindowPtr fromWin, WindowPtr toWin, int mode)
DeviceIntPtr dev;
WindowPtr fromWin, toWin;
int mode;
{ {
int out, in; /* for holding details for to/from int out, in; /* for holding details for to/from
PointerRoot/None */ PointerRoot/None */
@ -3654,8 +3577,7 @@ ProcSetInputFocus(client)
} }
int int
ProcGetInputFocus(client) ProcGetInputFocus(ClientPtr client)
ClientPtr client;
{ {
xGetInputFocusReply rep; xGetInputFocusReply rep;
/* REQUEST(xReq); */ /* REQUEST(xReq); */
@ -3676,8 +3598,7 @@ ProcGetInputFocus(client)
} }
int int
ProcGrabPointer(client) ProcGrabPointer(ClientPtr client)
ClientPtr client;
{ {
xGrabPointerReply rep; xGrabPointerReply rep;
DeviceIntPtr device = inputInfo.pointer; DeviceIntPtr device = inputInfo.pointer;
@ -3783,8 +3704,7 @@ ProcGrabPointer(client)
} }
int int
ProcChangeActivePointerGrab(client) ProcChangeActivePointerGrab(ClientPtr client)
ClientPtr client;
{ {
DeviceIntPtr device = inputInfo.pointer; DeviceIntPtr device = inputInfo.pointer;
register GrabPtr grab = device->grab; register GrabPtr grab = device->grab;
@ -3830,8 +3750,7 @@ ProcChangeActivePointerGrab(client)
} }
int int
ProcUngrabPointer(client) ProcUngrabPointer(ClientPtr client)
ClientPtr client;
{ {
DeviceIntPtr device = inputInfo.pointer; DeviceIntPtr device = inputInfo.pointer;
GrabPtr grab; GrabPtr grab;
@ -3850,17 +3769,9 @@ ProcUngrabPointer(client)
} }
int int
GrabDevice(client, dev, this_mode, other_mode, grabWindow, ownerEvents, ctime, GrabDevice(register ClientPtr client, register DeviceIntPtr dev,
mask, status) unsigned this_mode, unsigned other_mode, Window grabWindow,
register ClientPtr client; unsigned ownerEvents, Time ctime, Mask mask, CARD8 *status)
register DeviceIntPtr dev;
unsigned this_mode;
unsigned other_mode;
Window grabWindow;
unsigned ownerEvents;
Time ctime;
Mask mask;
CARD8 *status;
{ {
register WindowPtr pWin; register WindowPtr pWin;
register GrabPtr grab; register GrabPtr grab;
@ -3915,8 +3826,7 @@ GrabDevice(client, dev, this_mode, other_mode, grabWindow, ownerEvents, ctime,
} }
int int
ProcGrabKeyboard(client) ProcGrabKeyboard(ClientPtr client)
ClientPtr client;
{ {
xGrabKeyboardReply rep; xGrabKeyboardReply rep;
REQUEST(xGrabKeyboardReq); REQUEST(xGrabKeyboardReq);
@ -3945,8 +3855,7 @@ ProcGrabKeyboard(client)
} }
int int
ProcUngrabKeyboard(client) ProcUngrabKeyboard(ClientPtr client)
ClientPtr client;
{ {
DeviceIntPtr device = inputInfo.keyboard; DeviceIntPtr device = inputInfo.keyboard;
GrabPtr grab; GrabPtr grab;
@ -3965,8 +3874,7 @@ ProcUngrabKeyboard(client)
} }
int int
ProcQueryPointer(client) ProcQueryPointer(ClientPtr client)
ClientPtr client;
{ {
xQueryPointerReply rep; xQueryPointerReply rep;
WindowPtr pWin, t; WindowPtr pWin, t;
@ -4081,8 +3989,7 @@ CloseDownEvents(void)
} }
int int
ProcSendEvent(client) ProcSendEvent(ClientPtr client)
ClientPtr client;
{ {
WindowPtr pWin; WindowPtr pWin;
WindowPtr effectiveFocus = NullWindow; /* only set if dest==InputFocus */ WindowPtr effectiveFocus = NullWindow; /* only set if dest==InputFocus */
@ -4170,8 +4077,7 @@ ProcSendEvent(client)
} }
int int
ProcUngrabKey(client) ProcUngrabKey(ClientPtr client)
ClientPtr client;
{ {
REQUEST(xUngrabKeyReq); REQUEST(xUngrabKeyReq);
WindowPtr pWin; WindowPtr pWin;
@ -4212,8 +4118,7 @@ ProcUngrabKey(client)
} }
int int
ProcGrabKey(client) ProcGrabKey(ClientPtr client)
ClientPtr client;
{ {
WindowPtr pWin; WindowPtr pWin;
REQUEST(xGrabKeyReq); REQUEST(xGrabKeyReq);
@ -4267,8 +4172,7 @@ ProcGrabKey(client)
int int
ProcGrabButton(client) ProcGrabButton(ClientPtr client)
ClientPtr client;
{ {
WindowPtr pWin, confineTo; WindowPtr pWin, confineTo;
REQUEST(xGrabButtonReq); REQUEST(xGrabButtonReq);
@ -4342,8 +4246,7 @@ ProcGrabButton(client)
} }
int int
ProcUngrabButton(client) ProcUngrabButton(ClientPtr client)
ClientPtr client;
{ {
REQUEST(xUngrabButtonReq); REQUEST(xUngrabButtonReq);
WindowPtr pWin; WindowPtr pWin;
@ -4375,9 +4278,7 @@ ProcUngrabButton(client)
} }
void void
DeleteWindowFromAnyEvents(pWin, freeResources) DeleteWindowFromAnyEvents(WindowPtr pWin, Bool freeResources)
WindowPtr pWin;
Bool freeResources;
{ {
WindowPtr parent; WindowPtr parent;
DeviceIntPtr mouse = inputInfo.pointer; DeviceIntPtr mouse = inputInfo.pointer;
@ -4464,12 +4365,11 @@ DeleteWindowFromAnyEvents(pWin, freeResources)
#endif #endif
} }
/* Call this whenever some window at or below pWin has changed geometry */ /**
* Call this whenever some window at or below pWin has changed geometry
/*ARGSUSED*/ */
void void
CheckCursorConfinement(pWin) CheckCursorConfinement(WindowPtr pWin)
WindowPtr pWin;
{ {
GrabPtr grab = inputInfo.pointer->grab; GrabPtr grab = inputInfo.pointer->grab;
WindowPtr confineTo; WindowPtr confineTo;
@ -4488,9 +4388,7 @@ CheckCursorConfinement(pWin)
} }
Mask Mask
EventMaskForClient(pWin, client) EventMaskForClient(WindowPtr pWin, ClientPtr client)
WindowPtr pWin;
ClientPtr client;
{ {
register OtherClientsPtr other; register OtherClientsPtr other;
@ -4505,8 +4403,7 @@ EventMaskForClient(pWin, client)
} }
int int
ProcRecolorCursor(client) ProcRecolorCursor(ClientPtr client)
ClientPtr client;
{ {
CursorPtr pCursor; CursorPtr pCursor;
int nscr; int nscr;
@ -4547,10 +4444,7 @@ ProcRecolorCursor(client)
} }
void void
WriteEventsToClient(pClient, count, events) WriteEventsToClient(ClientPtr pClient, int count, xEvent *events)
ClientPtr pClient;
int count;
xEvent *events;
{ {
#ifdef PANORAMIX #ifdef PANORAMIX
xEvent eventCopy; xEvent eventCopy;

34
dix/extension.c
View File

@ -156,9 +156,7 @@ AddExtension(char *name, int NumEvents, int NumErrors,
return(ext); return(ext);
} }
Bool AddExtensionAlias(alias, ext) Bool AddExtensionAlias(char *alias, ExtensionEntry *ext)
char *alias;
ExtensionEntry *ext;
{ {
char *name; char *name;
char **aliases; char **aliases;
@ -219,9 +217,7 @@ CheckExtension(const char *extname)
} }
void void
DeclareExtensionSecurity(extname, secure) DeclareExtensionSecurity(char *extname, Bool secure)
char *extname;
Bool secure;
{ {
#ifdef XCSECURITY #ifdef XCSECURITY
int i = FindExtension(extname, strlen(extname)); int i = FindExtension(extname, strlen(extname));
@ -247,15 +243,13 @@ DeclareExtensionSecurity(extname, secure)
} }
unsigned short unsigned short
StandardMinorOpcode(client) StandardMinorOpcode(ClientPtr client)
ClientPtr client;
{ {
return ((xReq *)client->requestBuffer)->data; return ((xReq *)client->requestBuffer)->data;
} }
unsigned short unsigned short
MinorOpcodeOfRequest(client) MinorOpcodeOfRequest(ClientPtr client)
ClientPtr client;
{ {
unsigned char major; unsigned char major;
@ -307,8 +301,7 @@ CloseDownExtensions()
int int
ProcQueryExtension(client) ProcQueryExtension(ClientPtr client)
ClientPtr client;
{ {
xQueryExtensionReply reply; xQueryExtensionReply reply;
int i; int i;
@ -347,8 +340,7 @@ ProcQueryExtension(client)
} }
int int
ProcListExtensions(client) ProcListExtensions(ClientPtr client)
ClientPtr client;
{ {
xListExtensionsReply reply; xListExtensionsReply reply;
char *bufptr, *buffer; char *bufptr, *buffer;
@ -413,9 +405,7 @@ ProcListExtensions(client)
ExtensionLookupProc ExtensionLookupProc
LookupProc(name, pGC) LookupProc(char *name, GCPtr pGC)
char *name;
GCPtr pGC;
{ {
register int i; register int i;
register ScreenProcEntry *spentry; register ScreenProcEntry *spentry;
@ -430,19 +420,13 @@ LookupProc(name, pGC)
} }
Bool Bool
RegisterProc(name, pGC, proc) RegisterProc(char *name, GC *pGC, ExtensionLookupProc proc)
char *name;
GC *pGC;
ExtensionLookupProc proc;
{ {
return RegisterScreenProc(name, pGC->pScreen, proc); return RegisterScreenProc(name, pGC->pScreen, proc);
} }
Bool Bool
RegisterScreenProc(name, pScreen, proc) RegisterScreenProc(char *name, ScreenPtr pScreen, ExtensionLookupProc proc)
char *name;
ScreenPtr pScreen;
ExtensionLookupProc proc;
{ {
register ScreenProcEntry *spentry; register ScreenProcEntry *spentry;
register ProcEntryPtr procEntry = (ProcEntryPtr)NULL; register ProcEntryPtr procEntry = (ProcEntryPtr)NULL;

102
dix/gc.c
View File

@ -65,16 +65,12 @@ SOFTWARE.
extern XID clientErrorValue; extern XID clientErrorValue;
extern FontPtr defaultFont; extern FontPtr defaultFont;
static Bool CreateDefaultTile( static Bool CreateDefaultTile(GCPtr pGC);
GCPtr /*pGC*/
);
unsigned char DefaultDash[2] = {4, 4}; unsigned char DefaultDash[2] = {4, 4};
void void
ValidateGC(pDraw, pGC) ValidateGC(DrawablePtr pDraw, GC *pGC)
DrawablePtr pDraw;
GC *pGC;
{ {
(*pGC->funcs->ValidateGC) (pGC, pGC->stateChanges, pDraw); (*pGC->funcs->ValidateGC) (pGC, pGC->stateChanges, pDraw);
pGC->stateChanges = 0; pGC->stateChanges = 0;
@ -146,12 +142,7 @@ ValidateGC(pDraw, pGC)
assert(pUnion); _var = (_type)pUnion->ptr; pUnion++; } assert(pUnion); _var = (_type)pUnion->ptr; pUnion++; }
int int
dixChangeGC(client, pGC, mask, pC32, pUnion) dixChangeGC(ClientPtr client, register GC *pGC, register BITS32 mask, CARD32 *pC32, ChangeGCValPtr pUnion)
ClientPtr client;
register GC *pGC;
register BITS32 mask;
CARD32 *pC32;
ChangeGCValPtr pUnion;
{ {
register BITS32 index2; register BITS32 index2;
register int error = 0; register int error = 0;
@ -529,10 +520,7 @@ dixChangeGC(client, pGC, mask, pC32, pUnion)
/* Publically defined entry to ChangeGC. Just calls dixChangeGC and tells /* Publically defined entry to ChangeGC. Just calls dixChangeGC and tells
* it that all of the entries are constants or IDs */ * it that all of the entries are constants or IDs */
int int
ChangeGC(pGC, mask, pval) ChangeGC(register GC *pGC, register BITS32 mask, XID *pval)
register GC *pGC;
register BITS32 mask;
XID *pval;
{ {
return (dixChangeGC(NullClient, pGC, mask, pval, NULL)); return (dixChangeGC(NullClient, pGC, mask, pval, NULL));
} }
@ -558,11 +546,7 @@ NOTE:
32 bits long 32 bits long
*/ */
int int
DoChangeGC(pGC, mask, pval, fPointer) DoChangeGC(register GC *pGC, register BITS32 mask, XID *pval, int fPointer)
register GC *pGC;
register BITS32 mask;
XID *pval;
int fPointer;
{ {
if (fPointer) if (fPointer)
/* XXX might be a problem on 64 bit big-endian servers */ /* XXX might be a problem on 64 bit big-endian servers */
@ -614,11 +598,7 @@ AllocateGC(ScreenPtr pScreen)
} }
GCPtr GCPtr
CreateGC(pDrawable, mask, pval, pStatus) CreateGC(DrawablePtr pDrawable, BITS32 mask, XID *pval, int *pStatus)
DrawablePtr pDrawable;
BITS32 mask;
XID *pval;
int *pStatus;
{ {
register GCPtr pGC; register GCPtr pGC;
@ -699,8 +679,7 @@ CreateGC(pDrawable, mask, pval, pStatus)
} }
static Bool static Bool
CreateDefaultTile (pGC) CreateDefaultTile (GCPtr pGC)
GCPtr pGC;
{ {
XID tmpval[3]; XID tmpval[3];
PixmapPtr pTile; PixmapPtr pTile;
@ -743,10 +722,7 @@ CreateDefaultTile (pGC)
} }
int int
CopyGC(pgcSrc, pgcDst, mask) CopyGC(register GC *pgcSrc, register GC *pgcDst, register BITS32 mask)
register GC *pgcSrc;
register GC *pgcDst;
register BITS32 mask;
{ {
register BITS32 index2; register BITS32 index2;
BITS32 maskQ; BITS32 maskQ;
@ -904,16 +880,13 @@ CopyGC(pgcSrc, pgcDst, mask)
return error; return error;
} }
/***************** /**
* FreeGC * does the diX part of freeing the characteristics in the GC.
* does the diX part of freeing the characteristics in the GC *
***************/ * \param value must conform to DeleteType
*/
/*ARGSUSED*/
int int
FreeGC(value, gid) FreeGC(pointer value, XID gid)
pointer value; /* must conform to DeleteType */
XID gid;
{ {
GCPtr pGC = (GCPtr)value; GCPtr pGC = (GCPtr)value;
@ -933,10 +906,7 @@ FreeGC(value, gid)
} }
void void
SetGCMask(pGC, selectMask, newDataMask) SetGCMask(GCPtr pGC, Mask selectMask, Mask newDataMask)
GCPtr pGC;
Mask selectMask;
Mask newDataMask;
{ {
pGC->stateChanges = (~selectMask & pGC->stateChanges) | pGC->stateChanges = (~selectMask & pGC->stateChanges) |
(selectMask & newDataMask); (selectMask & newDataMask);
@ -960,9 +930,7 @@ go with CreateGC() or ChangeGC().)
*/ */
GCPtr GCPtr
CreateScratchGC(pScreen, depth) CreateScratchGC(ScreenPtr pScreen, unsigned depth)
ScreenPtr pScreen;
unsigned depth;
{ {
register GCPtr pGC; register GCPtr pGC;
@ -1014,8 +982,7 @@ CreateScratchGC(pScreen, depth)
} }
void void
FreeGCperDepth(screenNum) FreeGCperDepth(int screenNum)
int screenNum;
{ {
register int i; register int i;
register ScreenPtr pScreen; register ScreenPtr pScreen;
@ -1031,8 +998,7 @@ FreeGCperDepth(screenNum)
Bool Bool
CreateGCperDepth(screenNum) CreateGCperDepth(int screenNum)
int screenNum;
{ {
register int i; register int i;
register ScreenPtr pScreen; register ScreenPtr pScreen;
@ -1062,8 +1028,7 @@ CreateGCperDepth(screenNum)
} }
Bool Bool
CreateDefaultStipple(screenNum) CreateDefaultStipple(int screenNum)
int screenNum;
{ {
register ScreenPtr pScreen; register ScreenPtr pScreen;
XID tmpval[3]; XID tmpval[3];
@ -1100,19 +1065,14 @@ CreateDefaultStipple(screenNum)
} }
void void
FreeDefaultStipple(screenNum) FreeDefaultStipple(int screenNum)
int screenNum;
{ {
ScreenPtr pScreen = screenInfo.screens[screenNum]; ScreenPtr pScreen = screenInfo.screens[screenNum];
(*pScreen->DestroyPixmap)(pScreen->PixmapPerDepth[0]); (*pScreen->DestroyPixmap)(pScreen->PixmapPerDepth[0]);
} }
int int
SetDashes(pGC, offset, ndash, pdash) SetDashes(register GCPtr pGC, unsigned offset, unsigned ndash, unsigned char *pdash)
register GCPtr pGC;
unsigned offset;
register unsigned ndash;
register unsigned char *pdash;
{ {
register long i; register long i;
register unsigned char *p, *indash; register unsigned char *p, *indash;
@ -1168,10 +1128,7 @@ register unsigned char *pdash;
} }
int int
VerifyRectOrder(nrects, prects, ordering) VerifyRectOrder(int nrects, xRectangle *prects, int ordering)
int nrects;
xRectangle *prects;
int ordering;
{ {
register xRectangle *prectP, *prectN; register xRectangle *prectP, *prectN;
register int i; register int i;
@ -1221,12 +1178,8 @@ VerifyRectOrder(nrects, prects, ordering)
} }
int int
SetClipRects(pGC, xOrigin, yOrigin, nrects, prects, ordering) SetClipRects(GCPtr pGC, int xOrigin, int yOrigin, int nrects,
GCPtr pGC; xRectangle *prects, int ordering)
int xOrigin, yOrigin;
int nrects;
xRectangle *prects;
int ordering;
{ {
int newct, size; int newct, size;
xRectangle *prectsNew; xRectangle *prectsNew;
@ -1262,9 +1215,7 @@ SetClipRects(pGC, xOrigin, yOrigin, nrects, prects, ordering)
you use it often enough it will become real.) you use it often enough it will become real.)
*/ */
GCPtr GCPtr
GetScratchGC(depth, pScreen) GetScratchGC(register unsigned depth, register ScreenPtr pScreen)
register unsigned depth;
register ScreenPtr pScreen;
{ {
register int i; register int i;
register GCPtr pGC; register GCPtr pGC;
@ -1313,8 +1264,7 @@ mark it as available.
if not, free it for real if not, free it for real
*/ */
void void
FreeScratchGC(pGC) FreeScratchGC(register GCPtr pGC)
register GCPtr pGC;
{ {
register ScreenPtr pScreen = pGC->pScreen; register ScreenPtr pScreen = pGC->pScreen;
register int i; register int i;

11
dix/glyphcurs.c
View File

@ -71,11 +71,7 @@ cursor metrics.
*/ */
int int
ServerBitsFromGlyph(pfont, ch, cm, ppbits) ServerBitsFromGlyph(FontPtr pfont, unsigned ch, register CursorMetricPtr cm, unsigned char **ppbits)
FontPtr pfont;
unsigned int ch;
register CursorMetricPtr cm;
unsigned char **ppbits;
{ {
register ScreenPtr pScreen; register ScreenPtr pScreen;
register GCPtr pGC; register GCPtr pGC;
@ -141,10 +137,7 @@ ServerBitsFromGlyph(pfont, ch, cm, ppbits)
Bool Bool
CursorMetricsFromGlyph( pfont, ch, cm) CursorMetricsFromGlyph(register FontPtr pfont, unsigned ch, register CursorMetricPtr cm)
register FontPtr pfont;
unsigned ch;
register CursorMetricPtr cm;
{ {
CharInfoPtr pci; CharInfoPtr pci;
unsigned long nglyphs; unsigned long nglyphs;

14
dix/grabs.c
View File

@ -123,11 +123,8 @@ FreeGrab(GrabPtr pGrab)
xfree(pGrab); xfree(pGrab);
} }
/*ARGSUSED*/
int int
DeletePassiveGrab(value, id) DeletePassiveGrab(pointer value, XID id)
pointer value;
XID id;
{ {
register GrabPtr g, prev; register GrabPtr g, prev;
GrabPtr pGrab = (GrabPtr)value; GrabPtr pGrab = (GrabPtr)value;
@ -240,8 +237,7 @@ GrabSupersedesSecond(GrabPtr pFirstGrab, GrabPtr pSecondGrab)
} }
Bool Bool
GrabMatchesSecond(pFirstGrab, pSecondGrab) GrabMatchesSecond(GrabPtr pFirstGrab, GrabPtr pSecondGrab)
GrabPtr pFirstGrab, pSecondGrab;
{ {
if ((pFirstGrab->device != pSecondGrab->device) || if ((pFirstGrab->device != pSecondGrab->device) ||
(pFirstGrab->modifierDevice != pSecondGrab->modifierDevice) || (pFirstGrab->modifierDevice != pSecondGrab->modifierDevice) ||
@ -272,8 +268,7 @@ GrabMatchesSecond(pFirstGrab, pSecondGrab)
} }
int int
AddPassiveGrabToList(pGrab) AddPassiveGrabToList(GrabPtr pGrab)
GrabPtr pGrab;
{ {
GrabPtr grab; GrabPtr grab;
@ -306,8 +301,7 @@ AddPassiveGrabToList(pGrab)
*/ */
Bool Bool
DeletePassiveGrabFromList(pMinuendGrab) DeletePassiveGrabFromList(GrabPtr pMinuendGrab)
GrabPtr pMinuendGrab;
{ {
register GrabPtr grab; register GrabPtr grab;
GrabPtr *deletes, *adds; GrabPtr *deletes, *adds;

15
dix/main.c
View File

@ -1,4 +1,4 @@
/* $XdotOrg: xc/programs/Xserver/dix/main.c,v 1.3 2004/06/30 20:06:53 kem Exp $ */ /* $XdotOrg: xc/programs/Xserver/dix/main.c,v 1.4 2004/09/18 23:18:35 gisburn Exp $ */
/* $XFree86: xc/programs/Xserver/dix/main.c,v 3.43 2003/10/30 21:21:02 herrb Exp $ */ /* $XFree86: xc/programs/Xserver/dix/main.c,v 3.43 2003/10/30 21:21:02 herrb Exp $ */
/*********************************************************** /***********************************************************
@ -113,13 +113,9 @@ Equipment Corporation.
#include "dpmsproc.h" #include "dpmsproc.h"
#endif #endif
extern int InitClientPrivates( extern int InitClientPrivates(ClientPtr client);
ClientPtr /*client*/
);
extern void Dispatch( extern void Dispatch(void);
void
);
char *ConnectionInfo; char *ConnectionInfo;
xConnSetupPrefix connSetupPrefix; xConnSetupPrefix connSetupPrefix;
@ -152,7 +148,7 @@ NotImplemented(xEvent *from, xEvent *to)
/* /*
* Dummy entry for ReplySwapVector[] * Dummy entry for ReplySwapVector[]
*/ */
/*ARGSUSED*/
void void
ReplyNotSwappd( ReplyNotSwappd(
ClientPtr pClient , ClientPtr pClient ,
@ -780,8 +776,7 @@ AddScreen(
} }
static void static void
FreeScreen(pScreen) FreeScreen(ScreenPtr pScreen)
ScreenPtr pScreen;
{ {
xfree(pScreen->WindowPrivateSizes); xfree(pScreen->WindowPrivateSizes);
xfree(pScreen->GCPrivateSizes); xfree(pScreen->GCPrivateSizes);

24
dix/pixmap.c
View File

@ -48,15 +48,8 @@ from The Open Group.
/* callable by ddx */ /* callable by ddx */
PixmapPtr PixmapPtr
GetScratchPixmapHeader(pScreen, width, height, depth, bitsPerPixel, devKind, GetScratchPixmapHeader(ScreenPtr pScreen, int width, int height, int depth,
pPixData) int bitsPerPixel, int devKind, pointer pPixData)
ScreenPtr pScreen;
int width;
int height;
int depth;
int bitsPerPixel;
int devKind;
pointer pPixData;
{ {
PixmapPtr pPixmap = pScreen->pScratchPixmap; PixmapPtr pPixmap = pScreen->pScratchPixmap;
@ -78,8 +71,7 @@ GetScratchPixmapHeader(pScreen, width, height, depth, bitsPerPixel, devKind,
/* callable by ddx */ /* callable by ddx */
void void
FreeScratchPixmapHeader(pPixmap) FreeScratchPixmapHeader(PixmapPtr pPixmap)
PixmapPtr pPixmap;
{ {
if (pPixmap) if (pPixmap)
{ {
@ -95,8 +87,7 @@ FreeScratchPixmapHeader(pPixmap)
Bool Bool
CreateScratchPixmapsForScreen(scrnum) CreateScratchPixmapsForScreen(int scrnum)
int scrnum;
{ {
/* let it be created on first use */ /* let it be created on first use */
screenInfo.screens[scrnum]->pScratchPixmap = NULL; screenInfo.screens[scrnum]->pScratchPixmap = NULL;
@ -105,8 +96,7 @@ CreateScratchPixmapsForScreen(scrnum)
void void
FreeScratchPixmapsForScreen(scrnum) FreeScratchPixmapsForScreen(int scrnum)
int scrnum;
{ {
FreeScratchPixmapHeader(screenInfo.screens[scrnum]->pScratchPixmap); FreeScratchPixmapHeader(screenInfo.screens[scrnum]->pScratchPixmap);
} }
@ -114,9 +104,7 @@ FreeScratchPixmapsForScreen(scrnum)
/* callable by ddx */ /* callable by ddx */
PixmapPtr PixmapPtr
AllocatePixmap(pScreen, pixDataSize) AllocatePixmap(ScreenPtr pScreen, int pixDataSize)
ScreenPtr pScreen;
int pixDataSize;
{ {
PixmapPtr pPixmap; PixmapPtr pPixmap;
#ifdef PIXPRIV #ifdef PIXPRIV

24
dix/privates.c
View File

@ -73,9 +73,7 @@ AllocateClientPrivateIndex()
} }
Bool Bool
AllocateClientPrivate(index2, amount) AllocateClientPrivate(int index2, unsigned amount)
int index2;
unsigned amount;
{ {
unsigned oldamount; unsigned oldamount;
@ -166,10 +164,7 @@ AllocateWindowPrivateIndex()
} }
Bool Bool
AllocateWindowPrivate(pScreen, index2, amount) AllocateWindowPrivate(register ScreenPtr pScreen, int index2, unsigned amount)
register ScreenPtr pScreen;
int index2;
unsigned amount;
{ {
unsigned oldamount; unsigned oldamount;
@ -219,10 +214,7 @@ AllocateGCPrivateIndex()
} }
Bool Bool
AllocateGCPrivate(pScreen, index2, amount) AllocateGCPrivate(register ScreenPtr pScreen, int index2, unsigned amount)
register ScreenPtr pScreen;
int index2;
unsigned amount;
{ {
unsigned oldamount; unsigned oldamount;
@ -272,10 +264,7 @@ AllocatePixmapPrivateIndex()
} }
Bool Bool
AllocatePixmapPrivate(pScreen, index2, amount) AllocatePixmapPrivate(register ScreenPtr pScreen, int index2, unsigned amount)
register ScreenPtr pScreen;
int index2;
unsigned amount;
{ {
unsigned oldamount; unsigned oldamount;
@ -322,10 +311,7 @@ ResetColormapPrivates()
int int
AllocateColormapPrivateIndex (initPrivFunc) AllocateColormapPrivateIndex (InitCmapPrivFunc initPrivFunc)
InitCmapPrivFunc initPrivFunc;
{ {
int index; int index;
int i; int i;

35
dix/property.c
View File

@ -87,8 +87,7 @@ int fWriteToClient(ClientPtr client, int len, char *buf)
#ifdef notdef #ifdef notdef
static void static void
PrintPropertys(pWin) PrintPropertys(WindowPtr pWin)
WindowPtr pWin;
{ {
PropertyPtr pProp; PropertyPtr pProp;
register int j; register int j;
@ -107,8 +106,7 @@ PrintPropertys(pWin)
#endif #endif
int int
ProcRotateProperties(client) ProcRotateProperties(ClientPtr client)
ClientPtr client;
{ {
int i, j, delta; int i, j, delta;
REQUEST(xRotatePropertiesReq); REQUEST(xRotatePropertiesReq);
@ -200,8 +198,7 @@ found:
} }
int int
ProcChangeProperty(client) ProcChangeProperty(ClientPtr client)
ClientPtr client;
{ {
WindowPtr pWin; WindowPtr pWin;
char format, mode; char format, mode;
@ -274,13 +271,9 @@ ProcChangeProperty(client)
} }
int int
ChangeWindowProperty(pWin, property, type, format, mode, len, value, sendevent) ChangeWindowProperty(WindowPtr pWin, Atom property, Atom type, int format,
WindowPtr pWin; int mode, unsigned long len, pointer value,
Atom property, type; Bool sendevent)
int format, mode;
unsigned long len;
pointer value;
Bool sendevent;
{ {
#ifdef LBX #ifdef LBX
return LbxChangeWindowProperty(NULL, pWin, property, type, return LbxChangeWindowProperty(NULL, pWin, property, type,
@ -397,9 +390,7 @@ ChangeWindowProperty(pWin, property, type, format, mode, len, value, sendevent)
} }
int int
DeleteProperty(pWin, propName) DeleteProperty(WindowPtr pWin, Atom propName)
WindowPtr pWin;
Atom propName;
{ {
PropertyPtr pProp, prevProp; PropertyPtr pProp, prevProp;
xEvent event; xEvent event;
@ -442,8 +433,7 @@ DeleteProperty(pWin, propName)
} }
void void
DeleteAllWindowProperties(pWin) DeleteAllWindowProperties(WindowPtr pWin)
WindowPtr pWin;
{ {
PropertyPtr pProp, pNextProp; PropertyPtr pProp, pNextProp;
xEvent event; xEvent event;
@ -495,8 +485,7 @@ NullPropertyReply(
*****************/ *****************/
int int
ProcGetProperty(client) ProcGetProperty(ClientPtr client)
ClientPtr client;
{ {
PropertyPtr pProp, prevProp; PropertyPtr pProp, prevProp;
unsigned long n, len, ind; unsigned long n, len, ind;
@ -651,8 +640,7 @@ ProcGetProperty(client)
} }
int int
ProcListProperties(client) ProcListProperties(ClientPtr client)
ClientPtr client;
{ {
Atom *pAtoms = NULL, *temppAtoms; Atom *pAtoms = NULL, *temppAtoms;
xListPropertiesReply xlpr; xListPropertiesReply xlpr;
@ -699,8 +687,7 @@ ProcListProperties(client)
} }
int int
ProcDeleteProperty(client) ProcDeleteProperty(register ClientPtr client)
register ClientPtr client;
{ {
WindowPtr pWin; WindowPtr pWin;
REQUEST(xDeletePropertyReq); REQUEST(xDeletePropertyReq);

81
dix/resource.c
View File

@ -74,7 +74,7 @@ Equipment Corporation.
******************************************************************/ ******************************************************************/
/* $Xorg: resource.c,v 1.5 2001/02/09 02:04:40 xorgcvs Exp $ */ /* $Xorg: resource.c,v 1.5 2001/02/09 02:04:40 xorgcvs Exp $ */
/* $XdotOrg: xc/programs/Xserver/dix/resource.c,v 1.2 2004/04/23 19:04:44 eich Exp $ */ /* $XdotOrg: xc/programs/Xserver/dix/resource.c,v 1.3 2004/04/25 22:42:09 gisburn Exp $ */
/* $TOG: resource.c /main/41 1998/02/09 14:20:31 kaleb $ */ /* $TOG: resource.c /main/41 1998/02/09 14:20:31 kaleb $ */
/* Routines to manage various kinds of resources: /* Routines to manage various kinds of resources:
@ -167,8 +167,7 @@ void RegisterResourceName (RESTYPE type, char *name)
#endif #endif
RESTYPE RESTYPE
CreateNewResourceType(deleteFunc) CreateNewResourceType(DeleteType deleteFunc)
DeleteType deleteFunc;
{ {
RESTYPE next = lastResourceType + 1; RESTYPE next = lastResourceType + 1;
DeleteType *funcs; DeleteType *funcs;
@ -218,8 +217,7 @@ ClientResourceRec clientTable[MAXCLIENTS];
*****************/ *****************/
Bool Bool
InitClientResources(client) InitClientResources(ClientPtr client)
ClientPtr client;
{ {
register int i, j; register int i, j;
@ -322,10 +320,7 @@ AvailableID(
} }
void void
GetXIDRange(client, server, minp, maxp) GetXIDRange(int client, Bool server, XID *minp, XID *maxp)
int client;
Bool server;
XID *minp, *maxp;
{ {
register XID id, maxid; register XID id, maxid;
register ResourcePtr *resp; register ResourcePtr *resp;
@ -359,7 +354,8 @@ GetXIDRange(client, server, minp, maxp)
*maxp = maxid; *maxp = maxid;
} }
/* GetXIDList is called by the XC-MISC extension's MiscGetXIDList function. /**
* GetXIDList is called by the XC-MISC extension's MiscGetXIDList function.
* This function tries to find count unused XIDs for the given client. It * This function tries to find count unused XIDs for the given client. It
* puts the IDs in the array pids and returns the number found, which should * puts the IDs in the array pids and returns the number found, which should
* almost always be the number requested. * almost always be the number requested.
@ -375,10 +371,7 @@ GetXIDRange(client, server, minp, maxp)
*/ */
unsigned int unsigned int
GetXIDList(pClient, count, pids) GetXIDList(ClientPtr pClient, unsigned count, XID *pids)
ClientPtr pClient;
unsigned int count;
XID *pids;
{ {
unsigned int found = 0; unsigned int found = 0;
XID id = pClient->clientAsMask; XID id = pClient->clientAsMask;
@ -405,8 +398,7 @@ GetXIDList(pClient, count, pids)
*/ */
XID XID
FakeClientID(client) FakeClientID(register int client)
register int client;
{ {
XID id, maxid; XID id, maxid;
@ -427,10 +419,7 @@ FakeClientID(client)
} }
Bool Bool
AddResource(id, type, value) AddResource(XID id, RESTYPE type, pointer value)
XID id;
RESTYPE type;
pointer value;
{ {
int client; int client;
register ClientResourceRec *rrec; register ClientResourceRec *rrec;
@ -466,8 +455,7 @@ AddResource(id, type, value)
} }
static void static void
RebuildTable(client) RebuildTable(int client)
int client;
{ {
register int j; register int j;
register ResourcePtr res, next; register ResourcePtr res, next;
@ -516,9 +504,7 @@ RebuildTable(client)
} }
void void
FreeResource(id, skipDeleteFuncType) FreeResource(XID id, RESTYPE skipDeleteFuncType)
XID id;
RESTYPE skipDeleteFuncType;
{ {
int cid; int cid;
register ResourcePtr res; register ResourcePtr res;
@ -565,10 +551,7 @@ FreeResource(id, skipDeleteFuncType)
void void
FreeResourceByType(id, type, skipFree) FreeResourceByType(XID id, RESTYPE type, Bool skipFree)
XID id;
RESTYPE type;
Bool skipFree;
{ {
int cid; int cid;
register ResourcePtr res; register ResourcePtr res;
@ -608,10 +591,7 @@ FreeResourceByType(id, type, skipFree)
*/ */
Bool Bool
ChangeResourceValue (id, rtype, value) ChangeResourceValue (XID id, RESTYPE rtype, pointer value)
XID id;
RESTYPE rtype;
pointer value;
{ {
int cid; int cid;
register ResourcePtr res; register ResourcePtr res;
@ -760,8 +740,7 @@ FreeClientNeverRetainResources(ClientPtr client)
} }
void void
FreeClientResources(client) FreeClientResources(ClientPtr client)
ClientPtr client;
{ {
register ResourcePtr *resources; register ResourcePtr *resources;
register ResourcePtr this; register ResourcePtr this;
@ -819,9 +798,7 @@ FreeAllResources()
} }
Bool Bool
LegalNewID(id, client) LegalNewID(XID id, register ClientPtr client)
XID id;
register ClientPtr client;
{ {
#ifdef PANORAMIX #ifdef PANORAMIX
@ -851,11 +828,7 @@ LegalNewID(id, client)
*/ */
pointer pointer
SecurityLookupIDByType(client, id, rtype, mode) SecurityLookupIDByType(ClientPtr client, XID id, RESTYPE rtype, Mask mode)
ClientPtr client;
XID id;
RESTYPE rtype;
Mask mode;
{ {
int cid; int cid;
register ResourcePtr res; register ResourcePtr res;
@ -884,11 +857,7 @@ SecurityLookupIDByType(client, id, rtype, mode)
pointer pointer
SecurityLookupIDByClass(client, id, classes, mode) SecurityLookupIDByClass(ClientPtr client, XID id, RESTYPE classes, Mask mode)
ClientPtr client;
XID id;
RESTYPE classes;
Mask mode;
{ {
int cid; int cid;
register ResourcePtr res = NULL; register ResourcePtr res = NULL;
@ -920,18 +889,14 @@ SecurityLookupIDByClass(client, id, classes, mode)
*/ */
pointer pointer
LookupIDByType(id, rtype) LookupIDByType(XID id, RESTYPE rtype)
XID id;
RESTYPE rtype;
{ {
return SecurityLookupIDByType(NullClient, id, rtype, return SecurityLookupIDByType(NullClient, id, rtype,
SecurityUnknownAccess); SecurityUnknownAccess);
} }
pointer pointer
LookupIDByClass(id, classes) LookupIDByClass(XID id, RESTYPE classes)
XID id;
RESTYPE classes;
{ {
return SecurityLookupIDByClass(NullClient, id, classes, return SecurityLookupIDByClass(NullClient, id, classes,
SecurityUnknownAccess); SecurityUnknownAccess);
@ -943,9 +908,7 @@ LookupIDByClass(id, classes)
* LookupIDByType returns the object with the given id and type, else NULL. * LookupIDByType returns the object with the given id and type, else NULL.
*/ */
pointer pointer
LookupIDByType(id, rtype) LookupIDByType(XID id, RESTYPE rtype)
XID id;
RESTYPE rtype;
{ {
int cid; int cid;
register ResourcePtr res; register ResourcePtr res;
@ -967,9 +930,7 @@ LookupIDByType(id, rtype)
* given classes, else NULL. * given classes, else NULL.
*/ */
pointer pointer
LookupIDByClass(id, classes) LookupIDByClass(XID id, RESTYPE classes)
XID id;
RESTYPE classes;
{ {
int cid; int cid;
register ResourcePtr res; register ResourcePtr res;

358
dix/swaprep.c
View File

@ -59,27 +59,21 @@ SOFTWARE.
#include "swaprep.h" #include "swaprep.h"
#include "globals.h" #include "globals.h"
static void SwapFontInfo( static void SwapFontInfo(xQueryFontReply *pr);
xQueryFontReply * /* pr */
);
#ifndef LBX #ifndef LBX
static void SwapCharInfo( static void SwapCharInfo(xCharInfo *pInfo);
xCharInfo * /* pInfo */
);
static void SwapFont( static void SwapFont(xQueryFontReply *pr, Bool hasGlyphs);
xQueryFontReply * /* pr */,
Bool /* hasGlyphs */
);
#endif #endif
/* Thanks to Jack Palevich for testing and subsequently rewriting all this */ /**
* Thanks to Jack Palevich for testing and subsequently rewriting all this
*
* \param size size in bytes
*/
void void
Swap32Write(pClient, size, pbuf) Swap32Write(ClientPtr pClient, int size, register CARD32 *pbuf)
ClientPtr pClient;
int size; /* in bytes */
register CARD32 *pbuf;
{ {
register int i; register int i;
register char n; register char n;
@ -94,11 +88,12 @@ Swap32Write(pClient, size, pbuf)
(void)WriteToClient(pClient, size << 2, (char *) pbuf); (void)WriteToClient(pClient, size << 2, (char *) pbuf);
} }
/**
*
* \param size size in bytes
*/
void void
CopySwap32Write(pClient, size, pbuf) CopySwap32Write(ClientPtr pClient, int size, CARD32 *pbuf)
ClientPtr pClient;
int size; /* in bytes */
CARD32 *pbuf;
{ {
int bufsize = size; int bufsize = size;
CARD32 *pbufT; CARD32 *pbufT;
@ -141,11 +136,12 @@ CopySwap32Write(pClient, size, pbuf)
DEALLOCATE_LOCAL ((char *) pbufT); DEALLOCATE_LOCAL ((char *) pbufT);
} }
/**
*
* \param size size in bytes
*/
void void
CopySwap16Write(pClient, size, pbuf) CopySwap16Write(ClientPtr pClient, int size, short *pbuf)
ClientPtr pClient;
int size; /* in bytes */
short *pbuf;
{ {
int bufsize = size; int bufsize = size;
short *pbufT; short *pbufT;
@ -191,10 +187,7 @@ CopySwap16Write(pClient, size, pbuf)
/* Extra-small reply */ /* Extra-small reply */
void void
SGenericReply(pClient, size, pRep) SGenericReply(ClientPtr pClient, int size, xGenericReply *pRep)
ClientPtr pClient;
int size;
xGenericReply *pRep;
{ {
register char n; register char n;
@ -204,10 +197,8 @@ SGenericReply(pClient, size, pRep)
/* Extra-large reply */ /* Extra-large reply */
void void
SGetWindowAttributesReply(pClient, size, pRep) SGetWindowAttributesReply(ClientPtr pClient, int size,
ClientPtr pClient; xGetWindowAttributesReply *pRep)
int size;
xGetWindowAttributesReply *pRep;
{ {
register char n; register char n;
@ -225,10 +216,7 @@ SGetWindowAttributesReply(pClient, size, pRep)
} }
void void
SGetGeometryReply(pClient, size, pRep) SGetGeometryReply(ClientPtr pClient, int size, xGetGeometryReply *pRep)
ClientPtr pClient;
int size;
xGetGeometryReply *pRep;
{ {
register char n; register char n;
@ -243,10 +231,7 @@ SGetGeometryReply(pClient, size, pRep)
} }
void void
SQueryTreeReply(pClient, size, pRep) SQueryTreeReply(ClientPtr pClient, int size, xQueryTreeReply *pRep)
ClientPtr pClient;
int size;
xQueryTreeReply *pRep;
{ {
register char n; register char n;
@ -259,10 +244,7 @@ SQueryTreeReply(pClient, size, pRep)
} }
void void
SInternAtomReply(pClient, size, pRep) SInternAtomReply(ClientPtr pClient, int size, xInternAtomReply *pRep)
ClientPtr pClient;
int size;
xInternAtomReply *pRep;
{ {
register char n; register char n;
@ -272,10 +254,7 @@ SInternAtomReply(pClient, size, pRep)
} }
void void
SGetAtomNameReply(pClient, size, pRep) SGetAtomNameReply(ClientPtr pClient, int size, xGetAtomNameReply *pRep)
ClientPtr pClient;
int size;
xGetAtomNameReply *pRep;
{ {
register char n; register char n;
@ -287,10 +266,7 @@ SGetAtomNameReply(pClient, size, pRep)
void void
SGetPropertyReply(pClient, size, pRep) SGetPropertyReply(ClientPtr pClient, int size, xGetPropertyReply *pRep)
ClientPtr pClient;
int size;
xGetPropertyReply *pRep;
{ {
register char n; register char n;
@ -303,10 +279,7 @@ SGetPropertyReply(pClient, size, pRep)
} }
void void
SListPropertiesReply(pClient, size, pRep) SListPropertiesReply(ClientPtr pClient, int size, xListPropertiesReply *pRep)
ClientPtr pClient;
int size;
xListPropertiesReply *pRep;
{ {
register char n; register char n;
@ -317,10 +290,8 @@ SListPropertiesReply(pClient, size, pRep)
} }
void void
SGetSelectionOwnerReply(pClient, size, pRep) SGetSelectionOwnerReply(ClientPtr pClient, int size,
ClientPtr pClient; xGetSelectionOwnerReply *pRep)
int size;
xGetSelectionOwnerReply *pRep;
{ {
register char n; register char n;
@ -331,10 +302,7 @@ SGetSelectionOwnerReply(pClient, size, pRep)
void void
SQueryPointerReply(pClient, size, pRep) SQueryPointerReply(ClientPtr pClient, int size, xQueryPointerReply *pRep)
ClientPtr pClient;
int size;
xQueryPointerReply *pRep;
{ {
register char n; register char n;
@ -350,8 +318,7 @@ SQueryPointerReply(pClient, size, pRep)
} }
void void
SwapTimecoord(pCoord) SwapTimecoord(xTimecoord* pCoord)
xTimecoord *pCoord;
{ {
register char n; register char n;
@ -361,10 +328,7 @@ SwapTimecoord(pCoord)
} }
void void
SwapTimeCoordWrite(pClient, size, pRep) SwapTimeCoordWrite(ClientPtr pClient, int size, xTimecoord *pRep)
ClientPtr pClient;
int size;
xTimecoord *pRep;
{ {
int i, n; int i, n;
xTimecoord *pRepT; xTimecoord *pRepT;
@ -380,10 +344,7 @@ SwapTimeCoordWrite(pClient, size, pRep)
} }
void void
SGetMotionEventsReply(pClient, size, pRep) SGetMotionEventsReply(ClientPtr pClient, int size, xGetMotionEventsReply *pRep)
ClientPtr pClient;
int size;
xGetMotionEventsReply *pRep;
{ {
register char n; register char n;
@ -394,10 +355,7 @@ SGetMotionEventsReply(pClient, size, pRep)
} }
void void
STranslateCoordsReply(pClient, size, pRep) STranslateCoordsReply(ClientPtr pClient, int size, xTranslateCoordsReply *pRep)
ClientPtr pClient;
int size;
xTranslateCoordsReply *pRep;
{ {
register char n; register char n;
@ -409,10 +367,7 @@ STranslateCoordsReply(pClient, size, pRep)
} }
void void
SGetInputFocusReply(pClient, size, pRep) SGetInputFocusReply(ClientPtr pClient, int size, xGetInputFocusReply *pRep)
ClientPtr pClient;
int size;
xGetInputFocusReply *pRep;
{ {
register char n; register char n;
@ -423,10 +378,7 @@ SGetInputFocusReply(pClient, size, pRep)
/* extra long reply */ /* extra long reply */
void void
SQueryKeymapReply(pClient, size, pRep) SQueryKeymapReply(ClientPtr pClient, int size, xQueryKeymapReply *pRep)
ClientPtr pClient;
int size;
xQueryKeymapReply *pRep;
{ {
register char n; register char n;
@ -439,8 +391,7 @@ SQueryKeymapReply(pClient, size, pRep)
static static
#endif #endif
void void
SwapCharInfo(pInfo) SwapCharInfo(xCharInfo *pInfo)
xCharInfo *pInfo;
{ {
register char n; register char n;
@ -453,8 +404,7 @@ SwapCharInfo(pInfo)
} }
static void static void
SwapFontInfo(pr) SwapFontInfo(xQueryFontReply *pr)
xQueryFontReply *pr;
{ {
register char n; register char n;
@ -473,9 +423,7 @@ SwapFontInfo(pr)
static static
#endif #endif
void void
SwapFont( pr, hasGlyphs) SwapFont(xQueryFontReply *pr, Bool hasGlyphs)
xQueryFontReply * pr;
Bool hasGlyphs;
{ {
unsigned i; unsigned i;
xCharInfo * pxci; xCharInfo * pxci;
@ -507,20 +455,14 @@ SwapFont( pr, hasGlyphs)
} }
void void
SQueryFontReply(pClient, size, pRep) SQueryFontReply(ClientPtr pClient, int size, xQueryFontReply *pRep)
ClientPtr pClient;
int size;
xQueryFontReply *pRep;
{ {
SwapFont(pRep, TRUE); SwapFont(pRep, TRUE);
(void)WriteToClient(pClient, size, (char *) pRep); (void)WriteToClient(pClient, size, (char *) pRep);
} }
void void
SQueryTextExtentsReply(pClient, size, pRep) SQueryTextExtentsReply(ClientPtr pClient, int size, xQueryTextExtentsReply *pRep)
ClientPtr pClient;
int size;
xQueryTextExtentsReply *pRep;
{ {
register char n; register char n;
@ -536,10 +478,7 @@ SQueryTextExtentsReply(pClient, size, pRep)
} }
void void
SListFontsReply(pClient, size, pRep) SListFontsReply(ClientPtr pClient, int size, xListFontsReply *pRep)
ClientPtr pClient;
int size;
xListFontsReply *pRep;
{ {
register char n; register char n;
@ -550,20 +489,15 @@ SListFontsReply(pClient, size, pRep)
} }
void void
SListFontsWithInfoReply(pClient, size, pRep) SListFontsWithInfoReply(ClientPtr pClient, int size,
ClientPtr pClient; xListFontsWithInfoReply *pRep)
int size;
xListFontsWithInfoReply *pRep;
{ {
SwapFont((xQueryFontReply *)pRep, FALSE); SwapFont((xQueryFontReply *)pRep, FALSE);
(void)WriteToClient(pClient, size, (char *) pRep); (void)WriteToClient(pClient, size, (char *) pRep);
} }
void void
SGetFontPathReply(pClient, size, pRep) SGetFontPathReply(ClientPtr pClient, int size, xGetFontPathReply *pRep)
ClientPtr pClient;
int size;
xGetFontPathReply *pRep;
{ {
register char n; register char n;
@ -574,10 +508,7 @@ SGetFontPathReply(pClient, size, pRep)
} }
void void
SGetImageReply(pClient, size, pRep) SGetImageReply(ClientPtr pClient, int size, xGetImageReply *pRep)
ClientPtr pClient;
int size;
xGetImageReply *pRep;
{ {
register char n; register char n;
@ -589,10 +520,8 @@ SGetImageReply(pClient, size, pRep)
} }
void void
SListInstalledColormapsReply(pClient, size, pRep) SListInstalledColormapsReply(ClientPtr pClient, int size,
ClientPtr pClient; xListInstalledColormapsReply *pRep)
int size;
xListInstalledColormapsReply *pRep;
{ {
register char n; register char n;
@ -619,10 +548,7 @@ SAllocColorReply(pClient, size, pRep)
} }
void void
SAllocNamedColorReply(pClient, size, pRep) SAllocNamedColorReply(ClientPtr pClient, int size, xAllocNamedColorReply *pRep)
ClientPtr pClient;
int size;
xAllocNamedColorReply *pRep;
{ {
register char n; register char n;
@ -638,10 +564,7 @@ SAllocNamedColorReply(pClient, size, pRep)
} }
void void
SAllocColorCellsReply(pClient, size, pRep) SAllocColorCellsReply(ClientPtr pClient, int size, xAllocColorCellsReply *pRep)
ClientPtr pClient;
int size;
xAllocColorCellsReply *pRep;
{ {
register char n; register char n;
@ -654,10 +577,7 @@ SAllocColorCellsReply(pClient, size, pRep)
void void
SAllocColorPlanesReply(pClient, size, pRep) SAllocColorPlanesReply(ClientPtr pClient, int size, xAllocColorPlanesReply *pRep)
ClientPtr pClient;
int size;
xAllocColorPlanesReply *pRep;
{ {
register char n; register char n;
@ -671,8 +591,7 @@ SAllocColorPlanesReply(pClient, size, pRep)
} }
void void
SwapRGB(prgb) SwapRGB(xrgb *prgb)
xrgb *prgb;
{ {
register char n; register char n;
@ -682,10 +601,7 @@ SwapRGB(prgb)
} }
void void
SQColorsExtend(pClient, size, prgb) SQColorsExtend(ClientPtr pClient, int size, xrgb *prgb)
ClientPtr pClient;
int size;
xrgb *prgb;
{ {
int i, n; int i, n;
xrgb *prgbT; xrgb *prgbT;
@ -701,10 +617,7 @@ SQColorsExtend(pClient, size, prgb)
} }
void void
SQueryColorsReply(pClient, size, pRep) SQueryColorsReply(ClientPtr pClient, int size, xQueryColorsReply* pRep)
ClientPtr pClient;
int size;
xQueryColorsReply *pRep;
{ {
register char n; register char n;
@ -715,10 +628,7 @@ SQueryColorsReply(pClient, size, pRep)
} }
void void
SLookupColorReply(pClient, size, pRep) SLookupColorReply(ClientPtr pClient, int size, xLookupColorReply *pRep)
ClientPtr pClient;
int size;
xLookupColorReply *pRep;
{ {
register char n; register char n;
@ -733,10 +643,7 @@ SLookupColorReply(pClient, size, pRep)
} }
void void
SQueryBestSizeReply(pClient, size, pRep) SQueryBestSizeReply(ClientPtr pClient, int size, xQueryBestSizeReply *pRep)
ClientPtr pClient;
int size;
xQueryBestSizeReply *pRep;
{ {
register char n; register char n;
@ -747,10 +654,7 @@ SQueryBestSizeReply(pClient, size, pRep)
} }
void void
SListExtensionsReply(pClient, size, pRep) SListExtensionsReply(ClientPtr pClient, int size, xListExtensionsReply *pRep)
ClientPtr pClient;
int size;
xListExtensionsReply *pRep;
{ {
register char n; register char n;
@ -760,10 +664,8 @@ SListExtensionsReply(pClient, size, pRep)
} }
void void
SGetKeyboardMappingReply(pClient, size, pRep) SGetKeyboardMappingReply(ClientPtr pClient, int size,
ClientPtr pClient; xGetKeyboardMappingReply *pRep)
int size;
xGetKeyboardMappingReply *pRep;
{ {
register char n; register char n;
@ -773,10 +675,8 @@ SGetKeyboardMappingReply(pClient, size, pRep)
} }
void void
SGetPointerMappingReply(pClient, size, pRep) SGetPointerMappingReply(ClientPtr pClient, int size,
ClientPtr pClient; xGetPointerMappingReply *pRep)
int size;
xGetPointerMappingReply *pRep;
{ {
register char n; register char n;
@ -786,10 +686,8 @@ SGetPointerMappingReply(pClient, size, pRep)
} }
void void
SGetModifierMappingReply(pClient, size, pRep) SGetModifierMappingReply(ClientPtr pClient, int size,
ClientPtr pClient; xGetModifierMappingReply *pRep)
int size;
xGetModifierMappingReply *pRep;
{ {
register char n; register char n;
@ -799,10 +697,7 @@ SGetModifierMappingReply(pClient, size, pRep)
} }
void void
SGetKeyboardControlReply(pClient, size, pRep) SGetKeyboardControlReply(ClientPtr pClient, int size, xGetKeyboardControlReply *pRep)
ClientPtr pClient;
int size;
xGetKeyboardControlReply *pRep;
{ {
register char n; register char n;
@ -815,10 +710,7 @@ SGetKeyboardControlReply(pClient, size, pRep)
} }
void void
SGetPointerControlReply(pClient, size, pRep) SGetPointerControlReply(ClientPtr pClient, int size, xGetPointerControlReply *pRep)
ClientPtr pClient;
int size;
xGetPointerControlReply *pRep;
{ {
register char n; register char n;
@ -830,10 +722,7 @@ SGetPointerControlReply(pClient, size, pRep)
} }
void void
SGetScreenSaverReply(pClient, size, pRep) SGetScreenSaverReply(ClientPtr pClient, int size, xGetScreenSaverReply *pRep)
ClientPtr pClient;
int size;
xGetScreenSaverReply *pRep;
{ {
register char n; register char n;
@ -844,10 +733,7 @@ SGetScreenSaverReply(pClient, size, pRep)
} }
void void
SLHostsExtend(pClient, size, buf) SLHostsExtend(ClientPtr pClient, int size, char *buf)
ClientPtr pClient;
int size;
char *buf;
{ {
char *bufT = buf; char *bufT = buf;
char *endbuf = buf + size; char *endbuf = buf + size;
@ -862,10 +748,7 @@ SLHostsExtend(pClient, size, buf)
} }
void void
SListHostsReply(pClient, size, pRep) SListHostsReply(ClientPtr pClient, int size, xListHostsReply *pRep)
ClientPtr pClient;
int size;
xListHostsReply *pRep;
{ {
register char n; register char n;
@ -878,8 +761,7 @@ SListHostsReply(pClient, size, pRep)
void void
SErrorEvent(from, to) SErrorEvent(xError *from, xError *to)
xError *from, *to;
{ {
to->type = X_Error; to->type = X_Error;
to->errorCode = from->errorCode; to->errorCode = from->errorCode;
@ -890,8 +772,7 @@ SErrorEvent(from, to)
} }
void void
SKeyButtonPtrEvent(from, to) SKeyButtonPtrEvent(xEvent *from, xEvent *to)
xEvent *from, *to;
{ {
to->u.u.type = from->u.u.type; to->u.u.type = from->u.u.type;
to->u.u.detail = from->u.u.detail; to->u.u.detail = from->u.u.detail;
@ -919,8 +800,7 @@ SKeyButtonPtrEvent(from, to)
} }
void void
SEnterLeaveEvent(from, to) SEnterLeaveEvent(xEvent *from, xEvent *to)
xEvent *from, *to;
{ {
to->u.u.type = from->u.u.type; to->u.u.type = from->u.u.type;
to->u.u.detail = from->u.u.detail; to->u.u.detail = from->u.u.detail;
@ -939,8 +819,7 @@ SEnterLeaveEvent(from, to)
} }
void void
SFocusEvent(from, to) SFocusEvent(xEvent *from, xEvent *to)
xEvent *from, *to;
{ {
to->u.u.type = from->u.u.type; to->u.u.type = from->u.u.type;
to->u.u.detail = from->u.u.detail; to->u.u.detail = from->u.u.detail;
@ -950,8 +829,7 @@ SFocusEvent(from, to)
} }
void void
SExposeEvent(from, to) SExposeEvent(xEvent *from, xEvent *to)
xEvent *from, *to;
{ {
to->u.u.type = from->u.u.type; to->u.u.type = from->u.u.type;
cpswaps(from->u.u.sequenceNumber, to->u.u.sequenceNumber); cpswaps(from->u.u.sequenceNumber, to->u.u.sequenceNumber);
@ -964,8 +842,7 @@ SExposeEvent(from, to)
} }
void void
SGraphicsExposureEvent(from, to) SGraphicsExposureEvent(xEvent *from, xEvent *to)
xEvent *from, *to;
{ {
to->u.u.type = from->u.u.type; to->u.u.type = from->u.u.type;
cpswaps(from->u.u.sequenceNumber, to->u.u.sequenceNumber); cpswaps(from->u.u.sequenceNumber, to->u.u.sequenceNumber);
@ -988,8 +865,7 @@ SGraphicsExposureEvent(from, to)
} }
void void
SNoExposureEvent(from, to) SNoExposureEvent(xEvent *from, xEvent *to)
xEvent *from, *to;
{ {
to->u.u.type = from->u.u.type; to->u.u.type = from->u.u.type;
cpswaps(from->u.u.sequenceNumber, to->u.u.sequenceNumber); cpswaps(from->u.u.sequenceNumber, to->u.u.sequenceNumber);
@ -999,8 +875,7 @@ SNoExposureEvent(from, to)
} }
void void
SVisibilityEvent(from, to) SVisibilityEvent(xEvent *from, xEvent *to)
xEvent *from, *to;
{ {
to->u.u.type = from->u.u.type; to->u.u.type = from->u.u.type;
cpswaps(from->u.u.sequenceNumber, to->u.u.sequenceNumber); cpswaps(from->u.u.sequenceNumber, to->u.u.sequenceNumber);
@ -1009,8 +884,7 @@ SVisibilityEvent(from, to)
} }
void void
SCreateNotifyEvent(from, to) SCreateNotifyEvent(xEvent *from, xEvent *to)
xEvent *from, *to;
{ {
to->u.u.type = from->u.u.type; to->u.u.type = from->u.u.type;
cpswaps(from->u.u.sequenceNumber, to->u.u.sequenceNumber); cpswaps(from->u.u.sequenceNumber, to->u.u.sequenceNumber);
@ -1026,8 +900,7 @@ SCreateNotifyEvent(from, to)
} }
void void
SDestroyNotifyEvent(from, to) SDestroyNotifyEvent(xEvent *from, xEvent *to)
xEvent *from, *to;
{ {
to->u.u.type = from->u.u.type; to->u.u.type = from->u.u.type;
cpswaps(from->u.u.sequenceNumber, to->u.u.sequenceNumber); cpswaps(from->u.u.sequenceNumber, to->u.u.sequenceNumber);
@ -1036,8 +909,7 @@ SDestroyNotifyEvent(from, to)
} }
void void
SUnmapNotifyEvent(from, to) SUnmapNotifyEvent(xEvent *from, xEvent *to)
xEvent *from, *to;
{ {
to->u.u.type = from->u.u.type; to->u.u.type = from->u.u.type;
cpswaps(from->u.u.sequenceNumber, to->u.u.sequenceNumber); cpswaps(from->u.u.sequenceNumber, to->u.u.sequenceNumber);
@ -1047,8 +919,7 @@ SUnmapNotifyEvent(from, to)
} }
void void
SMapNotifyEvent(from, to) SMapNotifyEvent(xEvent *from, xEvent *to)
xEvent *from, *to;
{ {
to->u.u.type = from->u.u.type; to->u.u.type = from->u.u.type;
cpswaps(from->u.u.sequenceNumber, to->u.u.sequenceNumber); cpswaps(from->u.u.sequenceNumber, to->u.u.sequenceNumber);
@ -1058,8 +929,7 @@ SMapNotifyEvent(from, to)
} }
void void
SMapRequestEvent(from, to) SMapRequestEvent(xEvent *from, xEvent *to)
xEvent *from, *to;
{ {
to->u.u.type = from->u.u.type; to->u.u.type = from->u.u.type;
cpswaps(from->u.u.sequenceNumber, to->u.u.sequenceNumber); cpswaps(from->u.u.sequenceNumber, to->u.u.sequenceNumber);
@ -1068,8 +938,7 @@ SMapRequestEvent(from, to)
} }
void void
SReparentEvent(from, to) SReparentEvent(xEvent *from, xEvent *to)
xEvent *from, *to;
{ {
to->u.u.type = from->u.u.type; to->u.u.type = from->u.u.type;
cpswaps(from->u.u.sequenceNumber, to->u.u.sequenceNumber); cpswaps(from->u.u.sequenceNumber, to->u.u.sequenceNumber);
@ -1082,8 +951,7 @@ SReparentEvent(from, to)
} }
void void
SConfigureNotifyEvent(from, to) SConfigureNotifyEvent(xEvent *from, xEvent *to)
xEvent *from, *to;
{ {
to->u.u.type = from->u.u.type; to->u.u.type = from->u.u.type;
cpswaps(from->u.u.sequenceNumber, to->u.u.sequenceNumber); cpswaps(from->u.u.sequenceNumber, to->u.u.sequenceNumber);
@ -1104,8 +972,7 @@ SConfigureNotifyEvent(from, to)
} }
void void
SConfigureRequestEvent(from, to) SConfigureRequestEvent(xEvent *from, xEvent *to)
xEvent *from, *to;
{ {
to->u.u.type = from->u.u.type; to->u.u.type = from->u.u.type;
to->u.u.detail = from->u.u.detail; /* actually stack-mode */ to->u.u.detail = from->u.u.detail; /* actually stack-mode */
@ -1130,8 +997,7 @@ SConfigureRequestEvent(from, to)
void void
SGravityEvent(from, to) SGravityEvent(xEvent *from, xEvent *to)
xEvent *from, *to;
{ {
to->u.u.type = from->u.u.type; to->u.u.type = from->u.u.type;
cpswaps(from->u.u.sequenceNumber, to->u.u.sequenceNumber); cpswaps(from->u.u.sequenceNumber, to->u.u.sequenceNumber);
@ -1142,8 +1008,7 @@ SGravityEvent(from, to)
} }
void void
SResizeRequestEvent(from, to) SResizeRequestEvent(xEvent *from, xEvent *to)
xEvent *from, *to;
{ {
to->u.u.type = from->u.u.type; to->u.u.type = from->u.u.type;
cpswaps(from->u.u.sequenceNumber, to->u.u.sequenceNumber); cpswaps(from->u.u.sequenceNumber, to->u.u.sequenceNumber);
@ -1153,8 +1018,7 @@ SResizeRequestEvent(from, to)
} }
void void
SCirculateEvent(from, to) SCirculateEvent(xEvent *from, xEvent *to)
xEvent *from, *to;
{ {
to->u.u.type = from->u.u.type; to->u.u.type = from->u.u.type;
to->u.u.detail = from->u.u.detail; to->u.u.detail = from->u.u.detail;
@ -1166,8 +1030,7 @@ SCirculateEvent(from, to)
} }
void void
SPropertyEvent(from, to) SPropertyEvent(xEvent *from, xEvent *to)
xEvent *from, *to;
{ {
to->u.u.type = from->u.u.type; to->u.u.type = from->u.u.type;
cpswaps(from->u.u.sequenceNumber, to->u.u.sequenceNumber); cpswaps(from->u.u.sequenceNumber, to->u.u.sequenceNumber);
@ -1178,8 +1041,7 @@ SPropertyEvent(from, to)
} }
void void
SSelectionClearEvent(from, to) SSelectionClearEvent(xEvent *from, xEvent *to)
xEvent *from, *to;
{ {
to->u.u.type = from->u.u.type; to->u.u.type = from->u.u.type;
cpswaps(from->u.u.sequenceNumber, to->u.u.sequenceNumber); cpswaps(from->u.u.sequenceNumber, to->u.u.sequenceNumber);
@ -1189,8 +1051,7 @@ SSelectionClearEvent(from, to)
} }
void void
SSelectionRequestEvent(from, to) SSelectionRequestEvent(xEvent *from, xEvent *to)
xEvent *from, *to;
{ {
to->u.u.type = from->u.u.type; to->u.u.type = from->u.u.type;
cpswaps(from->u.u.sequenceNumber, to->u.u.sequenceNumber); cpswaps(from->u.u.sequenceNumber, to->u.u.sequenceNumber);
@ -1208,8 +1069,7 @@ SSelectionRequestEvent(from, to)
} }
void void
SSelectionNotifyEvent(from, to) SSelectionNotifyEvent(xEvent *from, xEvent *to)
xEvent *from, *to;
{ {
to->u.u.type = from->u.u.type; to->u.u.type = from->u.u.type;
cpswaps(from->u.u.sequenceNumber, to->u.u.sequenceNumber); cpswaps(from->u.u.sequenceNumber, to->u.u.sequenceNumber);
@ -1225,8 +1085,7 @@ SSelectionNotifyEvent(from, to)
} }
void void
SColormapEvent(from, to) SColormapEvent(xEvent *from, xEvent *to)
xEvent *from, *to;
{ {
to->u.u.type = from->u.u.type; to->u.u.type = from->u.u.type;
cpswaps(from->u.u.sequenceNumber, to->u.u.sequenceNumber); cpswaps(from->u.u.sequenceNumber, to->u.u.sequenceNumber);
@ -1237,8 +1096,7 @@ SColormapEvent(from, to)
} }
void void
SMappingEvent(from, to) SMappingEvent(xEvent *from, xEvent *to)
xEvent *from, *to;
{ {
to->u.u.type = from->u.u.type; to->u.u.type = from->u.u.type;
cpswaps(from->u.u.sequenceNumber, to->u.u.sequenceNumber); cpswaps(from->u.u.sequenceNumber, to->u.u.sequenceNumber);
@ -1249,8 +1107,7 @@ SMappingEvent(from, to)
} }
void void
SClientMessageEvent(from, to) SClientMessageEvent(xEvent *from, xEvent *to)
xEvent *from, *to;
{ {
to->u.u.type = from->u.u.type; to->u.u.type = from->u.u.type;
to->u.u.detail = from->u.u.detail; /* actually format */ to->u.u.detail = from->u.u.detail; /* actually format */
@ -1301,8 +1158,7 @@ SClientMessageEvent(from, to)
} }
void void
SKeymapNotifyEvent(from, to) SKeymapNotifyEvent(xEvent *from, xEvent *to)
xEvent *from, *to;
{ {
/* Keymap notify events are special; they have no /* Keymap notify events are special; they have no
sequence number field, and contain entirely 8-bit data */ sequence number field, and contain entirely 8-bit data */
@ -1362,10 +1218,7 @@ SwapConnSetupInfo(
void void
WriteSConnectionInfo(pClient, size, pInfo) WriteSConnectionInfo(ClientPtr pClient, unsigned long size, char *pInfo)
ClientPtr pClient;
unsigned long size;
char *pInfo;
{ {
char *pInfoTBase; char *pInfoTBase;
@ -1381,8 +1234,7 @@ WriteSConnectionInfo(pClient, size, pInfo)
} }
void void
SwapConnSetup(pConnSetup, pConnSetupT) SwapConnSetup(xConnSetup *pConnSetup, xConnSetup *pConnSetupT)
xConnSetup *pConnSetup, *pConnSetupT;
{ {
cpswapl(pConnSetup->release, pConnSetupT->release); cpswapl(pConnSetup->release, pConnSetupT->release);
cpswapl(pConnSetup->ridBase, pConnSetupT->ridBase); cpswapl(pConnSetup->ridBase, pConnSetupT->ridBase);
@ -1401,8 +1253,7 @@ SwapConnSetup(pConnSetup, pConnSetupT)
} }
void void
SwapWinRoot(pRoot, pRootT) SwapWinRoot(xWindowRoot *pRoot, xWindowRoot *pRootT)
xWindowRoot *pRoot, *pRootT;
{ {
cpswapl(pRoot->windowId, pRootT->windowId); cpswapl(pRoot->windowId, pRootT->windowId);
cpswapl(pRoot->defaultColormap, pRootT->defaultColormap); cpswapl(pRoot->defaultColormap, pRootT->defaultColormap);
@ -1423,8 +1274,7 @@ SwapWinRoot(pRoot, pRootT)
} }
void void
SwapVisual(pVis, pVisT) SwapVisual(xVisualType *pVis, xVisualType *pVisT)
xVisualType *pVis, *pVisT;
{ {
cpswapl(pVis->visualID, pVisT->visualID); cpswapl(pVis->visualID, pVisT->visualID);
pVisT->class = pVis->class; pVisT->class = pVis->class;
@ -1436,9 +1286,7 @@ SwapVisual(pVis, pVisT)
} }
void void
SwapConnSetupPrefix(pcspFrom, pcspTo) SwapConnSetupPrefix(xConnSetupPrefix *pcspFrom, xConnSetupPrefix *pcspTo)
xConnSetupPrefix *pcspFrom;
xConnSetupPrefix *pcspTo;
{ {
pcspTo->success = pcspFrom->success; pcspTo->success = pcspFrom->success;
pcspTo->lengthReason = pcspFrom->lengthReason; pcspTo->lengthReason = pcspFrom->lengthReason;
@ -1448,9 +1296,7 @@ SwapConnSetupPrefix(pcspFrom, pcspTo)
} }
void void
WriteSConnSetupPrefix(pClient, pcsp) WriteSConnSetupPrefix(ClientPtr pClient, xConnSetupPrefix *pcsp)
ClientPtr pClient;
xConnSetupPrefix *pcsp;
{ {
xConnSetupPrefix cspT; xConnSetupPrefix cspT;

213
dix/swapreq.c
View File

@ -62,9 +62,7 @@ SOFTWARE.
/* Byte swap a list of longs */ /* Byte swap a list of longs */
void void
SwapLongs (list, count) SwapLongs (register CARD32 *list, register unsigned long count)
register CARD32 *list;
register unsigned long count;
{ {
register char n; register char n;
@ -91,9 +89,7 @@ SwapLongs (list, count)
/* Byte swap a list of shorts */ /* Byte swap a list of shorts */
void void
SwapShorts (list, count) SwapShorts (register short *list, register unsigned long count)
register short *list;
register unsigned long count;
{ {
register char n; register char n;
@ -128,8 +124,7 @@ SwapShorts (list, count)
/* 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(register ClientPtr client)
register ClientPtr client;
{ {
register char n; register char n;
@ -142,8 +137,7 @@ SProcSimpleReq(client)
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(register ClientPtr client)
register ClientPtr client;
{ {
register char n; register char n;
@ -155,8 +149,7 @@ SProcResourceReq(client)
} }
int int
SProcCreateWindow(client) SProcCreateWindow(register ClientPtr client)
register ClientPtr client;
{ {
register char n; register char n;
@ -178,8 +171,7 @@ SProcCreateWindow(client)
} }
int int
SProcChangeWindowAttributes(client) SProcChangeWindowAttributes(register ClientPtr client)
register ClientPtr client;
{ {
register char n; register char n;
@ -193,8 +185,7 @@ SProcChangeWindowAttributes(client)
} }
int int
SProcReparentWindow(client) SProcReparentWindow(register ClientPtr client)
register ClientPtr client;
{ {
register char n; register char n;
REQUEST(xReparentWindowReq); REQUEST(xReparentWindowReq);
@ -208,8 +199,7 @@ SProcReparentWindow(client)
} }
int int
SProcConfigureWindow(client) SProcConfigureWindow(register ClientPtr client)
register ClientPtr client;
{ {
register char n; register char n;
REQUEST(xConfigureWindowReq); REQUEST(xConfigureWindowReq);
@ -224,8 +214,7 @@ SProcConfigureWindow(client)
int int
SProcInternAtom(client) SProcInternAtom(register ClientPtr client)
register ClientPtr client;
{ {
register char n; register char n;
REQUEST(xInternAtomReq); REQUEST(xInternAtomReq);
@ -236,8 +225,7 @@ SProcInternAtom(client)
} }
int int
SProcChangeProperty(client) SProcChangeProperty(register ClientPtr client)
register ClientPtr client;
{ {
register char n; register char n;
REQUEST(xChangePropertyReq); REQUEST(xChangePropertyReq);
@ -261,8 +249,7 @@ SProcChangeProperty(client)
} }
int int
SProcDeleteProperty(client) SProcDeleteProperty(register ClientPtr client)
register ClientPtr client;
{ {
register char n; register char n;
REQUEST(xDeletePropertyReq); REQUEST(xDeletePropertyReq);
@ -275,8 +262,7 @@ SProcDeleteProperty(client)
} }
int int
SProcGetProperty(client) SProcGetProperty(register ClientPtr client)
register ClientPtr client;
{ {
register char n; register char n;
REQUEST(xGetPropertyReq); REQUEST(xGetPropertyReq);
@ -291,8 +277,7 @@ SProcGetProperty(client)
} }
int int
SProcSetSelectionOwner(client) SProcSetSelectionOwner(register ClientPtr client)
register ClientPtr client;
{ {
register char n; register char n;
REQUEST(xSetSelectionOwnerReq); REQUEST(xSetSelectionOwnerReq);
@ -305,8 +290,7 @@ SProcSetSelectionOwner(client)
} }
int int
SProcConvertSelection(client) SProcConvertSelection(register ClientPtr client)
register ClientPtr client;
{ {
register char n; register char n;
REQUEST(xConvertSelectionReq); REQUEST(xConvertSelectionReq);
@ -321,8 +305,7 @@ SProcConvertSelection(client)
} }
int int
SProcSendEvent(client) SProcSendEvent(register ClientPtr client)
register ClientPtr client;
{ {
register char n; register char n;
xEvent eventT; xEvent eventT;
@ -344,8 +327,7 @@ SProcSendEvent(client)
} }
int int
SProcGrabPointer(client) SProcGrabPointer(register ClientPtr client)
register ClientPtr client;
{ {
register char n; register char n;
REQUEST(xGrabPointerReq); REQUEST(xGrabPointerReq);
@ -360,8 +342,7 @@ SProcGrabPointer(client)
} }
int int
SProcGrabButton(client) SProcGrabButton(register ClientPtr client)
register ClientPtr client;
{ {
register char n; register char n;
REQUEST(xGrabButtonReq); REQUEST(xGrabButtonReq);
@ -376,8 +357,7 @@ SProcGrabButton(client)
} }
int int
SProcUngrabButton(client) SProcUngrabButton(register ClientPtr client)
register ClientPtr client;
{ {
register char n; register char n;
REQUEST(xUngrabButtonReq); REQUEST(xUngrabButtonReq);
@ -389,8 +369,7 @@ SProcUngrabButton(client)
} }
int int
SProcChangeActivePointerGrab(client) SProcChangeActivePointerGrab(register ClientPtr client)
register ClientPtr client;
{ {
register char n; register char n;
REQUEST(xChangeActivePointerGrabReq); REQUEST(xChangeActivePointerGrabReq);
@ -403,8 +382,7 @@ SProcChangeActivePointerGrab(client)
} }
int int
SProcGrabKeyboard(client) SProcGrabKeyboard(register ClientPtr client)
register ClientPtr client;
{ {
register char n; register char n;
REQUEST(xGrabKeyboardReq); REQUEST(xGrabKeyboardReq);
@ -416,8 +394,7 @@ SProcGrabKeyboard(client)
} }
int int
SProcGrabKey(client) SProcGrabKey(register ClientPtr client)
register ClientPtr client;
{ {
register char n; register char n;
REQUEST(xGrabKeyReq); REQUEST(xGrabKeyReq);
@ -429,8 +406,7 @@ SProcGrabKey(client)
} }
int int
SProcUngrabKey(client) SProcUngrabKey(register ClientPtr client)
register ClientPtr client;
{ {
register char n; register char n;
REQUEST(xUngrabKeyReq); REQUEST(xUngrabKeyReq);
@ -442,8 +418,7 @@ SProcUngrabKey(client)
} }
int int
SProcGetMotionEvents(client) SProcGetMotionEvents(register ClientPtr client)
register ClientPtr client;
{ {
register char n; register char n;
REQUEST(xGetMotionEventsReq); REQUEST(xGetMotionEventsReq);
@ -456,8 +431,7 @@ SProcGetMotionEvents(client)
} }
int int
SProcTranslateCoords(client) SProcTranslateCoords(register ClientPtr client)
register ClientPtr client;
{ {
register char n; register char n;
REQUEST(xTranslateCoordsReq); REQUEST(xTranslateCoordsReq);
@ -471,8 +445,7 @@ SProcTranslateCoords(client)
} }
int int
SProcWarpPointer(client) SProcWarpPointer(register ClientPtr client)
register ClientPtr client;
{ {
register char n; register char n;
REQUEST(xWarpPointerReq); REQUEST(xWarpPointerReq);
@ -490,8 +463,7 @@ SProcWarpPointer(client)
} }
int int
SProcSetInputFocus(client) SProcSetInputFocus(register ClientPtr client)
register ClientPtr client;
{ {
register char n; register char n;
REQUEST(xSetInputFocusReq); REQUEST(xSetInputFocusReq);
@ -503,8 +475,7 @@ SProcSetInputFocus(client)
} }
int int
SProcOpenFont(client) SProcOpenFont(register ClientPtr client)
register ClientPtr client;
{ {
register char n; register char n;
REQUEST(xOpenFontReq); REQUEST(xOpenFontReq);
@ -516,8 +487,7 @@ SProcOpenFont(client)
} }
int int
SProcListFonts(client) SProcListFonts(register ClientPtr client)
register ClientPtr client;
{ {
register char n; register char n;
REQUEST(xListFontsReq); REQUEST(xListFontsReq);
@ -529,8 +499,7 @@ SProcListFonts(client)
} }
int int
SProcListFontsWithInfo(client) SProcListFontsWithInfo(register ClientPtr client)
register ClientPtr client;
{ {
register char n; register char n;
REQUEST(xListFontsWithInfoReq); REQUEST(xListFontsWithInfoReq);
@ -542,8 +511,7 @@ SProcListFontsWithInfo(client)
} }
int int
SProcSetFontPath(client) SProcSetFontPath(register ClientPtr client)
register ClientPtr client;
{ {
register char n; register char n;
REQUEST(xSetFontPathReq); REQUEST(xSetFontPathReq);
@ -554,8 +522,7 @@ SProcSetFontPath(client)
} }
int int
SProcCreatePixmap(client) SProcCreatePixmap(register ClientPtr client)
register ClientPtr client;
{ {
register char n; register char n;
REQUEST(xCreatePixmapReq); REQUEST(xCreatePixmapReq);
@ -570,8 +537,7 @@ SProcCreatePixmap(client)
} }
int int
SProcCreateGC(client) SProcCreateGC(register ClientPtr client)
register ClientPtr client;
{ {
register char n; register char n;
REQUEST(xCreateGCReq); REQUEST(xCreateGCReq);
@ -585,8 +551,7 @@ SProcCreateGC(client)
} }
int int
SProcChangeGC(client) SProcChangeGC(register ClientPtr client)
register ClientPtr client;
{ {
register char n; register char n;
REQUEST(xChangeGCReq); REQUEST(xChangeGCReq);
@ -599,8 +564,7 @@ SProcChangeGC(client)
} }
int int
SProcCopyGC(client) SProcCopyGC(register ClientPtr client)
register ClientPtr client;
{ {
register char n; register char n;
REQUEST(xCopyGCReq); REQUEST(xCopyGCReq);
@ -613,8 +577,7 @@ SProcCopyGC(client)
} }
int int
SProcSetDashes(client) SProcSetDashes(register ClientPtr client)
register ClientPtr client;
{ {
register char n; register char n;
REQUEST(xSetDashesReq); REQUEST(xSetDashesReq);
@ -628,8 +591,7 @@ SProcSetDashes(client)
} }
int int
SProcSetClipRectangles(client) SProcSetClipRectangles(register ClientPtr client)
register ClientPtr client;
{ {
register char n; register char n;
REQUEST(xSetClipRectanglesReq); REQUEST(xSetClipRectanglesReq);
@ -643,8 +605,7 @@ SProcSetClipRectangles(client)
} }
int int
SProcClearToBackground(client) SProcClearToBackground(register ClientPtr client)
register ClientPtr client;
{ {
register char n; register char n;
REQUEST(xClearAreaReq); REQUEST(xClearAreaReq);
@ -659,8 +620,7 @@ SProcClearToBackground(client)
} }
int int
SProcCopyArea(client) SProcCopyArea(register ClientPtr client)
register ClientPtr client;
{ {
register char n; register char n;
REQUEST(xCopyAreaReq); REQUEST(xCopyAreaReq);
@ -679,8 +639,7 @@ SProcCopyArea(client)
} }
int int
SProcCopyPlane(client) SProcCopyPlane(register ClientPtr client)
register ClientPtr client;
{ {
register char n; register char n;
REQUEST(xCopyPlaneReq); REQUEST(xCopyPlaneReq);
@ -702,8 +661,7 @@ SProcCopyPlane(client)
/* 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(register ClientPtr client)
register ClientPtr client;
{ {
register char n; register char n;
@ -720,8 +678,7 @@ SProcPoly(client)
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(register ClientPtr client)
register ClientPtr client;
{ {
register char n; register char n;
@ -735,8 +692,7 @@ SProcFillPoly(client)
} }
int int
SProcPutImage(client) SProcPutImage(register ClientPtr client)
register ClientPtr client;
{ {
register char n; register char n;
REQUEST(xPutImageReq); REQUEST(xPutImageReq);
@ -754,8 +710,7 @@ SProcPutImage(client)
} }
int int
SProcGetImage(client) SProcGetImage(register ClientPtr client)
register ClientPtr client;
{ {
register char n; register char n;
REQUEST(xGetImageReq); REQUEST(xGetImageReq);
@ -773,8 +728,7 @@ SProcGetImage(client)
/* ProcPolyText used for both PolyText8 and PolyText16 */ /* ProcPolyText used for both PolyText8 and PolyText16 */
int int
SProcPolyText(client) SProcPolyText(register ClientPtr client)
register ClientPtr client;
{ {
register char n; register char n;
REQUEST(xPolyTextReq); REQUEST(xPolyTextReq);
@ -790,8 +744,7 @@ SProcPolyText(client)
/* ProcImageText used for both ImageText8 and ImageText16 */ /* ProcImageText used for both ImageText8 and ImageText16 */
int int
SProcImageText(client) SProcImageText(register ClientPtr client)
register ClientPtr client;
{ {
register char n; register char n;
REQUEST(xImageTextReq); REQUEST(xImageTextReq);
@ -805,8 +758,7 @@ SProcImageText(client)
} }
int int
SProcCreateColormap(client) SProcCreateColormap(register ClientPtr client)
register ClientPtr client;
{ {
register char n; register char n;
REQUEST(xCreateColormapReq); REQUEST(xCreateColormapReq);
@ -820,8 +772,7 @@ SProcCreateColormap(client)
int int
SProcCopyColormapAndFree(client) SProcCopyColormapAndFree(register ClientPtr client)
register ClientPtr client;
{ {
register char n; register char n;
REQUEST(xCopyColormapAndFreeReq); REQUEST(xCopyColormapAndFreeReq);
@ -834,8 +785,7 @@ SProcCopyColormapAndFree(client)
} }
int int
SProcAllocColor (client) SProcAllocColor(register ClientPtr client)
register ClientPtr client;
{ {
register char n; register char n;
REQUEST(xAllocColorReq); REQUEST(xAllocColorReq);
@ -849,8 +799,7 @@ SProcAllocColor (client)
} }
int int
SProcAllocNamedColor (client) SProcAllocNamedColor(register ClientPtr client)
register ClientPtr client;
{ {
register char n; register char n;
@ -863,8 +812,7 @@ SProcAllocNamedColor (client)
} }
int int
SProcAllocColorCells (client) SProcAllocColorCells(register ClientPtr client)
register ClientPtr client;
{ {
register char n; register char n;
REQUEST(xAllocColorCellsReq); REQUEST(xAllocColorCellsReq);
@ -877,8 +825,7 @@ SProcAllocColorCells (client)
} }
int int
SProcAllocColorPlanes(client) SProcAllocColorPlanes(register ClientPtr client)
register ClientPtr client;
{ {
register char n; register char n;
REQUEST(xAllocColorPlanesReq); REQUEST(xAllocColorPlanesReq);
@ -893,8 +840,7 @@ SProcAllocColorPlanes(client)
} }
int int
SProcFreeColors (client) SProcFreeColors(register ClientPtr client)
register ClientPtr client;
{ {
register char n; register char n;
REQUEST(xFreeColorsReq); REQUEST(xFreeColorsReq);
@ -908,8 +854,7 @@ SProcFreeColors (client)
} }
void void
SwapColorItem(pItem) SwapColorItem(xColorItem *pItem)
xColorItem *pItem;
{ {
register char n; register char n;
@ -920,8 +865,7 @@ SwapColorItem(pItem)
} }
int int
SProcStoreColors (client) SProcStoreColors(register ClientPtr client)
register ClientPtr client;
{ {
register char n; register char n;
long count; long count;
@ -938,8 +882,7 @@ SProcStoreColors (client)
} }
int int
SProcStoreNamedColor (client) SProcStoreNamedColor (register ClientPtr client)
register ClientPtr client;
{ {
register char n; register char n;
REQUEST(xStoreNamedColorReq); REQUEST(xStoreNamedColorReq);
@ -952,8 +895,7 @@ SProcStoreNamedColor (client)
} }
int int
SProcQueryColors(client) SProcQueryColors (register ClientPtr client)
register ClientPtr client;
{ {
register char n; register char n;
REQUEST(xQueryColorsReq); REQUEST(xQueryColorsReq);
@ -965,8 +907,7 @@ SProcQueryColors(client)
} }
int int
SProcLookupColor(client) SProcLookupColor (register ClientPtr client)
register ClientPtr client;
{ {
register char n; register char n;
REQUEST(xLookupColorReq); REQUEST(xLookupColorReq);
@ -978,8 +919,7 @@ SProcLookupColor(client)
} }
int int
SProcCreateCursor( client) SProcCreateCursor (register ClientPtr client)
register ClientPtr client;
{ {
register char n; register char n;
REQUEST(xCreateCursorReq); REQUEST(xCreateCursorReq);
@ -1000,8 +940,7 @@ SProcCreateCursor( client)
} }
int int
SProcCreateGlyphCursor( client) SProcCreateGlyphCursor (register ClientPtr client)
register ClientPtr client;
{ {
register char n; register char n;
REQUEST(xCreateGlyphCursorReq); REQUEST(xCreateGlyphCursorReq);
@ -1023,8 +962,7 @@ SProcCreateGlyphCursor( client)
int int
SProcRecolorCursor(client) SProcRecolorCursor (register ClientPtr client)
register ClientPtr client;
{ {
register char n; register char n;
REQUEST(xRecolorCursorReq); REQUEST(xRecolorCursorReq);
@ -1041,8 +979,7 @@ SProcRecolorCursor(client)
} }
int int
SProcQueryBestSize (client) SProcQueryBestSize (register ClientPtr client)
register ClientPtr client;
{ {
register char n; register char n;
REQUEST(xQueryBestSizeReq); REQUEST(xQueryBestSizeReq);
@ -1056,8 +993,7 @@ SProcQueryBestSize (client)
} }
int int
SProcQueryExtension (client) SProcQueryExtension (register ClientPtr client)
register ClientPtr client;
{ {
register char n; register char n;
REQUEST(xQueryExtensionReq); REQUEST(xQueryExtensionReq);
@ -1068,8 +1004,7 @@ SProcQueryExtension (client)
} }
int int
SProcChangeKeyboardMapping (client) SProcChangeKeyboardMapping (register ClientPtr client)
register ClientPtr client;
{ {
register char n; register char n;
REQUEST(xChangeKeyboardMappingReq); REQUEST(xChangeKeyboardMappingReq);
@ -1081,8 +1016,7 @@ SProcChangeKeyboardMapping (client)
int int
SProcChangeKeyboardControl (client) SProcChangeKeyboardControl (register ClientPtr client)
register ClientPtr client;
{ {
register char n; register char n;
REQUEST(xChangeKeyboardControlReq); REQUEST(xChangeKeyboardControlReq);
@ -1094,8 +1028,7 @@ SProcChangeKeyboardControl (client)
} }
int int
SProcChangePointerControl (client) SProcChangePointerControl (register ClientPtr client)
register ClientPtr client;
{ {
register char n; register char n;
REQUEST(xChangePointerControlReq); REQUEST(xChangePointerControlReq);
@ -1109,8 +1042,7 @@ SProcChangePointerControl (client)
int int
SProcSetScreenSaver (client) SProcSetScreenSaver (register ClientPtr client)
register ClientPtr client;
{ {
register char n; register char n;
REQUEST(xSetScreenSaverReq); REQUEST(xSetScreenSaverReq);
@ -1122,8 +1054,7 @@ SProcSetScreenSaver (client)
} }
int int
SProcChangeHosts(client) SProcChangeHosts (register ClientPtr client)
register ClientPtr client;
{ {
register char n; register char n;
@ -1135,8 +1066,7 @@ SProcChangeHosts(client)
} }
int SProcRotateProperties(client) int SProcRotateProperties (register ClientPtr client)
register ClientPtr client;
{ {
register char n; register char n;
REQUEST(xRotatePropertiesReq); REQUEST(xRotatePropertiesReq);
@ -1149,10 +1079,8 @@ int SProcRotateProperties(client)
return ((* ProcVector[X_RotateProperties])(client)); return ((* ProcVector[X_RotateProperties])(client));
} }
/*ARGSUSED*/
int int
SProcNoOperation(client) SProcNoOperation(register ClientPtr client)
ClientPtr client;
{ {
register char n; register char n;
REQUEST(xReq); REQUEST(xReq);
@ -1161,8 +1089,7 @@ SProcNoOperation(client)
} }
void void
SwapConnClientPrefix(pCCP) SwapConnClientPrefix(xConnClientPrefix *pCCP)
xConnClientPrefix *pCCP;
{ {
register char n; register char n;

187
dix/window.c
View File

@ -1,4 +1,4 @@
/* $XdotOrg: xc/programs/Xserver/dix/window.c,v 1.4.2.1 2004/07/30 06:54:41 anholt Exp $ */ /* $XdotOrg: xc/programs/Xserver/dix/window.c,v 1.6 2004/07/31 08:24:13 anholt Exp $ */
/* $Xorg: window.c,v 1.4 2001/02/09 02:04:41 xorgcvs Exp $ */ /* $Xorg: window.c,v 1.4 2001/02/09 02:04:41 xorgcvs Exp $ */
/* /*
@ -132,10 +132,7 @@ extern void WindowHasNewCursor();
extern void RecalculateDeliverableEvents(); extern void RecalculateDeliverableEvents();
#endif #endif
static Bool TileScreenSaver( static Bool TileScreenSaver(int i, int kind);
int /*i*/,
int /*kind*/
);
#define INPUTONLY_LEGAL_MASK (CWWinGravity | CWEventMask | \ #define INPUTONLY_LEGAL_MASK (CWWinGravity | CWEventMask | \
@ -169,9 +166,7 @@ int deltaSaveUndersViewable = 0;
******/ ******/
int int
PrintChildren(p1, indent) PrintChildren(WindowPtr p1, int indent)
WindowPtr p1;
int indent;
{ {
WindowPtr p2; WindowPtr p2;
int i; int i;
@ -204,10 +199,7 @@ PrintWindowTree()
#endif #endif
int int
TraverseTree(pWin, func, data) TraverseTree(register WindowPtr pWin, VisitWindowProcPtr func, pointer data)
register WindowPtr pWin;
VisitWindowProcPtr func;
pointer data;
{ {
register int result; register int result;
register WindowPtr pChild; register WindowPtr pChild;
@ -242,10 +234,7 @@ TraverseTree(pWin, func, data)
*****/ *****/
int int
WalkTree(pScreen, func, data) WalkTree(ScreenPtr pScreen, VisitWindowProcPtr func, pointer data)
ScreenPtr pScreen;
VisitWindowProcPtr func;
pointer data;
{ {
return(TraverseTree(WindowTable[pScreen->myNum], func, data)); return(TraverseTree(WindowTable[pScreen->myNum], func, data));
} }
@ -343,8 +332,7 @@ MakeRootTile(WindowPtr pWin)
} }
WindowPtr WindowPtr
AllocateWindow(pScreen) AllocateWindow(ScreenPtr pScreen)
ScreenPtr pScreen;
{ {
WindowPtr pWin; WindowPtr pWin;
register char *ptr; register char *ptr;
@ -380,8 +368,7 @@ AllocateWindow(pScreen)
*****/ *****/
Bool Bool
CreateRootWindow(pScreen) CreateRootWindow(ScreenPtr pScreen)
ScreenPtr pScreen;
{ {
WindowPtr pWin; WindowPtr pWin;
BoxRec box; BoxRec box;
@ -489,8 +476,7 @@ CreateRootWindow(pScreen)
} }
void void
InitRootWindow(pWin) InitRootWindow(WindowPtr pWin)
WindowPtr pWin;
{ {
ScreenPtr pScreen = pWin->drawable.pScreen; ScreenPtr pScreen = pWin->drawable.pScreen;
@ -517,11 +503,9 @@ InitRootWindow(pWin)
*/ */
void void
ClippedRegionFromBox(pWin, Rgn, x, y, w, h) ClippedRegionFromBox(register WindowPtr pWin, RegionPtr Rgn,
register WindowPtr pWin; register int x, register int y,
RegionPtr Rgn; register int w, register int h)
register int x, y;
int w, h;
{ {
ScreenPtr pScreen = pWin->drawable.pScreen; ScreenPtr pScreen = pWin->drawable.pScreen;
BoxRec box; BoxRec box;
@ -547,8 +531,7 @@ ClippedRegionFromBox(pWin, Rgn, x, y, w, h)
} }
WindowPtr WindowPtr
RealChildHead(pWin) RealChildHead(register WindowPtr pWin)
register WindowPtr pWin;
{ {
if (!pWin->parent && if (!pWin->parent &&
(screenIsSaved == SCREEN_SAVER_ON) && (screenIsSaved == SCREEN_SAVER_ON) &&
@ -564,19 +547,9 @@ RealChildHead(pWin)
*****/ *****/
WindowPtr WindowPtr
CreateWindow(wid, pParent, x, y, w, h, bw, class, vmask, vlist, CreateWindow(Window wid, register WindowPtr pParent, int x, int y, unsigned w,
depth, client, visual, error) unsigned h, unsigned bw, unsigned class, register Mask vmask, XID *vlist,
Window wid; int depth, ClientPtr client, VisualID visual, int *error)
register WindowPtr pParent;
int x,y;
unsigned int w, h, bw;
unsigned int class;
register Mask vmask;
XID *vlist;
int depth;
ClientPtr client;
VisualID visual;
int *error;
{ {
register WindowPtr pWin; register WindowPtr pWin;
WindowPtr pHead; WindowPtr pHead;
@ -896,11 +869,8 @@ CrushTree(WindowPtr pWin)
* If wid is None, don't send any events * If wid is None, don't send any events
*****/ *****/
/*ARGSUSED*/
int int
DeleteWindow(value, wid) DeleteWindow(pointer value, XID wid)
pointer value;
XID wid;
{ {
register WindowPtr pParent; register WindowPtr pParent;
register WindowPtr pWin = (WindowPtr)value; register WindowPtr pWin = (WindowPtr)value;
@ -934,11 +904,8 @@ DeleteWindow(value, wid)
return Success; return Success;
} }
/*ARGSUSED*/
void void
DestroySubwindows(pWin, client) DestroySubwindows(register WindowPtr pWin, ClientPtr client)
register WindowPtr pWin;
ClientPtr client;
{ {
/* XXX /* XXX
* The protocol is quite clear that each window should be * The protocol is quite clear that each window should be
@ -965,11 +932,7 @@ DestroySubwindows(pWin, client)
*****/ *****/
int int
ChangeWindowAttributes(pWin, vmask, vlist, client) ChangeWindowAttributes(register WindowPtr pWin, Mask vmask, XID *vlist, ClientPtr client)
register WindowPtr pWin;
Mask vmask;
XID *vlist;
ClientPtr client;
{ {
register Mask index2; register Mask index2;
register XID *pVlist; register XID *pVlist;
@ -1509,10 +1472,7 @@ PatchUp:
*****/ *****/
void void
GetWindowAttributes(pWin, client, wa) GetWindowAttributes(register WindowPtr pWin, ClientPtr client, xGetWindowAttributesReply *wa)
register WindowPtr pWin;
ClientPtr client;
xGetWindowAttributesReply *wa;
{ {
wa->type = X_Reply; wa->type = X_Reply;
wa->bitGravity = pWin->bitGravity; wa->bitGravity = pWin->bitGravity;
@ -1548,8 +1508,7 @@ GetWindowAttributes(pWin, client, wa)
WindowPtr WindowPtr
MoveWindowInStack(pWin, pNextSib) MoveWindowInStack(register WindowPtr pWin, register WindowPtr pNextSib)
register WindowPtr pWin, pNextSib;
{ {
register WindowPtr pParent = pWin->parent; register WindowPtr pParent = pWin->parent;
WindowPtr pFirstChange = pWin; /* highest window where list changes */ WindowPtr pFirstChange = pWin; /* highest window where list changes */
@ -1633,8 +1592,7 @@ MoveWindowInStack(pWin, pNextSib)
} }
RegionPtr RegionPtr
CreateUnclippedWinSize (pWin) CreateUnclippedWinSize (register WindowPtr pWin)
register WindowPtr pWin;
{ {
RegionPtr pRgn; RegionPtr pRgn;
BoxRec box; BoxRec box;
@ -1661,8 +1619,7 @@ CreateUnclippedWinSize (pWin)
} }
void void
SetWinSize (pWin) SetWinSize (register WindowPtr pWin)
register WindowPtr pWin;
{ {
#ifdef COMPOSITE #ifdef COMPOSITE
if (pWin->redirectDraw) if (pWin->redirectDraw)
@ -1700,8 +1657,7 @@ SetWinSize (pWin)
} }
void void
SetBorderSize (pWin) SetBorderSize (register WindowPtr pWin)
register WindowPtr pWin;
{ {
int bw; int bw;
@ -1744,13 +1700,17 @@ SetBorderSize (pWin)
} }
} }
/**
*
* \param x,y new window position
* \param oldx,oldy old window position
* \param destx,desty position relative to gravity
*/
void void
GravityTranslate (x, y, oldx, oldy, dw, dh, gravity, destx, desty) GravityTranslate (register int x, register int y, int oldx, int oldy,
register int x, y; /* new window position */ int dw, int dh, unsigned gravity,
int oldx, oldy; /* old window position */ register int *destx, register int *desty)
int dw, dh;
unsigned gravity;
register int *destx, *desty; /* position relative to gravity */
{ {
switch (gravity) { switch (gravity) {
case NorthGravity: case NorthGravity:
@ -1798,9 +1758,7 @@ GravityTranslate (x, y, oldx, oldy, dw, dh, gravity, destx, desty)
/* XXX need to retile border on each window with ParentRelative origin */ /* XXX need to retile border on each window with ParentRelative origin */
void void
ResizeChildrenWinSize(pWin, dx, dy, dw, dh) ResizeChildrenWinSize(register WindowPtr pWin, int dx, int dy, int dw, int dh)
register WindowPtr pWin;
int dx, dy, dw, dh;
{ {
register ScreenPtr pScreen; register ScreenPtr pScreen;
register WindowPtr pSib, pChild; register WindowPtr pSib, pChild;
@ -2212,11 +2170,7 @@ ReflectStackChange(
*****/ *****/
int int
ConfigureWindow(pWin, mask, vlist, client) ConfigureWindow(register WindowPtr pWin, register Mask mask, XID *vlist, ClientPtr client)
register WindowPtr pWin;
register Mask mask;
XID *vlist;
ClientPtr client;
{ {
#define RESTACK_WIN 0 #define RESTACK_WIN 0
#define MOVE_WIN 1 #define MOVE_WIN 1
@ -2501,10 +2455,7 @@ ActuallyDoSomething:
******/ ******/
int int
CirculateWindow(pParent, direction, client) CirculateWindow(WindowPtr pParent, int direction, ClientPtr client)
WindowPtr pParent;
int direction;
ClientPtr client;
{ {
register WindowPtr pWin, pHead, pFirst; register WindowPtr pWin, pHead, pFirst;
xEvent event; xEvent event;
@ -2576,10 +2527,8 @@ CompareWIDs(
*****/ *****/
int int
ReparentWindow(pWin, pParent, x, y, client) ReparentWindow(register WindowPtr pWin, register WindowPtr pParent,
register WindowPtr pWin, pParent; int x, int y, ClientPtr client)
int x,y;
ClientPtr client;
{ {
WindowPtr pPrev, pPriorParent; WindowPtr pPrev, pPriorParent;
Bool WasMapped = (Bool)(pWin->mapped); Bool WasMapped = (Bool)(pWin->mapped);
@ -2711,9 +2660,7 @@ RealizeTree(WindowPtr pWin)
*****/ *****/
int int
MapWindow(pWin, client) MapWindow(register WindowPtr pWin, ClientPtr client)
register WindowPtr pWin;
ClientPtr client;
{ {
register ScreenPtr pScreen; register ScreenPtr pScreen;
@ -2839,9 +2786,7 @@ MapWindow(pWin, client)
*****/ *****/
void void
MapSubwindows(pParent, client) MapSubwindows(register WindowPtr pParent, ClientPtr client)
register WindowPtr pParent;
ClientPtr client;
{ {
register WindowPtr pWin; register WindowPtr pWin;
WindowPtr pFirstMapped = NullWindow; WindowPtr pFirstMapped = NullWindow;
@ -3020,9 +2965,7 @@ UnrealizeTree(
*****/ *****/
int int
UnmapWindow(pWin, fromConfigure) UnmapWindow(register WindowPtr pWin, Bool fromConfigure)
register WindowPtr pWin;
Bool fromConfigure;
{ {
register WindowPtr pParent; register WindowPtr pParent;
xEvent event; xEvent event;
@ -3081,8 +3024,7 @@ UnmapWindow(pWin, fromConfigure)
*****/ *****/
void void
UnmapSubwindows(pWin) UnmapSubwindows(register WindowPtr pWin)
register WindowPtr pWin;
{ {
register WindowPtr pChild, pHead; register WindowPtr pChild, pHead;
xEvent event; xEvent event;
@ -3173,8 +3115,7 @@ UnmapSubwindows(pWin)
void void
HandleSaveSet(client) HandleSaveSet(register ClientPtr client)
register ClientPtr client;
{ {
register WindowPtr pParent, pWin; register WindowPtr pParent, pWin;
register int j; register int j;
@ -3214,11 +3155,13 @@ HandleSaveSet(client)
client->saveSet = (SaveSetElt *)NULL; client->saveSet = (SaveSetElt *)NULL;
} }
/**
*
* \param x,y in root
* \param box "return" value
*/
Bool Bool
VisibleBoundingBoxFromPoint(pWin, x, y, box) VisibleBoundingBoxFromPoint(register WindowPtr pWin, int x, int y, BoxPtr box)
register WindowPtr pWin;
int x, y; /* in root */
BoxPtr box; /* "return" value */
{ {
if (!pWin->realized) if (!pWin->realized)
return (FALSE); return (FALSE);
@ -3227,10 +3170,12 @@ VisibleBoundingBoxFromPoint(pWin, x, y, box)
return(FALSE); return(FALSE);
} }
/**
*
* \param x,y in root
*/
Bool Bool
PointInWindowIsVisible(pWin, x, y) PointInWindowIsVisible(register WindowPtr pWin, int x, int y)
register WindowPtr pWin;
int x, y; /* in root */
{ {
BoxRec box; BoxRec box;
@ -3244,8 +3189,7 @@ PointInWindowIsVisible(pWin, x, y)
RegionPtr RegionPtr
NotClippedByChildren(pWin) NotClippedByChildren(register WindowPtr pWin)
register WindowPtr pWin;
{ {
register ScreenPtr pScreen; register ScreenPtr pScreen;
RegionPtr pReg; RegionPtr pReg;
@ -3262,8 +3206,7 @@ NotClippedByChildren(pWin)
} }
void void
SendVisibilityNotify(pWin) SendVisibilityNotify(WindowPtr pWin)
WindowPtr pWin;
{ {
xEvent event; xEvent event;
#ifndef NO_XINERAMA_PORT #ifndef NO_XINERAMA_PORT
@ -3335,14 +3278,12 @@ SendVisibilityNotify(pWin)
#ifndef NOLOGOHACK #ifndef NOLOGOHACK
static void DrawLogo( static void DrawLogo(
WindowPtr /*pWin*/ WindowPtr pWin
); );
#endif #endif
void void
SaveScreens(on, mode) SaveScreens(int on, int mode)
int on;
int mode;
{ {
int i; int i;
int what; int what;
@ -3573,8 +3514,7 @@ TileScreenSaver(int i, int kind)
*/ */
WindowPtr WindowPtr
FindWindowWithOptional (w) FindWindowWithOptional (register WindowPtr w)
register WindowPtr w;
{ {
do do
w = w->parent; w = w->parent;
@ -3591,8 +3531,7 @@ FindWindowWithOptional (w)
*/ */
void void
CheckWindowOptionalNeed (w) CheckWindowOptionalNeed (register WindowPtr w)
register WindowPtr w;
{ {
register WindowOptPtr optional; register WindowOptPtr optional;
register WindowOptPtr parentOptional; register WindowOptPtr parentOptional;
@ -3644,8 +3583,7 @@ CheckWindowOptionalNeed (w)
*/ */
Bool Bool
MakeWindowOptional (pWin) MakeWindowOptional (register WindowPtr pWin)
register WindowPtr pWin;
{ {
register WindowOptPtr optional; register WindowOptPtr optional;
register WindowOptPtr parentOptional; register WindowOptPtr parentOptional;
@ -3686,8 +3624,7 @@ MakeWindowOptional (pWin)
} }
void void
DisposeWindowOptional (pWin) DisposeWindowOptional (register WindowPtr pWin)
register WindowPtr pWin;
{ {
if (!pWin->optional) if (!pWin->optional)
return; return;