Fix code indenting, remove dead code, improve documentation.

There was still old (dead) code that had been deactivated by '#if 0'.
This code had been obsoleted by other functions, so it was time to
remove the dead parts of the code.

Many functions were not documented at all. I tried to add documentation,
but I ran out of time.

Todo: there are still some undocumented functions in src/fl_utf8.cxx.


git-svn-id: file:///fltk/svn/fltk/branches/branch-1.3@10760 ea41ed52-d2ee-0310-a9c1-e6b18d33e121

1 files changed, 536 insertions, 512 deletions

diff --git a/src/fl_utf8.cxx b/src/fl_utf8.cxx
index 1644fb400..81d61ad6a 100644
--- a/src/fl_utf8.cxx
+++ b/src/fl_utf8.cxx
@@ -75,42 +75,39 @@ extern "C" {
     @{
 */
 
-/*** NOTE : all functions are LIMITED to 24 bits Unicode values !!! ***/
-/***        but only 16 bits are really used under Linux and win32  ***/
+// *** NOTE : All functions are LIMITED to 24 bits Unicode values !!! ***
+// ***        But only 16 bits are really used under Linux and win32  ***
 
 
 #define NBC 0xFFFF + 1
 
-static int
-Toupper(
-	int ucs)
-{
-	long i;
-	static unsigned short *table = NULL;
-
-	if (!table) {
-		table = (unsigned short*) malloc(
-			sizeof(unsigned short) * (NBC));
-		for (i = 0; i < NBC; i++) {
-			table[i] = (unsigned short) i;
-		}
-		for (i = 0; i < NBC; i++) {
-			int l;
-			l = XUtf8Tolower(i);
-			if (l != i) table[l] = (unsigned short) i;
-		}
-
-	}
-	if (ucs >= NBC || ucs < 0) return ucs;
-	return table[ucs];
+static int Toupper(int ucs) {
+  long i;
+  static unsigned short *table = NULL;
+
+  if (!table) {
+    table = (unsigned short*) malloc(
+	    sizeof(unsigned short) * (NBC));
+    for (i = 0; i < NBC; i++) {
+      table[i] = (unsigned short) i;
+    }
+    for (i = 0; i < NBC; i++) {
+      int l;
+      l = XUtf8Tolower(i);
+      if (l != i) table[l] = (unsigned short) i;
+    }
+  }
+  if (ucs >= NBC || ucs < 0) return ucs;
+  return table[ucs];
 }
 
 /**
- return the byte length of the UTF-8 sequence with first byte \p c,
- or -1 if \p c is not valid.
- This function is helpful for finding faulty UTF8 sequences.
- \see fl_utf8len1
- */
+  Returns the byte length of the UTF-8 sequence with first byte \p c,
+  or -1 if \p c is not valid.
+
+  This function is helpful for finding faulty UTF-8 sequences.
+  \see fl_utf8len1
+*/
 int fl_utf8len(char c)
 {
   if (!(c & 0x80)) return 1;
@@ -134,12 +131,13 @@ int fl_utf8len(char c)
 
 
 /**
- Return the byte length of the UTF-8 sequence with first byte \p c,
- or 1 if \p c is not valid. 
- This function can be used to scan faulty UTF8 sequence, albeit ignoring invalid
- codes.
- \see fl_utf8len
- */
+  Returns the byte length of the UTF-8 sequence with first byte \p c,
+  or 1 if \p c is not valid.
+
+  This function can be used to scan faulty UTF-8 sequences, albeit
+  ignoring invalid codes.
+  \see fl_utf8len
+*/
 int fl_utf8len1(char c)
 {
   if (!(c & 0x80)) return 1;
@@ -163,43 +161,44 @@ int fl_utf8len1(char c)
 
 
 /**
-  returns the number of Unicode chars in the UTF-8 string
-  */
+  Returns the number of Unicode chars in the UTF-8 string.
+*/
 int
 fl_utf_nb_char(
 	const unsigned char 	*buf,
 	int 			len)
 {
-	int i = 0;
-	int nbc = 0;
-	while (i < len) {
-		int cl = fl_utf8len((buf+i)[0]);//fl_utflen(buf + i, len - i);
-		if (cl < 1) cl = 1;
-		nbc++;
-		i += cl;
-	}
-	return nbc;
+  int i = 0;
+  int nbc = 0;
+  while (i < len) {
+    int cl = fl_utf8len((buf+i)[0]); // fl_utflen(buf + i, len - i);
+    if (cl < 1) cl = 1;
+    nbc++;
+    i += cl;
+  }
+  return nbc;
 }
 
 
 /**
- UTF-8 aware strncasecmp - converts to lower case Unicode and tests.
- 
- \param s1, s2 the utf8 strings to compare
- \param n the maximum number of utf8 characters to compare
- \return 0 if the strings are equal
- \return >0 if s1 is greater than s2
- \return <0 if s1 is less than s2
-  */
+  UTF-8 aware strncasecmp - converts to lower case Unicode and tests.
+
+  \param s1, s2 the UTF-8 strings to compare
+  \param n the maximum number of UTF-8 characters to compare
+  \return result of comparison
+  \retval 0 if the strings are equal
+  \retval >0 if s1 is greater than s2
+  \retval <0 if s1 is less than s2
+*/
 int fl_utf_strncasecmp(const char *s1, const char *s2, int n)
 {
   int i;
   for (i = 0; i < n; i++) {
     int l1, l2;
     unsigned int u1, u2;
-    
+
     if (*s1==0 && *s2==0) return 0; // all compared equal, return 0
-    
+
     u1 = fl_utf8decode(s1, 0, &l1);
     u2 = fl_utf8decode(s2, 0, &l2);
     int res = XUtf8Tolower(u1) - XUtf8Tolower(u2);
@@ -212,151 +211,98 @@ int fl_utf_strncasecmp(const char *s1, const char *s2, int n)
 
 
 /**
- UTF-8 aware strcasecmp - converts to Unicode and tests.
- 
- \return 0 if the strings are equal
- \return 1 if s1 is greater than s2
- \return -1 if s1 is less than s2
-  */
+  UTF-8 aware strcasecmp - converts to Unicode and tests.
+
+  \return result of comparison
+  \retval 0 if the strings are equal
+  \retval 1 if s1 is greater than s2
+  \retval -1 if s1 is less than s2
+*/
 int fl_utf_strcasecmp(const char *s1, const char *s2)
 {
   return fl_utf_strncasecmp(s1, s2, 0x7fffffff);
 }
 
 /**
-  return the Unicode lower case value of \p ucs
-  */
+  Returns the Unicode lower case value of \p ucs.
+*/
 int fl_tolower(unsigned int ucs)
 {
-	return XUtf8Tolower(ucs);
+  return XUtf8Tolower(ucs);
 }
 
 /**
-  return the Unicode upper case value of \p ucs
-  */
+  Returns the Unicode upper case value of \p ucs.
+*/
 int fl_toupper(unsigned int ucs)
 {
-	return Toupper(ucs);
+  return Toupper(ucs);
 }
 
 /**
-  converts the str string to the lower case equivalent into buf.
+  Converts the string \p str to its lower case equivalent into buf.
   Warning: to be safe buf length must be at least 3 * len [for 16-bit Unicode]
-  */
+*/
 int fl_utf_tolower(const unsigned char *str, int len, char *buf)
 {
-	int i;
-	int l = 0;
-	char *end = (char *)&str[len];
-        for (i = 0; i < len;) {
-                int l1, l2;
-                unsigned int u1;
-
-//              l1 = fl_utf2ucs((unsigned char*)str + i, len - i, &u1);
-                u1 = fl_utf8decode((const char*)(str + i), end, &l1);
-                l2 = fl_utf8encode((unsigned int) XUtf8Tolower(u1), buf + l);
-                if (l1 < 1) {
-                        i += 1;
-                } else {
-                        i += l1;
-		}
-                if (l2 < 1) {
-                        l += 1;
-                } else {
-                        l += l2;
-		}
-
-	}
-	return l;
+  int i;
+  int l = 0;
+  char *end = (char *)&str[len];
+  for (i = 0; i < len;) {
+    int l1, l2;
+    unsigned int u1;
+
+//  l1 = fl_utf2ucs((unsigned char*)str + i, len - i, &u1);
+    u1 = fl_utf8decode((const char*)(str + i), end, &l1);
+    l2 = fl_utf8encode((unsigned int) XUtf8Tolower(u1), buf + l);
+    if (l1 < 1) {
+      i += 1;
+    } else {
+      i += l1;
+    }
+    if (l2 < 1) {
+      l += 1;
+    } else {
+      l += l2;
+    }
+  }
+  return l;
 }
 
 /**
-  converts the str string to the upper case equivalent into buf.
+  Converts the string \p str to its upper case equivalent into buf.
   Warning: to be safe buf length must be at least 3 * len [for 16-bit Unicode]
-  */
+*/
 int fl_utf_toupper(const unsigned char *str, int len, char *buf)
 {
-	int i;
-	int l = 0;
-	char *end = (char *)&str[len];
-        for (i = 0; i < len;) {
-                int l1, l2;
-                unsigned int u1;
-
-//              l1 = fl_utf2ucs((unsigned char*)str + i, len - i, &u1);
-                u1 = fl_utf8decode((const char*)(str + i), end, &l1);
-                l2 = fl_utf8encode((unsigned int) Toupper(u1), buf + l);
-                if (l1 < 1) {
-                        i += 1;
-                } else {
-                        i += l1;
-		}
-                if (l2 < 1) {
-                        l += 1;
-                } else {
-                        l += l2;
-		}
-	}
-	return l;
+  int i;
+  int l = 0;
+  char *end = (char *)&str[len];
+  for (i = 0; i < len;) {
+    int l1, l2;
+    unsigned int u1;
+
+//  l1 = fl_utf2ucs((unsigned char*)str + i, len - i, &u1);
+    u1 = fl_utf8decode((const char*)(str + i), end, &l1);
+    l2 = fl_utf8encode((unsigned int) Toupper(u1), buf + l);
+    if (l1 < 1) {
+      i += 1;
+    } else {
+      i += l1;
+    }
+    if (l2 < 1) {
+      l += 1;
+    } else {
+      l += l2;
+    }
+  }
+  return l;
 }
 
-#if 0 // deprecated in favour of FLTK2's fl_utf8toa
-/*
- * convert UTF-8 str to latin1
- * Warning: buf must be at least len long
- */
-int fl_utf2latin1(const unsigned char *str, int len, char *buf)
-{
-	int i;
-	int l = 0;
-	char *end = (char *)&str[len];
-        for (i = 0; i < len;) {
-                unsigned int u1;
-		int l1;
-
-//              l1 = fl_utf2ucs((unsigned char*)str + i, len - i, &u1);
-                u1 = fl_utf8decode((const char*)(str + i), end, &l1);
-		if (u1 > 0xFF) u1 = '?';
-		buf[l] = (char) u1;
-                if (l1 < 1) {
-                        i += 1;
-                } else {
-                        i += l1;
-		}
-		l++;
-
-	}
-	return l;
-}
-#endif
-
-#if 0 // deprecated in favour of FLTK2's fl_utf8froma
-/*
- * convert latin1 str to UTF-8
- * Warning: buf must be at least 2 * len long
- */
-int fl_latin12utf(const unsigned char *str, int len, char *buf)
-{
-	int i;
-	int l = 0;
-	int l1 = 0;
-        for (i = 0; i < len; i++) {
-		unsigned int n = (unsigned int) str[i];
-		l1 = fl_utf8encode(n, buf + l);
-                if (l1 < 1) {
-                        l = l + 1;
-                } else {
-                        l = l + l1;
-		}
-
-	}
-	return l;
-}
-#endif
 
 /**
-  returns true if the character is non-spacing.
-  
+  Returns true if the Unicode character \p ucs is non-spacing.
+
   Non-spacing characters in Unicode are typically combining marks like
   tilde (~), diaeresis (¨), or other marks that are added to a base
   character, for instance 'a' (base character) + '¨' (combining mark) = 'ä'
@@ -365,7 +311,7 @@ int fl_latin12utf(const unsigned char *str, int len, char *buf)
   - http://unicode.org/glossary/#base_character
   - http://unicode.org/glossary/#nonspacing_mark
   - http://unicode.org/glossary/#combining_character
-  */
+*/
 unsigned int fl_nonspacing(unsigned int ucs)
 {
   return (unsigned int) XUtf8IsNonSpacing(ucs);
@@ -388,143 +334,136 @@ static unsigned short *wbufa = NULL;
 // FIXME: This should *maybe* return 'const char *' instead of 'char *'
 char *fl_utf8_to_locale(const char *s, int len, UINT codepage)
 {
-	if (!s) return (char *)"";
-	int l = 0;
-//	if (buf_len < len * 2 + 1) {
-//		buf_len = len * 2 + 1;
-//		buf = (char*) realloc(buf, buf_len);
-//		wbufa = (unsigned short*) realloc(wbufa, buf_len * sizeof(short));
-//	}
-	unsigned wn = fl_utf8toUtf16(s, len, NULL, 0); // Query length
-	wn = wn * 2 + 1;
-	if (wn >= (unsigned)buf_len) {
-		buf_len = wn;
-		buf = (char*) realloc(buf, buf_len);
-		wbufa = (unsigned short*) realloc(wbufa, buf_len * sizeof(short));
-	}
-	if (codepage < 1) codepage = fl_codepage;
-//	l = fl_utf2unicode((const unsigned char *)s, len, (xchar*) wbufa);
-	l = fl_utf8toUtf16(s, len, wbufa, wn); // Convert string
-	wbufa[l] = 0;
-	buf[l] = 0;
-	l = WideCharToMultiByte(codepage, 0, (WCHAR*)wbufa, l, buf, buf_len, NULL, NULL);
-	if (l < 0) l = 0;
-	buf[l] = 0;
-	return buf;
+  if (!s) return (char *)"";
+  int l = 0;
+  //  if (buf_len < len * 2 + 1) {
+  //    buf_len = len * 2 + 1;
+  //    buf = (char*) realloc(buf, buf_len);
+  //    wbufa = (unsigned short*) realloc(wbufa, buf_len * sizeof(short));
+  //  }
+  unsigned wn = fl_utf8toUtf16(s, len, NULL, 0); // Query length
+  wn = wn * 2 + 1;
+  if (wn >= (unsigned)buf_len) {
+    buf_len = wn;
+    buf = (char*) realloc(buf, buf_len);
+    wbufa = (unsigned short*) realloc(wbufa, buf_len * sizeof(short));
+  }
+  if (codepage < 1) codepage = fl_codepage;
+  // l = fl_utf2unicode((const unsigned char *)s, len, (xchar*) wbufa);
+  l = fl_utf8toUtf16(s, len, wbufa, wn); // Convert string
+  wbufa[l] = 0;
+  buf[l] = 0;
+  l = WideCharToMultiByte(codepage, 0, (WCHAR*)wbufa, l, buf, buf_len, NULL, NULL);
+  if (l < 0) l = 0;
+  buf[l] = 0;
+  return buf;
 }
 
 // FIXME: This should maybe return 'const char *' instead of 'char *'
 char *fl_locale_to_utf8(const char *s, int len, UINT codepage)
 {
-	if (!s) return (char *)"";
-	int l = 0;
-	if (buf_len < len * 5 + 1) {
-		buf_len = len * 5 + 1;
-		buf = (char*) realloc(buf, buf_len);
-		wbufa = (unsigned short*) realloc(wbufa, buf_len * sizeof(short));
-	}
-	if (codepage < 1) codepage = fl_codepage;
-	buf[l] = 0;
-
-	l = MultiByteToWideChar(codepage, 0, s, len, (WCHAR*)wbufa, buf_len);
-	if (l < 0) l = 0;
-	wbufa[l] = 0;
-//	l = fl_unicode2utf((xchar*)wbufa, l, buf);
-	l = fl_utf8fromwc(buf, buf_len, (xchar*)wbufa, l);
-	buf[l] = 0;
-	return buf;
+  if (!s) return (char *)"";
+  int l = 0;
+  if (buf_len < len * 5 + 1) {
+    buf_len = len * 5 + 1;
+    buf = (char*) realloc(buf, buf_len);
+    wbufa = (unsigned short*) realloc(wbufa, buf_len * sizeof(short));
+  }
+  if (codepage < 1) codepage = fl_codepage;
+  buf[l] = 0;
+
+  l = MultiByteToWideChar(codepage, 0, s, len, (WCHAR*)wbufa, buf_len);
+  if (l < 0) l = 0;
+  wbufa[l] = 0;
+//l = fl_unicode2utf((xchar*)wbufa, l, buf);
+  l = fl_utf8fromwc(buf, buf_len, (xchar*)wbufa, l);
+  buf[l] = 0;
+  return buf;
 }
 #endif
 
 /**
-  converts UTF8 to a local multi-byte character string.
-  */
+  Converts UTF-8 string \p s to a local multi-byte character string.
+*/
 char * fl_utf2mbcs(const char *s)
 {
-	if (!s) return NULL;
+  if (!s) return NULL;
+
 #if defined(WIN32) && !defined(__CYGWIN__)
-	size_t l = strlen(s);
-	static char *buf = NULL;
-
-//	mbwbuf = (xchar*)realloc(mbwbuf, (l+6) * sizeof(xchar));
-//	l = fl_utf2unicode((unsigned char*)s, l, mbwbuf);
-//	mbwbuf[l] = 0;
-	unsigned wn = fl_utf8toUtf16(s, (unsigned) l, NULL, 0) + 7; // Query length
-	mbwbuf = (xchar*)realloc(mbwbuf, sizeof(xchar)*wn);
-	l = fl_utf8toUtf16(s, (unsigned) l, (unsigned short *)mbwbuf, wn); // Convert string
-	mbwbuf[l] = 0;
-
-	buf = (char*)realloc(buf, (unsigned) (l * 6 + 1));
-	l = (unsigned) wcstombs(buf, mbwbuf, (unsigned) l * 6);
-	buf[l] = 0;
-	return buf;
+
+  size_t l = strlen(s);
+  static char *buf = NULL;
+
+//  mbwbuf = (xchar*)realloc(mbwbuf, (l+6) * sizeof(xchar));
+//  l = fl_utf2unicode((unsigned char*)s, l, mbwbuf);
+//  mbwbuf[l] = 0;
+  unsigned wn = fl_utf8toUtf16(s, (unsigned) l, NULL, 0) + 7; // Query length
+  mbwbuf = (xchar*)realloc(mbwbuf, sizeof(xchar)*wn);
+  l = fl_utf8toUtf16(s, (unsigned) l, (unsigned short *)mbwbuf, wn); // Convert string
+  mbwbuf[l] = 0;
+
+  buf = (char*)realloc(buf, (unsigned) (l * 6 + 1));
+  l = (unsigned) wcstombs(buf, mbwbuf, (unsigned) l * 6);
+  buf[l] = 0;
+  return buf;
 #else
-	return (char*) s;
+  return (char*) s;
 #endif
 }
 
 
-#if 0 // deprecated in favour of FLTK2's fl_utf8from_mb
-char * fl_mbcs2utf(const char *s)
-{
-	if (!s) return NULL;
-#if defined(WIN32)
-	int l = strlen(s);
-	unsigned dstlen;
-	static char *buf = NULL;
-
-	mbwbuf = (xchar*)realloc(mbwbuf,(l * 6 + 6) * sizeof(xchar));
-	l = mbstowcs(mbwbuf, s, l);
-	dstlen = l * 6 + 1;
-	buf = (char*)realloc(buf, dstlen);
-//	l = fl_unicode2utf(mbwbuf, l, buf);
-	l = fl_utf8fromwc(buf, dstlen, mbwbuf, l);
-	buf[l] = 0;
-	return buf;
-#else
-	return (char*) s;
-#endif
-} // fl_mbcs2utf
-#endif
+/** Cross-platform function to get environment variables with a UTF-8 encoded
+  name or value.
 
-#if defined(WIN32)  && !defined(__CYGWIN__)
-static xchar *wbuf = NULL;
-static xchar *wbuf1 = NULL;
-#endif
+  This function is especially useful under the MSWindows platform where
+  non-ASCII environment variables are encoded as wide characters.
+  The returned value of the variable is encoded in UTF-8 as well.
 
+  On platforms other than MSWindows this function calls getenv directly.
+  The return value is returned as-is.
+
+  \param[in] v the UTF-8 encoded environment variable
+  \return  the environment variable in UTF-8 encoding, or NULL in case of error.
+*/
+
+char *fl_getenv(const char* v) {
 
-char *fl_getenv(const char* v)
-{
 #if defined (WIN32) && !defined(__CYGWIN__)
-	size_t l =  strlen(v);
-//	static xchar* wbuf = NULL;
-//	wbuf = (xchar*)realloc(wbuf, sizeof(xchar) * (l+1));
-//	wbuf[fl_utf2unicode((const unsigned char*)v, l, wbuf)] = 0;
-	unsigned wn = fl_utf8toUtf16(v, (unsigned) l, NULL, 0) + 1; // Query length
-	wbuf = (xchar*)realloc(wbuf, sizeof(xchar)*wn);
-	wn = fl_utf8toUtf16(v, (unsigned) l, (unsigned short *)wbuf, wn); // Convert string
-	wbuf[wn] = 0;
-	xchar *ret = _wgetenv(wbuf);
-	static char *buf = NULL;
-	if (ret) {
-		l = (unsigned) wcslen(ret);
-		wn = fl_utf8fromwc(NULL, 0, ret, (unsigned) l) + 1; // query length
-		buf = (char*) realloc(buf, wn);
-//		buf[fl_unicode2utf(ret, l, buf)] = 0;
-		wn = fl_utf8fromwc(buf, wn, ret, (unsigned) l); // convert string
-		buf[wn] = 0;
-		return buf;
-	} else {
-		return NULL;
-	}
+
+  size_t l =  strlen(v);
+  // static xchar* wbuf = NULL;
+  // wbuf = (xchar*)realloc(wbuf, sizeof(xchar) * (l+1));
+  // wbuf[fl_utf2unicode((const unsigned char*)v, l, wbuf)] = 0;
+  unsigned wn = fl_utf8toUtf16(v, (unsigned) l, NULL, 0) + 1; // Query length
+  wbuf = (xchar*)realloc(wbuf, sizeof(xchar)*wn);
+  wn = fl_utf8toUtf16(v, (unsigned) l, (unsigned short *)wbuf, wn); // Convert string
+  wbuf[wn] = 0;
+  xchar *ret = _wgetenv(wbuf);
+  static char *buf = NULL;
+  if (ret) {
+    l = (unsigned) wcslen(ret);
+    wn = fl_utf8fromwc(NULL, 0, ret, (unsigned) l) + 1; // query length
+    buf = (char*) realloc(buf, wn);
+    // buf[fl_unicode2utf(ret, l, buf)] = 0;
+    wn = fl_utf8fromwc(buf, wn, ret, (unsigned) l); // convert string
+    buf[wn] = 0;
+    return buf;
+  } else {
+    return NULL;
+  }
+
 #else
-	return getenv(v);
+
+  return getenv(v);
+
 #endif
-}
+
+} // fl_getenv()
+
 
 /** Cross-platform function to open files with a UTF-8 encoded name.
- 
- This function is especially useful under the MSWindows platform where the 
+
+ This function is especially useful under the MSWindows platform where the
  standard open() function fails with UTF-8 encoded non-ASCII filenames.
  \param f  the UTF-8 encoded filename
  \param oflags  other arguments are as in the standard open() function
@@ -533,271 +472,350 @@ char *fl_getenv(const char* v)
  */
 int fl_open(const char* f, int oflags, ...)
 {
-	int pmode;
-	va_list ap;
-	va_start(ap, oflags);
-	pmode = va_arg (ap, int);
-	va_end(ap);
+  int pmode;
+  va_list ap;
+  va_start(ap, oflags);
+  pmode = va_arg (ap, int);
+  va_end(ap);
+
 #if defined (WIN32) && !defined(__CYGWIN__)
-		unsigned l = (unsigned) strlen(f);
-//		wbuf = (xchar*)realloc(wbuf, sizeof(xchar) * (l+1));
-//		wbuf[fl_utf2unicode((const unsigned char*)f, l, wbuf)] = 0;
-		unsigned wn = fl_utf8toUtf16(f, l, NULL, 0) + 1; // Query length
-		wbuf = (xchar*)realloc(wbuf, sizeof(xchar)*wn);
-		wn = fl_utf8toUtf16(f, l, (unsigned short *)wbuf, wn); // Convert string
-		wbuf[wn] = 0;
-		if (pmode == -1) return _wopen(wbuf, oflags);
-		else return _wopen(wbuf, oflags, pmode);
+
+  unsigned l = (unsigned) strlen(f);
+  // wbuf = (xchar*)realloc(wbuf, sizeof(xchar) * (l+1));
+  // wbuf[fl_utf2unicode((const unsigned char*)f, l, wbuf)] = 0;
+  unsigned wn = fl_utf8toUtf16(f, l, NULL, 0) + 1; // Query length
+  wbuf = (xchar*)realloc(wbuf, sizeof(xchar)*wn);
+  wn = fl_utf8toUtf16(f, l, (unsigned short *)wbuf, wn); // Convert string
+  wbuf[wn] = 0;
+  if (pmode == -1) return _wopen(wbuf, oflags);
+  else return _wopen(wbuf, oflags, pmode);
+
 #else
-	if (pmode == -1) return open(f, oflags);
-	else return open(f, oflags, pmode);
+
+  if (pmode == -1) return open(f, oflags);
+  else return open(f, oflags, pmode);
+
 #endif
-}
+
+} // fl_open()
+
 
 /** Cross-platform function to open files with a UTF-8 encoded name.
- 
- This function is especially useful under the MSWindows platform where the 
- standard fopen() function fails with UTF-8 encoded non-ASCII filenames.
- \param f  the UTF-8 encoded filename
- \param mode  same as the second argument of the standard fopen() function
- \return  a FILE pointer upon successful completion, or NULL in case of error.
- \sa fl_open().
- */
-FILE *fl_fopen(const char* f, const char *mode)
-{
+
+  This function is especially useful under the MSWindows platform where the
+  standard fopen() function fails with UTF-8 encoded non-ASCII filenames.
+  \param f  the UTF-8 encoded filename
+  \param mode  same as the second argument of the standard fopen() function
+  \return  a FILE pointer upon successful completion, or NULL in case of error.
+  \sa fl_open().
+*/
+FILE *fl_fopen(const char* f, const char *mode) {
+
 #if  defined (WIN32) && !defined(__CYGWIN__)
-		size_t l = strlen(f);
-//		wbuf = (xchar*)realloc(wbuf, sizeof(xchar) * (l+1));
-//		wbuf[fl_utf2unicode((const unsigned char*)f, l, wbuf)] = 0;
-		unsigned wn = fl_utf8toUtf16(f, (unsigned) l, NULL, 0) + 1; // Query length
-		wbuf = (xchar*)realloc(wbuf, sizeof(xchar)*wn);
-		wn = fl_utf8toUtf16(f, (unsigned) l, (unsigned short *)wbuf, wn); // Convert string
-		wbuf[wn] = 0;
-		l = strlen(mode);
-//		wbuf1 = (xchar*)realloc(wbuf1, sizeof(xchar) * (l+1));
-//		wbuf1[fl_utf2unicode((const unsigned char*)mode, l, wbuf1)] = 0;
-		wn = fl_utf8toUtf16(mode, (unsigned) l, NULL, 0) + 1; // Query length
-		wbuf1 = (xchar*)realloc(wbuf1, sizeof(xchar)*wn);
-		wn = fl_utf8toUtf16(mode, (unsigned) l, (unsigned short *)wbuf1, wn); // Convert string
-		wbuf1[wn] = 0;
-		return _wfopen(wbuf, wbuf1);
+
+  size_t l = strlen(f);
+  // wbuf = (xchar*)realloc(wbuf, sizeof(xchar) * (l+1));
+  // wbuf[fl_utf2unicode((const unsigned char*)f, l, wbuf)] = 0;
+  unsigned wn = fl_utf8toUtf16(f, (unsigned) l, NULL, 0) + 1; // Query length
+  wbuf = (xchar*)realloc(wbuf, sizeof(xchar)*wn);
+  wn = fl_utf8toUtf16(f, (unsigned) l, (unsigned short *)wbuf, wn); // Convert string
+  wbuf[wn] = 0;
+  l = strlen(mode);
+  // wbuf1 = (xchar*)realloc(wbuf1, sizeof(xchar) * (l+1));
+  // wbuf1[fl_utf2unicode((const unsigned char*)mode, l, wbuf1)] = 0;
+  wn = fl_utf8toUtf16(mode, (unsigned) l, NULL, 0) + 1; // Query length
+  wbuf1 = (xchar*)realloc(wbuf1, sizeof(xchar)*wn);
+  wn = fl_utf8toUtf16(mode, (unsigned) l, (unsigned short *)wbuf1, wn); // Convert string
+  wbuf1[wn] = 0;
+  return _wfopen(wbuf, wbuf1);
+
 #else
-	return fopen(f, mode);
+
+  return fopen(f, mode);
+
 #endif
-}
 
-int fl_system(const char* f)
+} // fl_fopen()
+
+
+/** Cross-platform function to run a system command with a UTF-8 encoded string.
+
+  This function is especially useful under the MSWindows platform where
+  non-ASCII program (file) names must be encoded as wide characters.
+
+  On platforms other than MSWindows this function calls system() directly.
+
+  \param[in] cmd the UTF-8 encoded command string
+  \return the return value of _wsystem() on Windows or system() on other platforms.
+*/
+
+int fl_system(const char* cmd)
 {
-#if  defined (WIN32) && !defined(__CYGWIN__)
-#  ifdef __MINGW32__
-	return system(fl_utf2mbcs(f));
-#  else
-		size_t l = strlen(f);
-//		wbuf = (xchar*)realloc(wbuf, sizeof(xchar) * (l+1));
-//		wbuf[fl_utf2unicode((const unsigned char*)f, l, wbuf)] = 0;
-		unsigned wn = fl_utf8toUtf16(f, (unsigned) l, NULL, 0) + 1; // Query length
-		wbuf = (xchar*)realloc(wbuf, sizeof(xchar)*wn);
-		wn = fl_utf8toUtf16(f, (unsigned) l, (unsigned short *)wbuf, wn); // Convert string
-		wbuf[wn] = 0;
-		return _wsystem(wbuf);
-#  endif
+#if defined(WIN32) && !defined(__CYGWIN__)
+
+# ifdef __MINGW32__
+  return system(fl_utf2mbcs(cmd));
+# else
+  size_t l = strlen(cmd);
+  // wbuf = (xchar*)realloc(wbuf, sizeof(xchar) * (l+1));
+  // wbuf[fl_utf2unicode((const unsigned char*)cmd, l, wbuf)] = 0;
+  unsigned wn = fl_utf8toUtf16(cmd, (unsigned) l, NULL, 0) + 1; // Query length
+  wbuf = (xchar*)realloc(wbuf, sizeof(xchar)*wn);
+  wn = fl_utf8toUtf16(cmd, (unsigned) l, (unsigned short *)wbuf, wn); // Convert string
+  wbuf[wn] = 0;
+  return _wsystem(wbuf);
+# endif
+
 #else
-	return system(f);
+  return system(cmd);
 #endif
 }
 
 int fl_execvp(const char *file, char *const *argv)
 {
-#if  defined (WIN32) && !defined(__CYGWIN__)
-#ifdef __MINGW32__
-	return _execvp(fl_utf2mbcs(file), argv);
-#else
-		size_t l = strlen(file);
-		int i, n;
-		xchar **ar;
-//		wbuf = (xchar*)realloc(wbuf, sizeof(xchar) * (l+1));
-//		wbuf[fl_utf2unicode((const unsigned char*)file, l, wbuf)] = 0;
-		unsigned wn = fl_utf8toUtf16(file, (unsigned) l, NULL, 0) + 1; // Query length
-		wbuf = (xchar*)realloc(wbuf, sizeof(xchar)*wn);
-		wn = fl_utf8toUtf16(file, (unsigned) l, (unsigned short *)wbuf, wn); // Convert string
-		wbuf[wn] = 0;
-
-		i = 0; n = 0;
-		while (argv[i]) {i++; n++;}
-		ar = (xchar**) malloc(sizeof(xchar*) * (n + 1));
-		i = 0;
-		while (i <= n) {
-			unsigned wn;
-			l = strlen(argv[i]);
-//			ar[i] = (xchar *)malloc(sizeof(xchar) * (l+1));
-//			ar[i][fl_utf2unicode((const unsigned char*)argv[i], l, ar[i])] = 0;
-			wn = fl_utf8toUtf16(argv[i], (unsigned) l, NULL, 0) + 1; // Query length
-			ar[i] = (xchar *)malloc(sizeof(xchar)*wn);
-			wn = fl_utf8toUtf16(argv[i], (unsigned) l, (unsigned short *)ar[i], wn); // Convert string
-			ar[i][wn] = 0;
-			i++;
-		}
-		ar[n] = NULL;
-		_wexecvp(wbuf, ar);  // STR #3040
-		i = 0;
-		while (i <= n) {
-			free(ar[i]);
-			i++;
-		}
-		free(ar);
-		return -1;	     // STR #3040
-#endif
-#else
-	return execvp(file, argv);
+#if defined(WIN32) && !defined(__CYGWIN__) // Windows
+
+# ifdef __MINGW32__
+  return _execvp(fl_utf2mbcs(file), argv);
+# else
+  size_t l = strlen(file);
+  int i, n;
+  xchar **ar;
+  // wbuf = (xchar*)realloc(wbuf, sizeof(xchar) * (l+1));
+  // wbuf[fl_utf2unicode((const unsigned char*)file, l, wbuf)] = 0;
+  unsigned wn = fl_utf8toUtf16(file, (unsigned) l, NULL, 0) + 1; // Query length
+  wbuf = (xchar*)realloc(wbuf, sizeof(xchar)*wn);
+  wn = fl_utf8toUtf16(file, (unsigned) l, (unsigned short *)wbuf, wn); // Convert string
+  wbuf[wn] = 0;
+
+  i = 0; n = 0;
+  while (argv[i]) {i++; n++;}
+  ar = (xchar**) malloc(sizeof(xchar*) * (n + 1));
+  i = 0;
+  while (i <= n) {
+    unsigned wn;
+    l = strlen(argv[i]);
+    // ar[i] = (xchar *)malloc(sizeof(xchar) * (l+1));
+    // ar[i][fl_utf2unicode((const unsigned char*)argv[i], l, ar[i])] = 0;
+    wn = fl_utf8toUtf16(argv[i], (unsigned) l, NULL, 0) + 1; // Query length
+    ar[i] = (xchar *)malloc(sizeof(xchar)*wn);
+    wn = fl_utf8toUtf16(argv[i], (unsigned) l, (unsigned short *)ar[i], wn); // Convert string
+    ar[i][wn] = 0;
+    i++;
+  }
+  ar[n] = NULL;
+  _wexecvp(wbuf, ar);	// STR #3040
+  i = 0;
+  while (i <= n) {
+    free(ar[i]);
+    i++;
+  }
+  free(ar);
+  return -1;		// STR #3040
+# endif
+
+#else			// other platforms
+  return execvp(file, argv);
 #endif
+
 }
 
 
 
-int fl_chmod(const char* f, int mode)
-{
-#if  defined (WIN32) && !defined(__CYGWIN__)
-		size_t l = strlen(f);
-//		wbuf = (xchar*)realloc(wbuf, sizeof(xchar) * (l+1));
-//		wbuf[fl_utf2unicode((const unsigned char*)f, l, wbuf)] = 0;
-		unsigned wn = fl_utf8toUtf16(f, (unsigned) l, NULL, 0) + 1; // Query length
-		wbuf = (xchar*)realloc(wbuf, sizeof(xchar)*wn);
-		wn = fl_utf8toUtf16(f, (unsigned) l, (unsigned short *)wbuf, wn); // Convert string
-		wbuf[wn] = 0;
-		return _wchmod(wbuf, mode);
-#else
-	return chmod(f, mode);
+int fl_chmod(const char* f, int mode) {
+
+#if defined(WIN32) && !defined(__CYGWIN__) // Windows
+
+  size_t l = strlen(f);
+  // wbuf = (xchar*)realloc(wbuf, sizeof(xchar) * (l+1));
+  // wbuf[fl_utf2unicode((const unsigned char*)f, l, wbuf)] = 0;
+  unsigned wn = fl_utf8toUtf16(f, (unsigned) l, NULL, 0) + 1; // Query length
+  wbuf = (xchar*)realloc(wbuf, sizeof(xchar)*wn);
+  wn = fl_utf8toUtf16(f, (unsigned) l, (unsigned short *)wbuf, wn); // Convert string
+  wbuf[wn] = 0;
+  return _wchmod(wbuf, mode);
+
+#else // other platforms
+
+  return chmod(f, mode);
+
 #endif
-}
 
-int fl_access(const char* f, int mode)
-{
-#if defined (WIN32) && !defined(__CYGWIN__)
-		size_t l = strlen(f);
-//		wbuf = (xchar*)realloc(wbuf, sizeof(xchar) * (l+1));
-//		wbuf[fl_utf2unicode((const unsigned char*)f, l, wbuf)] = 0;
-		unsigned wn = fl_utf8toUtf16(f, (unsigned) l, NULL, 0) + 1; // Query length
-		wbuf = (xchar*)realloc(wbuf, sizeof(xchar)*wn);
-		wn = fl_utf8toUtf16(f, (unsigned) l, (unsigned short *)wbuf, wn); // Convert string
-		wbuf[wn] = 0;
-		return _waccess(wbuf, mode);
-#else
-	return access(f, mode);
+} // fl_chmod()
+
+
+int fl_access(const char* f, int mode) {
+
+#if defined (WIN32) && !defined(__CYGWIN__) // Windows
+
+  size_t l = strlen(f);
+  // wbuf = (xchar*)realloc(wbuf, sizeof(xchar) * (l+1));
+  // wbuf[fl_utf2unicode((const unsigned char*)f, l, wbuf)] = 0;
+  unsigned wn = fl_utf8toUtf16(f, (unsigned) l, NULL, 0) + 1; // Query length
+  wbuf = (xchar*)realloc(wbuf, sizeof(xchar)*wn);
+  wn = fl_utf8toUtf16(f, (unsigned) l, (unsigned short *)wbuf, wn); // Convert string
+  wbuf[wn] = 0;
+  return _waccess(wbuf, mode);
+
+#else // other platforms
+
+  return access(f, mode);
+
 #endif
-}
 
+} // fl_access()
+
+
+int fl_stat(const char* f, struct stat *b) {
+
+#if defined(WIN32) && !defined(__CYGWIN__) // Windows
+
+  size_t l = strlen(f);
+  // wbuf = (xchar*)realloc(wbuf, sizeof(xchar) * (l+1));
+  // wbuf[fl_utf2unicode((const unsigned char*)f, l, wbuf)] = 0;
+  unsigned wn = fl_utf8toUtf16(f, (unsigned) l, NULL, 0) + 1; // Query length
+  wbuf = (xchar*)realloc(wbuf, sizeof(xchar)*wn);
+  wn = fl_utf8toUtf16(f, (unsigned) l, (unsigned short *)wbuf, wn); // Convert string
+  wbuf[wn] = 0;
+  return _wstat(wbuf, (struct _stat*)b);
+
+#else // other platforms
+
+  return stat(f, b);
 
-int fl_stat(const char* f, struct stat *b)
-{
-#if defined(WIN32) && !defined(__CYGWIN__)
-		size_t l = strlen(f);
-//		wbuf = (xchar*)realloc(wbuf, sizeof(xchar) * (l+1));
-//		wbuf[fl_utf2unicode((const unsigned char*)f, l, wbuf)] = 0;
-		unsigned wn = fl_utf8toUtf16(f, (unsigned) l, NULL, 0) + 1; // Query length
-		wbuf = (xchar*)realloc(wbuf, sizeof(xchar)*wn);
-		wn = fl_utf8toUtf16(f, (unsigned) l, (unsigned short *)wbuf, wn); // Convert string
-		wbuf[wn] = 0;
-		return _wstat(wbuf, (struct _stat*)b);
-#else
-	return stat(f, b);
 #endif
-}
 
-char *fl_getcwd(char* b, int l)
-{
-	if (b == NULL) {
-		b = (char*) malloc(l+1);
-	}
-#if defined(WIN32) && !defined(__CYGWIN__)
-		static xchar *wbuf = NULL;
-		wbuf = (xchar*)realloc(wbuf, sizeof(xchar) * (l+1));
-//		xchar *ret = _wgetcwd(wbuf, l / 5);
-		xchar *ret = _wgetcwd(wbuf, l);
-		if (ret) {
-			unsigned dstlen = l;
-			l = (int) wcslen(wbuf);
-//			b[fl_unicode2utf(wbuf, l, b)] = 0;
-			dstlen = fl_utf8fromwc(b, dstlen, wbuf, (unsigned) l);
-			b[dstlen] = 0;
-			return b;
-		} else {
-			return NULL;
-		}
-#else
-	return getcwd(b, l);
+} // fl_stat()
+
+
+char *fl_getcwd(char* b, int l) {
+
+  if (b == NULL) {
+    b = (char*) malloc(l+1);
+  }
+
+#if defined(WIN32) && !defined(__CYGWIN__) // Windows
+
+  static xchar *wbuf = NULL;
+  wbuf = (xchar*)realloc(wbuf, sizeof(xchar) * (l+1));
+  // xchar *ret = _wgetcwd(wbuf, l / 5);
+  xchar *ret = _wgetcwd(wbuf, l);
+  if (ret) {
+    unsigned dstlen = l;
+    l = (int) wcslen(wbuf);
+    // b[fl_unicode2utf(wbuf, l, b)] = 0;
+    dstlen = fl_utf8fromwc(b, dstlen, wbuf, (unsigned) l);
+    b[dstlen] = 0;
+    return b;
+  } else {
+    return NULL;
+  }
+
+#else // other platforms
+
+  return getcwd(b, l);
+
 #endif
-}
 
+} // fl_getcwd()
+
+
+int fl_unlink(const char* f) {
+
+#if defined(WIN32) && !defined(__CYGWIN__) // Windows
+
+  size_t l = strlen(f);
+  // wbuf = (xchar*)realloc(wbuf, sizeof(xchar) * (l+1));
+  // wbuf[fl_utf2unicode((const unsigned char*)f, l, wbuf)] = 0;
+  unsigned wn = fl_utf8toUtf16(f, (unsigned) l, NULL, 0) + 1; // Query length
+  wbuf = (xchar*)realloc(wbuf, sizeof(xchar)*wn);
+  wn = fl_utf8toUtf16(f, (unsigned) l, (unsigned short *)wbuf, wn); // Convert string
+  wbuf[wn] = 0;
+  return _wunlink(wbuf);
+
+#else // other platforms
+
+  return unlink(f);
 
-int fl_unlink(const char* f)
-{
-#if defined(WIN32) && !defined(__CYGWIN__)
-		size_t l = strlen(f);
-//		wbuf = (xchar*)realloc(wbuf, sizeof(xchar) * (l+1));
-//		wbuf[fl_utf2unicode((const unsigned char*)f, l, wbuf)] = 0;
-		unsigned wn = fl_utf8toUtf16(f, (unsigned) l, NULL, 0) + 1; // Query length
-		wbuf = (xchar*)realloc(wbuf, sizeof(xchar)*wn);
-		wn = fl_utf8toUtf16(f, (unsigned) l, (unsigned short *)wbuf, wn); // Convert string
-		wbuf[wn] = 0;
-		return _wunlink(wbuf);
-#else
-	return unlink(f);
 #endif
-}
 
-int fl_mkdir(const char* f, int mode)
-{
-#if defined(WIN32) && !defined(__CYGWIN__)
-		size_t l = strlen(f);
-//		wbuf = (xchar*)realloc(wbuf, sizeof(short) * (l+1));
-//		wbuf[fl_utf2unicode((const unsigned char*)f, l, wbuf)] = 0;
-		unsigned wn = fl_utf8toUtf16(f, (unsigned) l, NULL, 0) + 1; // Query length
-		wbuf = (xchar*)realloc(wbuf, sizeof(xchar)*wn);
-		wn = fl_utf8toUtf16(f, (unsigned) l, (unsigned short *)wbuf, wn); // Convert string
-		wbuf[wn] = 0;
-		return _wmkdir(wbuf);
-#else
-	return mkdir(f, mode);
+} // fl_unlink()
+
+
+int fl_mkdir(const char* f, int mode) {
+
+#if defined(WIN32) && !defined(__CYGWIN__) // Windows
+
+  size_t l = strlen(f);
+  // wbuf = (xchar*)realloc(wbuf, sizeof(short) * (l+1));
+  // wbuf[fl_utf2unicode((const unsigned char*)f, l, wbuf)] = 0;
+  unsigned wn = fl_utf8toUtf16(f, (unsigned) l, NULL, 0) + 1; // Query length
+  wbuf = (xchar*)realloc(wbuf, sizeof(xchar)*wn);
+  wn = fl_utf8toUtf16(f, (unsigned) l, (unsigned short *)wbuf, wn); // Convert string
+  wbuf[wn] = 0;
+  return _wmkdir(wbuf);
+
+#else // other platforms
+
+  return mkdir(f, mode);
+
 #endif
-}
 
+} // fl_mkdir()
+
+
+int fl_rmdir(const char* f) {
+
+#if defined (WIN32) && !defined(__CYGWIN__) // Windows
+
+  size_t l = strlen(f);
+  // wbuf = (xchar*)realloc(wbuf, sizeof(xchar) * (l+1));
+  // wbuf[fl_utf2unicode((const unsigned char*)f, l, wbuf)] = 0;
+  unsigned wn = fl_utf8toUtf16(f, (unsigned) l, NULL, 0) + 1; // Query length
+  wbuf = (xchar*)realloc(wbuf, sizeof(xchar)*wn);
+  wn = fl_utf8toUtf16(f, (unsigned) l, (unsigned short *)wbuf, wn); // Convert string
+  wbuf[wn] = 0;
+  return _wrmdir(wbuf);
 
-int fl_rmdir(const char* f)
-{
-#if defined (WIN32) && !defined(__CYGWIN__)
-		size_t l = strlen(f);
-//		wbuf = (xchar*)realloc(wbuf, sizeof(xchar) * (l+1));
-//		wbuf[fl_utf2unicode((const unsigned char*)f, l, wbuf)] = 0;
-		unsigned wn = fl_utf8toUtf16(f, (unsigned) l, NULL, 0) + 1; // Query length
-		wbuf = (xchar*)realloc(wbuf, sizeof(xchar)*wn);
-		wn = fl_utf8toUtf16(f, (unsigned) l, (unsigned short *)wbuf, wn); // Convert string
-		wbuf[wn] = 0;
-		return _wrmdir(wbuf);
 #else
-	return rmdir(f);
+
+  return rmdir(f);
+
 #endif
-}
 
-int fl_rename(const char* f, const char *n)
-{
-#if defined (WIN32) && !defined(__CYGWIN__)
-		size_t l = strlen(f);
-		unsigned wn = fl_utf8toUtf16(f, (unsigned) l, NULL, 0) + 1; // Query length
-		wbuf = (xchar*)realloc(wbuf, sizeof(xchar)*wn);
-		wn = fl_utf8toUtf16(f, (unsigned) l, (unsigned short *)wbuf, wn); // Convert string
-		wbuf[wn] = 0;
-		l = strlen(n);
-		wn = fl_utf8toUtf16(n, (unsigned) l, NULL, 0) + 1; // Query length
-		wbuf1 = (xchar*)realloc(wbuf1, sizeof(xchar)*wn);
-		wn = fl_utf8toUtf16(n, (unsigned) l, (unsigned short *)wbuf1, wn); // Convert string
-		wbuf1[wn] = 0;
-		return _wrename(wbuf, wbuf1);
+} // fl_rmdir()
+
+
+int fl_rename(const char* f, const char *n) {
+
+#if defined (WIN32) && !defined(__CYGWIN__) // Windows
+
+  size_t l = strlen(f);
+  unsigned wn = fl_utf8toUtf16(f, (unsigned) l, NULL, 0) + 1; // Query length
+  wbuf = (xchar*)realloc(wbuf, sizeof(xchar)*wn);
+  wn = fl_utf8toUtf16(f, (unsigned) l, (unsigned short *)wbuf, wn); // Convert string
+  wbuf[wn] = 0;
+  l = strlen(n);
+  wn = fl_utf8toUtf16(n, (unsigned) l, NULL, 0) + 1; // Query length
+  wbuf1 = (xchar*)realloc(wbuf1, sizeof(xchar)*wn);
+  wn = fl_utf8toUtf16(n, (unsigned) l, (unsigned short *)wbuf1, wn); // Convert string
+  wbuf1[wn] = 0;
+  return _wrename(wbuf, wbuf1);
+
 #else
-	return rename(f, n);
+
+  return rename(f, n);
+
 #endif
-}
 
-// recursively create a path in the file system
+} // fl_rename()
+
+
+/** Cross-platform function to recursively create a path in the file system.
+
+  This function creates a \p path in the file system by recursively creating
+  all directories.
+*/
 char fl_make_path( const char *path ) {
   if (fl_access(path, 0)) {
     const char *s = strrchr( path, '/' );
@@ -813,9 +831,14 @@ char fl_make_path( const char *path ) {
   return 1;
 }
 
-// strip the filename and create a path
-void fl_make_path_for_file( const char *path )
-{
+/** Cross-platform function to create a path for the file in the file system.
+
+  This function strips the filename from the given \p path and creates
+  a path in the file system by recursively creating all directories.
+*/
+
+void fl_make_path_for_file( const char *path ) {
+
   const char *s = strrchr( path, '/' );
   if ( !s ) return;
   size_t len =  (s-path);
@@ -824,7 +847,8 @@ void fl_make_path_for_file( const char *path )
   p[len] = 0;
   fl_make_path( p );
   free( p );
-}
+
+} // fl_make_path_for_file()
 
 /** @} */