Introduce a consistent coding style

This is strictly the application of the script 'x-indent-all.sh'
from util/modular. Compared to the patch that Daniel posted in
January, I've added a few indent flags:

	-bap
	-psl
	-T PrivatePtr
	-T pmWait
	-T _XFUNCPROTOBEGIN
	-T _XFUNCPROTOEND
	-T _X_EXPORT

The typedefs were needed to make the output of sdksyms.sh match the
previous output, otherwise, the code is formatted badly enough that
sdksyms.sh generates incorrect output.

The generated code was compared with the previous version and found to
be essentially identical -- "assert" line numbers and BUILD_TIME were
the only differences found.

The comparison was done with this script:

dir1=$1
dir2=$2

for dir in $dir1 $dir2; do
	(cd $dir && find . -name '*.o' | while read file; do
		dir=`dirname $file`
		base=`basename $file .o`
		dump=$dir/$base.dump
		objdump -d $file > $dump
	done)
done

find $dir1 -name '*.dump' | while read dump; do
	otherdump=`echo $dump | sed "s;$dir1;$dir2;"`
	diff -u $dump $otherdump
done

Signed-off-by: Keith Packard <keithp@keithp.com>
Acked-by: Daniel Stone <daniel@fooishbar.org>
Acked-by: Alan Coopersmith <alan.coopersmith@oracle.com>
This commit is contained in:
Keith Packard
2012-03-21 12:55:09 -07:00
parent 75199129c6
commit 9838b7032e
1258 changed files with 257574 additions and 252857 deletions

View File

@@ -40,40 +40,39 @@
#include "picturestr.h"
static char **filterNames;
static int nfilterNames;
static int nfilterNames;
/*
* standard but not required filters don't have constant indices
*/
int
PictureGetFilterId (const char *filter, int len, Bool makeit)
PictureGetFilterId(const char *filter, int len, Bool makeit)
{
int i;
char *name;
char **names;
int i;
char *name;
char **names;
if (len < 0)
len = strlen (filter);
len = strlen(filter);
for (i = 0; i < nfilterNames; i++)
if (!CompareISOLatin1Lowered ((const unsigned char *) filterNames[i], -1,
(const unsigned char *) filter, len))
return i;
if (!CompareISOLatin1Lowered((const unsigned char *) filterNames[i], -1,
(const unsigned char *) filter, len))
return i;
if (!makeit)
return -1;
return -1;
name = malloc(len + 1);
if (!name)
return -1;
memcpy (name, filter, len);
return -1;
memcpy(name, filter, len);
name[len] = '\0';
if (filterNames)
names = realloc(filterNames, (nfilterNames + 1) * sizeof (char *));
names = realloc(filterNames, (nfilterNames + 1) * sizeof(char *));
else
names = malloc(sizeof (char *));
if (!names)
{
free(name);
return -1;
names = malloc(sizeof(char *));
if (!names) {
free(name);
return -1;
}
filterNames = names;
i = nfilterNames++;
@@ -82,77 +81,78 @@ PictureGetFilterId (const char *filter, int len, Bool makeit)
}
static Bool
PictureSetDefaultIds (void)
PictureSetDefaultIds(void)
{
/* careful here -- this list must match the #define values */
if (PictureGetFilterId (FilterNearest, -1, TRUE) != PictFilterNearest)
return FALSE;
if (PictureGetFilterId (FilterBilinear, -1, TRUE) != PictFilterBilinear)
return FALSE;
if (PictureGetFilterId(FilterNearest, -1, TRUE) != PictFilterNearest)
return FALSE;
if (PictureGetFilterId(FilterBilinear, -1, TRUE) != PictFilterBilinear)
return FALSE;
if (PictureGetFilterId (FilterFast, -1, TRUE) != PictFilterFast)
return FALSE;
if (PictureGetFilterId (FilterGood, -1, TRUE) != PictFilterGood)
return FALSE;
if (PictureGetFilterId (FilterBest, -1, TRUE) != PictFilterBest)
return FALSE;
if (PictureGetFilterId(FilterFast, -1, TRUE) != PictFilterFast)
return FALSE;
if (PictureGetFilterId(FilterGood, -1, TRUE) != PictFilterGood)
return FALSE;
if (PictureGetFilterId(FilterBest, -1, TRUE) != PictFilterBest)
return FALSE;
if (PictureGetFilterId (FilterConvolution, -1, TRUE) != PictFilterConvolution)
return FALSE;
if (PictureGetFilterId(FilterConvolution, -1, TRUE) !=
PictFilterConvolution)
return FALSE;
return TRUE;
}
char *
PictureGetFilterName (int id)
PictureGetFilterName(int id)
{
if (0 <= id && id < nfilterNames)
return filterNames[id];
return filterNames[id];
else
return 0;
return 0;
}
static void
PictureFreeFilterIds (void)
PictureFreeFilterIds(void)
{
int i;
int i;
for (i = 0; i < nfilterNames; i++)
free(filterNames[i]);
free(filterNames[i]);
free(filterNames);
nfilterNames = 0;
filterNames = 0;
}
int
PictureAddFilter (ScreenPtr pScreen,
const char *filter,
PictFilterValidateParamsProcPtr ValidateParams,
int width,
int height)
PictureAddFilter(ScreenPtr pScreen,
const char *filter,
PictFilterValidateParamsProcPtr ValidateParams,
int width, int height)
{
PictureScreenPtr ps = GetPictureScreen(pScreen);
int id = PictureGetFilterId (filter, -1, TRUE);
int i;
PictFilterPtr filters;
PictureScreenPtr ps = GetPictureScreen(pScreen);
int id = PictureGetFilterId(filter, -1, TRUE);
int i;
PictFilterPtr filters;
if (id < 0)
return -1;
return -1;
/*
* It's an error to attempt to reregister a filter
*/
for (i = 0; i < ps->nfilters; i++)
if (ps->filters[i].id == id)
return -1;
if (ps->filters[i].id == id)
return -1;
if (ps->filters)
filters = realloc(ps->filters, (ps->nfilters + 1) * sizeof (PictFilterRec));
filters =
realloc(ps->filters, (ps->nfilters + 1) * sizeof(PictFilterRec));
else
filters = malloc(sizeof (PictFilterRec));
filters = malloc(sizeof(PictFilterRec));
if (!filters)
return -1;
return -1;
ps->filters = filters;
i = ps->nfilters++;
ps->filters[i].name = PictureGetFilterName (id);
ps->filters[i].name = PictureGetFilterName(id);
ps->filters[i].id = id;
ps->filters[i].ValidateParams = ValidateParams;
ps->filters[i].width = width;
@@ -161,79 +161,76 @@ PictureAddFilter (ScreenPtr pScreen,
}
Bool
PictureSetFilterAlias (ScreenPtr pScreen, const char *filter, const char *alias)
PictureSetFilterAlias(ScreenPtr pScreen, const char *filter, const char *alias)
{
PictureScreenPtr ps = GetPictureScreen(pScreen);
int filter_id = PictureGetFilterId (filter, -1, FALSE);
int alias_id = PictureGetFilterId (alias, -1, TRUE);
int i;
PictureScreenPtr ps = GetPictureScreen(pScreen);
int filter_id = PictureGetFilterId(filter, -1, FALSE);
int alias_id = PictureGetFilterId(alias, -1, TRUE);
int i;
if (filter_id < 0 || alias_id < 0)
return FALSE;
return FALSE;
for (i = 0; i < ps->nfilterAliases; i++)
if (ps->filterAliases[i].alias_id == alias_id)
break;
if (i == ps->nfilterAliases)
{
PictFilterAliasPtr aliases;
if (ps->filterAliases[i].alias_id == alias_id)
break;
if (i == ps->nfilterAliases) {
PictFilterAliasPtr aliases;
if (ps->filterAliases)
aliases = realloc(ps->filterAliases,
(ps->nfilterAliases + 1) *
sizeof (PictFilterAliasRec));
else
aliases = malloc(sizeof (PictFilterAliasRec));
if (!aliases)
return FALSE;
ps->filterAliases = aliases;
ps->filterAliases[i].alias = PictureGetFilterName (alias_id);
ps->filterAliases[i].alias_id = alias_id;
ps->nfilterAliases++;
if (ps->filterAliases)
aliases = realloc(ps->filterAliases,
(ps->nfilterAliases + 1) *
sizeof(PictFilterAliasRec));
else
aliases = malloc(sizeof(PictFilterAliasRec));
if (!aliases)
return FALSE;
ps->filterAliases = aliases;
ps->filterAliases[i].alias = PictureGetFilterName(alias_id);
ps->filterAliases[i].alias_id = alias_id;
ps->nfilterAliases++;
}
ps->filterAliases[i].filter_id = filter_id;
return TRUE;
}
PictFilterPtr
PictureFindFilter (ScreenPtr pScreen, char *name, int len)
PictureFindFilter(ScreenPtr pScreen, char *name, int len)
{
PictureScreenPtr ps = GetPictureScreen(pScreen);
int id = PictureGetFilterId (name, len, FALSE);
int i;
PictureScreenPtr ps = GetPictureScreen(pScreen);
int id = PictureGetFilterId(name, len, FALSE);
int i;
if (id < 0)
return 0;
return 0;
/* Check for an alias, allow them to recurse */
for (i = 0; i < ps->nfilterAliases; i++)
if (ps->filterAliases[i].alias_id == id)
{
id = ps->filterAliases[i].filter_id;
i = 0;
}
if (ps->filterAliases[i].alias_id == id) {
id = ps->filterAliases[i].filter_id;
i = 0;
}
/* find the filter */
for (i = 0; i < ps->nfilters; i++)
if (ps->filters[i].id == id)
return &ps->filters[i];
if (ps->filters[i].id == id)
return &ps->filters[i];
return 0;
}
static Bool
convolutionFilterValidateParams (ScreenPtr pScreen,
int filter,
xFixed *params,
int nparams,
int *width,
int *height)
convolutionFilterValidateParams(ScreenPtr pScreen,
int filter,
xFixed * params,
int nparams, int *width, int *height)
{
int w, h;
int w, h;
if (nparams < 3)
return FALSE;
if (xFixedFrac (params[0]) || xFixedFrac (params[1]))
if (xFixedFrac(params[0]) || xFixedFrac(params[1]))
return FALSE;
w = xFixedToInt (params[0]);
h = xFixedToInt (params[1]);
w = xFixedToInt(params[0]);
h = xFixedToInt(params[1]);
nparams -= 2;
if (w * h > nparams)
@@ -244,117 +241,117 @@ convolutionFilterValidateParams (ScreenPtr pScreen,
return TRUE;
}
Bool
PictureSetDefaultFilters (ScreenPtr pScreen)
PictureSetDefaultFilters(ScreenPtr pScreen)
{
if (!filterNames)
if (!PictureSetDefaultIds ())
return FALSE;
if (PictureAddFilter (pScreen, FilterNearest, 0, 1, 1) < 0)
return FALSE;
if (PictureAddFilter (pScreen, FilterBilinear, 0, 2, 2) < 0)
return FALSE;
if (!PictureSetDefaultIds())
return FALSE;
if (PictureAddFilter(pScreen, FilterNearest, 0, 1, 1) < 0)
return FALSE;
if (PictureAddFilter(pScreen, FilterBilinear, 0, 2, 2) < 0)
return FALSE;
if (!PictureSetFilterAlias (pScreen, FilterNearest, FilterFast))
return FALSE;
if (!PictureSetFilterAlias (pScreen, FilterBilinear, FilterGood))
return FALSE;
if (!PictureSetFilterAlias (pScreen, FilterBilinear, FilterBest))
return FALSE;
if (!PictureSetFilterAlias(pScreen, FilterNearest, FilterFast))
return FALSE;
if (!PictureSetFilterAlias(pScreen, FilterBilinear, FilterGood))
return FALSE;
if (!PictureSetFilterAlias(pScreen, FilterBilinear, FilterBest))
return FALSE;
if (PictureAddFilter (pScreen, FilterConvolution, convolutionFilterValidateParams, 0, 0) < 0)
if (PictureAddFilter
(pScreen, FilterConvolution, convolutionFilterValidateParams, 0, 0) < 0)
return FALSE;
return TRUE;
}
void
PictureResetFilters (ScreenPtr pScreen)
PictureResetFilters(ScreenPtr pScreen)
{
PictureScreenPtr ps = GetPictureScreen(pScreen);
PictureScreenPtr ps = GetPictureScreen(pScreen);
free(ps->filters);
free(ps->filterAliases);
PictureFreeFilterIds ();
PictureFreeFilterIds();
}
int
SetPictureFilter (PicturePtr pPicture, char *name, int len, xFixed *params, int nparams)
SetPictureFilter(PicturePtr pPicture, char *name, int len, xFixed * params,
int nparams)
{
PictFilterPtr pFilter;
ScreenPtr pScreen;
PictFilterPtr pFilter;
ScreenPtr pScreen;
if (pPicture->pDrawable != NULL)
pScreen = pPicture->pDrawable->pScreen;
pScreen = pPicture->pDrawable->pScreen;
else
pScreen = screenInfo.screens[0];
pScreen = screenInfo.screens[0];
pFilter = PictureFindFilter (pScreen, name, len);
pFilter = PictureFindFilter(pScreen, name, len);
if (!pFilter)
return BadName;
return BadName;
if (pPicture->pDrawable == NULL)
{
int s;
/* For source pictures, the picture isn't tied to a screen. So, ensure
* that all screens can handle a filter we set for the picture.
*/
for (s = 1; s < screenInfo.numScreens; s++)
{
PictFilterPtr pScreenFilter;
pScreenFilter = PictureFindFilter (screenInfo.screens[s],
name, len);
if (!pScreenFilter || pScreenFilter->id != pFilter->id)
return BadMatch;
}
if (pPicture->pDrawable == NULL) {
int s;
/* For source pictures, the picture isn't tied to a screen. So, ensure
* that all screens can handle a filter we set for the picture.
*/
for (s = 1; s < screenInfo.numScreens; s++) {
PictFilterPtr pScreenFilter;
pScreenFilter = PictureFindFilter(screenInfo.screens[s], name, len);
if (!pScreenFilter || pScreenFilter->id != pFilter->id)
return BadMatch;
}
}
return SetPicturePictFilter (pPicture, pFilter, params, nparams);
return SetPicturePictFilter(pPicture, pFilter, params, nparams);
}
int
SetPicturePictFilter (PicturePtr pPicture, PictFilterPtr pFilter,
xFixed *params, int nparams)
SetPicturePictFilter(PicturePtr pPicture, PictFilterPtr pFilter,
xFixed * params, int nparams)
{
ScreenPtr pScreen;
int i;
ScreenPtr pScreen;
int i;
if (pPicture->pDrawable)
pScreen = pPicture->pDrawable->pScreen;
pScreen = pPicture->pDrawable->pScreen;
else
pScreen = screenInfo.screens[0];
pScreen = screenInfo.screens[0];
if (pFilter->ValidateParams)
{
int width, height;
if (!(*pFilter->ValidateParams) (pScreen, pFilter->id, params, nparams, &width, &height))
return BadMatch;
if (pFilter->ValidateParams) {
int width, height;
if (!(*pFilter->ValidateParams)
(pScreen, pFilter->id, params, nparams, &width, &height))
return BadMatch;
}
else if (nparams)
return BadMatch;
return BadMatch;
if (nparams != pPicture->filter_nparams)
{
xFixed *new_params = malloc(nparams * sizeof (xFixed));
if (!new_params && nparams)
return BadAlloc;
free(pPicture->filter_params);
pPicture->filter_params = new_params;
pPicture->filter_nparams = nparams;
if (nparams != pPicture->filter_nparams) {
xFixed *new_params = malloc(nparams * sizeof(xFixed));
if (!new_params && nparams)
return BadAlloc;
free(pPicture->filter_params);
pPicture->filter_params = new_params;
pPicture->filter_nparams = nparams;
}
for (i = 0; i < nparams; i++)
pPicture->filter_params[i] = params[i];
pPicture->filter_params[i] = params[i];
pPicture->filter = pFilter->id;
if (pPicture->pDrawable)
{
PictureScreenPtr ps = GetPictureScreen(pScreen);
int result;
if (pPicture->pDrawable) {
PictureScreenPtr ps = GetPictureScreen(pScreen);
int result;
result = (*ps->ChangePictureFilter) (pPicture, pPicture->filter,
params, nparams);
return result;
result = (*ps->ChangePictureFilter) (pPicture, pPicture->filter,
params, nparams);
return result;
}
return Success;
}