1 files changed, 305 insertions, 305 deletions

diff --git a/src/uscxml/plugins/Pluma/uce-dirent.h b/src/uscxml/plugins/Pluma/uce-dirent.h
index 8cbd0e5..bafd4e4 100644
--- a/src/uscxml/plugins/Pluma/uce-dirent.h
+++ b/src/uscxml/plugins/Pluma/uce-dirent.h
@@ -278,25 +278,25 @@ typedef struct DIR {
 extern "C" {
 # endif
 
-	/* supply prototypes for dirent functions */
-	static DIR *opendir (const char *dirname);
-	static struct dirent *readdir (DIR *dirp);
-	static int closedir (DIR *dirp);
-	static void rewinddir (DIR *dirp);
-
-	/*
-	 * Implement dirent interface as static functions so that the user does not
-	 * need to change his project in any way to use dirent function.  With this
-	 * it is sufficient to include this very header from source modules using
-	 * dirent functions and the functions will be pulled in automatically.
-	 */
+/* supply prototypes for dirent functions */
+static DIR *opendir (const char *dirname);
+static struct dirent *readdir (DIR *dirp);
+static int closedir (DIR *dirp);
+static void rewinddir (DIR *dirp);
+
+/*
+ * Implement dirent interface as static functions so that the user does not
+ * need to change his project in any way to use dirent function.  With this
+ * it is sufficient to include this very header from source modules using
+ * dirent functions and the functions will be pulled in automatically.
+ */
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <assert.h>
 #include <errno.h>
 
-	/* use ffblk instead of _find_t if requested */
+/* use ffblk instead of _find_t if requested */
 #if defined(DIRENT_USE_FFBLK)
 # define _A_ARCH   (FA_ARCH)
 # define _A_HIDDEN (FA_HIDDEN)
@@ -309,353 +309,353 @@ extern "C" {
 # define _dos_findfirst(name,flags,dest) findfirst(name,dest,flags)
 #endif
 
-	static int _initdir (DIR *p);
-	static const char *_getdirname (const struct dirent *dp);
-	static void _setdirname (struct DIR *dirp);
-
-	/*
-	 * <function name="opendir">
-	 * <intro>open directory stream for reading
-	 * <syntax>DIR *opendir (const char *dirname);
-	 *
-	 * <desc>Open named directory stream for read and return pointer to the
-	 * internal working area that is used for retrieving individual directory
-	 * entries.  The internal working area has no fields of your interest.
-	 *
-	 * <ret>Returns a pointer to the internal working area or NULL in case the
-	 * directory stream could not be opened.  Global `errno' variable will set
-	 * in case of error as follows:
-	 *
-	 * <table>
-	 * [EACESS  |Permission denied.
-	 * [EMFILE  |Too many open files used by the process.
-	 * [ENFILE  |Too many open files in system.
-	 * [ENOENT  |Directory does not exist.
-	 * [ENOMEM  |Insufficient memory.
-	 * [ENOTDIR |dirname does not refer to directory.  This value is not
-	 *           reliable on MS-DOS and MS-Windows platforms.  Many
-	 *           implementations return ENOENT even when the name refers to a
-	 *           file.]
-	 * </table>
-	 * </function>
-	 */
-	static DIR *
-	opendir(
-	    const char *dirname) {
-		DIR *dirp;
-		assert (dirname != NULL);
-
-		dirp = (DIR*)malloc (sizeof (struct DIR));
-		if (dirp != NULL) {
-			char *p;
-
-			/* allocate room for directory name */
-			dirp->dirname = (char*) malloc (strlen (dirname) + 1 + strlen ("\\*.*"));
-			if (dirp->dirname == NULL) {
-				/* failed to duplicate directory name.  errno set by malloc() */
-				free (dirp);
-				return NULL;
-			}
-			/* Copy directory name while appending directory separator and "*.*".
-			 * Directory separator is not appended if the name already ends with
-			 * drive or directory separator.  Directory separator is assumed to be
-			 * '/' or '\' and drive separator is assumed to be ':'. */
-			strcpy (dirp->dirname, dirname);
-			p = strchr (dirp->dirname, '\0');
-			if (dirp->dirname < p  &&
-			        *(p - 1) != '\\'  &&  *(p - 1) != '/'  &&  *(p - 1) != ':') {
-				strcpy (p++, "/");
-			}
+static int _initdir (DIR *p);
+static const char *_getdirname (const struct dirent *dp);
+static void _setdirname (struct DIR *dirp);
+
+/*
+ * <function name="opendir">
+ * <intro>open directory stream for reading
+ * <syntax>DIR *opendir (const char *dirname);
+ *
+ * <desc>Open named directory stream for read and return pointer to the
+ * internal working area that is used for retrieving individual directory
+ * entries.  The internal working area has no fields of your interest.
+ *
+ * <ret>Returns a pointer to the internal working area or NULL in case the
+ * directory stream could not be opened.  Global `errno' variable will set
+ * in case of error as follows:
+ *
+ * <table>
+ * [EACESS  |Permission denied.
+ * [EMFILE  |Too many open files used by the process.
+ * [ENFILE  |Too many open files in system.
+ * [ENOENT  |Directory does not exist.
+ * [ENOMEM  |Insufficient memory.
+ * [ENOTDIR |dirname does not refer to directory.  This value is not
+ *           reliable on MS-DOS and MS-Windows platforms.  Many
+ *           implementations return ENOENT even when the name refers to a
+ *           file.]
+ * </table>
+ * </function>
+ */
+static DIR *
+opendir(
+    const char *dirname) {
+	DIR *dirp;
+	assert (dirname != NULL);
+
+	dirp = (DIR*)malloc (sizeof (struct DIR));
+	if (dirp != NULL) {
+		char *p;
+
+		/* allocate room for directory name */
+		dirp->dirname = (char*) malloc (strlen (dirname) + 1 + strlen ("\\*.*"));
+		if (dirp->dirname == NULL) {
+			/* failed to duplicate directory name.  errno set by malloc() */
+			free (dirp);
+			return NULL;
+		}
+		/* Copy directory name while appending directory separator and "*.*".
+		 * Directory separator is not appended if the name already ends with
+		 * drive or directory separator.  Directory separator is assumed to be
+		 * '/' or '\' and drive separator is assumed to be ':'. */
+		strcpy (dirp->dirname, dirname);
+		p = strchr (dirp->dirname, '\0');
+		if (dirp->dirname < p  &&
+		        *(p - 1) != '\\'  &&  *(p - 1) != '/'  &&  *(p - 1) != ':') {
+			strcpy (p++, "/");
+		}
 # ifdef DIRENT_WIN32_INTERFACE
-			strcpy (p, "*"); /*scan files with and without extension in win32*/
+		strcpy (p, "*"); /*scan files with and without extension in win32*/
 # else
-			strcpy (p, "*.*"); /*scan files with and without extension in DOS*/
+		strcpy (p, "*.*"); /*scan files with and without extension in DOS*/
 # endif
 
-			/* open stream */
-			if (_initdir (dirp) == 0) {
-				/* initialization failed */
-				free (dirp->dirname);
-				free (dirp);
-				return NULL;
-			}
+		/* open stream */
+		if (_initdir (dirp) == 0) {
+			/* initialization failed */
+			free (dirp->dirname);
+			free (dirp);
+			return NULL;
 		}
-		return dirp;
 	}
+	return dirp;
+}
 
 
-	/*
-	 * <function name="readdir">
-	 * <intro>read a directory entry
-	 * <syntax>struct dirent *readdir (DIR *dirp);
-	 *
-	 * <desc>Read individual directory entry and return pointer to a structure
-	 * containing the name of the entry.  Individual directory entries returned
-	 * include normal files, sub-directories, pseudo-directories "." and ".."
-	 * and also volume labels, hidden files and system files in MS-DOS and
-	 * MS-Windows.   You might want to use stat(2) function to determinate which
-	 * one are you dealing with.  Many dirent implementations already contain
-	 * equivalent information in dirent structure but you cannot depend on
-	 * this.
-	 *
-	 * The dirent structure contains several system dependent fields that
-	 * generally have no interest to you.  The only interesting one is char
-	 * d_name[] that is also portable across different systems.  The d_name
-	 * field contains the name of the directory entry without leading path.
-	 * While d_name is portable across different systems the actual storage
-	 * capacity of d_name varies from system to system and there is no portable
-	 * way to find out it at compile time as different systems define the
-	 * capacity of d_name with different macros and some systems do not define
-	 * capacity at all (besides actual declaration of the field). If you really
-	 * need to find out storage capacity of d_name then you might want to try
-	 * NAME_MAX macro. The NAME_MAX is defined in POSIX standard althought
-	 * there are many MS-DOS and MS-Windows implementations those do not define
-	 * it.  There are also systems that declare d_name as "char d_name[1]" and
-	 * then allocate suitable amount of memory at run-time.  Thanks to Alain
-	 * Decamps (Alain.Decamps@advalvas.be) for pointing it out to me.
-	 *
-	 * This all leads to the fact that it is difficult to allocate space
-	 * for the directory names when the very same program is being compiled on
-	 * number of operating systems.  Therefore I suggest that you always
-	 * allocate space for directory names dynamically.
-	 *
-	 * <ret>
-	 * Returns a pointer to a structure containing name of the directory entry
-	 * in `d_name' field or NULL if there was an error.  In case of an error the
-	 * global `errno' variable will set as follows:
-	 *
-	 * <table>
-	 * [EBADF  |dir parameter refers to an invalid directory stream.  This value
-	 *          is not set reliably on all implementations.]
-	 * </table>
-	 * </function>
-	 */
-	static struct dirent *
-	readdir (DIR *dirp) {
-		assert (dirp != NULL);
-		if (dirp == NULL) {
-			errno = EBADF;
-			return NULL;
-		}
+/*
+ * <function name="readdir">
+ * <intro>read a directory entry
+ * <syntax>struct dirent *readdir (DIR *dirp);
+ *
+ * <desc>Read individual directory entry and return pointer to a structure
+ * containing the name of the entry.  Individual directory entries returned
+ * include normal files, sub-directories, pseudo-directories "." and ".."
+ * and also volume labels, hidden files and system files in MS-DOS and
+ * MS-Windows.   You might want to use stat(2) function to determinate which
+ * one are you dealing with.  Many dirent implementations already contain
+ * equivalent information in dirent structure but you cannot depend on
+ * this.
+ *
+ * The dirent structure contains several system dependent fields that
+ * generally have no interest to you.  The only interesting one is char
+ * d_name[] that is also portable across different systems.  The d_name
+ * field contains the name of the directory entry without leading path.
+ * While d_name is portable across different systems the actual storage
+ * capacity of d_name varies from system to system and there is no portable
+ * way to find out it at compile time as different systems define the
+ * capacity of d_name with different macros and some systems do not define
+ * capacity at all (besides actual declaration of the field). If you really
+ * need to find out storage capacity of d_name then you might want to try
+ * NAME_MAX macro. The NAME_MAX is defined in POSIX standard althought
+ * there are many MS-DOS and MS-Windows implementations those do not define
+ * it.  There are also systems that declare d_name as "char d_name[1]" and
+ * then allocate suitable amount of memory at run-time.  Thanks to Alain
+ * Decamps (Alain.Decamps@advalvas.be) for pointing it out to me.
+ *
+ * This all leads to the fact that it is difficult to allocate space
+ * for the directory names when the very same program is being compiled on
+ * number of operating systems.  Therefore I suggest that you always
+ * allocate space for directory names dynamically.
+ *
+ * <ret>
+ * Returns a pointer to a structure containing name of the directory entry
+ * in `d_name' field or NULL if there was an error.  In case of an error the
+ * global `errno' variable will set as follows:
+ *
+ * <table>
+ * [EBADF  |dir parameter refers to an invalid directory stream.  This value
+ *          is not set reliably on all implementations.]
+ * </table>
+ * </function>
+ */
+static struct dirent *
+readdir (DIR *dirp) {
+	assert (dirp != NULL);
+	if (dirp == NULL) {
+		errno = EBADF;
+		return NULL;
+	}
 
 #if defined(DIRENT_WIN32_INTERFACE)
-		if (dirp->search_handle == INVALID_HANDLE_VALUE) {
-			/* directory stream was opened/rewound incorrectly or it ended normally */
-			errno = EBADF;
-			return NULL;
-		}
+	if (dirp->search_handle == INVALID_HANDLE_VALUE) {
+		/* directory stream was opened/rewound incorrectly or it ended normally */
+		errno = EBADF;
+		return NULL;
+	}
 #endif
 
-		if (dirp->dirent_filled != 0) {
-			/*
-			 * Directory entry has already been retrieved and there is no need to
-			 * retrieve a new one.  Directory entry will be retrieved in advance
-			 * when the user calls readdir function for the first time.  This is so
-			 * because real dirent has separate functions for opening and reading
-			 * the stream whereas Win32 and DOS dirents open the stream
-			 * automatically when we retrieve the first file.  Therefore, we have to
-			 * save the first file when opening the stream and later we have to
-			 * return the saved entry when the user tries to read the first entry.
-			 */
-			dirp->dirent_filled = 0;
-		} else {
-			/* fill in entry and return that */
+	if (dirp->dirent_filled != 0) {
+		/*
+		 * Directory entry has already been retrieved and there is no need to
+		 * retrieve a new one.  Directory entry will be retrieved in advance
+		 * when the user calls readdir function for the first time.  This is so
+		 * because real dirent has separate functions for opening and reading
+		 * the stream whereas Win32 and DOS dirents open the stream
+		 * automatically when we retrieve the first file.  Therefore, we have to
+		 * save the first file when opening the stream and later we have to
+		 * return the saved entry when the user tries to read the first entry.
+		 */
+		dirp->dirent_filled = 0;
+	} else {
+		/* fill in entry and return that */
 #if defined(DIRENT_WIN32_INTERFACE)
-			if (FindNextFile (dirp->search_handle, &dirp->current.data) == FALSE) {
-				/* Last file has been processed or an error occured */
-				FindClose (dirp->search_handle);
-				dirp->search_handle = INVALID_HANDLE_VALUE;
-				errno = ENOENT;
-				return NULL;
-			}
+		if (FindNextFile (dirp->search_handle, &dirp->current.data) == FALSE) {
+			/* Last file has been processed or an error occured */
+			FindClose (dirp->search_handle);
+			dirp->search_handle = INVALID_HANDLE_VALUE;
+			errno = ENOENT;
+			return NULL;
+		}
 
 # elif defined(DIRENT_MSDOS_INTERFACE)
-			if (_dos_findnext (&dirp->current.data) != 0) {
-				/* _dos_findnext and findnext will set errno to ENOENT when no
-				 * more entries could be retrieved. */
-				return NULL;
-			}
+		if (_dos_findnext (&dirp->current.data) != 0) {
+			/* _dos_findnext and findnext will set errno to ENOENT when no
+			 * more entries could be retrieved. */
+			return NULL;
+		}
 # endif
 
-			_setdirname (dirp);
-			assert (dirp->dirent_filled == 0);
-		}
-		return &dirp->current;
+		_setdirname (dirp);
+		assert (dirp->dirent_filled == 0);
 	}
+	return &dirp->current;
+}
 
 
-	/*
-	 * <function name="closedir">
-	 * <intro>close directory stream.
-	 * <syntax>int closedir (DIR *dirp);
-	 *
-	 * <desc>Close directory stream opened by the `opendir' function.  Close of
-	 * directory stream invalidates the DIR structure as well as previously read
-	 * dirent entry.
-	 *
-	 * <ret>The function typically returns 0 on success and -1 on failure but
-	 * the function may be declared to return void on same systems.  At least
-	 * Borland C/C++ and some UNIX implementations use void as a return type.
-	 * The dirent wrapper tries to define VOID_CLOSEDIR whenever closedir is
-	 * known to return nothing.  The very same definition is made by the GNU
-	 * autoconf if you happen to use it.
-	 *
-	 * The global `errno' variable will set to EBADF in case of error.
-	 * </function>
-	 */
-	static int
-	closedir (DIR *dirp) {
-		int retcode = 0;
-
-		/* make sure that dirp points to legal structure */
-		assert (dirp != NULL);
-		if (dirp == NULL) {
-			errno = EBADF;
-			return -1;
-		}
+/*
+ * <function name="closedir">
+ * <intro>close directory stream.
+ * <syntax>int closedir (DIR *dirp);
+ *
+ * <desc>Close directory stream opened by the `opendir' function.  Close of
+ * directory stream invalidates the DIR structure as well as previously read
+ * dirent entry.
+ *
+ * <ret>The function typically returns 0 on success and -1 on failure but
+ * the function may be declared to return void on same systems.  At least
+ * Borland C/C++ and some UNIX implementations use void as a return type.
+ * The dirent wrapper tries to define VOID_CLOSEDIR whenever closedir is
+ * known to return nothing.  The very same definition is made by the GNU
+ * autoconf if you happen to use it.
+ *
+ * The global `errno' variable will set to EBADF in case of error.
+ * </function>
+ */
+static int
+closedir (DIR *dirp) {
+	int retcode = 0;
+
+	/* make sure that dirp points to legal structure */
+	assert (dirp != NULL);
+	if (dirp == NULL) {
+		errno = EBADF;
+		return -1;
+	}
 
-		/* free directory name and search handles */
-		if (dirp->dirname != NULL) free (dirp->dirname);
+	/* free directory name and search handles */
+	if (dirp->dirname != NULL) free (dirp->dirname);
 
 #if defined(DIRENT_WIN32_INTERFACE)
-		if (dirp->search_handle != INVALID_HANDLE_VALUE) {
-			if (FindClose (dirp->search_handle) == FALSE) {
-				/* Unknown error */
-				retcode = -1;
-				errno = EBADF;
-			}
+	if (dirp->search_handle != INVALID_HANDLE_VALUE) {
+		if (FindClose (dirp->search_handle) == FALSE) {
+			/* Unknown error */
+			retcode = -1;
+			errno = EBADF;
 		}
+	}
 #endif
 
-		/* clear dirp structure to make sure that it cannot be used anymore*/
-		memset (dirp, 0, sizeof (*dirp));
+	/* clear dirp structure to make sure that it cannot be used anymore*/
+	memset (dirp, 0, sizeof (*dirp));
 # if defined(DIRENT_WIN32_INTERFACE)
-		dirp->search_handle = INVALID_HANDLE_VALUE;
+	dirp->search_handle = INVALID_HANDLE_VALUE;
 # endif
 
-		free (dirp);
-		return retcode;
-	}
+	free (dirp);
+	return retcode;
+}
 
 
-	/*
-	 * <function name="rewinddir">
-	 * <intro>rewind directory stream to the beginning
-	 * <syntax>void rewinddir (DIR *dirp);
-	 *
-	 * <desc>Rewind directory stream to the beginning so that the next call of
-	 * readdir() returns the very first directory entry again.  However, note
-	 * that next call of readdir() may not return the same directory entry as it
-	 * did in first time.  The directory stream may have been affected by newly
-	 * created files.
-	 *
-	 * Almost every dirent implementation ensure that rewinddir will update
-	 * the directory stream to reflect any changes made to the directory entries
-	 * since the previous ``opendir'' or ``rewinddir'' call.  Keep an eye on
-	 * this if your program depends on the feature.  I know at least one dirent
-	 * implementation where you are required to close and re-open the stream to
-	 * see the changes.
-	 *
-	 * <ret>Returns nothing.  If something went wrong while rewinding, you will
-	 * notice it later when you try to retrieve the first directory entry.
-	 */
-	static void
-	rewinddir (DIR *dirp) {
-		/* make sure that dirp is legal */
-		assert (dirp != NULL);
-		if (dirp == NULL) {
-			errno = EBADF;
-			return;
-		}
-		assert (dirp->dirname != NULL);
+/*
+ * <function name="rewinddir">
+ * <intro>rewind directory stream to the beginning
+ * <syntax>void rewinddir (DIR *dirp);
+ *
+ * <desc>Rewind directory stream to the beginning so that the next call of
+ * readdir() returns the very first directory entry again.  However, note
+ * that next call of readdir() may not return the same directory entry as it
+ * did in first time.  The directory stream may have been affected by newly
+ * created files.
+ *
+ * Almost every dirent implementation ensure that rewinddir will update
+ * the directory stream to reflect any changes made to the directory entries
+ * since the previous ``opendir'' or ``rewinddir'' call.  Keep an eye on
+ * this if your program depends on the feature.  I know at least one dirent
+ * implementation where you are required to close and re-open the stream to
+ * see the changes.
+ *
+ * <ret>Returns nothing.  If something went wrong while rewinding, you will
+ * notice it later when you try to retrieve the first directory entry.
+ */
+static void
+rewinddir (DIR *dirp) {
+	/* make sure that dirp is legal */
+	assert (dirp != NULL);
+	if (dirp == NULL) {
+		errno = EBADF;
+		return;
+	}
+	assert (dirp->dirname != NULL);
 
-		/* close previous stream */
+	/* close previous stream */
 #if defined(DIRENT_WIN32_INTERFACE)
-		if (dirp->search_handle != INVALID_HANDLE_VALUE) {
-			if (FindClose (dirp->search_handle) == FALSE) {
-				/* Unknown error */
-				errno = EBADF;
-			}
+	if (dirp->search_handle != INVALID_HANDLE_VALUE) {
+		if (FindClose (dirp->search_handle) == FALSE) {
+			/* Unknown error */
+			errno = EBADF;
 		}
+	}
 #endif
 
-		/* re-open previous stream */
-		if (_initdir (dirp) == 0) {
-			/* initialization failed but we cannot deal with error.  User will notice
-			 * error later when she tries to retrieve first directory enty. */
-			/*EMPTY*/;
-		}
+	/* re-open previous stream */
+	if (_initdir (dirp) == 0) {
+		/* initialization failed but we cannot deal with error.  User will notice
+		 * error later when she tries to retrieve first directory enty. */
+		/*EMPTY*/;
 	}
+}
 
 
-	/*
-	 * Open native directory stream object and retrieve first file.
-	 * Be sure to close previous stream before opening new one.
-	 */
-	static int
-	_initdir (DIR *dirp) {
-		assert (dirp != NULL);
-		assert (dirp->dirname != NULL);
-		dirp->dirent_filled = 0;
+/*
+ * Open native directory stream object and retrieve first file.
+ * Be sure to close previous stream before opening new one.
+ */
+static int
+_initdir (DIR *dirp) {
+	assert (dirp != NULL);
+	assert (dirp->dirname != NULL);
+	dirp->dirent_filled = 0;
 
 # if defined(DIRENT_WIN32_INTERFACE)
-		/* Open stream and retrieve first file */
-		dirp->search_handle = FindFirstFile (dirp->dirname, &dirp->current.data);
-		if (dirp->search_handle == INVALID_HANDLE_VALUE) {
-			/* something went wrong but we don't know what.  GetLastError() could
-			 * give us more information about the error, but then we should map
-			 * the error code into errno. */
-			errno = ENOENT;
-			return 0;
-		}
+	/* Open stream and retrieve first file */
+	dirp->search_handle = FindFirstFile (dirp->dirname, &dirp->current.data);
+	if (dirp->search_handle == INVALID_HANDLE_VALUE) {
+		/* something went wrong but we don't know what.  GetLastError() could
+		 * give us more information about the error, but then we should map
+		 * the error code into errno. */
+		errno = ENOENT;
+		return 0;
+	}
 
 # elif defined(DIRENT_MSDOS_INTERFACE)
-		if (_dos_findfirst (dirp->dirname,
-		                    _A_SUBDIR | _A_RDONLY | _A_ARCH | _A_SYSTEM | _A_HIDDEN,
-		                    &dirp->current.data) != 0) {
-			/* _dos_findfirst and findfirst will set errno to ENOENT when no
-			 * more entries could be retrieved. */
-			return 0;
-		}
+	if (_dos_findfirst (dirp->dirname,
+	                    _A_SUBDIR | _A_RDONLY | _A_ARCH | _A_SYSTEM | _A_HIDDEN,
+	                    &dirp->current.data) != 0) {
+		/* _dos_findfirst and findfirst will set errno to ENOENT when no
+		 * more entries could be retrieved. */
+		return 0;
+	}
 # endif
 
-		/* initialize DIR and it's first entry */
-		_setdirname (dirp);
-		dirp->dirent_filled = 1;
-		return 1;
-	}
+	/* initialize DIR and it's first entry */
+	_setdirname (dirp);
+	dirp->dirent_filled = 1;
+	return 1;
+}
 
 
-	/*
-	 * Return implementation dependent name of the current directory entry.
-	 */
-	static const char *
-	_getdirname (const struct dirent *dp) {
+/*
+ * Return implementation dependent name of the current directory entry.
+ */
+static const char *
+_getdirname (const struct dirent *dp) {
 #if defined(DIRENT_WIN32_INTERFACE)
-		return dp->data.cFileName;
+	return dp->data.cFileName;
 
 #elif defined(DIRENT_USE_FFBLK)
-		return dp->data.ff_name;
+	return dp->data.ff_name;
 
 #else
-		return dp->data.name;
+	return dp->data.name;
 #endif
-	}
-
+}
 
-	/*
-	 * Copy name of implementation dependent directory entry to the d_name field.
-	 */
-	static void
-	_setdirname (struct DIR *dirp) {
-		/* make sure that d_name is long enough */
-		assert (strlen (_getdirname (&dirp->current)) <= NAME_MAX);
 
-		strncpy (dirp->current.d_name,
-		         _getdirname (&dirp->current),
-		         NAME_MAX);
-		dirp->current.d_name[NAME_MAX] = '\0'; /*char d_name[NAME_MAX+1]*/
-	}
+/*
+ * Copy name of implementation dependent directory entry to the d_name field.
+ */
+static void
+_setdirname (struct DIR *dirp) {
+	/* make sure that d_name is long enough */
+	assert (strlen (_getdirname (&dirp->current)) <= NAME_MAX);
+
+	strncpy (dirp->current.d_name,
+	         _getdirname (&dirp->current),
+	         NAME_MAX);
+	dirp->current.d_name[NAME_MAX] = '\0'; /*char d_name[NAME_MAX+1]*/
+}
 
 # ifdef __cplusplus
 }