Merge remote-tracking branch 'origin/released'

Conflicts:
	pixman/pixman/pixman-mmx.c
	xorg-server/Xext/shm.c
	xorg-server/Xext/syncsrv.h
	xorg-server/Xext/xvmain.c
	xorg-server/Xi/exevents.c
	xorg-server/Xi/opendev.c
	xorg-server/composite/compalloc.c
	xorg-server/composite/compoverlay.c
	xorg-server/dix/colormap.c
	xorg-server/dix/devices.c
	xorg-server/dix/dispatch.c
	xorg-server/dix/dixfonts.c
	xorg-server/dix/eventconvert.c
	xorg-server/dix/events.c
	xorg-server/dix/gc.c
	xorg-server/dix/getevents.c
	xorg-server/dix/main.c
	xorg-server/dix/privates.c
	xorg-server/dix/registry.c
	xorg-server/dix/resource.c
	xorg-server/exa/exa_accel.c
	xorg-server/exa/exa_migration_classic.c
	xorg-server/exa/exa_unaccel.c
	xorg-server/fb/fb.h
	xorg-server/fb/fbcopy.c
	xorg-server/fb/fbpixmap.c
	xorg-server/glx/dispatch.h
	xorg-server/glx/glapi.h
	xorg-server/glx/glapi_gentable.c
	xorg-server/glx/glapitable.h
	xorg-server/glx/glprocs.h
	xorg-server/glx/glxcmds.c
	xorg-server/glx/glxcmdsswap.c
	xorg-server/glx/glxdricommon.c
	xorg-server/glx/glxdriswrast.c
	xorg-server/glx/glxext.c
	xorg-server/glx/indirect_dispatch.c
	xorg-server/glx/indirect_dispatch.h
	xorg-server/glx/indirect_dispatch_swap.c
	xorg-server/glx/indirect_size.h
	xorg-server/glx/indirect_size_get.h
	xorg-server/glx/indirect_table.c
	xorg-server/glx/indirect_util.c
	xorg-server/glx/rensize.c
	xorg-server/glx/single2swap.c
	xorg-server/glx/singlepix.c
	xorg-server/glx/singlepixswap.c
	xorg-server/glx/singlesize.c
	xorg-server/hw/dmx/dmxinit.c
	xorg-server/hw/kdrive/ephyr/ephyr.c
	xorg-server/hw/kdrive/ephyr/hostx.c
	xorg-server/hw/kdrive/ephyr/hostx.h
	xorg-server/hw/kdrive/src/kinput.c
	xorg-server/hw/xfree86/common/compiler.h
	xorg-server/hw/xwin/InitInput.c
	xorg-server/hw/xwin/InitOutput.c
	xorg-server/hw/xwin/ddraw.h
	xorg-server/hw/xwin/glx/glwrap.c
	xorg-server/hw/xwin/glx/indirect.c
	xorg-server/hw/xwin/glx/wgl_ext_api.h
	xorg-server/hw/xwin/glx/winpriv.c
	xorg-server/hw/xwin/win.h
	xorg-server/hw/xwin/winallpriv.c
	xorg-server/hw/xwin/winauth.c
	xorg-server/hw/xwin/winclipboard.h
	xorg-server/hw/xwin/winclipboardinit.c
	xorg-server/hw/xwin/winclipboardthread.c
	xorg-server/hw/xwin/winclipboardunicode.c
	xorg-server/hw/xwin/winclipboardwndproc.c
	xorg-server/hw/xwin/winclipboardwrappers.c
	xorg-server/hw/xwin/winclipboardxevents.c
	xorg-server/hw/xwin/wincmap.c
	xorg-server/hw/xwin/winconfig.c
	xorg-server/hw/xwin/wincreatewnd.c
	xorg-server/hw/xwin/wincursor.c
	xorg-server/hw/xwin/windialogs.c
	xorg-server/hw/xwin/winengine.c
	xorg-server/hw/xwin/winerror.c
	xorg-server/hw/xwin/wingc.c
	xorg-server/hw/xwin/wingetsp.c
	xorg-server/hw/xwin/winkeybd.c
	xorg-server/hw/xwin/winkeybd.h
	xorg-server/hw/xwin/winlayouts.h
	xorg-server/hw/xwin/winmisc.c
	xorg-server/hw/xwin/winmonitors.c
	xorg-server/hw/xwin/winmouse.c
	xorg-server/hw/xwin/winmsg.c
	xorg-server/hw/xwin/winmsg.h
	xorg-server/hw/xwin/winmultiwindowclass.c
	xorg-server/hw/xwin/winmultiwindowicons.c
	xorg-server/hw/xwin/winmultiwindowshape.c
	xorg-server/hw/xwin/winmultiwindowwindow.c
	xorg-server/hw/xwin/winmultiwindowwm.c
	xorg-server/hw/xwin/winmultiwindowwndproc.c
	xorg-server/hw/xwin/winnativegdi.c
	xorg-server/hw/xwin/winpfbdd.c
	xorg-server/hw/xwin/winpixmap.c
	xorg-server/hw/xwin/winpolyline.c
	xorg-server/hw/xwin/winprefs.c
	xorg-server/hw/xwin/winprocarg.c
	xorg-server/hw/xwin/winregistry.c
	xorg-server/hw/xwin/winscrinit.c
	xorg-server/hw/xwin/winsetsp.c
	xorg-server/hw/xwin/winshaddd.c
	xorg-server/hw/xwin/winshadddnl.c
	xorg-server/hw/xwin/winshadgdi.c
	xorg-server/hw/xwin/wintrayicon.c
	xorg-server/hw/xwin/winwin32rootless.c
	xorg-server/hw/xwin/winwin32rootlesswindow.c
	xorg-server/hw/xwin/winwin32rootlesswndproc.c
	xorg-server/hw/xwin/winwindow.c
	xorg-server/hw/xwin/winwindow.h
	xorg-server/hw/xwin/winwindowswm.c
	xorg-server/hw/xwin/winwndproc.c
	xorg-server/include/callback.h
	xorg-server/include/dixstruct.h
	xorg-server/include/misc.h
	xorg-server/include/os.h
	xorg-server/include/scrnintstr.h
	xorg-server/mi/micmap.c
	xorg-server/mi/miinitext.c
	xorg-server/mi/mioverlay.c
	xorg-server/mi/misprite.c
	xorg-server/mi/mivaltree.c
	xorg-server/mi/miwindow.c
	xorg-server/miext/damage/damage.c
	xorg-server/miext/rootless/rootlessGC.c
	xorg-server/miext/rootless/rootlessWindow.c
	xorg-server/os/WaitFor.c
	xorg-server/os/access.c
	xorg-server/os/connection.c
	xorg-server/os/io.c
	xorg-server/os/log.c
	xorg-server/os/osinit.c
	xorg-server/os/utils.c
	xorg-server/os/xdmcp.c
	xorg-server/os/xprintf.c
	xorg-server/os/xstrans.c
	xorg-server/render/mipict.c
	xorg-server/xkb/xkbActions.c
	xorg-server/xkb/xkbInit.c
	xorg-server/xkeyboard-config/compat/default.in

1 files changed, 766 insertions, 775 deletions

diff --git a/xorg-server/hw/xfree86/parser/scan.c b/xorg-server/hw/xfree86/parser/scan.c
index 156bc299a..795da615f 100644
--- a/xorg-server/hw/xfree86/parser/scan.c
+++ b/xorg-server/hw/xfree86/parser/scan.c
@@ -51,7 +51,6 @@
  * authorization from the copyright holder(s) and author(s).
  */
 
-
 /* View/edit this file with tab stops set to 4 */
 
 #ifdef HAVE_XORG_CONFIG_H
@@ -75,11 +74,11 @@
 #define _POSIX_SOURCE
 #include <limits.h>
 #undef _POSIX_SOURCE
-#endif /* _POSIX_SOURCE */
+#endif                          /* _POSIX_SOURCE */
 
 #if !defined(MAXHOSTNAMELEN)
 #define MAXHOSTNAMELEN 32
-#endif /* !MAXHOSTNAMELEN */
+#endif                          /* !MAXHOSTNAMELEN */
 
 /* For PATH_MAX */
 #include "misc.h"
@@ -90,22 +89,22 @@
 #define CONFIG_BUF_LEN     1024
 #define CONFIG_MAX_FILES   64
 
-static int StringToToken (const char *, xf86ConfigSymTabRec *);
+static int StringToToken(const char *, xf86ConfigSymTabRec *);
 
 static struct {
-	FILE *file;
-	char *path;
+    FILE *file;
+    char *path;
 } configFiles[CONFIG_MAX_FILES];
 static const char **builtinConfig = NULL;
 static int builtinIndex = 0;
-static int configPos = 0;		/* current readers position */
-static int configLineNo = 0;	/* linenumber */
-static char *configBuf, *configRBuf;	/* buffer for lines */
-static char *configSection = NULL;	/* name of current section being parsed */
-static int numFiles = 0;		/* number of config files */
-static int curFileIndex = 0;		/* index of current config file */
+static int configPos = 0;       /* current readers position */
+static int configLineNo = 0;    /* linenumber */
+static char *configBuf, *configRBuf;    /* buffer for lines */
+static char *configSection = NULL;      /* name of current section being parsed */
+static int numFiles = 0;        /* number of config files */
+static int curFileIndex = 0;    /* index of current config file */
 static int pushToken = LOCK_TOKEN;
-static int eol_seen = 0;		/* private state to handle comments */
+static int eol_seen = 0;        /* private state to handle comments */
 LexRec val;
 
 /*
@@ -119,123 +118,129 @@ LexRec val;
  *  support that.
  */
 
-static char*
+static char *
 xf86getNextLine(void)
 {
-	static int configBufLen = CONFIG_BUF_LEN;
-	char *tmpConfigBuf, *tmpConfigRBuf;
-	int c, i, pos = 0, eolFound = 0;
-	char *ret = NULL;
+    static int configBufLen = CONFIG_BUF_LEN;
+    char *tmpConfigBuf, *tmpConfigRBuf;
+    int c, i, pos = 0, eolFound = 0;
+    char *ret = NULL;
 
-	/*
-	 * reallocate the string if it was grown last time (i.e., is no
-	 * longer CONFIG_BUF_LEN); we malloc the new strings first, so
-	 * that if either of the mallocs fail, we can fall back on the
-	 * existing buffer allocations
-	 */
+    /*
+     * reallocate the string if it was grown last time (i.e., is no
+     * longer CONFIG_BUF_LEN); we malloc the new strings first, so
+     * that if either of the mallocs fail, we can fall back on the
+     * existing buffer allocations
+     */
 
-	if (configBufLen != CONFIG_BUF_LEN) {
+    if (configBufLen != CONFIG_BUF_LEN) {
 
-		tmpConfigBuf = malloc(CONFIG_BUF_LEN);
-		tmpConfigRBuf = malloc(CONFIG_BUF_LEN);
+        tmpConfigBuf = malloc(CONFIG_BUF_LEN);
+        tmpConfigRBuf = malloc(CONFIG_BUF_LEN);
 
-		if (!tmpConfigBuf || !tmpConfigRBuf) {
+        if (!tmpConfigBuf || !tmpConfigRBuf) {
 
-			/*
-			 * at least one of the mallocs failed; keep the old buffers
-			 * and free any partial allocations
-			 */
+            /*
+             * at least one of the mallocs failed; keep the old buffers
+             * and free any partial allocations
+             */
 
-			free(tmpConfigBuf);
-			free(tmpConfigRBuf);
+            free(tmpConfigBuf);
+            free(tmpConfigRBuf);
 
-		} else {
+        }
+        else {
 
-			/*
-			 * malloc succeeded; free the old buffers and use the new
-			 * buffers
-			 */
+            /*
+             * malloc succeeded; free the old buffers and use the new
+             * buffers
+             */
 
-			configBufLen = CONFIG_BUF_LEN;
+            configBufLen = CONFIG_BUF_LEN;
 
-			free(configBuf);
-			free(configRBuf);
+            free(configBuf);
+            free(configRBuf);
 
-			configBuf = tmpConfigBuf;
-			configRBuf = tmpConfigRBuf;
-		}
-	}
+            configBuf = tmpConfigBuf;
+            configRBuf = tmpConfigRBuf;
+        }
+    }
 
-	/* read in another block of chars */
+    /* read in another block of chars */
 
-	do {
-		ret = fgets(configBuf + pos, configBufLen - pos - 1,
-			    configFiles[curFileIndex].file);
+    do {
+        ret = fgets(configBuf + pos, configBufLen - pos - 1,
+                    configFiles[curFileIndex].file);
 
-		if (!ret) {
-			/*
-			 * if the file doesn't end in a newline, add one
-			 * and trigger another read
-			 */
-			if (pos != 0) {
-				strcpy(&configBuf[pos], "\n");
-				ret = configBuf;
-			} else
-				break;
-		}
+        if (!ret) {
+            /*
+             * if the file doesn't end in a newline, add one
+             * and trigger another read
+             */
+            if (pos != 0) {
+                strcpy(&configBuf[pos], "\n");
+                ret = configBuf;
+            }
+            else
+                break;
+        }
 
-		/* search for EOL in the new block of chars */
+        /* search for EOL in the new block of chars */
 
-		for (i = pos; i < (configBufLen - 1); i++) {
-			c = configBuf[i];
+        for (i = pos; i < (configBufLen - 1); i++) {
+            c = configBuf[i];
 
-			if (c == '\0') break;
+            if (c == '\0')
+                break;
 
-			if ((c == '\n') || (c == '\r')) {
-				eolFound = 1;
-				break;
-			}
-		}
+            if ((c == '\n') || (c == '\r')) {
+                eolFound = 1;
+                break;
+            }
+        }
 
-		/*
-		 * if we didn't find EOL, then grow the string and
-		 * read in more
-		 */
+        /*
+         * if we didn't find EOL, then grow the string and
+         * read in more
+         */
 
-		if (!eolFound) {
+        if (!eolFound) {
 
-			tmpConfigBuf = realloc(configBuf, configBufLen + CONFIG_BUF_LEN);
-			tmpConfigRBuf = realloc(configRBuf, configBufLen + CONFIG_BUF_LEN);
+            tmpConfigBuf = realloc(configBuf, configBufLen + CONFIG_BUF_LEN);
+            tmpConfigRBuf = realloc(configRBuf, configBufLen + CONFIG_BUF_LEN);
 
-			if (!tmpConfigBuf || !tmpConfigRBuf) {
+            if (!tmpConfigBuf || !tmpConfigRBuf) {
 
-				/*
-				 * at least one of the reallocations failed; use the
-				 * new allocation that succeeded, but we have to
-				 * fallback to the previous configBufLen size and use
-				 * the string we have, even though we don't have an
-				 * EOL
-				 */
+                /*
+                 * at least one of the reallocations failed; use the
+                 * new allocation that succeeded, but we have to
+                 * fallback to the previous configBufLen size and use
+                 * the string we have, even though we don't have an
+                 * EOL
+                 */
 
-				if (tmpConfigBuf) configBuf = tmpConfigBuf;
-				if (tmpConfigRBuf) configRBuf = tmpConfigRBuf;
+                if (tmpConfigBuf)
+                    configBuf = tmpConfigBuf;
+                if (tmpConfigRBuf)
+                    configRBuf = tmpConfigRBuf;
 
-				break;
+                break;
 
-			} else {
+            }
+            else {
 
-				/* reallocation succeeded */
+                /* reallocation succeeded */
 
-				configBuf = tmpConfigBuf;
-				configRBuf = tmpConfigRBuf;
-				pos = i;
-				configBufLen += CONFIG_BUF_LEN;
-			}
-		}
+                configBuf = tmpConfigBuf;
+                configRBuf = tmpConfigRBuf;
+                pos = i;
+                configBufLen += CONFIG_BUF_LEN;
+            }
+        }
 
-	} while (!eolFound);
+    } while (!eolFound);
 
-	return ret;
+    return ret;
 }
 
 /* 
@@ -244,295 +249,278 @@ xf86getNextLine(void)
  *      pushToken.
  */
 int
-xf86getToken (xf86ConfigSymTabRec * tab)
+xf86getToken(xf86ConfigSymTabRec * tab)
 {
-	int c, i;
-
-	/* 
-	 * First check whether pushToken has a different value than LOCK_TOKEN.
-	 * In this case rBuf[] contains a valid STRING/TOKEN/NUMBER. But in the
-	 * oth * case the next token must be read from the input.
-	 */
-	if (pushToken == EOF_TOKEN)
-		return EOF_TOKEN;
-	else if (pushToken == LOCK_TOKEN)
-	{
-		/*
-		 * eol_seen is only set for the first token after a newline.
-		 */
-		eol_seen = 0;
-
-		c = configBuf[configPos];
-
-		/* 
-		 * Get start of next Token. EOF is handled,
-		 * whitespaces are skipped. 
-		 */
-
-again:
-		if (!c)
-		{
-			char *ret;
-			if (numFiles > 0)
-				ret = xf86getNextLine();
-			else {
-				if (builtinConfig[builtinIndex] == NULL)
-					ret = NULL;
-				else {
-					strlcpy(configBuf,
-						builtinConfig[builtinIndex],
-						CONFIG_BUF_LEN);
-					ret = configBuf;
-					builtinIndex++;
-				}
-			}
-			if (ret == NULL)
-			{
-				/*
-				 * if necessary, move to the next file and
-				 * read the first line
-				 */
-				if (curFileIndex + 1 < numFiles) {
-					curFileIndex++;
-					configLineNo = 0;
-					goto again;
-				}
-				else
-					return pushToken = EOF_TOKEN;
-			}
-			configLineNo++;
-			configPos = 0;
-			eol_seen = 1;
-		}
-
-		i = 0;
-		for (;;) {
-			c = configBuf[configPos++];
-			configRBuf[i++] = c;
-			switch (c) {
-				case ' ':
-				case '\t':
-				case '\r':
-					continue;
-				case '\n':
-					i = 0;
-					continue;
-			}
-			break;
-		}
-		if (c == '\0')
-			goto again;
-
-		if (c == '#')
-		{
-			do
-			{
-				configRBuf[i++] = (c = configBuf[configPos++]);
-			}
-			while ((c != '\n') && (c != '\r') && (c != '\0'));
-			configRBuf[i] = '\0';
-			/* XXX no private copy.
-			 * Use xf86addComment when setting a comment.
-			 */
-			val.str = configRBuf;
-			return COMMENT;
-		}
-
-		/* GJA -- handle '-' and ','  * Be careful: "-hsync" is a keyword. */
-		else if ((c == ',') && !isalpha (configBuf[configPos]))
-		{
-			return COMMA;
-		}
-		else if ((c == '-') && !isalpha (configBuf[configPos]))
-		{
-			return DASH;
-		}
-
-		/* 
-		 * Numbers are returned immediately ...
-		 */
-		if (isdigit (c))
-		{
-			int base;
-
-			if (c == '0')
-				if ((configBuf[configPos] == 'x') ||
-					(configBuf[configPos] == 'X'))
-                                {
-					base = 16;
-                                        val.numType = PARSE_HEX;
-                                }
-				else
-                                {
-					base = 8;
-                                        val.numType = PARSE_OCTAL;
-                                }
-			else
-                        {
-				base = 10;
-                                val.numType = PARSE_DECIMAL;
-                        }
-
-			configRBuf[0] = c;
-			i = 1;
-			while (isdigit (c = configBuf[configPos++]) ||
-				   (c == '.') || (c == 'x') || (c == 'X') ||
-				   ((base == 16) && (((c >= 'a') && (c <= 'f')) ||
-									 ((c >= 'A') && (c <= 'F')))))
-				configRBuf[i++] = c;
-			configPos--;		/* GJA -- one too far */
-			configRBuf[i] = '\0';
-			val.num = strtoul (configRBuf, NULL, 0);
-			val.realnum = atof (configRBuf);
-			return NUMBER;
-		}
-
-		/* 
-		 * All Strings START with a \" ...
-		 */
-		else if (c == '\"')
-		{
-			i = -1;
-			do
-			{
-				configRBuf[++i] = (c = configBuf[configPos++]);
-			}
-			while ((c != '\"') && (c != '\n') && (c != '\r') && (c != '\0'));
-			configRBuf[i] = '\0';
-			val.str = malloc (strlen (configRBuf) + 1);
-			strcpy (val.str, configRBuf);	/* private copy ! */
-			return STRING;
-		}
-
-		/* 
-		 * ... and now we MUST have a valid token.  The search is
-		 * handled later along with the pushed tokens.
-		 */
-		else
-		{
-			configRBuf[0] = c;
-			i = 0;
-			do
-			{
-				configRBuf[++i] = (c = configBuf[configPos++]);
-			}
-			while ((c != ' ') && (c != '\t') && (c != '\n') && (c != '\r') && (c != '\0') && (c != '#'));
-			--configPos;
-			configRBuf[i] = '\0';
-			i = 0;
-		}
-
-	}
-	else
-	{
-
-		/* 
-		 * Here we deal with pushed tokens. Reinitialize pushToken again. If
-		 * the pushed token was NUMBER || STRING return them again ...
-		 */
-		int temp = pushToken;
-		pushToken = LOCK_TOKEN;
-
-		if (temp == COMMA || temp == DASH)
-			return temp;
-		if (temp == NUMBER || temp == STRING)
-			return temp;
-	}
-
-	/* 
-	 * Joop, at last we have to lookup the token ...
-	 */
-	if (tab)
-	{
-		i = 0;
-		while (tab[i].token != -1)
-			if (xf86nameCompare (configRBuf, tab[i].name) == 0)
-				return tab[i].token;
-			else
-				i++;
-	}
-
-	return ERROR_TOKEN;		/* Error catcher */
+    int c, i;
+
+    /* 
+     * First check whether pushToken has a different value than LOCK_TOKEN.
+     * In this case rBuf[] contains a valid STRING/TOKEN/NUMBER. But in the
+     * oth * case the next token must be read from the input.
+     */
+    if (pushToken == EOF_TOKEN)
+        return EOF_TOKEN;
+    else if (pushToken == LOCK_TOKEN) {
+        /*
+         * eol_seen is only set for the first token after a newline.
+         */
+        eol_seen = 0;
+
+        c = configBuf[configPos];
+
+        /* 
+         * Get start of next Token. EOF is handled,
+         * whitespaces are skipped. 
+         */
+
+ again:
+        if (!c) {
+            char *ret;
+
+            if (numFiles > 0)
+                ret = xf86getNextLine();
+            else {
+                if (builtinConfig[builtinIndex] == NULL)
+                    ret = NULL;
+                else {
+                    strlcpy(configBuf,
+                            builtinConfig[builtinIndex], CONFIG_BUF_LEN);
+                    ret = configBuf;
+                    builtinIndex++;
+                }
+            }
+            if (ret == NULL) {
+                /*
+                 * if necessary, move to the next file and
+                 * read the first line
+                 */
+                if (curFileIndex + 1 < numFiles) {
+                    curFileIndex++;
+                    configLineNo = 0;
+                    goto again;
+                }
+                else
+                    return pushToken = EOF_TOKEN;
+            }
+            configLineNo++;
+            configPos = 0;
+            eol_seen = 1;
+        }
+
+        i = 0;
+        for (;;) {
+            c = configBuf[configPos++];
+            configRBuf[i++] = c;
+            switch (c) {
+            case ' ':
+            case '\t':
+            case '\r':
+                continue;
+            case '\n':
+                i = 0;
+                continue;
+            }
+            break;
+        }
+        if (c == '\0')
+            goto again;
+
+        if (c == '#') {
+            do {
+                configRBuf[i++] = (c = configBuf[configPos++]);
+            }
+            while ((c != '\n') && (c != '\r') && (c != '\0'));
+            configRBuf[i] = '\0';
+            /* XXX no private copy.
+             * Use xf86addComment when setting a comment.
+             */
+            val.str = configRBuf;
+            return COMMENT;
+        }
+
+        /* GJA -- handle '-' and ','  * Be careful: "-hsync" is a keyword. */
+        else if ((c == ',') && !isalpha(configBuf[configPos])) {
+            return COMMA;
+        }
+        else if ((c == '-') && !isalpha(configBuf[configPos])) {
+            return DASH;
+        }
+
+        /* 
+         * Numbers are returned immediately ...
+         */
+        if (isdigit(c)) {
+            int base;
+
+            if (c == '0')
+                if ((configBuf[configPos] == 'x') ||
+                    (configBuf[configPos] == 'X')) {
+                    base = 16;
+                    val.numType = PARSE_HEX;
+                }
+                else {
+                    base = 8;
+                    val.numType = PARSE_OCTAL;
+                }
+            else {
+                base = 10;
+                val.numType = PARSE_DECIMAL;
+            }
+
+            configRBuf[0] = c;
+            i = 1;
+            while (isdigit(c = configBuf[configPos++]) ||
+                   (c == '.') || (c == 'x') || (c == 'X') ||
+                   ((base == 16) && (((c >= 'a') && (c <= 'f')) ||
+                                     ((c >= 'A') && (c <= 'F')))))
+                configRBuf[i++] = c;
+            configPos--;        /* GJA -- one too far */
+            configRBuf[i] = '\0';
+            val.num = strtoul(configRBuf, NULL, 0);
+            val.realnum = atof(configRBuf);
+            return NUMBER;
+        }
+
+        /* 
+         * All Strings START with a \" ...
+         */
+        else if (c == '\"') {
+            i = -1;
+            do {
+                configRBuf[++i] = (c = configBuf[configPos++]);
+            }
+            while ((c != '\"') && (c != '\n') && (c != '\r') && (c != '\0'));
+            configRBuf[i] = '\0';
+            val.str = malloc(strlen(configRBuf) + 1);
+            strcpy(val.str, configRBuf);        /* private copy ! */
+            return STRING;
+        }
+
+        /* 
+         * ... and now we MUST have a valid token.  The search is
+         * handled later along with the pushed tokens.
+         */
+        else {
+            configRBuf[0] = c;
+            i = 0;
+            do {
+                configRBuf[++i] = (c = configBuf[configPos++]);
+            }
+            while ((c != ' ') && (c != '\t') && (c != '\n') && (c != '\r') &&
+                   (c != '\0') && (c != '#'));
+            --configPos;
+            configRBuf[i] = '\0';
+            i = 0;
+        }
+
+    }
+    else {
+
+        /* 
+         * Here we deal with pushed tokens. Reinitialize pushToken again. If
+         * the pushed token was NUMBER || STRING return them again ...
+         */
+        int temp = pushToken;
+
+        pushToken = LOCK_TOKEN;
+
+        if (temp == COMMA || temp == DASH)
+            return temp;
+        if (temp == NUMBER || temp == STRING)
+            return temp;
+    }
+
+    /* 
+     * Joop, at last we have to lookup the token ...
+     */
+    if (tab) {
+        i = 0;
+        while (tab[i].token != -1)
+            if (xf86nameCompare(configRBuf, tab[i].name) == 0)
+                return tab[i].token;
+            else
+                i++;
+    }
+
+    return ERROR_TOKEN;         /* Error catcher */
 }
 
 int
-xf86getSubToken (char **comment)
+xf86getSubToken(char **comment)
 {
-	int token;
-
-	for (;;) {
-		token = xf86getToken(NULL);
-		if (token == COMMENT) {
-			if (comment)
-				*comment = xf86addComment(*comment, val.str);
-		}
-		else
-			return token;
-	}
-	/*NOTREACHED*/
-}
+    int token;
+
+    for (;;) {
+        token = xf86getToken(NULL);
+        if (token == COMMENT) {
+            if (comment)
+                *comment = xf86addComment(*comment, val.str);
+        }
+        else
+            return token;
+    }
+ /*NOTREACHED*/}
 
 int
-xf86getSubTokenWithTab (char **comment, xf86ConfigSymTabRec *tab)
+xf86getSubTokenWithTab(char **comment, xf86ConfigSymTabRec * tab)
 {
-	int token;
-
-	for (;;) {
-		token = xf86getToken(tab);
-		if (token == COMMENT) {
-			if (comment)
-				*comment = xf86addComment(*comment, val.str);
-		}
-		else
-			return token;
-	}
-	/*NOTREACHED*/
-}
+    int token;
+
+    for (;;) {
+        token = xf86getToken(tab);
+        if (token == COMMENT) {
+            if (comment)
+                *comment = xf86addComment(*comment, val.str);
+        }
+        else
+            return token;
+    }
+ /*NOTREACHED*/}
 
 void
-xf86unGetToken (int token)
+xf86unGetToken(int token)
 {
-	pushToken = token;
+    pushToken = token;
 }
 
 char *
-xf86tokenString (void)
+xf86tokenString(void)
 {
-	return configRBuf;
+    return configRBuf;
 }
 
 int
 xf86pathIsAbsolute(const char *path)
 {
-	if (path && path[0] == '/')
-		return 1;
-	return 0;
+    if (path && path[0] == '/')
+        return 1;
+    return 0;
 }
 
 /* A path is "safe" if it is relative and if it contains no ".." elements. */
 int
 xf86pathIsSafe(const char *path)
 {
-	if (xf86pathIsAbsolute(path))
-		return 0;
+    if (xf86pathIsAbsolute(path))
+        return 0;
 
-	/* Compare with ".." */
-	if (!strcmp(path, ".."))
-		return 0;
+    /* Compare with ".." */
+    if (!strcmp(path, ".."))
+        return 0;
 
-	/* Look for leading "../" */
-	if (!strncmp(path, "../", 3))
-		return 0;
+    /* Look for leading "../" */
+    if (!strncmp(path, "../", 3))
+        return 0;
 
-	/* Look for trailing "/.." */
-	if ((strlen(path) > 3) && !strcmp(path + strlen(path) - 3, "/.."))
-		return 0;
+    /* Look for trailing "/.." */
+    if ((strlen(path) > 3) && !strcmp(path + strlen(path) - 3, "/.."))
+        return 0;
 
-	/* Look for "/../" */
-	if (strstr(path, "/../"))
-		return 0;
+    /* Look for "/../" */
+    if (strstr(path, "/../"))
+        return 0;
 
-	return 1;
+    return 1;
 }
 
 /*
@@ -596,129 +584,136 @@ xf86pathIsSafe(const char *path)
 
 static char *
 DoSubstitution(const char *template, const char *cmdline, const char *projroot,
-				int *cmdlineUsed, int *envUsed,
-				const char *XConfigFile)
+               int *cmdlineUsed, int *envUsed, const char *XConfigFile)
 {
-	char *result;
-	int i, l;
-	static const char *env = NULL;
-	static char *hostname = NULL;
-
-	if (!template)
-		return NULL;
-
-	if (cmdlineUsed)
-		*cmdlineUsed = 0;
-	if (envUsed)
-		*envUsed = 0;
-
-	result = malloc(PATH_MAX + 1);
-	l = 0;
-	for (i = 0; template[i]; i++) {
-		if (template[i] != '%') {
-			result[l++] = template[i];
-			CHECK_LENGTH;
-		} else {
-			switch (template[++i]) {
-			case 'A':
-				if (cmdline && xf86pathIsAbsolute(cmdline)) {
-					APPEND_STR(cmdline);
-					if (cmdlineUsed)
-						*cmdlineUsed = 1;
-				} else
-					BAIL_OUT;
-				break;
-			case 'R':
-				if (cmdline && !xf86pathIsAbsolute(cmdline)) {
-					APPEND_STR(cmdline);
-					if (cmdlineUsed)
-						*cmdlineUsed = 1;
-				} else 
-					BAIL_OUT;
-				break;
-			case 'S':
-				if (cmdline && xf86pathIsSafe(cmdline)) {
-					APPEND_STR(cmdline);
-					if (cmdlineUsed)
-						*cmdlineUsed = 1;
-				} else 
-					BAIL_OUT;
-				break;
-			case 'X':
-				APPEND_STR(XConfigFile);
-				break;
-			case 'H':
-				if (!hostname) {
-					if ((hostname = malloc(MAXHOSTNAMELEN + 1))) {
-						if (gethostname(hostname, MAXHOSTNAMELEN) == 0) {
-							hostname[MAXHOSTNAMELEN] = '\0';
-						} else {
-							free(hostname);
-							hostname = NULL;
-						}
-					}
-				}
-				if (hostname)
-					APPEND_STR(hostname);
-				break;
-			case 'E':
-				if (!env)
-					env = getenv(XCONFENV);
-				if (env && xf86pathIsAbsolute(env)) {
-					APPEND_STR(env);
-					if (envUsed)
-						*envUsed = 1;
-				} else
-					BAIL_OUT;
-				break;
-			case 'F':
-				if (!env)
-					env = getenv(XCONFENV);
-				if (env && !xf86pathIsAbsolute(env)) {
-					APPEND_STR(env);
-					if (envUsed)
-						*envUsed = 1;
-				} else
-					BAIL_OUT;
-				break;
-			case 'G':
-				if (!env)
-					env = getenv(XCONFENV);
-				if (env && xf86pathIsSafe(env)) {
-					APPEND_STR(env);
-					if (envUsed)
-						*envUsed = 1;
-				} else
-					BAIL_OUT;
-				break;
-			case 'P':
-				if (projroot && xf86pathIsAbsolute(projroot))
-					APPEND_STR(projroot);
-				else
-					BAIL_OUT;
-				break;
-			case 'C':
-				APPEND_STR(SYSCONFDIR);
-				break;
-			case 'D':
-				APPEND_STR(DATADIR);
-				break;
-			case '%':
-				result[l++] = '%';
-				CHECK_LENGTH;
-				break;
-			default:
-				fprintf(stderr, "invalid escape %%%c found in path template\n",
-						template[i]);
-				BAIL_OUT;
-				break;
-			}
-		}
-	}
+    char *result;
+    int i, l;
+    static const char *env = NULL;
+    static char *hostname = NULL;
+
+    if (!template)
+        return NULL;
+
+    if (cmdlineUsed)
+        *cmdlineUsed = 0;
+    if (envUsed)
+        *envUsed = 0;
+
+    result = malloc(PATH_MAX + 1);
+    l = 0;
+    for (i = 0; template[i]; i++) {
+        if (template[i] != '%') {
+            result[l++] = template[i];
+            CHECK_LENGTH;
+        }
+        else {
+            switch (template[++i]) {
+            case 'A':
+                if (cmdline && xf86pathIsAbsolute(cmdline)) {
+                    APPEND_STR(cmdline);
+                    if (cmdlineUsed)
+                        *cmdlineUsed = 1;
+                }
+                else
+                    BAIL_OUT;
+                break;
+            case 'R':
+                if (cmdline && !xf86pathIsAbsolute(cmdline)) {
+                    APPEND_STR(cmdline);
+                    if (cmdlineUsed)
+                        *cmdlineUsed = 1;
+                }
+                else
+                    BAIL_OUT;
+                break;
+            case 'S':
+                if (cmdline && xf86pathIsSafe(cmdline)) {
+                    APPEND_STR(cmdline);
+                    if (cmdlineUsed)
+                        *cmdlineUsed = 1;
+                }
+                else
+                    BAIL_OUT;
+                break;
+            case 'X':
+                APPEND_STR(XConfigFile);
+                break;
+            case 'H':
+                if (!hostname) {
+                    if ((hostname = malloc(MAXHOSTNAMELEN + 1))) {
+                        if (gethostname(hostname, MAXHOSTNAMELEN) == 0) {
+                            hostname[MAXHOSTNAMELEN] = '\0';
+                        }
+                        else {
+                            free(hostname);
+                            hostname = NULL;
+                        }
+                    }
+                }
+                if (hostname)
+                    APPEND_STR(hostname);
+                break;
+            case 'E':
+                if (!env)
+                    env = getenv(XCONFENV);
+                if (env && xf86pathIsAbsolute(env)) {
+                    APPEND_STR(env);
+                    if (envUsed)
+                        *envUsed = 1;
+                }
+                else
+                    BAIL_OUT;
+                break;
+            case 'F':
+                if (!env)
+                    env = getenv(XCONFENV);
+                if (env && !xf86pathIsAbsolute(env)) {
+                    APPEND_STR(env);
+                    if (envUsed)
+                        *envUsed = 1;
+                }
+                else
+                    BAIL_OUT;
+                break;
+            case 'G':
+                if (!env)
+                    env = getenv(XCONFENV);
+                if (env && xf86pathIsSafe(env)) {
+                    APPEND_STR(env);
+                    if (envUsed)
+                        *envUsed = 1;
+                }
+                else
+                    BAIL_OUT;
+                break;
+            case 'P':
+                if (projroot && xf86pathIsAbsolute(projroot))
+                    APPEND_STR(projroot);
+                else
+                    BAIL_OUT;
+                break;
+            case 'C':
+                APPEND_STR(SYSCONFDIR);
+                break;
+            case 'D':
+                APPEND_STR(DATADIR);
+                break;
+            case '%':
+                result[l++] = '%';
+                CHECK_LENGTH;
+                break;
+            default:
+                fprintf(stderr, "invalid escape %%%c found in path template\n",
+                        template[i]);
+                BAIL_OUT;
+                break;
+            }
+        }
+    }
 #ifdef DEBUG
-	fprintf(stderr, "Converted `%s' to `%s'\n", template, result);
+    fprintf(stderr, "Converted `%s' to `%s'\n", template, result);
 #endif
-	return result;
+    return result;
 }
 
 /*
@@ -726,40 +721,40 @@ DoSubstitution(const char *template, const char *cmdline, const char *projroot,
  */
 static char *
 OpenConfigFile(const char *path, const char *cmdline, const char *projroot,
-	       const char *confname)
+               const char *confname)
 {
-	char *filepath = NULL;
-	char *pathcopy;
-	const char *template;
-	int cmdlineUsed = 0;
-	FILE *file = NULL;
-
-	pathcopy = strdup(path);
-	for (template = strtok(pathcopy, ","); template && !file;
-	     template = strtok(NULL, ",")) {
-		filepath = DoSubstitution(template, cmdline, projroot,
-					  &cmdlineUsed, NULL, confname);
-		if (!filepath)
-			continue;
-		if (cmdline && !cmdlineUsed) {
-			free(filepath);
-			filepath = NULL;
-			continue;
-		}
-		file = fopen(filepath, "r");
-		if (!file) {
-			free(filepath);
-			filepath = NULL;
-		}
-	}
-
-	free(pathcopy);
-	if (file) {
-		configFiles[numFiles].file = file;
-		configFiles[numFiles].path = strdup(filepath);
-		numFiles++;
-	}
-	return filepath;
+    char *filepath = NULL;
+    char *pathcopy;
+    const char *template;
+    int cmdlineUsed = 0;
+    FILE *file = NULL;
+
+    pathcopy = strdup(path);
+    for (template = strtok(pathcopy, ","); template && !file;
+         template = strtok(NULL, ",")) {
+        filepath = DoSubstitution(template, cmdline, projroot,
+                                  &cmdlineUsed, NULL, confname);
+        if (!filepath)
+            continue;
+        if (cmdline && !cmdlineUsed) {
+            free(filepath);
+            filepath = NULL;
+            continue;
+        }
+        file = fopen(filepath, "r");
+        if (!file) {
+            free(filepath);
+            filepath = NULL;
+        }
+    }
+
+    free(pathcopy);
+    if (file) {
+        configFiles[numFiles].file = file;
+        configFiles[numFiles].path = strdup(filepath);
+        numFiles++;
+    }
+    return filepath;
 }
 
 /*
@@ -769,56 +764,54 @@ OpenConfigFile(const char *path, const char *cmdline, const char *projroot,
 static int
 ConfigFilter(const struct dirent *de)
 {
-	const char *name = de->d_name;
-	size_t len;
-	size_t suflen = strlen(XCONFIGSUFFIX);
-
-	if (!name || name[0] == '.')
-		return 0;
-	len = strlen(name);
-	if(len <= suflen)
-		return 0;
-	if (strcmp(&name[len-suflen], XCONFIGSUFFIX) != 0)
-		return 0;
-	return 1;
+    const char *name = de->d_name;
+    size_t len;
+    size_t suflen = strlen(XCONFIGSUFFIX);
+
+    if (!name || name[0] == '.')
+        return 0;
+    len = strlen(name);
+    if (len <= suflen)
+        return 0;
+    if (strcmp(&name[len - suflen], XCONFIGSUFFIX) != 0)
+        return 0;
+    return 1;
 }
 
 static Bool
 AddConfigDirFiles(const char *dirpath, struct dirent **list, int num)
 {
-	int i;
-	Bool openedFile = FALSE;
-	Bool warnOnce = FALSE;
-
-	for (i = 0; i < num; i++) {
-		char *path;
-		FILE *file;
-
-		if (numFiles >= CONFIG_MAX_FILES) {
-			if (!warnOnce) {
-				ErrorF("Maximum number of configuration "
-				       "files opened\n");
-				warnOnce = TRUE;
-			}
-			continue;
-		}
-
-		path = malloc(PATH_MAX + 1);
-		snprintf(path, PATH_MAX + 1, "%s/%s", dirpath,
-			 list[i]->d_name);
-		file = fopen(path, "r");
-		if (!file) {
-			free(path);
-			continue;
-		}
-		openedFile = TRUE;
-
-		configFiles[numFiles].file = file;
-		configFiles[numFiles].path = path;
-		numFiles++;
-	}
-
-	return openedFile;
+    int i;
+    Bool openedFile = FALSE;
+    Bool warnOnce = FALSE;
+
+    for (i = 0; i < num; i++) {
+        char *path;
+        FILE *file;
+
+        if (numFiles >= CONFIG_MAX_FILES) {
+            if (!warnOnce) {
+                ErrorF("Maximum number of configuration " "files opened\n");
+                warnOnce = TRUE;
+            }
+            continue;
+        }
+
+        path = malloc(PATH_MAX + 1);
+        snprintf(path, PATH_MAX + 1, "%s/%s", dirpath, list[i]->d_name);
+        file = fopen(path, "r");
+        if (!file) {
+            free(path);
+            continue;
+        }
+        openedFile = TRUE;
+
+        configFiles[numFiles].file = file;
+        configFiles[numFiles].path = path;
+        numFiles++;
+    }
+
+    return openedFile;
 }
 
 /*
@@ -827,47 +820,47 @@ AddConfigDirFiles(const char *dirpath, struct dirent **list, int num)
  */
 static char *
 OpenConfigDir(const char *path, const char *cmdline, const char *projroot,
-	      const char *confname)
+              const char *confname)
 {
-	char *dirpath, *pathcopy;
-	const char *template;
-	Bool found = FALSE;
-	int cmdlineUsed = 0;
-
-	pathcopy = strdup(path);
-	for (template = strtok(pathcopy, ","); template && !found;
-	     template = strtok(NULL, ",")) {
-		struct dirent **list = NULL;
-		int num;
-
-		dirpath = DoSubstitution(template, cmdline, projroot,
-					 &cmdlineUsed, NULL, confname);
-		if (!dirpath)
-			continue;
-		if (cmdline && !cmdlineUsed) {
-			free(dirpath);
-			dirpath = NULL;
-			continue;
-		}
-
-		/* match files named *.conf */
-		num = scandir(dirpath, &list, ConfigFilter, alphasort);
-		if (num < 0) {
-			list = NULL;
-			num = 0;
-		}
-		found = AddConfigDirFiles(dirpath, list, num);
-		if (!found) {
-			free(dirpath);
-			dirpath = NULL;
-		}
-		while (num--)
-			free(list[num]);
-		free(list);
-	}
-
-	free(pathcopy);
-	return dirpath;
+    char *dirpath, *pathcopy;
+    const char *template;
+    Bool found = FALSE;
+    int cmdlineUsed = 0;
+
+    pathcopy = strdup(path);
+    for (template = strtok(pathcopy, ","); template && !found;
+         template = strtok(NULL, ",")) {
+        struct dirent **list = NULL;
+        int num;
+
+        dirpath = DoSubstitution(template, cmdline, projroot,
+                                 &cmdlineUsed, NULL, confname);
+        if (!dirpath)
+            continue;
+        if (cmdline && !cmdlineUsed) {
+            free(dirpath);
+            dirpath = NULL;
+            continue;
+        }
+
+        /* match files named *.conf */
+        num = scandir(dirpath, &list, ConfigFilter, alphasort);
+        if (num < 0) {
+            list = NULL;
+            num = 0;
+        }
+        found = AddConfigDirFiles(dirpath, list, num);
+        if (!found) {
+            free(dirpath);
+            dirpath = NULL;
+        }
+        while (num--)
+            free(list[num]);
+        free(list);
+    }
+
+    free(pathcopy);
+    return dirpath;
 }
 
 /*
@@ -876,14 +869,14 @@ OpenConfigDir(const char *path, const char *cmdline, const char *projroot,
 void
 xf86initConfigFiles(void)
 {
-	curFileIndex = 0;
-	configPos = 0;
-	configLineNo = 0;
-	pushToken = LOCK_TOKEN;
-
-	configBuf = malloc(CONFIG_BUF_LEN);
-	configRBuf = malloc(CONFIG_BUF_LEN);
-	configBuf[0] = '\0';	/* sanity ... */
+    curFileIndex = 0;
+    configPos = 0;
+    configLineNo = 0;
+    pushToken = LOCK_TOKEN;
+
+    configBuf = malloc(CONFIG_BUF_LEN);
+    configRBuf = malloc(CONFIG_BUF_LEN);
+    configBuf[0] = '\0';        /* sanity ... */
 }
 
 /*
@@ -922,13 +915,13 @@ xf86initConfigFiles(void)
 char *
 xf86openConfigFile(const char *path, const char *cmdline, const char *projroot)
 {
-	if (!path || !path[0])
-		path = DEFAULT_CONF_PATH;
-	if (!projroot || !projroot[0])
-		projroot = PROJECTROOT;
+    if (!path || !path[0])
+        path = DEFAULT_CONF_PATH;
+    if (!projroot || !projroot[0])
+        projroot = PROJECTROOT;
 
-	/* Search for a config file */
-	return OpenConfigFile(path, cmdline, projroot, XCONFIGFILE);
+    /* Search for a config file */
+    return OpenConfigFile(path, cmdline, projroot, XCONFIGFILE);
 }
 
 /*
@@ -949,82 +942,82 @@ xf86openConfigFile(const char *path, const char *cmdline, const char *projroot)
  */
 char *
 xf86openConfigDirFiles(const char *path, const char *cmdline,
-		       const char *projroot)
+                       const char *projroot)
 {
-	if (!path || !path[0])
-		path = DEFAULT_CONF_PATH;
-	if (!projroot || !projroot[0])
-		projroot = PROJECTROOT;
+    if (!path || !path[0])
+        path = DEFAULT_CONF_PATH;
+    if (!projroot || !projroot[0])
+        projroot = PROJECTROOT;
 
-	/* Search for the multiconf directory */
-	return OpenConfigDir(path, cmdline, projroot, XCONFIGDIR);
+    /* Search for the multiconf directory */
+    return OpenConfigDir(path, cmdline, projroot, XCONFIGDIR);
 }
 
 void
-xf86closeConfigFile (void)
+xf86closeConfigFile(void)
 {
-	int i;
-
-	free (configRBuf);
-	configRBuf = NULL;
-	free (configBuf);
-	configBuf = NULL;
-
-	if (numFiles == 0) {
-		builtinConfig = NULL;
-		builtinIndex = 0;
-	}
-	for (i = 0; i < numFiles; i++) {
-		fclose(configFiles[i].file);
-		configFiles[i].file = NULL;
-		free(configFiles[i].path);
-		configFiles[i].path = NULL;
-	}
-	numFiles = 0;
+    int i;
+
+    free(configRBuf);
+    configRBuf = NULL;
+    free(configBuf);
+    configBuf = NULL;
+
+    if (numFiles == 0) {
+        builtinConfig = NULL;
+        builtinIndex = 0;
+    }
+    for (i = 0; i < numFiles; i++) {
+        fclose(configFiles[i].file);
+        configFiles[i].file = NULL;
+        free(configFiles[i].path);
+        configFiles[i].path = NULL;
+    }
+    numFiles = 0;
 }
 
 void
 xf86setBuiltinConfig(const char *config[])
 {
-	builtinConfig = config;
+    builtinConfig = config;
 }
 
 void
-xf86parseError (const char *format,...)
+xf86parseError(const char *format, ...)
 {
-	va_list ap;
-	const char *filename = numFiles ? configFiles[curFileIndex].path
-					: "<builtin configuration>";
+    va_list ap;
+    const char *filename = numFiles ? configFiles[curFileIndex].path
+        : "<builtin configuration>";
 
-	ErrorF ("Parse error on line %d of section %s in file %s\n\t",
-		 configLineNo, configSection, filename);
-	va_start (ap, format);
-	VErrorF (format, ap);
-	va_end (ap);
+    ErrorF("Parse error on line %d of section %s in file %s\n\t",
+           configLineNo, configSection, filename);
+    va_start(ap, format);
+    VErrorF(format, ap);
+    va_end(ap);
 
-	ErrorF ("\n");
+    ErrorF("\n");
 }
 
 void
-xf86validationError (const char *format,...)
+xf86validationError(const char *format, ...)
 {
-	va_list ap;
-	const char *filename = numFiles ? configFiles[curFileIndex].path
-					: "<builtin configuration>";
+    va_list ap;
+    const char *filename = numFiles ? configFiles[curFileIndex].path
+        : "<builtin configuration>";
 
-	ErrorF ("Data incomplete in file %s\n\t", filename);
-	va_start (ap, format);
-	VErrorF (format, ap);
-	va_end (ap);
+    ErrorF("Data incomplete in file %s\n\t", filename);
+    va_start(ap, format);
+    VErrorF(format, ap);
+    va_end(ap);
 
-	ErrorF ("\n");
+    ErrorF("\n");
 }
 
 void
-xf86setSection (const char *section)
+xf86setSection(const char *section)
 {
-	free(configSection);
-	configSection = strdup(section);
+    free(configSection);
+    configSection = strdup(section);
 }
 
 /* 
@@ -1032,145 +1025,143 @@ xf86setSection (const char *section)
  *  Lookup a string if it is actually a token in disguise.
  */
 int
-xf86getStringToken (xf86ConfigSymTabRec * tab)
+xf86getStringToken(xf86ConfigSymTabRec * tab)
 {
-	return StringToToken (val.str, tab);
+    return StringToToken(val.str, tab);
 }
 
 static int
-StringToToken (const char *str, xf86ConfigSymTabRec * tab)
+StringToToken(const char *str, xf86ConfigSymTabRec * tab)
 {
-	int i;
-
-	for (i = 0; tab[i].token != -1; i++)
-	{
-		if (!xf86nameCompare (tab[i].name, str))
-			return tab[i].token;
-	}
-	return ERROR_TOKEN;
-}
+    int i;
 
+    for (i = 0; tab[i].token != -1; i++) {
+        if (!xf86nameCompare(tab[i].name, str))
+            return tab[i].token;
+    }
+    return ERROR_TOKEN;
+}
 
 /* 
  * Compare two names.  The characters '_', ' ', and '\t' are ignored
  * in the comparison.
  */
 int
-xf86nameCompare (const char *s1, const char *s2)
+xf86nameCompare(const char *s1, const char *s2)
 {
-	char c1, c2;
-
-	if (!s1 || *s1 == 0) {
-		if (!s2 || *s2 == 0)
-			return 0;
-		else
-			return 1;
-		}
-
-	while (*s1 == '_' || *s1 == ' ' || *s1 == '\t')
-		s1++;
-	while (*s2 == '_' || *s2 == ' ' || *s2 == '\t')
-		s2++;
-	c1 = (isupper (*s1) ? tolower (*s1) : *s1);
-	c2 = (isupper (*s2) ? tolower (*s2) : *s2);
-	while (c1 == c2)
-	{
-		if (c1 == '\0')
-			return 0;
-		s1++;
-		s2++;
-		while (*s1 == '_' || *s1 == ' ' || *s1 == '\t')
-			s1++;
-		while (*s2 == '_' || *s2 == ' ' || *s2 == '\t')
-			s2++;
-		c1 = (isupper (*s1) ? tolower (*s1) : *s1);
-		c2 = (isupper (*s2) ? tolower (*s2) : *s2);
-	}
-	return c1 - c2;
+    char c1, c2;
+
+    if (!s1 || *s1 == 0) {
+        if (!s2 || *s2 == 0)
+            return 0;
+        else
+            return 1;
+    }
+
+    while (*s1 == '_' || *s1 == ' ' || *s1 == '\t')
+        s1++;
+    while (*s2 == '_' || *s2 == ' ' || *s2 == '\t')
+        s2++;
+    c1 = (isupper(*s1) ? tolower(*s1) : *s1);
+    c2 = (isupper(*s2) ? tolower(*s2) : *s2);
+    while (c1 == c2) {
+        if (c1 == '\0')
+            return 0;
+        s1++;
+        s2++;
+        while (*s1 == '_' || *s1 == ' ' || *s1 == '\t')
+            s1++;
+        while (*s2 == '_' || *s2 == ' ' || *s2 == '\t')
+            s2++;
+        c1 = (isupper(*s1) ? tolower(*s1) : *s1);
+        c2 = (isupper(*s2) ? tolower(*s2) : *s2);
+    }
+    return c1 - c2;
 }
 
 char *
 xf86addComment(char *cur, char *add)
 {
-	char *str;
-	int len, curlen, iscomment, hasnewline = 0, insnewline, endnewline;
-
-	if (add == NULL || add[0] == '\0')
-		return cur;
-
-	if (cur) {
-		curlen = strlen(cur);
-		if (curlen)
-		    hasnewline = cur[curlen - 1] == '\n';
-		eol_seen = 0;
-	}
-	else
-		curlen = 0;
-
-	str = add;
-	iscomment = 0;
-	while (*str) {
-	    if (*str != ' ' && *str != '\t')
-		break;
-	    ++str;
-	}
-	iscomment = (*str == '#');
-
-	len = strlen(add);
-	endnewline = add[len - 1] == '\n';
-
-	insnewline = eol_seen || (curlen && !hasnewline);
-	if (insnewline)
-		len++;
-	if (!iscomment)
-		len++;
-	if (!endnewline)
-		len++;
-
-	/* Allocate + 1 char for '\0' terminator. */
-	str = realloc(cur, curlen + len + 1);
-	if (!str)
-		return cur;
-
-	cur = str;
-
-	if (insnewline)
-		cur[curlen++] = '\n';
-	if (!iscomment)
-		cur[curlen++] = '#';
-	strcpy(cur + curlen, add);
-	if (!endnewline)
-		strcat(cur, "\n");
-
-	return cur;
+    char *str;
+    int len, curlen, iscomment, hasnewline = 0, insnewline, endnewline;
+
+    if (add == NULL || add[0] == '\0')
+        return cur;
+
+    if (cur) {
+        curlen = strlen(cur);
+        if (curlen)
+            hasnewline = cur[curlen - 1] == '\n';
+        eol_seen = 0;
+    }
+    else
+        curlen = 0;
+
+    str = add;
+    iscomment = 0;
+    while (*str) {
+        if (*str != ' ' && *str != '\t')
+            break;
+        ++str;
+    }
+    iscomment = (*str == '#');
+
+    len = strlen(add);
+    endnewline = add[len - 1] == '\n';
+
+    insnewline = eol_seen || (curlen && !hasnewline);
+    if (insnewline)
+        len++;
+    if (!iscomment)
+        len++;
+    if (!endnewline)
+        len++;
+
+    /* Allocate + 1 char for '\0' terminator. */
+    str = realloc(cur, curlen + len + 1);
+    if (!str)
+        return cur;
+
+    cur = str;
+
+    if (insnewline)
+        cur[curlen++] = '\n';
+    if (!iscomment)
+        cur[curlen++] = '#';
+    strcpy(cur + curlen, add);
+    if (!endnewline)
+        strcat(cur, "\n");
+
+    return cur;
 }
 
 Bool
 xf86getBoolValue(Bool *val, const char *str)
 {
-	if (!val || !str)
-		return FALSE;
-	if (*str == '\0') {
-		*val = TRUE;
-	} else {
-		if (xf86nameCompare(str, "1") == 0)
-			*val = TRUE;
-		else if (xf86nameCompare(str, "on") == 0)
-			*val = TRUE;
-		else if (xf86nameCompare(str, "true") == 0)
-			*val = TRUE;
-		else if (xf86nameCompare(str, "yes") == 0)
-			*val = TRUE;
-		else if (xf86nameCompare(str, "0") == 0)
-			*val = FALSE;
-		else if (xf86nameCompare(str, "off") == 0)
-			*val = FALSE;
-		else if (xf86nameCompare(str, "false") == 0)
-			*val = FALSE;
-		else if (xf86nameCompare(str, "no") == 0)
-			*val = FALSE;
-		else
-			return FALSE;
-	}
-	return TRUE;
+    if (!val || !str)
+        return FALSE;
+    if (*str == '\0') {
+        *val = TRUE;
+    }
+    else {
+        if (xf86nameCompare(str, "1") == 0)
+            *val = TRUE;
+        else if (xf86nameCompare(str, "on") == 0)
+            *val = TRUE;
+        else if (xf86nameCompare(str, "true") == 0)
+            *val = TRUE;
+        else if (xf86nameCompare(str, "yes") == 0)
+            *val = TRUE;
+        else if (xf86nameCompare(str, "0") == 0)
+            *val = FALSE;
+        else if (xf86nameCompare(str, "off") == 0)
+            *val = FALSE;
+        else if (xf86nameCompare(str, "false") == 0)
+            *val = FALSE;
+        else if (xf86nameCompare(str, "no") == 0)
+            *val = FALSE;
+        else
+            return FALSE;
+    }
+    return TRUE;
 }