46 files changed, 7745 insertions, 7745 deletions
diff --git a/zen/basic_math.h b/zen/basic_math.h
index 7836ae81..722722a5 100755
--- a/zen/basic_math.h
+++ b/zen/basic_math.h
@@ -1,383 +1,383 @@
-// *****************************************************************************
-// * This file is part of the FreeFileSync project. It is distributed under    *
-// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
-// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
-// *****************************************************************************
-
-#ifndef BASIC_MATH_H_3472639843265675
-#define BASIC_MATH_H_3472639843265675
-
-#include <algorithm>
-#include <iterator>
-#include <limits>
-#include <cmath>
-#include <functional>
-#include <cassert>
-
-
-namespace numeric
-{
-template <class T> T abs(T value);
-template <class T> auto dist(T a, T b);
-template <class T> int sign(T value); //returns one of {-1, 0, 1}
-template <class T> T min(T a, T b, T c);
-template <class T> T max(T a, T b, T c);
-template <class T> bool isNull(T value);
-
-template <class T>
-void clamp(T& val, T minVal, T maxVal); //make sure minVal <= val && val <= maxVal
-template <class T>
-T clampCpy(T val, T minVal, T maxVal);
-
-template <class T, class InputIterator> //precondition: range must be sorted!
-auto nearMatch(const T& val, InputIterator first, InputIterator last);
-
-int round(double d); //"little rounding function"
-
-template <class N, class D>
-auto integerDivideRoundUp(N numerator, D denominator);
-
-template <size_t N, class T>
-T power(T value);
-
-double radToDeg(double rad);    //convert unit [rad] into [�]
-double degToRad(double degree); //convert unit [�] into [rad]
-
-template <class InputIterator>
-double arithmeticMean(InputIterator first, InputIterator last);
-
-template <class RandomAccessIterator>
-double median(RandomAccessIterator first, RandomAccessIterator last); //note: invalidates input range!
-
-template <class InputIterator>
-double stdDeviation(InputIterator first, InputIterator last, double* mean = nullptr); //estimate standard deviation (and thereby arithmetic mean)
-
-//median absolute deviation: "mad / 0.6745" is a robust measure for standard deviation of a normal distribution
-template <class RandomAccessIterator>
-double mad(RandomAccessIterator first, RandomAccessIterator last); //note: invalidates input range!
-
-template <class InputIterator>
-double norm2(InputIterator first, InputIterator last);
-
-//constants
-const double pi    = 3.14159265358979323846;
-const double e     = 2.71828182845904523536;
-const double sqrt2 = 1.41421356237309504880;
-const double ln2   = 0.693147180559945309417;
-//----------------------------------------------------------------------------------
-
-
-
-
-
-
-
-
-
-
-
-
-
-//################# inline implementation #########################
-template <class T> inline
-T abs(T value)
-{
-    //static_assert(std::is_signed<T>::value, "");
-    if (value < 0)
-        return -value; //operator "?:" caveat: may be different type than "value"
-    else
-        return value;
-}
-
-template <class T> inline
-auto dist(T a, T b) //return type might be different than T, e.g. std::chrono::duration instead of std::chrono::time_point
-{
-    return a > b ? a - b : b - a;
-}
-
-
-template <class T> inline
-int sign(T value) //returns one of {-1, 0, 1}
-{
-    static_assert(std::is_signed<T>::value, "");
-    return value < 0 ? -1 : (value > 0 ? 1 : 0);
-}
-
-
-template <class T> inline
-T min(T a, T b, T c) //don't follow std::min's "const T&(const T&, const T&)" API
-{
-    if (a < b)
-        return a < c ? a : c;
-    else
-        return b < c ? b : c;
-    //return std::min(std::min(a, b), c);
-}
-
-
-template <class T> inline
-T max(T a, T b, T c)
-{
-    if (a > b)
-        return a > c ? a : c;
-    else
-        return b > c ? b : c;
-    //return std::max(std::max(a, b), c);
-}
-
-
-template <class T> inline
-T clampCpy(T val, T minVal, T maxVal)
-{
-    assert(minVal <= maxVal);
-    if (val < minVal)
-        return minVal;
-    else if (val > maxVal)
-        return maxVal;
-    return val;
-}
-
-template <class T> inline
-void clamp(T& val, T minVal, T maxVal)
-{
-    assert(minVal <= maxVal);
-    if (val < minVal)
-        val = minVal;
-    else if (val > maxVal)
-        val = maxVal;
-}
-
-
-/*
-part of C++11 now!
-template <class InputIterator, class Compare> inline
-std::pair<InputIterator, InputIterator> minMaxElement(InputIterator first, InputIterator last, Compare compLess)
-{
-    //by factor 1.5 to 3 faster than boost::minmax_element (=two-step algorithm) for built-in types!
-
-    InputIterator lowest  = first;
-    InputIterator largest = first;
-
-    if (first != last)
-    {
-        auto minVal = *lowest;  //nice speedup on 64 bit!
-        auto maxVal = *largest; //
-        for (;;)
-        {
-            ++first;
-            if (first == last)
-                break;
-            const auto val = *first;
-
-            if (compLess(maxVal, val))
-            {
-                largest = first;
-                maxVal  = val;
-            }
-            else if (compLess(val, minVal))
-            {
-                lowest = first;
-                minVal = val;
-            }
-        }
-    }
-    return std::make_pair(lowest, largest);
-}
-
-
-template <class InputIterator> inline
-std::pair<InputIterator, InputIterator> minMaxElement(InputIterator first, InputIterator last)
-{
-    return minMaxElement(first, last, std::less<typename std::iterator_traits<InputIterator>::value_type>());
-}
-*/
-
-template <class T, class InputIterator> inline
-auto nearMatch(const T& val, InputIterator first, InputIterator last)
-{
-    if (first == last)
-        return static_cast<decltype(*first)>(0);
-
-    assert(std::is_sorted(first, last));
-    InputIterator it = std::lower_bound(first, last, val);
-    if (it == last)
-        return *--last;
-    if (it == first)
-        return *first;
-
-    const auto nextVal = *it;
-    const auto prevVal = *--it;
-    return val - prevVal < nextVal - val ? prevVal : nextVal;
-}
-
-
-template <class T> inline
-bool isNull(T value)
-{
-    return abs(value) <= std::numeric_limits<T>::epsilon(); //epsilon is 0 f�r integral types => less-equal
-}
-
-
-inline
-int round(double d)
-{
-    assert(d - 0.5 >= std::numeric_limits<int>::min() && //if double is larger than what int can represent:
-           d + 0.5 <= std::numeric_limits<int>::max());  //=> undefined behavior!
-    return static_cast<int>(d < 0 ? d - 0.5 : d + 0.5);
-}
-
-
-template <class N, class D> inline
-auto integerDivideRoundUp(N numerator, D denominator)
-{
-    static_assert(std::is_integral<N>::value && std::is_unsigned<N>::value, "");
-    static_assert(std::is_integral<D>::value && std::is_unsigned<D>::value, "");
-    assert(denominator > 0);
-    return (numerator + denominator - 1) / denominator;
-}
-
-
-namespace
-{
-template <size_t N, class T> struct PowerImpl;
-/*
-    template <size_t N, class T> -> let's use non-recursive specializations to help the compiler
-    struct PowerImpl { static T result(const T& value) { return PowerImpl<N - 1, T>::result(value) * value; } };
-*/
-template <class T> struct PowerImpl<2, T> { static T result(T value) { return value * value; } };
-template <class T> struct PowerImpl<3, T> { static T result(T value) { return value * value * value; } };
-}
-
-template <size_t n, class T> inline
-T power(T value)
-{
-    return PowerImpl<n, T>::result(value);
-}
-
-
-inline
-double radToDeg(double rad)
-{
-    return rad * 180.0 / numeric::pi;
-}
-
-
-inline
-double degToRad(double degree)
-{
-    return degree * numeric::pi / 180.0;
-}
-
-
-template <class InputIterator> inline
-double arithmeticMean(InputIterator first, InputIterator last)
-{
-    size_t n      = 0; //avoid random-access requirement for iterator!
-    double sum_xi = 0;
-
-    for (; first != last; ++first, ++n)
-        sum_xi += *first;
-
-    return n == 0 ? 0 : sum_xi / n;
-}
-
-
-template <class RandomAccessIterator> inline
-double median(RandomAccessIterator first, RandomAccessIterator last) //note: invalidates input range!
-{
-    const size_t n = last - first;
-    if (n > 0)
-    {
-        std::nth_element(first, first + n / 2, last); //complexity: O(n)
-        const double midVal = *(first + n / 2);
-
-        if (n % 2 != 0)
-            return midVal;
-        else //n is even and >= 2 in this context: return mean of two middle values
-            return 0.5 * (*std::max_element(first, first + n / 2) + midVal); //this operation is the reason why median() CANNOT support a comparison predicate!!!
-    }
-    return 0;
-}
-
-
-template <class RandomAccessIterator> inline
-double mad(RandomAccessIterator first, RandomAccessIterator last) //note: invalidates input range!
-{
-    //http://en.wikipedia.org/wiki/Median_absolute_deviation
-
-    const size_t n = last - first;
-    if (n > 0)
-    {
-        const double m = median(first, last);
-
-        //the second median needs to operate on absolute residuals => avoid transforming input range which may have less than double precision!
-
-        auto lessMedAbs = [m](double lhs, double rhs) { return abs(lhs - m) < abs(rhs - m); };
-
-        std::nth_element(first, first + n / 2, last, lessMedAbs); //complexity: O(n)
-        const double midVal = abs(*(first + n / 2) - m);
-
-        if (n % 2 != 0)
-            return midVal;
-        else //n is even and >= 2 in this context: return mean of two middle values
-            return 0.5 * (abs(*std::max_element(first, first + n / 2, lessMedAbs) - m) + midVal);
-    }
-    return 0;
-}
-
-
-template <class InputIterator> inline
-double stdDeviation(InputIterator first, InputIterator last, double* arithMean)
-{
-    //implementation minimizing rounding errors, see: http://en.wikipedia.org/wiki/Standard_deviation
-    //combined with technique avoiding overflow, see: http://www.netlib.org/blas/dnrm2.f -> only 10% performance degradation
-
-    size_t n     = 0;
-    double mean  = 0;
-    double q     = 0;
-    double scale = 1;
-
-    for (; first != last; ++first)
-    {
-        ++n;
-        const double val = *first - mean;
-
-        if (abs(val) > scale)
-        {
-            q = (n - 1.0) / n + q * power<2>(scale / val);
-            scale = abs(val);
-        }
-        else
-            q += (n - 1.0) * power<2>(val / scale) / n;
-
-        mean += val / n;
-    }
-
-    if (arithMean)
-        *arithMean = mean;
-
-    return n <= 1 ? 0 : std::sqrt(q / (n - 1)) * scale;
-}
-
-
-template <class InputIterator> inline
-double norm2(InputIterator first, InputIterator last)
-{
-    double result = 0;
-    double scale  = 1;
-    for (; first != last; ++first)
-    {
-        const double tmp = abs(*first);
-        if (tmp > scale)
-        {
-            result = 1 + result * power<2>(scale / tmp);
-            scale = tmp;
-        }
-        else
-            result += power<2>(tmp / scale);
-    }
-    return std::sqrt(result) * scale;
-}
-}
-
-#endif //BASIC_MATH_H_3472639843265675
+// *****************************************************************************
+// * This file is part of the FreeFileSync project. It is distributed under    *
+// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
+// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
+// *****************************************************************************
+
+#ifndef BASIC_MATH_H_3472639843265675
+#define BASIC_MATH_H_3472639843265675
+
+#include <algorithm>
+#include <iterator>
+#include <limits>
+#include <cmath>
+#include <functional>
+#include <cassert>
+
+
+namespace numeric
+{
+template <class T> T abs(T value);
+template <class T> auto dist(T a, T b);
+template <class T> int sign(T value); //returns one of {-1, 0, 1}
+template <class T> T min(T a, T b, T c);
+template <class T> T max(T a, T b, T c);
+template <class T> bool isNull(T value);
+
+template <class T>
+void clamp(T& val, T minVal, T maxVal); //make sure minVal <= val && val <= maxVal
+template <class T>
+T clampCpy(T val, T minVal, T maxVal);
+
+template <class T, class InputIterator> //precondition: range must be sorted!
+auto nearMatch(const T& val, InputIterator first, InputIterator last);
+
+int round(double d); //"little rounding function"
+
+template <class N, class D>
+auto integerDivideRoundUp(N numerator, D denominator);
+
+template <size_t N, class T>
+T power(T value);
+
+double radToDeg(double rad);    //convert unit [rad] into [�]
+double degToRad(double degree); //convert unit [�] into [rad]
+
+template <class InputIterator>
+double arithmeticMean(InputIterator first, InputIterator last);
+
+template <class RandomAccessIterator>
+double median(RandomAccessIterator first, RandomAccessIterator last); //note: invalidates input range!
+
+template <class InputIterator>
+double stdDeviation(InputIterator first, InputIterator last, double* mean = nullptr); //estimate standard deviation (and thereby arithmetic mean)
+
+//median absolute deviation: "mad / 0.6745" is a robust measure for standard deviation of a normal distribution
+template <class RandomAccessIterator>
+double mad(RandomAccessIterator first, RandomAccessIterator last); //note: invalidates input range!
+
+template <class InputIterator>
+double norm2(InputIterator first, InputIterator last);
+
+//constants
+const double pi    = 3.14159265358979323846;
+const double e     = 2.71828182845904523536;
+const double sqrt2 = 1.41421356237309504880;
+const double ln2   = 0.693147180559945309417;
+//----------------------------------------------------------------------------------
+
+
+
+
+
+
+
+
+
+
+
+
+
+//################# inline implementation #########################
+template <class T> inline
+T abs(T value)
+{
+    //static_assert(std::is_signed<T>::value, "");
+    if (value < 0)
+        return -value; //operator "?:" caveat: may be different type than "value"
+    else
+        return value;
+}
+
+template <class T> inline
+auto dist(T a, T b) //return type might be different than T, e.g. std::chrono::duration instead of std::chrono::time_point
+{
+    return a > b ? a - b : b - a;
+}
+
+
+template <class T> inline
+int sign(T value) //returns one of {-1, 0, 1}
+{
+    static_assert(std::is_signed<T>::value, "");
+    return value < 0 ? -1 : (value > 0 ? 1 : 0);
+}
+
+
+template <class T> inline
+T min(T a, T b, T c) //don't follow std::min's "const T&(const T&, const T&)" API
+{
+    if (a < b)
+        return a < c ? a : c;
+    else
+        return b < c ? b : c;
+    //return std::min(std::min(a, b), c);
+}
+
+
+template <class T> inline
+T max(T a, T b, T c)
+{
+    if (a > b)
+        return a > c ? a : c;
+    else
+        return b > c ? b : c;
+    //return std::max(std::max(a, b), c);
+}
+
+
+template <class T> inline
+T clampCpy(T val, T minVal, T maxVal)
+{
+    assert(minVal <= maxVal);
+    if (val < minVal)
+        return minVal;
+    else if (val > maxVal)
+        return maxVal;
+    return val;
+}
+
+template <class T> inline
+void clamp(T& val, T minVal, T maxVal)
+{
+    assert(minVal <= maxVal);
+    if (val < minVal)
+        val = minVal;
+    else if (val > maxVal)
+        val = maxVal;
+}
+
+
+/*
+part of C++11 now!
+template <class InputIterator, class Compare> inline
+std::pair<InputIterator, InputIterator> minMaxElement(InputIterator first, InputIterator last, Compare compLess)
+{
+    //by factor 1.5 to 3 faster than boost::minmax_element (=two-step algorithm) for built-in types!
+
+    InputIterator lowest  = first;
+    InputIterator largest = first;
+
+    if (first != last)
+    {
+        auto minVal = *lowest;  //nice speedup on 64 bit!
+        auto maxVal = *largest; //
+        for (;;)
+        {
+            ++first;
+            if (first == last)
+                break;
+            const auto val = *first;
+
+            if (compLess(maxVal, val))
+            {
+                largest = first;
+                maxVal  = val;
+            }
+            else if (compLess(val, minVal))
+            {
+                lowest = first;
+                minVal = val;
+            }
+        }
+    }
+    return std::make_pair(lowest, largest);
+}
+
+
+template <class InputIterator> inline
+std::pair<InputIterator, InputIterator> minMaxElement(InputIterator first, InputIterator last)
+{
+    return minMaxElement(first, last, std::less<typename std::iterator_traits<InputIterator>::value_type>());
+}
+*/
+
+template <class T, class InputIterator> inline
+auto nearMatch(const T& val, InputIterator first, InputIterator last)
+{
+    if (first == last)
+        return static_cast<decltype(*first)>(0);
+
+    assert(std::is_sorted(first, last));
+    InputIterator it = std::lower_bound(first, last, val);
+    if (it == last)
+        return *--last;
+    if (it == first)
+        return *first;
+
+    const auto nextVal = *it;
+    const auto prevVal = *--it;
+    return val - prevVal < nextVal - val ? prevVal : nextVal;
+}
+
+
+template <class T> inline
+bool isNull(T value)
+{
+    return abs(value) <= std::numeric_limits<T>::epsilon(); //epsilon is 0 f�r integral types => less-equal
+}
+
+
+inline
+int round(double d)
+{
+    assert(d - 0.5 >= std::numeric_limits<int>::min() && //if double is larger than what int can represent:
+           d + 0.5 <= std::numeric_limits<int>::max());  //=> undefined behavior!
+    return static_cast<int>(d < 0 ? d - 0.5 : d + 0.5);
+}
+
+
+template <class N, class D> inline
+auto integerDivideRoundUp(N numerator, D denominator)
+{
+    static_assert(std::is_integral<N>::value && std::is_unsigned<N>::value, "");
+    static_assert(std::is_integral<D>::value && std::is_unsigned<D>::value, "");
+    assert(denominator > 0);
+    return (numerator + denominator - 1) / denominator;
+}
+
+
+namespace
+{
+template <size_t N, class T> struct PowerImpl;
+/*
+    template <size_t N, class T> -> let's use non-recursive specializations to help the compiler
+    struct PowerImpl { static T result(const T& value) { return PowerImpl<N - 1, T>::result(value) * value; } };
+*/
+template <class T> struct PowerImpl<2, T> { static T result(T value) { return value * value; } };
+template <class T> struct PowerImpl<3, T> { static T result(T value) { return value * value * value; } };
+}
+
+template <size_t n, class T> inline
+T power(T value)
+{
+    return PowerImpl<n, T>::result(value);
+}
+
+
+inline
+double radToDeg(double rad)
+{
+    return rad * 180.0 / numeric::pi;
+}
+
+
+inline
+double degToRad(double degree)
+{
+    return degree * numeric::pi / 180.0;
+}
+
+
+template <class InputIterator> inline
+double arithmeticMean(InputIterator first, InputIterator last)
+{
+    size_t n      = 0; //avoid random-access requirement for iterator!
+    double sum_xi = 0;
+
+    for (; first != last; ++first, ++n)
+        sum_xi += *first;
+
+    return n == 0 ? 0 : sum_xi / n;
+}
+
+
+template <class RandomAccessIterator> inline
+double median(RandomAccessIterator first, RandomAccessIterator last) //note: invalidates input range!
+{
+    const size_t n = last - first;
+    if (n > 0)
+    {
+        std::nth_element(first, first + n / 2, last); //complexity: O(n)
+        const double midVal = *(first + n / 2);
+
+        if (n % 2 != 0)
+            return midVal;
+        else //n is even and >= 2 in this context: return mean of two middle values
+            return 0.5 * (*std::max_element(first, first + n / 2) + midVal); //this operation is the reason why median() CANNOT support a comparison predicate!!!
+    }
+    return 0;
+}
+
+
+template <class RandomAccessIterator> inline
+double mad(RandomAccessIterator first, RandomAccessIterator last) //note: invalidates input range!
+{
+    //http://en.wikipedia.org/wiki/Median_absolute_deviation
+
+    const size_t n = last - first;
+    if (n > 0)
+    {
+        const double m = median(first, last);
+
+        //the second median needs to operate on absolute residuals => avoid transforming input range which may have less than double precision!
+
+        auto lessMedAbs = [m](double lhs, double rhs) { return abs(lhs - m) < abs(rhs - m); };
+
+        std::nth_element(first, first + n / 2, last, lessMedAbs); //complexity: O(n)
+        const double midVal = abs(*(first + n / 2) - m);
+
+        if (n % 2 != 0)
+            return midVal;
+        else //n is even and >= 2 in this context: return mean of two middle values
+            return 0.5 * (abs(*std::max_element(first, first + n / 2, lessMedAbs) - m) + midVal);
+    }
+    return 0;
+}
+
+
+template <class InputIterator> inline
+double stdDeviation(InputIterator first, InputIterator last, double* arithMean)
+{
+    //implementation minimizing rounding errors, see: http://en.wikipedia.org/wiki/Standard_deviation
+    //combined with technique avoiding overflow, see: http://www.netlib.org/blas/dnrm2.f -> only 10% performance degradation
+
+    size_t n     = 0;
+    double mean  = 0;
+    double q     = 0;
+    double scale = 1;
+
+    for (; first != last; ++first)
+    {
+        ++n;
+        const double val = *first - mean;
+
+        if (abs(val) > scale)
+        {
+            q = (n - 1.0) / n + q * power<2>(scale / val);
+            scale = abs(val);
+        }
+        else
+            q += (n - 1.0) * power<2>(val / scale) / n;
+
+        mean += val / n;
+    }
+
+    if (arithMean)
+        *arithMean = mean;
+
+    return n <= 1 ? 0 : std::sqrt(q / (n - 1)) * scale;
+}
+
+
+template <class InputIterator> inline
+double norm2(InputIterator first, InputIterator last)
+{
+    double result = 0;
+    double scale  = 1;
+    for (; first != last; ++first)
+    {
+        const double tmp = abs(*first);
+        if (tmp > scale)
+        {
+            result = 1 + result * power<2>(scale / tmp);
+            scale = tmp;
+        }
+        else
+            result += power<2>(tmp / scale);
+    }
+    return std::sqrt(result) * scale;
+}
+}
+
+#endif //BASIC_MATH_H_3472639843265675
diff --git a/zen/build_info.h b/zen/build_info.h
index f3f7f5b1..8354f492 100755
--- a/zen/build_info.h
+++ b/zen/build_info.h
@@ -1,29 +1,29 @@
-// *****************************************************************************
-// * This file is part of the FreeFileSync project. It is distributed under    *
-// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
-// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
-// *****************************************************************************
-
-#ifndef BUILD_INFO_H_5928539285603428657
-#define BUILD_INFO_H_5928539285603428657
-
-namespace zen
-{
-//determine build info: defines ZEN_BUILD_32BIT or ZEN_BUILD_64BIT
-
-    #ifdef __LP64__
-        #define ZEN_BUILD_64BIT
-    #else
-        #define ZEN_BUILD_32BIT
-    #endif
-
-#ifdef ZEN_BUILD_32BIT
-    static_assert(sizeof(void*) == 4, "");
-#endif
-
-#ifdef ZEN_BUILD_64BIT
-    static_assert(sizeof(void*) == 8, "");
-#endif
-}
-
-#endif //BUILD_INFO_H_5928539285603428657
+// *****************************************************************************
+// * This file is part of the FreeFileSync project. It is distributed under    *
+// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
+// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
+// *****************************************************************************
+
+#ifndef BUILD_INFO_H_5928539285603428657
+#define BUILD_INFO_H_5928539285603428657
+
+namespace zen
+{
+//determine build info: defines ZEN_BUILD_32BIT or ZEN_BUILD_64BIT
+
+    #ifdef __LP64__
+        #define ZEN_BUILD_64BIT
+    #else
+        #define ZEN_BUILD_32BIT
+    #endif
+
+#ifdef ZEN_BUILD_32BIT
+    static_assert(sizeof(void*) == 4, "");
+#endif
+
+#ifdef ZEN_BUILD_64BIT
+    static_assert(sizeof(void*) == 8, "");
+#endif
+}
+
+#endif //BUILD_INFO_H_5928539285603428657
diff --git a/zen/crc.h b/zen/crc.h
index b4d53d12..67f0460e 100755
--- a/zen/crc.h
+++ b/zen/crc.h
@@ -1,54 +1,54 @@
-// *****************************************************************************
-// * This file is part of the FreeFileSync project. It is distributed under    *
-// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
-// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
-// *****************************************************************************
-
-#ifndef CRC_H_23489275827847235
-#define CRC_H_23489275827847235
-
-#include <boost/crc.hpp>
-
-
-namespace zen
-{
-uint16_t getCrc16(const std::string& str);
-uint32_t getCrc32(const std::string& str);
-template <class ByteIterator> uint16_t getCrc16(ByteIterator first, ByteIterator last);
-template <class ByteIterator> uint32_t getCrc32(ByteIterator first, ByteIterator last);
-
-
-
-
-//------------------------- implementation -------------------------------
-inline uint16_t getCrc16(const std::string& str) { return getCrc16(str.begin(), str.end()); }
-inline uint32_t getCrc32(const std::string& str) { return getCrc32(str.begin(), str.end()); }
-
-
-template <class ByteIterator> inline
-uint16_t getCrc16(ByteIterator first, ByteIterator last)
-{
-    static_assert(sizeof(typename std::iterator_traits<ByteIterator>::value_type) == 1, "");
-    boost::crc_16_type result;
-    if (first != last)
-        result.process_bytes(&*first, last - first);
-    auto rv = result.checksum();
-    static_assert(sizeof(rv) == sizeof(uint16_t), "");
-    return rv;
-}
-
-
-template <class ByteIterator> inline
-uint32_t getCrc32(ByteIterator first, ByteIterator last)
-{
-    static_assert(sizeof(typename std::iterator_traits<ByteIterator>::value_type) == 1, "");
-    boost::crc_32_type result;
-    if (first != last)
-        result.process_bytes(&*first, last - first);
-    auto rv = result.checksum();
-    static_assert(sizeof(rv) == sizeof(uint32_t), "");
-    return rv;
-}
-}
-
-#endif //CRC_H_23489275827847235
+// *****************************************************************************
+// * This file is part of the FreeFileSync project. It is distributed under    *
+// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
+// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
+// *****************************************************************************
+
+#ifndef CRC_H_23489275827847235
+#define CRC_H_23489275827847235
+
+#include <boost/crc.hpp>
+
+
+namespace zen
+{
+uint16_t getCrc16(const std::string& str);
+uint32_t getCrc32(const std::string& str);
+template <class ByteIterator> uint16_t getCrc16(ByteIterator first, ByteIterator last);
+template <class ByteIterator> uint32_t getCrc32(ByteIterator first, ByteIterator last);
+
+
+
+
+//------------------------- implementation -------------------------------
+inline uint16_t getCrc16(const std::string& str) { return getCrc16(str.begin(), str.end()); }
+inline uint32_t getCrc32(const std::string& str) { return getCrc32(str.begin(), str.end()); }
+
+
+template <class ByteIterator> inline
+uint16_t getCrc16(ByteIterator first, ByteIterator last)
+{
+    static_assert(sizeof(typename std::iterator_traits<ByteIterator>::value_type) == 1, "");
+    boost::crc_16_type result;
+    if (first != last)
+        result.process_bytes(&*first, last - first);
+    auto rv = result.checksum();
+    static_assert(sizeof(rv) == sizeof(uint16_t), "");
+    return rv;
+}
+
+
+template <class ByteIterator> inline
+uint32_t getCrc32(ByteIterator first, ByteIterator last)
+{
+    static_assert(sizeof(typename std::iterator_traits<ByteIterator>::value_type) == 1, "");
+    boost::crc_32_type result;
+    if (first != last)
+        result.process_bytes(&*first, last - first);
+    auto rv = result.checksum();
+    static_assert(sizeof(rv) == sizeof(uint32_t), "");
+    return rv;
+}
+}
+
+#endif //CRC_H_23489275827847235
diff --git a/zen/deprecate.h b/zen/deprecate.h
index 94273ad8..c2a1ebfa 100755
--- a/zen/deprecate.h
+++ b/zen/deprecate.h
@@ -1,14 +1,14 @@
-// *****************************************************************************
-// * This file is part of the FreeFileSync project. It is distributed under    *
-// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
-// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
-// *****************************************************************************
-
-#ifndef DEPRECATE_H_234897087787348
-#define DEPRECATE_H_234897087787348
-
-//compiler macros: http://predef.sourceforge.net/precomp.html
-    #define ZEN_DEPRECATE __attribute__ ((deprecated))
-
-
-#endif //DEPRECATE_H_234897087787348
+// *****************************************************************************
+// * This file is part of the FreeFileSync project. It is distributed under    *
+// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
+// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
+// *****************************************************************************
+
+#ifndef DEPRECATE_H_234897087787348
+#define DEPRECATE_H_234897087787348
+
+//compiler macros: http://predef.sourceforge.net/precomp.html
+    #define ZEN_DEPRECATE __attribute__ ((deprecated))
+
+
+#endif //DEPRECATE_H_234897087787348
diff --git a/zen/dir_watcher.cpp b/zen/dir_watcher.cpp
index 1b6f6f5c..4e759d55 100755
--- a/zen/dir_watcher.cpp
+++ b/zen/dir_watcher.cpp
@@ -1,158 +1,158 @@
-// *****************************************************************************
-// * This file is part of the FreeFileSync project. It is distributed under    *
-// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
-// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
-// *****************************************************************************
-
-#include "dir_watcher.h"
-#include <algorithm>
-#include <set>
-#include "thread.h"
-#include "scope_guard.h"
-#include "basic_math.h"
-
-    #include <map>
-    #include <sys/inotify.h>
-    #include <fcntl.h> //fcntl
-    #include <unistd.h> //close
-    #include <limits.h> //NAME_MAX
-    #include "file_traverser.h"
-
-
-using namespace zen;
-
-
-struct DirWatcher::Impl
-{
-    int notifDescr = 0;
-    std::map<int, Zstring> watchDescrs; //watch descriptor and (sub-)directory name (postfixed with separator) -> owned by "notifDescr"
-};
-
-
-DirWatcher::DirWatcher(const Zstring& dirPath) : //throw FileError
-    baseDirPath(dirPath),
-    pimpl_(std::make_unique<Impl>())
-{
-    //get all subdirectories
-    std::vector<Zstring> fullFolderList { baseDirPath };
-    {
-        std::function<void (const Zstring& path)> traverse;
-
-        traverse = [&traverse, &fullFolderList](const Zstring& path)
-        {
-            traverseFolder(path, nullptr,
-            [&](const FolderInfo& fi ) { fullFolderList.push_back(fi.fullPath); traverse(fi.fullPath); },
-            nullptr, //don't traverse into symlinks (analog to windows build)
-            [&](const std::wstring& errorMsg) { throw FileError(errorMsg); });
-        };
-
-        traverse(baseDirPath);
-    }
-
-    //init
-    pimpl_->notifDescr  = ::inotify_init();
-    if (pimpl_->notifDescr == -1)
-        THROW_LAST_FILE_ERROR(replaceCpy(_("Cannot monitor directory %x."), L"%x", fmtPath(baseDirPath)), L"inotify_init");
-
-    ZEN_ON_SCOPE_FAIL( ::close(pimpl_->notifDescr); );
-
-    //set non-blocking mode
-    bool initSuccess = false;
-    {
-        int flags = ::fcntl(pimpl_->notifDescr, F_GETFL);
-        if (flags != -1)
-            initSuccess = ::fcntl(pimpl_->notifDescr, F_SETFL, flags | O_NONBLOCK) != -1;
-    }
-    if (!initSuccess)
-        THROW_LAST_FILE_ERROR(replaceCpy(_("Cannot monitor directory %x."), L"%x", fmtPath(baseDirPath)), L"fcntl");
-
-    //add watches
-    for (const Zstring& subDirPath : fullFolderList)
-    {
-        int wd = ::inotify_add_watch(pimpl_->notifDescr, subDirPath.c_str(),
-                                     IN_ONLYDIR     | //"Only watch pathname if it is a directory."
-                                     IN_DONT_FOLLOW | //don't follow symbolic links
-                                     IN_CREATE      |
-                                     IN_MODIFY      |
-                                     IN_CLOSE_WRITE |
-                                     IN_DELETE      |
-                                     IN_DELETE_SELF |
-                                     IN_MOVED_FROM  |
-                                     IN_MOVED_TO    |
-                                     IN_MOVE_SELF);
-        if (wd == -1)
-        {
-            const ErrorCode ec = getLastError(); //copy before directly/indirectly making other system calls!
-            if (ec == ENOSPC) //fix misleading system message "No space left on device"
-                throw FileError(replaceCpy(_("Cannot monitor directory %x."), L"%x", fmtPath(subDirPath)),
-                                formatSystemError(L"inotify_add_watch", numberTo<std::wstring>(ec), L"The user limit on the total number of inotify watches was reached or the kernel failed to allocate a needed resource."));
-
-            throw FileError(replaceCpy(_("Cannot monitor directory %x."), L"%x", fmtPath(subDirPath)), formatSystemError(L"inotify_add_watch", ec));
-        }
-
-        pimpl_->watchDescrs.emplace(wd, appendSeparator(subDirPath));
-    }
-}
-
-
-DirWatcher::~DirWatcher()
-{
-    ::close(pimpl_->notifDescr); //associated watches are removed automatically!
-}
-
-
-std::vector<DirWatcher::Entry> DirWatcher::getChanges(const std::function<void()>&) //throw FileError
-{
-    std::vector<char> buffer(512 * (sizeof(struct ::inotify_event) + NAME_MAX + 1));
-
-    ssize_t bytesRead = 0;
-    do
-    {
-        //non-blocking call, see O_NONBLOCK
-        bytesRead = ::read(pimpl_->notifDescr, &buffer[0], buffer.size());
-    }
-    while (bytesRead < 0 && errno == EINTR); //"Interrupted function call; When this happens, you should try the call again."
-
-    if (bytesRead < 0)
-    {
-        if (errno == EAGAIN)  //this error is ignored in all inotify wrappers I found
-            return std::vector<Entry>();
-
-        THROW_LAST_FILE_ERROR(replaceCpy(_("Cannot monitor directory %x."), L"%x", fmtPath(baseDirPath)), L"read");
-    }
-
-    std::vector<Entry> output;
-
-    ssize_t bytePos = 0;
-    while (bytePos < bytesRead)
-    {
-        struct ::inotify_event& evt = reinterpret_cast<struct ::inotify_event&>(buffer[bytePos]);
-
-        if (evt.len != 0) //exclude case: deletion of "self", already reported by parent directory watch
-        {
-            auto it = pimpl_->watchDescrs.find(evt.wd);
-            if (it != pimpl_->watchDescrs.end())
-            {
-                //Note: evt.len is NOT the size of the evt.name c-string, but the array size including all padding 0 characters!
-                //It may be even 0 in which case evt.name must not be used!
-                const Zstring fullname = it->second + evt.name;
-
-                if ((evt.mask & IN_CREATE) ||
-                    (evt.mask & IN_MOVED_TO))
-                    output.emplace_back(ACTION_CREATE, fullname);
-                else if ((evt.mask & IN_MODIFY) ||
-                         (evt.mask & IN_CLOSE_WRITE))
-                    output.emplace_back(ACTION_UPDATE, fullname);
-                else if ((evt.mask & IN_DELETE     ) ||
-                         (evt.mask & IN_DELETE_SELF) ||
-                         (evt.mask & IN_MOVE_SELF  ) ||
-                         (evt.mask & IN_MOVED_FROM))
-                    output.emplace_back(ACTION_DELETE, fullname);
-            }
-        }
-        bytePos += sizeof(struct ::inotify_event) + evt.len;
-    }
-
-    return output;
-}
-
+// *****************************************************************************
+// * This file is part of the FreeFileSync project. It is distributed under    *
+// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
+// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
+// *****************************************************************************
+
+#include "dir_watcher.h"
+#include <algorithm>
+#include <set>
+#include "thread.h"
+#include "scope_guard.h"
+#include "basic_math.h"
+
+    #include <map>
+    #include <sys/inotify.h>
+    #include <fcntl.h> //fcntl
+    #include <unistd.h> //close
+    #include <limits.h> //NAME_MAX
+    #include "file_traverser.h"
+
+
+using namespace zen;
+
+
+struct DirWatcher::Impl
+{
+    int notifDescr = 0;
+    std::map<int, Zstring> watchDescrs; //watch descriptor and (sub-)directory name (postfixed with separator) -> owned by "notifDescr"
+};
+
+
+DirWatcher::DirWatcher(const Zstring& dirPath) : //throw FileError
+    baseDirPath(dirPath),
+    pimpl_(std::make_unique<Impl>())
+{
+    //get all subdirectories
+    std::vector<Zstring> fullFolderList { baseDirPath };
+    {
+        std::function<void (const Zstring& path)> traverse;
+
+        traverse = [&traverse, &fullFolderList](const Zstring& path)
+        {
+            traverseFolder(path, nullptr,
+            [&](const FolderInfo& fi ) { fullFolderList.push_back(fi.fullPath); traverse(fi.fullPath); },
+            nullptr, //don't traverse into symlinks (analog to windows build)
+            [&](const std::wstring& errorMsg) { throw FileError(errorMsg); });
+        };
+
+        traverse(baseDirPath);
+    }
+
+    //init
+    pimpl_->notifDescr  = ::inotify_init();
+    if (pimpl_->notifDescr == -1)
+        THROW_LAST_FILE_ERROR(replaceCpy(_("Cannot monitor directory %x."), L"%x", fmtPath(baseDirPath)), L"inotify_init");
+
+    ZEN_ON_SCOPE_FAIL( ::close(pimpl_->notifDescr); );
+
+    //set non-blocking mode
+    bool initSuccess = false;
+    {
+        int flags = ::fcntl(pimpl_->notifDescr, F_GETFL);
+        if (flags != -1)
+            initSuccess = ::fcntl(pimpl_->notifDescr, F_SETFL, flags | O_NONBLOCK) != -1;
+    }
+    if (!initSuccess)
+        THROW_LAST_FILE_ERROR(replaceCpy(_("Cannot monitor directory %x."), L"%x", fmtPath(baseDirPath)), L"fcntl");
+
+    //add watches
+    for (const Zstring& subDirPath : fullFolderList)
+    {
+        int wd = ::inotify_add_watch(pimpl_->notifDescr, subDirPath.c_str(),
+                                     IN_ONLYDIR     | //"Only watch pathname if it is a directory."
+                                     IN_DONT_FOLLOW | //don't follow symbolic links
+                                     IN_CREATE      |
+                                     IN_MODIFY      |
+                                     IN_CLOSE_WRITE |
+                                     IN_DELETE      |
+                                     IN_DELETE_SELF |
+                                     IN_MOVED_FROM  |
+                                     IN_MOVED_TO    |
+                                     IN_MOVE_SELF);
+        if (wd == -1)
+        {
+            const ErrorCode ec = getLastError(); //copy before directly/indirectly making other system calls!
+            if (ec == ENOSPC) //fix misleading system message "No space left on device"
+                throw FileError(replaceCpy(_("Cannot monitor directory %x."), L"%x", fmtPath(subDirPath)),
+                                formatSystemError(L"inotify_add_watch", numberTo<std::wstring>(ec), L"The user limit on the total number of inotify watches was reached or the kernel failed to allocate a needed resource."));
+
+            throw FileError(replaceCpy(_("Cannot monitor directory %x."), L"%x", fmtPath(subDirPath)), formatSystemError(L"inotify_add_watch", ec));
+        }
+
+        pimpl_->watchDescrs.emplace(wd, appendSeparator(subDirPath));
+    }
+}
+
+
+DirWatcher::~DirWatcher()
+{
+    ::close(pimpl_->notifDescr); //associated watches are removed automatically!
+}
+
+
+std::vector<DirWatcher::Entry> DirWatcher::getChanges(const std::function<void()>&) //throw FileError
+{
+    std::vector<char> buffer(512 * (sizeof(struct ::inotify_event) + NAME_MAX + 1));
+
+    ssize_t bytesRead = 0;
+    do
+    {
+        //non-blocking call, see O_NONBLOCK
+        bytesRead = ::read(pimpl_->notifDescr, &buffer[0], buffer.size());
+    }
+    while (bytesRead < 0 && errno == EINTR); //"Interrupted function call; When this happens, you should try the call again."
+
+    if (bytesRead < 0)
+    {
+        if (errno == EAGAIN)  //this error is ignored in all inotify wrappers I found
+            return std::vector<Entry>();
+
+        THROW_LAST_FILE_ERROR(replaceCpy(_("Cannot monitor directory %x."), L"%x", fmtPath(baseDirPath)), L"read");
+    }
+
+    std::vector<Entry> output;
+
+    ssize_t bytePos = 0;
+    while (bytePos < bytesRead)
+    {
+        struct ::inotify_event& evt = reinterpret_cast<struct ::inotify_event&>(buffer[bytePos]);
+
+        if (evt.len != 0) //exclude case: deletion of "self", already reported by parent directory watch
+        {
+            auto it = pimpl_->watchDescrs.find(evt.wd);
+            if (it != pimpl_->watchDescrs.end())
+            {
+                //Note: evt.len is NOT the size of the evt.name c-string, but the array size including all padding 0 characters!
+                //It may be even 0 in which case evt.name must not be used!
+                const Zstring fullname = it->second + evt.name;
+
+                if ((evt.mask & IN_CREATE) ||
+                    (evt.mask & IN_MOVED_TO))
+                    output.emplace_back(ACTION_CREATE, fullname);
+                else if ((evt.mask & IN_MODIFY) ||
+                         (evt.mask & IN_CLOSE_WRITE))
+                    output.emplace_back(ACTION_UPDATE, fullname);
+                else if ((evt.mask & IN_DELETE     ) ||
+                         (evt.mask & IN_DELETE_SELF) ||
+                         (evt.mask & IN_MOVE_SELF  ) ||
+                         (evt.mask & IN_MOVED_FROM))
+                    output.emplace_back(ACTION_DELETE, fullname);
+            }
+        }
+        bytePos += sizeof(struct ::inotify_event) + evt.len;
+    }
+
+    return output;
+}
+
diff --git a/zen/dir_watcher.h b/zen/dir_watcher.h
index b16cd417..5676555f 100755
--- a/zen/dir_watcher.h
+++ b/zen/dir_watcher.h
@@ -1,75 +1,75 @@
-// *****************************************************************************
-// * This file is part of the FreeFileSync project. It is distributed under    *
-// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
-// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
-// *****************************************************************************
-
-#ifndef DIR_WATCHER_348577025748023458
-#define DIR_WATCHER_348577025748023458
-
-#include <vector>
-#include <memory>
-#include <functional>
-#include "file_error.h"
-
-
-namespace zen
-{
-//Windows: ReadDirectoryChangesW https://msdn.microsoft.com/en-us/library/aa365465
-//Linux:   inotify               http://linux.die.net/man/7/inotify
-//OS X:    kqueue                http://developer.apple.com/library/mac/documentation/Darwin/Reference/ManPages/man2/kqueue.2.html
-
-//watch directory including subdirectories
-/*
-!Note handling of directories!:
-    Windows: removal of top watched directory is NOT notified when watching the dir handle, e.g. brute force usb stick removal,
-             (watchting for GUID_DEVINTERFACE_WPD OTOH works fine!)
-             however manual unmount IS notified (e.g. usb stick removal, then re-insert), but watching is stopped!
-             Renaming of top watched directory handled incorrectly: Not notified(!) + additional changes in subfolders
-             now do report FILE_ACTION_MODIFIED for directory (check that should prevent this fails!)
-
-    Linux: newly added subdirectories are reported but not automatically added for watching! -> reset Dirwatcher!
-           removal of top watched directory is NOT notified!
-
-    OS X: everything works as expected; renaming of top level folder is also detected
-
-    Overcome all issues portably: check existence of top watched directory externally + reinstall watch after changes in directory structure (added directories) are detected
-*/
-class DirWatcher
-{
-public:
-    DirWatcher(const Zstring& dirPath); //throw FileError
-    ~DirWatcher();
-
-    enum ActionType
-    {
-        ACTION_CREATE, //informal only!
-        ACTION_UPDATE, //use for debugging/logging only!
-        ACTION_DELETE, //
-    };
-
-    struct Entry
-    {
-        Entry() {}
-        Entry(ActionType action, const Zstring& filepath) : action_(action), filepath_(filepath) {}
-
-        ActionType action_ = ACTION_CREATE;
-        Zstring filepath_;
-    };
-
-    //extract accumulated changes since last call
-    std::vector<Entry> getChanges(const std::function<void()>& processGuiMessages); //throw FileError
-
-private:
-    DirWatcher           (const DirWatcher&) = delete;
-    DirWatcher& operator=(const DirWatcher&) = delete;
-
-    const Zstring baseDirPath;
-
-    struct Impl;
-    const std::unique_ptr<Impl> pimpl_;
-};
-
-}
-
-#endif
+// *****************************************************************************
+// * This file is part of the FreeFileSync project. It is distributed under    *
+// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
+// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
+// *****************************************************************************
+
+#ifndef DIR_WATCHER_348577025748023458
+#define DIR_WATCHER_348577025748023458
+
+#include <vector>
+#include <memory>
+#include <functional>
+#include "file_error.h"
+
+
+namespace zen
+{
+//Windows: ReadDirectoryChangesW https://msdn.microsoft.com/en-us/library/aa365465
+//Linux:   inotify               http://linux.die.net/man/7/inotify
+//OS X:    kqueue                http://developer.apple.com/library/mac/documentation/Darwin/Reference/ManPages/man2/kqueue.2.html
+
+//watch directory including subdirectories
+/*
+!Note handling of directories!:
+    Windows: removal of top watched directory is NOT notified when watching the dir handle, e.g. brute force usb stick removal,
+             (watchting for GUID_DEVINTERFACE_WPD OTOH works fine!)
+             however manual unmount IS notified (e.g. usb stick removal, then re-insert), but watching is stopped!
+             Renaming of top watched directory handled incorrectly: Not notified(!) + additional changes in subfolders
+             now do report FILE_ACTION_MODIFIED for directory (check that should prevent this fails!)
+
+    Linux: newly added subdirectories are reported but not automatically added for watching! -> reset Dirwatcher!
+           removal of top watched directory is NOT notified!
+
+    OS X: everything works as expected; renaming of top level folder is also detected
+
+    Overcome all issues portably: check existence of top watched directory externally + reinstall watch after changes in directory structure (added directories) are detected
+*/
+class DirWatcher
+{
+public:
+    DirWatcher(const Zstring& dirPath); //throw FileError
+    ~DirWatcher();
+
+    enum ActionType
+    {
+        ACTION_CREATE, //informal only!
+        ACTION_UPDATE, //use for debugging/logging only!
+        ACTION_DELETE, //
+    };
+
+    struct Entry
+    {
+        Entry() {}
+        Entry(ActionType action, const Zstring& filepath) : action_(action), filepath_(filepath) {}
+
+        ActionType action_ = ACTION_CREATE;
+        Zstring filepath_;
+    };
+
+    //extract accumulated changes since last call
+    std::vector<Entry> getChanges(const std::function<void()>& processGuiMessages); //throw FileError
+
+private:
+    DirWatcher           (const DirWatcher&) = delete;
+    DirWatcher& operator=(const DirWatcher&) = delete;
+
+    const Zstring baseDirPath;
+
+    struct Impl;
+    const std::unique_ptr<Impl> pimpl_;
+};
+
+}
+
+#endif
diff --git a/zen/error_log.h b/zen/error_log.h
index 1a9d2679..90016666 100755
--- a/zen/error_log.h
+++ b/zen/error_log.h
@@ -1,135 +1,135 @@
-// *****************************************************************************
-// * This file is part of the FreeFileSync project. It is distributed under    *
-// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
-// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
-// *****************************************************************************
-
-#ifndef ERROR_LOG_H_8917590832147915
-#define ERROR_LOG_H_8917590832147915
-
-#include <cassert>
-#include <algorithm>
-#include <vector>
-#include <string>
-#include "time.h"
-#include "i18n.h"
-#include "string_base.h"
-
-
-namespace zen
-{
-enum MessageType
-{
-    TYPE_INFO        = 0x1,
-    TYPE_WARNING     = 0x2,
-    TYPE_ERROR       = 0x4,
-    TYPE_FATAL_ERROR = 0x8,
-};
-
-using MsgString = Zbase<wchar_t>; //std::wstring may employ small string optimization: we cannot accept bloating the "ErrorLog::entries" memory block below (think 1 million items)
-
-struct LogEntry
-{
-    time_t      time;
-    MessageType type;
-    MsgString   message;
-};
-
-template <class String>
-String formatMessage(const LogEntry& entry);
-
-
-class ErrorLog
-{
-public:
-    template <class String> //a wchar_t-based string!
-    void logMsg(const String& text, MessageType type);
-
-    int getItemCount(int typeFilter = TYPE_INFO | TYPE_WARNING | TYPE_ERROR | TYPE_FATAL_ERROR) const;
-
-    //subset of std::vector<> interface:
-    using const_iterator = std::vector<LogEntry>::const_iterator;
-    const_iterator begin() const { return entries.begin(); }
-    const_iterator end  () const { return entries.end  (); }
-    bool empty() const { return entries.empty(); }
-
-private:
-    std::vector<LogEntry> entries; //list of non-resolved errors and warnings
-};
-
-
-
-
-
-
-
-
-
-//######################## implementation ##########################
-template <class String> inline
-void ErrorLog::logMsg(const String& text, zen::MessageType type)
-{
-    const LogEntry newEntry = { std::time(nullptr), type, copyStringTo<MsgString>(text) };
-    entries.push_back(newEntry);
-}
-
-
-inline
-int ErrorLog::getItemCount(int typeFilter) const
-{
-    return static_cast<int>(std::count_if(entries.begin(), entries.end(), [&](const LogEntry& e) { return e.type & typeFilter; }));
-}
-
-
-namespace
-{
-template <class String>
-String formatMessageImpl(const LogEntry& entry) //internal linkage
-{
-    auto getTypeName = [&]
-    {
-        switch (entry.type)
-        {
-            case TYPE_INFO:
-                return _("Info");
-            case TYPE_WARNING:
-                return _("Warning");
-            case TYPE_ERROR:
-                return _("Error");
-            case TYPE_FATAL_ERROR:
-                return _("Serious Error");
-        }
-        assert(false);
-        return std::wstring();
-    };
-
-    String formattedText = L"[" + formatTime<String>(FORMAT_TIME, getLocalTime(entry.time)) + L"] " + copyStringTo<String>(getTypeName()) + L": ";
-    const size_t prefixLen = formattedText.size();
-
-    for (auto it = entry.message.begin(); it != entry.message.end(); )
-        if (*it == L'\n')
-        {
-            formattedText += L'\n';
-
-            String blanks;
-            blanks.resize(prefixLen, L' ');
-            formattedText += blanks;
-
-            do //skip duplicate newlines
-            {
-                ++it;
-            }
-            while (it != entry.message.end() && *it == L'\n');
-        }
-        else
-            formattedText += *it++;
-
-    return formattedText;
-}
-}
-
-template <class String> inline
-String formatMessage(const LogEntry& entry) { return formatMessageImpl<String>(entry); }
-}
-
-#endif //ERROR_LOG_H_8917590832147915
+// *****************************************************************************
+// * This file is part of the FreeFileSync project. It is distributed under    *
+// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
+// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
+// *****************************************************************************
+
+#ifndef ERROR_LOG_H_8917590832147915
+#define ERROR_LOG_H_8917590832147915
+
+#include <cassert>
+#include <algorithm>
+#include <vector>
+#include <string>
+#include "time.h"
+#include "i18n.h"
+#include "string_base.h"
+
+
+namespace zen
+{
+enum MessageType
+{
+    TYPE_INFO        = 0x1,
+    TYPE_WARNING     = 0x2,
+    TYPE_ERROR       = 0x4,
+    TYPE_FATAL_ERROR = 0x8,
+};
+
+using MsgString = Zbase<wchar_t>; //std::wstring may employ small string optimization: we cannot accept bloating the "ErrorLog::entries" memory block below (think 1 million items)
+
+struct LogEntry
+{
+    time_t      time;
+    MessageType type;
+    MsgString   message;
+};
+
+template <class String>
+String formatMessage(const LogEntry& entry);
+
+
+class ErrorLog
+{
+public:
+    template <class String> //a wchar_t-based string!
+    void logMsg(const String& text, MessageType type);
+
+    int getItemCount(int typeFilter = TYPE_INFO | TYPE_WARNING | TYPE_ERROR | TYPE_FATAL_ERROR) const;
+
+    //subset of std::vector<> interface:
+    using const_iterator = std::vector<LogEntry>::const_iterator;
+    const_iterator begin() const { return entries.begin(); }
+    const_iterator end  () const { return entries.end  (); }
+    bool empty() const { return entries.empty(); }
+
+private:
+    std::vector<LogEntry> entries; //list of non-resolved errors and warnings
+};
+
+
+
+
+
+
+
+
+
+//######################## implementation ##########################
+template <class String> inline
+void ErrorLog::logMsg(const String& text, zen::MessageType type)
+{
+    const LogEntry newEntry = { std::time(nullptr), type, copyStringTo<MsgString>(text) };
+    entries.push_back(newEntry);
+}
+
+
+inline
+int ErrorLog::getItemCount(int typeFilter) const
+{
+    return static_cast<int>(std::count_if(entries.begin(), entries.end(), [&](const LogEntry& e) { return e.type & typeFilter; }));
+}
+
+
+namespace
+{
+template <class String>
+String formatMessageImpl(const LogEntry& entry) //internal linkage
+{
+    auto getTypeName = [&]
+    {
+        switch (entry.type)
+        {
+            case TYPE_INFO:
+                return _("Info");
+            case TYPE_WARNING:
+                return _("Warning");
+            case TYPE_ERROR:
+                return _("Error");
+            case TYPE_FATAL_ERROR:
+                return _("Serious Error");
+        }
+        assert(false);
+        return std::wstring();
+    };
+
+    String formattedText = L"[" + formatTime<String>(FORMAT_TIME, getLocalTime(entry.time)) + L"] " + copyStringTo<String>(getTypeName()) + L": ";
+    const size_t prefixLen = formattedText.size();
+
+    for (auto it = entry.message.begin(); it != entry.message.end(); )
+        if (*it == L'\n')
+        {
+            formattedText += L'\n';
+
+            String blanks;
+            blanks.resize(prefixLen, L' ');
+            formattedText += blanks;
+
+            do //skip duplicate newlines
+            {
+                ++it;
+            }
+            while (it != entry.message.end() && *it == L'\n');
+        }
+        else
+            formattedText += *it++;
+
+    return formattedText;
+}
+}
+
+template <class String> inline
+String formatMessage(const LogEntry& entry) { return formatMessageImpl<String>(entry); }
+}
+
+#endif //ERROR_LOG_H_8917590832147915
diff --git a/zen/file_access.cpp b/zen/file_access.cpp
index 71d00386..ed66aac4 100755
--- a/zen/file_access.cpp
+++ b/zen/file_access.cpp
@@ -1,676 +1,676 @@
-// *****************************************************************************
-// * This file is part of the FreeFileSync project. It is distributed under    *
-// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
-// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
-// *****************************************************************************
-
-#include "file_access.h"
-#include <map>
-#include <algorithm>
-#include <stdexcept>
-#include "file_traverser.h"
-#include "scope_guard.h"
-#include "symlink_target.h"
-#include "file_id_def.h"
-#include "file_io.h"
-
-    #include <sys/vfs.h> //statfs
-    #include <sys/time.h> //lutimes
-    #ifdef HAVE_SELINUX
-        #include <selinux/selinux.h>
-    #endif
-
-
-    #include <fcntl.h> //open, close, AT_SYMLINK_NOFOLLOW, UTIME_OMIT
-    #include <sys/stat.h>
-
-using namespace zen;
-
-
-Opt<PathComponents> zen::parsePathComponents(const Zstring& itemPath)
-{
-    if (startsWith(itemPath, "/"))
-    {
-        Zstring relPath(itemPath.c_str() + 1);
-        if (endsWith(relPath, FILE_NAME_SEPARATOR))
-            relPath.pop_back();
-        return PathComponents({ "/", relPath });
-    }
-    //we do NOT support relative paths!
-    return NoValue();
-}
-
-
-
-Opt<Zstring> zen::getParentFolderPath(const Zstring& itemPath)
-{
-    if (const Opt<PathComponents> comp = parsePathComponents(itemPath))
-    {
-        if (comp->relPath.empty())
-            return NoValue();
-
-        const Zstring parentRelPath = beforeLast(comp->relPath, FILE_NAME_SEPARATOR, IF_MISSING_RETURN_NONE);
-        if (parentRelPath.empty())
-            return comp->rootPath;
-        return appendSeparator(comp->rootPath) + parentRelPath;
-    }
-    assert(false);
-    return NoValue();
-}
-
-
-ItemType zen::getItemType(const Zstring& itemPath) //throw FileError
-{
-    struct ::stat itemInfo = {};
-    if (::lstat(itemPath.c_str(), &itemInfo) != 0)
-        THROW_LAST_FILE_ERROR(replaceCpy(_("Cannot read file attributes of %x."), L"%x", fmtPath(itemPath)), L"lstat");
-
-    if (S_ISLNK(itemInfo.st_mode))
-        return ItemType::SYMLINK;
-    if (S_ISDIR(itemInfo.st_mode))
-        return ItemType::FOLDER;
-    return ItemType::FILE; //S_ISREG || S_ISCHR || S_ISBLK || S_ISFIFO || S_ISSOCK
-}
-
-
-PathStatus zen::getPathStatus(const Zstring& itemPath) //throw FileError
-{
-    const Opt<Zstring> parentPath = getParentFolderPath(itemPath);
-    try
-    {
-        return { getItemType(itemPath), itemPath, {} }; //throw FileError
-    }
-    catch (FileError&)
-    {
-        if (!parentPath) //device root
-            throw;
-        //else: let's dig deeper... don't bother checking Win32 codes; e.g. not existing item may have the codes:
-        //  ERROR_FILE_NOT_FOUND, ERROR_PATH_NOT_FOUND, ERROR_INVALID_NAME, ERROR_INVALID_DRIVE,
-        //  ERROR_NOT_READY, ERROR_INVALID_PARAMETER, ERROR_BAD_PATHNAME, ERROR_BAD_NETPATH => not reliable
-    }
-    const Zstring itemName = afterLast(itemPath, FILE_NAME_SEPARATOR, IF_MISSING_RETURN_ALL);
-    assert(!itemName.empty());
-
-    PathStatus pd = getPathStatus(*parentPath); //throw FileError
-    if (!pd.relPath.empty())
-    {
-        pd.relPath.push_back(itemName);
-        return { pd.existingType, pd.existingPath, pd.relPath };
-    }
-
-    try
-    {
-        traverseFolder(*parentPath,
-        [&](const FileInfo&    fi) { if (equalFilePath(fi.itemName, itemName)) throw ItemType::FILE; },
-        [&](const FolderInfo&  fi) { if (equalFilePath(fi.itemName, itemName)) throw ItemType::FOLDER; },
-        [&](const SymlinkInfo& si) { if (equalFilePath(si.itemName, itemName)) throw ItemType::SYMLINK; },
-        [](const std::wstring& errorMsg) { throw FileError(errorMsg); });
-
-        return { pd.existingType, *parentPath, { itemName } }; //throw FileError
-    }
-    catch (const ItemType& type) { return { type, itemPath, {} }; } //yes, exceptions for control-flow are bad design... but, but...
-    //we're not CPU-bound here and finding the item after getItemType() previously failed is exceptional (even C:\pagefile.sys should be found)
-}
-
-
-Opt<ItemType> zen::getItemTypeIfExists(const Zstring& itemPath) //throw FileError
-{
-    const PathStatus pd = getPathStatus(itemPath); //throw FileError
-    if (pd.relPath.empty())
-        return pd.existingType;
-    return NoValue();
-}
-
-
-bool zen::fileAvailable(const Zstring& filePath) //noexcept
-{
-    //symbolic links (broken or not) are also treated as existing files!
-    struct ::stat fileInfo = {};
-    if (::stat(filePath.c_str(), &fileInfo) == 0) //follow symlinks!
-        return S_ISREG(fileInfo.st_mode);
-    return false;
-}
-
-
-bool zen::dirAvailable(const Zstring& dirPath) //noexcept
-{
-    //symbolic links (broken or not) are also treated as existing directories!
-    struct ::stat dirInfo = {};
-    if (::stat(dirPath.c_str(), &dirInfo) == 0) //follow symlinks!
-        return S_ISDIR(dirInfo.st_mode);
-    return false;
-}
-
-
-bool zen::itemNotExisting(const Zstring& itemPath)
-{
-    try
-    {
-        return !getItemTypeIfExists(itemPath); //throw FileError
-    }
-    catch (FileError&) { return false; }
-}
-
-
-namespace
-{
-}
-
-
-uint64_t zen::getFileSize(const Zstring& filePath) //throw FileError
-{
-    struct ::stat fileInfo = {};
-    if (::stat(filePath.c_str(), &fileInfo) != 0)
-        THROW_LAST_FILE_ERROR(replaceCpy(_("Cannot read file attributes of %x."), L"%x", fmtPath(filePath)), L"stat");
-
-    return fileInfo.st_size;
-}
-
-
-uint64_t zen::getFreeDiskSpace(const Zstring& path) //throw FileError, returns 0 if not available
-{
-    struct ::statfs info = {};
-    if (::statfs(path.c_str(), &info) != 0)
-        THROW_LAST_FILE_ERROR(replaceCpy(_("Cannot determine free disk space for %x."), L"%x", fmtPath(path)), L"statfs");
-
-    return static_cast<uint64_t>(info.f_bsize) * info.f_bavail;
-}
-
-
-VolumeId zen::getVolumeId(const Zstring& itemPath) //throw FileError
-{
-    struct ::stat fileInfo = {};
-    if (::stat(itemPath.c_str(), &fileInfo) != 0)
-        THROW_LAST_FILE_ERROR(replaceCpy(_("Cannot read file attributes of %x."), L"%x", fmtPath(itemPath)), L"stat");
-
-    return fileInfo.st_dev;
-}
-
-
-Zstring zen::getTempFolderPath() //throw FileError
-{
-    const char* buf = ::getenv("TMPDIR"); //no extended error reporting
-    if (!buf)
-        throw FileError(_("Cannot get process information."), L"getenv: TMPDIR not found.");
-    return buf;
-}
-
-
-void zen::removeFilePlain(const Zstring& filePath) //throw FileError
-{
-    const wchar_t functionName[] = L"unlink";
-    if (::unlink(filePath.c_str()) != 0)
-    {
-        ErrorCode ec = getLastError(); //copy before directly/indirectly making other system calls!
-        //begin of "regular" error reporting
-        std::wstring errorDescr = formatSystemError(functionName, ec);
-
-        throw FileError(replaceCpy(_("Cannot delete file %x."), L"%x", fmtPath(filePath)), errorDescr);
-    }
-}
-
-
-void zen::removeSymlinkPlain(const Zstring& linkPath) //throw FileError
-{
-    removeFilePlain(linkPath); //throw FileError
-}
-
-
-void zen::removeDirectoryPlain(const Zstring& dirPath) //throw FileError
-{
-    const wchar_t functionName[] = L"rmdir";
-    if (::rmdir(dirPath.c_str()) != 0)
-    {
-        ErrorCode ec = getLastError(); //copy before making other system calls!
-        bool symlinkExists = false;
-        try { symlinkExists = getItemType(dirPath) == ItemType::SYMLINK; } /*throw FileError*/ catch (FileError&) {} //previous exception is more relevant
-
-        if (symlinkExists)
-        {
-            if (::unlink(dirPath.c_str()) != 0)
-                THROW_LAST_FILE_ERROR(replaceCpy(_("Cannot delete directory %x."), L"%x", fmtPath(dirPath)), L"unlink");
-            return;
-        }
-        throw FileError(replaceCpy(_("Cannot delete directory %x."), L"%x", fmtPath(dirPath)), formatSystemError(functionName, ec));
-    }
-    /*
-    Windows: may spuriously fail with ERROR_DIR_NOT_EMPTY(145) even though all child items have
-    successfully been *marked* for deletion, but some application still has a handle open!
-    e.g. Open "C:\Test\Dir1\Dir2" (filled with lots of files) in Explorer, then delete "C:\Test\Dir1" via ::RemoveDirectory() => Error 145
-    Sample code: http://us.generation-nt.com/answer/createfile-directory-handles-removing-parent-help-29126332.html
-    Alternatives: 1. move file/empty folder to some other location, then DeleteFile()/RemoveDirectory()
-                  2. use CreateFile/FILE_FLAG_DELETE_ON_CLOSE *without* FILE_SHARE_DELETE instead of DeleteFile() => early failure
-    */
-}
-
-
-namespace
-{
-void removeDirectoryImpl(const Zstring& folderPath) //throw FileError
-{
-    std::vector<Zstring> filePaths;
-    std::vector<Zstring> symlinkPaths;
-    std::vector<Zstring> folderPaths;
-
-    //get all files and directories from current directory (WITHOUT subdirectories!)
-    traverseFolder(folderPath,
-    [&](const FileInfo&    fi) { filePaths   .push_back(fi.fullPath); },
-    [&](const FolderInfo&  fi) { folderPaths .push_back(fi.fullPath); }, //defer recursion => save stack space and allow deletion of extremely deep hierarchies!
-    [&](const SymlinkInfo& si) { symlinkPaths.push_back(si.fullPath); },
-    [](const std::wstring& errorMsg) { throw FileError(errorMsg); });
-
-    for (const Zstring& filePath : filePaths)
-        removeFilePlain(filePath); //throw FileError
-
-    for (const Zstring& symlinkPath : symlinkPaths)
-        removeSymlinkPlain(symlinkPath); //throw FileError
-
-    //delete directories recursively
-    for (const Zstring& subFolderPath : folderPaths)
-        removeDirectoryImpl(subFolderPath); //throw FileError; call recursively to correctly handle symbolic links
-
-    removeDirectoryPlain(folderPath); //throw FileError
-}
-}
-
-
-void zen::removeDirectoryPlainRecursion(const Zstring& dirPath) //throw FileError
-{
-    if (getItemType(dirPath) == ItemType::SYMLINK) //throw FileError
-        removeSymlinkPlain(dirPath); //throw FileError
-    else
-        removeDirectoryImpl(dirPath); //throw FileError
-}
-
-
-namespace
-{
-/* Usage overview: (avoid circular pattern!)
-
-  renameFile()  -->  renameFile_sub()
-      |               /|\
-     \|/               |
-      Fix8Dot3NameClash()
-*/
-//wrapper for file system rename function:
-void renameFile_sub(const Zstring& pathSource, const Zstring& pathTarget) //throw FileError, ErrorDifferentVolume, ErrorTargetExisting
-{
-    //rename() will never fail with EEXIST, but always (atomically) overwrite!
-    //=> equivalent to SetFileInformationByHandle() + FILE_RENAME_INFO::ReplaceIfExists or ::MoveFileEx + MOVEFILE_REPLACE_EXISTING
-    //=> Linux: renameat2() with RENAME_NOREPLACE -> still new, probably buggy
-    //=> OS X: no solution
-
-    auto throwException = [&](int ec)
-    {
-        const std::wstring errorMsg = replaceCpy(replaceCpy(_("Cannot move file %x to %y."), L"%x", L"\n" + fmtPath(pathSource)), L"%y", L"\n" + fmtPath(pathTarget));
-        const std::wstring errorDescr = formatSystemError(L"rename", ec);
-
-        if (ec == EXDEV)
-            throw ErrorDifferentVolume(errorMsg, errorDescr);
-        if (ec == EEXIST)
-            throw ErrorTargetExisting(errorMsg, errorDescr);
-        throw FileError(errorMsg, errorDescr);
-    };
-
-    if (!equalFilePath(pathSource, pathTarget)) //exception for OS X: changing file name case is not an "already exists" situation!
-    {
-        bool alreadyExists = true;
-        try {  /*ItemType type = */getItemType(pathTarget); } /*throw FileError*/ catch (FileError&) { alreadyExists = false; }
-
-        if (alreadyExists)
-            throwException(EEXIST);
-        //else: nothing exists or other error (hopefully ::rename will also fail!)
-    }
-
-    if (::rename(pathSource.c_str(), pathTarget.c_str()) != 0)
-        throwException(errno);
-}
-
-
-}
-
-
-//rename file: no copying!!!
-void zen::renameFile(const Zstring& pathSource, const Zstring& pathTarget) //throw FileError, ErrorDifferentVolume, ErrorTargetExisting
-{
-    try
-    {
-        renameFile_sub(pathSource, pathTarget); //throw FileError, ErrorDifferentVolume, ErrorTargetExisting
-    }
-    catch (const ErrorTargetExisting&)
-    {
-        throw;
-    }
-}
-
-
-namespace
-{
-void setWriteTimeNative(const Zstring& itemPath, const struct ::timespec& modTime, ProcSymlink procSl) //throw FileError
-{
-    /*
-    [2013-05-01] sigh, we can't use utimensat() on NTFS volumes on Ubuntu: silent failure!!! what morons are programming this shit???
-    => fallback to "retarded-idiot version"! -- DarkByte
-
-    [2015-03-09]
-     - cannot reproduce issues with NTFS and utimensat() on Ubuntu
-     - utimensat() is supposed to obsolete utime/utimes and is also used by "cp" and "touch"
-        => let's give utimensat another chance:
-        using open()/futimens() for regular files and utimensat(AT_SYMLINK_NOFOLLOW) for symlinks is consistent with "cp" and "touch"!
-    */
-    struct ::timespec newTimes[2] = {};
-    newTimes[0].tv_sec = ::time(nullptr); //access time; using UTIME_OMIT for tv_nsec would trigger even more bugs: http://www.freefilesync.org/forum/viewtopic.php?t=1701
-    newTimes[1] = modTime; //modification time
-
-    if (procSl == ProcSymlink::FOLLOW)
-    {
-        //hell knows why files on gvfs-mounted Samba shares fail to open(O_WRONLY) returning EOPNOTSUPP:
-        //http://www.freefilesync.org/forum/viewtopic.php?t=2803 => utimensat() works
-        if (::utimensat(AT_FDCWD, itemPath.c_str(), newTimes, 0) == 0)
-            return;
-
-        //in other cases utimensat() returns EINVAL for CIFS/NTFS drives, but open+futimens works: http://www.freefilesync.org/forum/viewtopic.php?t=387
-        const int fdFile = ::open(itemPath.c_str(), O_WRONLY);
-        if (fdFile == -1)
-            THROW_LAST_FILE_ERROR(replaceCpy(_("Cannot write modification time of %x."), L"%x", fmtPath(itemPath)), L"open");
-        ZEN_ON_SCOPE_EXIT(::close(fdFile));
-
-        if (::futimens(fdFile, newTimes) != 0)
-            THROW_LAST_FILE_ERROR(replaceCpy(_("Cannot write modification time of %x."), L"%x", fmtPath(itemPath)), L"futimens");
-    }
-    else
-    {
-        if (::utimensat(AT_FDCWD, itemPath.c_str(), newTimes, AT_SYMLINK_NOFOLLOW) != 0)
-            THROW_LAST_FILE_ERROR(replaceCpy(_("Cannot write modification time of %x."), L"%x", fmtPath(itemPath)), L"utimensat");
-    }
-}
-
-
-}
-
-
-void zen::setFileTime(const Zstring& filePath, int64_t modTime, ProcSymlink procSl) //throw FileError
-{
-    struct ::timespec writeTime = {};
-    writeTime.tv_sec = modTime;
-    setWriteTimeNative(filePath, writeTime, procSl); //throw FileError
-
-}
-
-
-bool zen::supportsPermissions(const Zstring& dirPath) //throw FileError
-{
-    return true;
-}
-
-
-namespace
-{
-#ifdef HAVE_SELINUX
-//copy SELinux security context
-void copySecurityContext(const Zstring& source, const Zstring& target, ProcSymlink procSl) //throw FileError
-{
-    security_context_t contextSource = nullptr;
-    const int rv = procSl == ProcSymlink::FOLLOW ?
-                   ::getfilecon(source.c_str(), &contextSource) :
-                   ::lgetfilecon(source.c_str(), &contextSource);
-    if (rv < 0)
-    {
-        if (errno == ENODATA ||  //no security context (allegedly) is not an error condition on SELinux
-            errno == EOPNOTSUPP) //extended attributes are not supported by the filesystem
-            return;
-
-        THROW_LAST_FILE_ERROR(replaceCpy(_("Cannot read security context of %x."), L"%x", fmtPath(source)), L"getfilecon");
-    }
-    ZEN_ON_SCOPE_EXIT(::freecon(contextSource));
-
-    {
-        security_context_t contextTarget = nullptr;
-        const int rv2 = procSl == ProcSymlink::FOLLOW ?
-                        ::getfilecon(target.c_str(), &contextTarget) :
-                        ::lgetfilecon(target.c_str(), &contextTarget);
-        if (rv2 < 0)
-        {
-            if (errno == EOPNOTSUPP)
-                return;
-            //else: still try to set security context
-        }
-        else
-        {
-            ZEN_ON_SCOPE_EXIT(::freecon(contextTarget));
-
-            if (::strcmp(contextSource, contextTarget) == 0) //nothing to do
-                return;
-        }
-    }
-
-    const int rv3 = procSl == ProcSymlink::FOLLOW ?
-                    ::setfilecon(target.c_str(), contextSource) :
-                    ::lsetfilecon(target.c_str(), contextSource);
-    if (rv3 < 0)
-        THROW_LAST_FILE_ERROR(replaceCpy(_("Cannot write security context of %x."), L"%x", fmtPath(target)), L"setfilecon");
-}
-#endif
-
-
-//copy permissions for files, directories or symbolic links: requires admin rights
-void copyItemPermissions(const Zstring& sourcePath, const Zstring& targetPath, ProcSymlink procSl) //throw FileError
-{
-
-#ifdef HAVE_SELINUX  //copy SELinux security context
-    copySecurityContext(sourcePath, targetPath, procSl); //throw FileError
-#endif
-
-    struct ::stat fileInfo = {};
-    if (procSl == ProcSymlink::FOLLOW)
-    {
-        if (::stat(sourcePath.c_str(), &fileInfo) != 0)
-            THROW_LAST_FILE_ERROR(replaceCpy(_("Cannot read permissions of %x."), L"%x", fmtPath(sourcePath)), L"stat");
-
-        if (::chown(targetPath.c_str(), fileInfo.st_uid, fileInfo.st_gid) != 0) // may require admin rights!
-            THROW_LAST_FILE_ERROR(replaceCpy(_("Cannot write permissions of %x."), L"%x", fmtPath(targetPath)), L"chown");
-
-        if (::chmod(targetPath.c_str(), fileInfo.st_mode) != 0)
-            THROW_LAST_FILE_ERROR(replaceCpy(_("Cannot write permissions of %x."), L"%x", fmtPath(targetPath)), L"chmod");
-    }
-    else
-    {
-        if (::lstat(sourcePath.c_str(), &fileInfo) != 0)
-            THROW_LAST_FILE_ERROR(replaceCpy(_("Cannot read permissions of %x."), L"%x", fmtPath(sourcePath)), L"lstat");
-
-        if (::lchown(targetPath.c_str(), fileInfo.st_uid, fileInfo.st_gid) != 0) // may require admin rights!
-            THROW_LAST_FILE_ERROR(replaceCpy(_("Cannot write permissions of %x."), L"%x", fmtPath(targetPath)), L"lchown");
-
-        const bool isSymlinkTarget = getItemType(targetPath) == ItemType::SYMLINK; //throw FileError
-        if (!isSymlinkTarget && //setting access permissions doesn't make sense for symlinks on Linux: there is no lchmod()
-            ::chmod(targetPath.c_str(), fileInfo.st_mode) != 0)
-            THROW_LAST_FILE_ERROR(replaceCpy(_("Cannot write permissions of %x."), L"%x", fmtPath(targetPath)), L"chmod");
-    }
-
-}
-}
-
-
-void zen::createDirectoryIfMissingRecursion(const Zstring& dirPath) //throw FileError
-{
-    if (!getParentFolderPath(dirPath)) //device root
-        return static_cast<void>(/*ItemType =*/ getItemType(dirPath)); //throw FileError
-
-    try
-    {
-        copyNewDirectory(Zstring(), dirPath, false /*copyFilePermissions*/); //throw FileError, ErrorTargetExisting
-    }
-    catch (FileError&)
-    {
-        Opt<PathStatus> pd;
-        try { pd = getPathStatus(dirPath); /*throw FileError*/ }
-        catch (FileError&) {} //previous exception is more relevant
-
-        if (pd && pd->existingType != ItemType::FILE)
-        {
-            Zstring intermediatePath = pd->existingPath;
-            for (const Zstring& itemName : pd->relPath)
-            {
-                intermediatePath = appendSeparator(intermediatePath) + itemName;
-                copyNewDirectory(Zstring(), intermediatePath, false /*copyFilePermissions*/); //throw FileError, (ErrorTargetExisting)
-            }
-            return;
-        }
-        throw;
-    }
-}
-
-
-//source path is optional (may be empty)
-void zen::copyNewDirectory(const Zstring& sourcePath, const Zstring& targetPath, //throw FileError, ErrorTargetExisting
-                           bool copyFilePermissions)
-{
-    mode_t mode = S_IRWXU | S_IRWXG | S_IRWXO; //0777, default for newly created directories
-
-    struct ::stat dirInfo = {};
-    if (!sourcePath.empty())
-        if (::stat(sourcePath.c_str(), &dirInfo) == 0)
-        {
-            mode = dirInfo.st_mode & (S_IRWXU | S_IRWXG | S_IRWXO); //analog to "cp" which copies "mode" (considering umask) by default
-            mode |= S_IRWXU; //FFS only: we need full access to copy child items! "cp" seems to apply permissions *after* copying child items
-        }
-    //=> need copyItemPermissions() only for "chown" and umask-agnostic permissions
-
-    if (::mkdir(targetPath.c_str(), mode) != 0)
-    {
-        const int lastError = errno; //copy before directly or indirectly making other system calls!
-        const std::wstring errorMsg = replaceCpy(_("Cannot create directory %x."), L"%x", fmtPath(targetPath));
-        const std::wstring errorDescr = formatSystemError(L"mkdir", lastError);
-
-        if (lastError == EEXIST)
-            throw ErrorTargetExisting(errorMsg, errorDescr);
-        //else if (lastError == ENOENT)
-        //    throw ErrorTargetPathMissing(errorMsg, errorDescr);
-        throw FileError(errorMsg, errorDescr);
-    }
-
-    if (!sourcePath.empty())
-    {
-
-        ZEN_ON_SCOPE_FAIL(try { removeDirectoryPlain(targetPath); }
-        catch (FileError&) {});   //ensure cleanup:
-
-        //enforce copying file permissions: it's advertized on GUI...
-        if (copyFilePermissions)
-            copyItemPermissions(sourcePath, targetPath, ProcSymlink::FOLLOW); //throw FileError
-    }
-}
-
-
-void zen::copySymlink(const Zstring& sourceLink, const Zstring& targetLink, bool copyFilePermissions) //throw FileError
-{
-    const Zstring linkPath = getSymlinkTargetRaw(sourceLink); //throw FileError; accept broken symlinks
-
-    const wchar_t functionName[] = L"symlink";
-    if (::symlink(linkPath.c_str(), targetLink.c_str()) != 0)
-        THROW_LAST_FILE_ERROR(replaceCpy(replaceCpy(_("Cannot copy symbolic link %x to %y."), L"%x", L"\n" + fmtPath(sourceLink)), L"%y", L"\n" + fmtPath(targetLink)), functionName);
-
-    //allow only consistent objects to be created -> don't place before ::symlink, targetLink may already exist!
-    ZEN_ON_SCOPE_FAIL(try { removeSymlinkPlain(targetLink); /*throw FileError*/ }
-    catch (FileError&) {});
-
-    //file times: essential for sync'ing a symlink: enforce this! (don't just try!)
-    struct ::stat sourceInfo = {};
-    if (::lstat(sourceLink.c_str(), &sourceInfo) != 0)
-        THROW_LAST_FILE_ERROR(replaceCpy(_("Cannot read file attributes of %x."), L"%x", fmtPath(sourceLink)), L"lstat");
-
-    setWriteTimeNative(targetLink, sourceInfo.st_mtim, ProcSymlink::DIRECT); //throw FileError
-
-    if (copyFilePermissions)
-        copyItemPermissions(sourceLink, targetLink, ProcSymlink::DIRECT); //throw FileError
-}
-
-
-namespace
-{
-InSyncAttributes copyFileOsSpecific(const Zstring& sourceFile, //throw FileError, ErrorTargetExisting
-                                    const Zstring& targetFile,
-                                    const IOCallback& notifyUnbufferedIO)
-{
-    int64_t totalUnbufferedIO = 0;
-
-    FileInput fileIn(sourceFile, IOCallbackDivider(notifyUnbufferedIO, totalUnbufferedIO)); //throw FileError, (ErrorFileLocked -> Windows-only)
-
-    struct ::stat sourceInfo = {};
-    if (::fstat(fileIn.getHandle(), &sourceInfo) != 0)
-        THROW_LAST_FILE_ERROR(replaceCpy(_("Cannot read file attributes of %x."), L"%x", fmtPath(sourceFile)), L"fstat");
-
-    const mode_t mode = sourceInfo.st_mode & (S_IRWXU | S_IRWXG | S_IRWXO); //analog to "cp" which copies "mode" (considering umask) by default
-    //it seems we don't need S_IWUSR, not even for the setFileTime() below! (tested with source file having different user/group!)
-
-    //=> need copyItemPermissions() only for "chown" and umask-agnostic permissions
-    const int fdTarget = ::open(targetFile.c_str(), O_WRONLY | O_CREAT | O_EXCL, mode);
-    if (fdTarget == -1)
-    {
-        const int ec = errno; //copy before making other system calls!
-        const std::wstring errorMsg = replaceCpy(_("Cannot write file %x."), L"%x", fmtPath(targetFile));
-        const std::wstring errorDescr = formatSystemError(L"open", ec);
-
-        if (ec == EEXIST)
-            throw ErrorTargetExisting(errorMsg, errorDescr);
-
-        throw FileError(errorMsg, errorDescr);
-    }
-    ZEN_ON_SCOPE_FAIL( try { removeFilePlain(targetFile); }
-    catch (FileError&) {} );
-    //place guard AFTER ::open() and BEFORE lifetime of FileOutput:
-    //=> don't delete file that existed previously!!!
-    FileOutput fileOut(fdTarget, targetFile, IOCallbackDivider(notifyUnbufferedIO, totalUnbufferedIO)); //pass ownership
-
-    bufferedStreamCopy(fileIn, fileOut); //throw FileError, X
-    fileOut.flushBuffers();              //throw FileError, X
-    struct ::stat targetInfo = {};
-    if (::fstat(fileOut.getHandle(), &targetInfo) != 0)
-        THROW_LAST_FILE_ERROR(replaceCpy(_("Cannot read file attributes of %x."), L"%x", fmtPath(targetFile)), L"fstat");
-
-    //close output file handle before setting file time; also good place to catch errors when closing stream!
-    fileOut.finalize(); //throw FileError, (X)  essentially a close() since  buffers were already flushed
-
-    //we cannot set the target file times (::futimes) while the file descriptor is still open after a write operation:
-    //this triggers bugs on samba shares where the modification time is set to current time instead.
-    //Linux: http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=340236
-    //       http://comments.gmane.org/gmane.linux.file-systems.cifs/2854
-    //OS X:  http://www.freefilesync.org/forum/viewtopic.php?t=356
-    setWriteTimeNative(targetFile, sourceInfo.st_mtim, ProcSymlink::FOLLOW); //throw FileError
-
-    InSyncAttributes newAttrib;
-    newAttrib.fileSize         = sourceInfo.st_size;
-    newAttrib.modificationTime = sourceInfo.st_mtim.tv_sec; //
-    newAttrib.sourceFileId     = extractFileId(sourceInfo);
-    newAttrib.targetFileId     = extractFileId(targetInfo);
-    return newAttrib;
-}
-
-/*                  ------------------
-                    |File Copy Layers|
-                    ------------------
-                       copyNewFile
-                            |
-                   copyFileOsSpecific (solve 8.3 issue on Windows)
-                            |
-                  copyFileWindowsSelectRoutine
-                  /                           \
-copyFileWindowsDefault(::CopyFileEx)  copyFileWindowsStream(::BackupRead/::BackupWrite)
-*/
-}
-
-
-InSyncAttributes zen::copyNewFile(const Zstring& sourceFile, const Zstring& targetFile, bool copyFilePermissions, //throw FileError, ErrorTargetExisting, ErrorFileLocked
-                                  const IOCallback& notifyUnbufferedIO)
-{
-    const InSyncAttributes attr = copyFileOsSpecific(sourceFile, targetFile, notifyUnbufferedIO); //throw FileError, ErrorTargetExisting, ErrorFileLocked
-
-    //at this point we know we created a new file, so it's fine to delete it for cleanup!
-    ZEN_ON_SCOPE_FAIL(try { removeFilePlain(targetFile); }
-    catch (FileError&) {});
-
-    if (copyFilePermissions)
-        copyItemPermissions(sourceFile, targetFile, ProcSymlink::FOLLOW); //throw FileError
-
-    return attr;
-}
+// *****************************************************************************
+// * This file is part of the FreeFileSync project. It is distributed under    *
+// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
+// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
+// *****************************************************************************
+
+#include "file_access.h"
+#include <map>
+#include <algorithm>
+#include <stdexcept>
+#include "file_traverser.h"
+#include "scope_guard.h"
+#include "symlink_target.h"
+#include "file_id_def.h"
+#include "file_io.h"
+
+    #include <sys/vfs.h> //statfs
+    #include <sys/time.h> //lutimes
+    #ifdef HAVE_SELINUX
+        #include <selinux/selinux.h>
+    #endif
+
+
+    #include <fcntl.h> //open, close, AT_SYMLINK_NOFOLLOW, UTIME_OMIT
+    #include <sys/stat.h>
+
+using namespace zen;
+
+
+Opt<PathComponents> zen::parsePathComponents(const Zstring& itemPath)
+{
+    if (startsWith(itemPath, "/"))
+    {
+        Zstring relPath(itemPath.c_str() + 1);
+        if (endsWith(relPath, FILE_NAME_SEPARATOR))
+            relPath.pop_back();
+        return PathComponents({ "/", relPath });
+    }
+    //we do NOT support relative paths!
+    return NoValue();
+}
+
+
+
+Opt<Zstring> zen::getParentFolderPath(const Zstring& itemPath)
+{
+    if (const Opt<PathComponents> comp = parsePathComponents(itemPath))
+    {
+        if (comp->relPath.empty())
+            return NoValue();
+
+        const Zstring parentRelPath = beforeLast(comp->relPath, FILE_NAME_SEPARATOR, IF_MISSING_RETURN_NONE);
+        if (parentRelPath.empty())
+            return comp->rootPath;
+        return appendSeparator(comp->rootPath) + parentRelPath;
+    }
+    assert(false);
+    return NoValue();
+}
+
+
+ItemType zen::getItemType(const Zstring& itemPath) //throw FileError
+{
+    struct ::stat itemInfo = {};
+    if (::lstat(itemPath.c_str(), &itemInfo) != 0)
+        THROW_LAST_FILE_ERROR(replaceCpy(_("Cannot read file attributes of %x."), L"%x", fmtPath(itemPath)), L"lstat");
+
+    if (S_ISLNK(itemInfo.st_mode))
+        return ItemType::SYMLINK;
+    if (S_ISDIR(itemInfo.st_mode))
+        return ItemType::FOLDER;
+    return ItemType::FILE; //S_ISREG || S_ISCHR || S_ISBLK || S_ISFIFO || S_ISSOCK
+}
+
+
+PathStatus zen::getPathStatus(const Zstring& itemPath) //throw FileError
+{
+    const Opt<Zstring> parentPath = getParentFolderPath(itemPath);
+    try
+    {
+        return { getItemType(itemPath), itemPath, {} }; //throw FileError
+    }
+    catch (FileError&)
+    {
+        if (!parentPath) //device root
+            throw;
+        //else: let's dig deeper... don't bother checking Win32 codes; e.g. not existing item may have the codes:
+        //  ERROR_FILE_NOT_FOUND, ERROR_PATH_NOT_FOUND, ERROR_INVALID_NAME, ERROR_INVALID_DRIVE,
+        //  ERROR_NOT_READY, ERROR_INVALID_PARAMETER, ERROR_BAD_PATHNAME, ERROR_BAD_NETPATH => not reliable
+    }
+    const Zstring itemName = afterLast(itemPath, FILE_NAME_SEPARATOR, IF_MISSING_RETURN_ALL);
+    assert(!itemName.empty());
+
+    PathStatus pd = getPathStatus(*parentPath); //throw FileError
+    if (!pd.relPath.empty())
+    {
+        pd.relPath.push_back(itemName);
+        return { pd.existingType, pd.existingPath, pd.relPath };
+    }
+
+    try
+    {
+        traverseFolder(*parentPath,
+        [&](const FileInfo&    fi) { if (equalFilePath(fi.itemName, itemName)) throw ItemType::FILE; },
+        [&](const FolderInfo&  fi) { if (equalFilePath(fi.itemName, itemName)) throw ItemType::FOLDER; },
+        [&](const SymlinkInfo& si) { if (equalFilePath(si.itemName, itemName)) throw ItemType::SYMLINK; },
+        [](const std::wstring& errorMsg) { throw FileError(errorMsg); });
+
+        return { pd.existingType, *parentPath, { itemName } }; //throw FileError
+    }
+    catch (const ItemType& type) { return { type, itemPath, {} }; } //yes, exceptions for control-flow are bad design... but, but...
+    //we're not CPU-bound here and finding the item after getItemType() previously failed is exceptional (even C:\pagefile.sys should be found)
+}
+
+
+Opt<ItemType> zen::getItemTypeIfExists(const Zstring& itemPath) //throw FileError
+{
+    const PathStatus pd = getPathStatus(itemPath); //throw FileError
+    if (pd.relPath.empty())
+        return pd.existingType;
+    return NoValue();
+}
+
+
+bool zen::fileAvailable(const Zstring& filePath) //noexcept
+{
+    //symbolic links (broken or not) are also treated as existing files!
+    struct ::stat fileInfo = {};
+    if (::stat(filePath.c_str(), &fileInfo) == 0) //follow symlinks!
+        return S_ISREG(fileInfo.st_mode);
+    return false;
+}
+
+
+bool zen::dirAvailable(const Zstring& dirPath) //noexcept
+{
+    //symbolic links (broken or not) are also treated as existing directories!
+    struct ::stat dirInfo = {};
+    if (::stat(dirPath.c_str(), &dirInfo) == 0) //follow symlinks!
+        return S_ISDIR(dirInfo.st_mode);
+    return false;
+}
+
+
+bool zen::itemNotExisting(const Zstring& itemPath)
+{
+    try
+    {
+        return !getItemTypeIfExists(itemPath); //throw FileError
+    }
+    catch (FileError&) { return false; }
+}
+
+
+namespace
+{
+}
+
+
+uint64_t zen::getFileSize(const Zstring& filePath) //throw FileError
+{
+    struct ::stat fileInfo = {};
+    if (::stat(filePath.c_str(), &fileInfo) != 0)
+        THROW_LAST_FILE_ERROR(replaceCpy(_("Cannot read file attributes of %x."), L"%x", fmtPath(filePath)), L"stat");
+
+    return fileInfo.st_size;
+}
+
+
+uint64_t zen::getFreeDiskSpace(const Zstring& path) //throw FileError, returns 0 if not available
+{
+    struct ::statfs info = {};
+    if (::statfs(path.c_str(), &info) != 0)
+        THROW_LAST_FILE_ERROR(replaceCpy(_("Cannot determine free disk space for %x."), L"%x", fmtPath(path)), L"statfs");
+
+    return static_cast<uint64_t>(info.f_bsize) * info.f_bavail;
+}
+
+
+VolumeId zen::getVolumeId(const Zstring& itemPath) //throw FileError
+{
+    struct ::stat fileInfo = {};
+    if (::stat(itemPath.c_str(), &fileInfo) != 0)
+        THROW_LAST_FILE_ERROR(replaceCpy(_("Cannot read file attributes of %x."), L"%x", fmtPath(itemPath)), L"stat");
+
+    return fileInfo.st_dev;
+}
+
+
+Zstring zen::getTempFolderPath() //throw FileError
+{
+    const char* buf = ::getenv("TMPDIR"); //no extended error reporting
+    if (!buf)
+        throw FileError(_("Cannot get process information."), L"getenv: TMPDIR not found.");
+    return buf;
+}
+
+
+void zen::removeFilePlain(const Zstring& filePath) //throw FileError
+{
+    const wchar_t functionName[] = L"unlink";
+    if (::unlink(filePath.c_str()) != 0)
+    {
+        ErrorCode ec = getLastError(); //copy before directly/indirectly making other system calls!
+        //begin of "regular" error reporting
+        std::wstring errorDescr = formatSystemError(functionName, ec);
+
+        throw FileError(replaceCpy(_("Cannot delete file %x."), L"%x", fmtPath(filePath)), errorDescr);
+    }
+}
+
+
+void zen::removeSymlinkPlain(const Zstring& linkPath) //throw FileError
+{
+    removeFilePlain(linkPath); //throw FileError
+}
+
+
+void zen::removeDirectoryPlain(const Zstring& dirPath) //throw FileError
+{
+    const wchar_t functionName[] = L"rmdir";
+    if (::rmdir(dirPath.c_str()) != 0)
+    {
+        ErrorCode ec = getLastError(); //copy before making other system calls!
+        bool symlinkExists = false;
+        try { symlinkExists = getItemType(dirPath) == ItemType::SYMLINK; } /*throw FileError*/ catch (FileError&) {} //previous exception is more relevant
+
+        if (symlinkExists)
+        {
+            if (::unlink(dirPath.c_str()) != 0)
+                THROW_LAST_FILE_ERROR(replaceCpy(_("Cannot delete directory %x."), L"%x", fmtPath(dirPath)), L"unlink");
+            return;
+        }
+        throw FileError(replaceCpy(_("Cannot delete directory %x."), L"%x", fmtPath(dirPath)), formatSystemError(functionName, ec));
+    }
+    /*
+    Windows: may spuriously fail with ERROR_DIR_NOT_EMPTY(145) even though all child items have
+    successfully been *marked* for deletion, but some application still has a handle open!
+    e.g. Open "C:\Test\Dir1\Dir2" (filled with lots of files) in Explorer, then delete "C:\Test\Dir1" via ::RemoveDirectory() => Error 145
+    Sample code: http://us.generation-nt.com/answer/createfile-directory-handles-removing-parent-help-29126332.html
+    Alternatives: 1. move file/empty folder to some other location, then DeleteFile()/RemoveDirectory()
+                  2. use CreateFile/FILE_FLAG_DELETE_ON_CLOSE *without* FILE_SHARE_DELETE instead of DeleteFile() => early failure
+    */
+}
+
+
+namespace
+{
+void removeDirectoryImpl(const Zstring& folderPath) //throw FileError
+{
+    std::vector<Zstring> filePaths;
+    std::vector<Zstring> symlinkPaths;
+    std::vector<Zstring> folderPaths;
+
+    //get all files and directories from current directory (WITHOUT subdirectories!)
+    traverseFolder(folderPath,
+    [&](const FileInfo&    fi) { filePaths   .push_back(fi.fullPath); },
+    [&](const FolderInfo&  fi) { folderPaths .push_back(fi.fullPath); }, //defer recursion => save stack space and allow deletion of extremely deep hierarchies!
+    [&](const SymlinkInfo& si) { symlinkPaths.push_back(si.fullPath); },
+    [](const std::wstring& errorMsg) { throw FileError(errorMsg); });
+
+    for (const Zstring& filePath : filePaths)
+        removeFilePlain(filePath); //throw FileError
+
+    for (const Zstring& symlinkPath : symlinkPaths)
+        removeSymlinkPlain(symlinkPath); //throw FileError
+
+    //delete directories recursively
+    for (const Zstring& subFolderPath : folderPaths)
+        removeDirectoryImpl(subFolderPath); //throw FileError; call recursively to correctly handle symbolic links
+
+    removeDirectoryPlain(folderPath); //throw FileError
+}
+}
+
+
+void zen::removeDirectoryPlainRecursion(const Zstring& dirPath) //throw FileError
+{
+    if (getItemType(dirPath) == ItemType::SYMLINK) //throw FileError
+        removeSymlinkPlain(dirPath); //throw FileError
+    else
+        removeDirectoryImpl(dirPath); //throw FileError
+}
+
+
+namespace
+{
+/* Usage overview: (avoid circular pattern!)
+
+  renameFile()  -->  renameFile_sub()
+      |               /|\
+     \|/               |
+      Fix8Dot3NameClash()
+*/
+//wrapper for file system rename function:
+void renameFile_sub(const Zstring& pathSource, const Zstring& pathTarget) //throw FileError, ErrorDifferentVolume, ErrorTargetExisting
+{
+    //rename() will never fail with EEXIST, but always (atomically) overwrite!
+    //=> equivalent to SetFileInformationByHandle() + FILE_RENAME_INFO::ReplaceIfExists or ::MoveFileEx + MOVEFILE_REPLACE_EXISTING
+    //=> Linux: renameat2() with RENAME_NOREPLACE -> still new, probably buggy
+    //=> OS X: no solution
+
+    auto throwException = [&](int ec)
+    {
+        const std::wstring errorMsg = replaceCpy(replaceCpy(_("Cannot move file %x to %y."), L"%x", L"\n" + fmtPath(pathSource)), L"%y", L"\n" + fmtPath(pathTarget));
+        const std::wstring errorDescr = formatSystemError(L"rename", ec);
+
+        if (ec == EXDEV)
+            throw ErrorDifferentVolume(errorMsg, errorDescr);
+        if (ec == EEXIST)
+            throw ErrorTargetExisting(errorMsg, errorDescr);
+        throw FileError(errorMsg, errorDescr);
+    };
+
+    if (!equalFilePath(pathSource, pathTarget)) //exception for OS X: changing file name case is not an "already exists" situation!
+    {
+        bool alreadyExists = true;
+        try {  /*ItemType type = */getItemType(pathTarget); } /*throw FileError*/ catch (FileError&) { alreadyExists = false; }
+
+        if (alreadyExists)
+            throwException(EEXIST);
+        //else: nothing exists or other error (hopefully ::rename will also fail!)
+    }
+
+    if (::rename(pathSource.c_str(), pathTarget.c_str()) != 0)
+        throwException(errno);
+}
+
+
+}
+
+
+//rename file: no copying!!!
+void zen::renameFile(const Zstring& pathSource, const Zstring& pathTarget) //throw FileError, ErrorDifferentVolume, ErrorTargetExisting
+{
+    try
+    {
+        renameFile_sub(pathSource, pathTarget); //throw FileError, ErrorDifferentVolume, ErrorTargetExisting
+    }
+    catch (const ErrorTargetExisting&)
+    {
+        throw;
+    }
+}
+
+
+namespace
+{
+void setWriteTimeNative(const Zstring& itemPath, const struct ::timespec& modTime, ProcSymlink procSl) //throw FileError
+{
+    /*
+    [2013-05-01] sigh, we can't use utimensat() on NTFS volumes on Ubuntu: silent failure!!! what morons are programming this shit???
+    => fallback to "retarded-idiot version"! -- DarkByte
+
+    [2015-03-09]
+     - cannot reproduce issues with NTFS and utimensat() on Ubuntu
+     - utimensat() is supposed to obsolete utime/utimes and is also used by "cp" and "touch"
+        => let's give utimensat another chance:
+        using open()/futimens() for regular files and utimensat(AT_SYMLINK_NOFOLLOW) for symlinks is consistent with "cp" and "touch"!
+    */
+    struct ::timespec newTimes[2] = {};
+    newTimes[0].tv_sec = ::time(nullptr); //access time; using UTIME_OMIT for tv_nsec would trigger even more bugs: http://www.freefilesync.org/forum/viewtopic.php?t=1701
+    newTimes[1] = modTime; //modification time
+
+    if (procSl == ProcSymlink::FOLLOW)
+    {
+        //hell knows why files on gvfs-mounted Samba shares fail to open(O_WRONLY) returning EOPNOTSUPP:
+        //http://www.freefilesync.org/forum/viewtopic.php?t=2803 => utimensat() works
+        if (::utimensat(AT_FDCWD, itemPath.c_str(), newTimes, 0) == 0)
+            return;
+
+        //in other cases utimensat() returns EINVAL for CIFS/NTFS drives, but open+futimens works: http://www.freefilesync.org/forum/viewtopic.php?t=387
+        const int fdFile = ::open(itemPath.c_str(), O_WRONLY);
+        if (fdFile == -1)
+            THROW_LAST_FILE_ERROR(replaceCpy(_("Cannot write modification time of %x."), L"%x", fmtPath(itemPath)), L"open");
+        ZEN_ON_SCOPE_EXIT(::close(fdFile));
+
+        if (::futimens(fdFile, newTimes) != 0)
+            THROW_LAST_FILE_ERROR(replaceCpy(_("Cannot write modification time of %x."), L"%x", fmtPath(itemPath)), L"futimens");
+    }
+    else
+    {
+        if (::utimensat(AT_FDCWD, itemPath.c_str(), newTimes, AT_SYMLINK_NOFOLLOW) != 0)
+            THROW_LAST_FILE_ERROR(replaceCpy(_("Cannot write modification time of %x."), L"%x", fmtPath(itemPath)), L"utimensat");
+    }
+}
+
+
+}
+
+
+void zen::setFileTime(const Zstring& filePath, int64_t modTime, ProcSymlink procSl) //throw FileError
+{
+    struct ::timespec writeTime = {};
+    writeTime.tv_sec = modTime;
+    setWriteTimeNative(filePath, writeTime, procSl); //throw FileError
+
+}
+
+
+bool zen::supportsPermissions(const Zstring& dirPath) //throw FileError
+{
+    return true;
+}
+
+
+namespace
+{
+#ifdef HAVE_SELINUX
+//copy SELinux security context
+void copySecurityContext(const Zstring& source, const Zstring& target, ProcSymlink procSl) //throw FileError
+{
+    security_context_t contextSource = nullptr;
+    const int rv = procSl == ProcSymlink::FOLLOW ?
+                   ::getfilecon(source.c_str(), &contextSource) :
+                   ::lgetfilecon(source.c_str(), &contextSource);
+    if (rv < 0)
+    {
+        if (errno == ENODATA ||  //no security context (allegedly) is not an error condition on SELinux
+            errno == EOPNOTSUPP) //extended attributes are not supported by the filesystem
+            return;
+
+        THROW_LAST_FILE_ERROR(replaceCpy(_("Cannot read security context of %x."), L"%x", fmtPath(source)), L"getfilecon");
+    }
+    ZEN_ON_SCOPE_EXIT(::freecon(contextSource));
+
+    {
+        security_context_t contextTarget = nullptr;
+        const int rv2 = procSl == ProcSymlink::FOLLOW ?
+                        ::getfilecon(target.c_str(), &contextTarget) :
+                        ::lgetfilecon(target.c_str(), &contextTarget);
+        if (rv2 < 0)
+        {
+            if (errno == EOPNOTSUPP)
+                return;
+            //else: still try to set security context
+        }
+        else
+        {
+            ZEN_ON_SCOPE_EXIT(::freecon(contextTarget));
+
+            if (::strcmp(contextSource, contextTarget) == 0) //nothing to do
+                return;
+        }
+    }
+
+    const int rv3 = procSl == ProcSymlink::FOLLOW ?
+                    ::setfilecon(target.c_str(), contextSource) :
+                    ::lsetfilecon(target.c_str(), contextSource);
+    if (rv3 < 0)
+        THROW_LAST_FILE_ERROR(replaceCpy(_("Cannot write security context of %x."), L"%x", fmtPath(target)), L"setfilecon");
+}
+#endif
+
+
+//copy permissions for files, directories or symbolic links: requires admin rights
+void copyItemPermissions(const Zstring& sourcePath, const Zstring& targetPath, ProcSymlink procSl) //throw FileError
+{
+
+#ifdef HAVE_SELINUX  //copy SELinux security context
+    copySecurityContext(sourcePath, targetPath, procSl); //throw FileError
+#endif
+
+    struct ::stat fileInfo = {};
+    if (procSl == ProcSymlink::FOLLOW)
+    {
+        if (::stat(sourcePath.c_str(), &fileInfo) != 0)
+            THROW_LAST_FILE_ERROR(replaceCpy(_("Cannot read permissions of %x."), L"%x", fmtPath(sourcePath)), L"stat");
+
+        if (::chown(targetPath.c_str(), fileInfo.st_uid, fileInfo.st_gid) != 0) // may require admin rights!
+            THROW_LAST_FILE_ERROR(replaceCpy(_("Cannot write permissions of %x."), L"%x", fmtPath(targetPath)), L"chown");
+
+        if (::chmod(targetPath.c_str(), fileInfo.st_mode) != 0)
+            THROW_LAST_FILE_ERROR(replaceCpy(_("Cannot write permissions of %x."), L"%x", fmtPath(targetPath)), L"chmod");
+    }
+    else
+    {
+        if (::lstat(sourcePath.c_str(), &fileInfo) != 0)
+            THROW_LAST_FILE_ERROR(replaceCpy(_("Cannot read permissions of %x."), L"%x", fmtPath(sourcePath)), L"lstat");
+
+        if (::lchown(targetPath.c_str(), fileInfo.st_uid, fileInfo.st_gid) != 0) // may require admin rights!
+            THROW_LAST_FILE_ERROR(replaceCpy(_("Cannot write permissions of %x."), L"%x", fmtPath(targetPath)), L"lchown");
+
+        const bool isSymlinkTarget = getItemType(targetPath) == ItemType::SYMLINK; //throw FileError
+        if (!isSymlinkTarget && //setting access permissions doesn't make sense for symlinks on Linux: there is no lchmod()
+            ::chmod(targetPath.c_str(), fileInfo.st_mode) != 0)
+            THROW_LAST_FILE_ERROR(replaceCpy(_("Cannot write permissions of %x."), L"%x", fmtPath(targetPath)), L"chmod");
+    }
+
+}
+}
+
+
+void zen::createDirectoryIfMissingRecursion(const Zstring& dirPath) //throw FileError
+{
+    if (!getParentFolderPath(dirPath)) //device root
+        return static_cast<void>(/*ItemType =*/ getItemType(dirPath)); //throw FileError
+
+    try
+    {
+        copyNewDirectory(Zstring(), dirPath, false /*copyFilePermissions*/); //throw FileError, ErrorTargetExisting
+    }
+    catch (FileError&)
+    {
+        Opt<PathStatus> pd;
+        try { pd = getPathStatus(dirPath); /*throw FileError*/ }
+        catch (FileError&) {} //previous exception is more relevant
+
+        if (pd && pd->existingType != ItemType::FILE)
+        {
+            Zstring intermediatePath = pd->existingPath;
+            for (const Zstring& itemName : pd->relPath)
+            {
+                intermediatePath = appendSeparator(intermediatePath) + itemName;
+                copyNewDirectory(Zstring(), intermediatePath, false /*copyFilePermissions*/); //throw FileError, (ErrorTargetExisting)
+            }
+            return;
+        }
+        throw;
+    }
+}
+
+
+//source path is optional (may be empty)
+void zen::copyNewDirectory(const Zstring& sourcePath, const Zstring& targetPath, //throw FileError, ErrorTargetExisting
+                           bool copyFilePermissions)
+{
+    mode_t mode = S_IRWXU | S_IRWXG | S_IRWXO; //0777, default for newly created directories
+
+    struct ::stat dirInfo = {};
+    if (!sourcePath.empty())
+        if (::stat(sourcePath.c_str(), &dirInfo) == 0)
+        {
+            mode = dirInfo.st_mode & (S_IRWXU | S_IRWXG | S_IRWXO); //analog to "cp" which copies "mode" (considering umask) by default
+            mode |= S_IRWXU; //FFS only: we need full access to copy child items! "cp" seems to apply permissions *after* copying child items
+        }
+    //=> need copyItemPermissions() only for "chown" and umask-agnostic permissions
+
+    if (::mkdir(targetPath.c_str(), mode) != 0)
+    {
+        const int lastError = errno; //copy before directly or indirectly making other system calls!
+        const std::wstring errorMsg = replaceCpy(_("Cannot create directory %x."), L"%x", fmtPath(targetPath));
+        const std::wstring errorDescr = formatSystemError(L"mkdir", lastError);
+
+        if (lastError == EEXIST)
+            throw ErrorTargetExisting(errorMsg, errorDescr);
+        //else if (lastError == ENOENT)
+        //    throw ErrorTargetPathMissing(errorMsg, errorDescr);
+        throw FileError(errorMsg, errorDescr);
+    }
+
+    if (!sourcePath.empty())
+    {
+
+        ZEN_ON_SCOPE_FAIL(try { removeDirectoryPlain(targetPath); }
+        catch (FileError&) {});   //ensure cleanup:
+
+        //enforce copying file permissions: it's advertized on GUI...
+        if (copyFilePermissions)
+            copyItemPermissions(sourcePath, targetPath, ProcSymlink::FOLLOW); //throw FileError
+    }
+}
+
+
+void zen::copySymlink(const Zstring& sourceLink, const Zstring& targetLink, bool copyFilePermissions) //throw FileError
+{
+    const Zstring linkPath = getSymlinkTargetRaw(sourceLink); //throw FileError; accept broken symlinks
+
+    const wchar_t functionName[] = L"symlink";
+    if (::symlink(linkPath.c_str(), targetLink.c_str()) != 0)
+        THROW_LAST_FILE_ERROR(replaceCpy(replaceCpy(_("Cannot copy symbolic link %x to %y."), L"%x", L"\n" + fmtPath(sourceLink)), L"%y", L"\n" + fmtPath(targetLink)), functionName);
+
+    //allow only consistent objects to be created -> don't place before ::symlink, targetLink may already exist!
+    ZEN_ON_SCOPE_FAIL(try { removeSymlinkPlain(targetLink); /*throw FileError*/ }
+    catch (FileError&) {});
+
+    //file times: essential for sync'ing a symlink: enforce this! (don't just try!)
+    struct ::stat sourceInfo = {};
+    if (::lstat(sourceLink.c_str(), &sourceInfo) != 0)
+        THROW_LAST_FILE_ERROR(replaceCpy(_("Cannot read file attributes of %x."), L"%x", fmtPath(sourceLink)), L"lstat");
+
+    setWriteTimeNative(targetLink, sourceInfo.st_mtim, ProcSymlink::DIRECT); //throw FileError
+
+    if (copyFilePermissions)
+        copyItemPermissions(sourceLink, targetLink, ProcSymlink::DIRECT); //throw FileError
+}
+
+
+namespace
+{
+InSyncAttributes copyFileOsSpecific(const Zstring& sourceFile, //throw FileError, ErrorTargetExisting
+                                    const Zstring& targetFile,
+                                    const IOCallback& notifyUnbufferedIO)
+{
+    int64_t totalUnbufferedIO = 0;
+
+    FileInput fileIn(sourceFile, IOCallbackDivider(notifyUnbufferedIO, totalUnbufferedIO)); //throw FileError, (ErrorFileLocked -> Windows-only)
+
+    struct ::stat sourceInfo = {};
+    if (::fstat(fileIn.getHandle(), &sourceInfo) != 0)
+        THROW_LAST_FILE_ERROR(replaceCpy(_("Cannot read file attributes of %x."), L"%x", fmtPath(sourceFile)), L"fstat");
+
+    const mode_t mode = sourceInfo.st_mode & (S_IRWXU | S_IRWXG | S_IRWXO); //analog to "cp" which copies "mode" (considering umask) by default
+    //it seems we don't need S_IWUSR, not even for the setFileTime() below! (tested with source file having different user/group!)
+
+    //=> need copyItemPermissions() only for "chown" and umask-agnostic permissions
+    const int fdTarget = ::open(targetFile.c_str(), O_WRONLY | O_CREAT | O_EXCL, mode);
+    if (fdTarget == -1)
+    {
+        const int ec = errno; //copy before making other system calls!
+        const std::wstring errorMsg = replaceCpy(_("Cannot write file %x."), L"%x", fmtPath(targetFile));
+        const std::wstring errorDescr = formatSystemError(L"open", ec);
+
+        if (ec == EEXIST)
+            throw ErrorTargetExisting(errorMsg, errorDescr);
+
+        throw FileError(errorMsg, errorDescr);
+    }
+    ZEN_ON_SCOPE_FAIL( try { removeFilePlain(targetFile); }
+    catch (FileError&) {} );
+    //place guard AFTER ::open() and BEFORE lifetime of FileOutput:
+    //=> don't delete file that existed previously!!!
+    FileOutput fileOut(fdTarget, targetFile, IOCallbackDivider(notifyUnbufferedIO, totalUnbufferedIO)); //pass ownership
+
+    bufferedStreamCopy(fileIn, fileOut); //throw FileError, X
+    fileOut.flushBuffers();              //throw FileError, X
+    struct ::stat targetInfo = {};
+    if (::fstat(fileOut.getHandle(), &targetInfo) != 0)
+        THROW_LAST_FILE_ERROR(replaceCpy(_("Cannot read file attributes of %x."), L"%x", fmtPath(targetFile)), L"fstat");
+
+    //close output file handle before setting file time; also good place to catch errors when closing stream!
+    fileOut.finalize(); //throw FileError, (X)  essentially a close() since  buffers were already flushed
+
+    //we cannot set the target file times (::futimes) while the file descriptor is still open after a write operation:
+    //this triggers bugs on samba shares where the modification time is set to current time instead.
+    //Linux: http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=340236
+    //       http://comments.gmane.org/gmane.linux.file-systems.cifs/2854
+    //OS X:  http://www.freefilesync.org/forum/viewtopic.php?t=356
+    setWriteTimeNative(targetFile, sourceInfo.st_mtim, ProcSymlink::FOLLOW); //throw FileError
+
+    InSyncAttributes newAttrib;
+    newAttrib.fileSize         = sourceInfo.st_size;
+    newAttrib.modificationTime = sourceInfo.st_mtim.tv_sec; //
+    newAttrib.sourceFileId     = extractFileId(sourceInfo);
+    newAttrib.targetFileId     = extractFileId(targetInfo);
+    return newAttrib;
+}
+
+/*                  ------------------
+                    |File Copy Layers|
+                    ------------------
+                       copyNewFile
+                            |
+                   copyFileOsSpecific (solve 8.3 issue on Windows)
+                            |
+                  copyFileWindowsSelectRoutine
+                  /                           \
+copyFileWindowsDefault(::CopyFileEx)  copyFileWindowsStream(::BackupRead/::BackupWrite)
+*/
+}
+
+
+InSyncAttributes zen::copyNewFile(const Zstring& sourceFile, const Zstring& targetFile, bool copyFilePermissions, //throw FileError, ErrorTargetExisting, ErrorFileLocked
+                                  const IOCallback& notifyUnbufferedIO)
+{
+    const InSyncAttributes attr = copyFileOsSpecific(sourceFile, targetFile, notifyUnbufferedIO); //throw FileError, ErrorTargetExisting, ErrorFileLocked
+
+    //at this point we know we created a new file, so it's fine to delete it for cleanup!
+    ZEN_ON_SCOPE_FAIL(try { removeFilePlain(targetFile); }
+    catch (FileError&) {});
+
+    if (copyFilePermissions)
+        copyItemPermissions(sourceFile, targetFile, ProcSymlink::FOLLOW); //throw FileError
+
+    return attr;
+}
diff --git a/zen/file_access.h b/zen/file_access.h
index a6b221e5..ee33da93 100755
--- a/zen/file_access.h
+++ b/zen/file_access.h
@@ -1,101 +1,101 @@
-// *****************************************************************************
-// * This file is part of the FreeFileSync project. It is distributed under    *
-// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
-// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
-// *****************************************************************************
-
-#ifndef FILE_ACCESS_H_8017341345614857
-#define FILE_ACCESS_H_8017341345614857
-
-#include <functional>
-#include "zstring.h"
-#include "file_error.h"
-#include "file_id_def.h"
-#include "serialize.h"
-
-namespace zen
-{
-//note: certain functions require COM initialization! (vista_file_op.h)
-
-struct PathComponents
-{
-    Zstring rootPath; //itemPath = rootPath + (FILE_NAME_SEPARATOR?) + relPath
-    Zstring relPath;  //
-};
-Opt<PathComponents> parsePathComponents(const Zstring& itemPath); //no value on failure
-
-Opt<Zstring> getParentFolderPath(const Zstring& itemPath);
-
-//POSITIVE existence checks; if false: 1. item not existing 2. different type 3.device access error or similar
-bool fileAvailable(const Zstring& filePath); //noexcept
-bool dirAvailable (const Zstring& dirPath ); //
-//NEGATIVE existence checks; if false: 1. item existing 2.device access error or similar
-bool itemNotExisting(const Zstring& itemPath);
-
-enum class ItemType
-{
-    FILE,
-    FOLDER,
-    SYMLINK,
-};
-//(hopefully) fast: does not distinguish between error/not existing
-ItemType      getItemType        (const Zstring& itemPath); //throw FileError
-//execute potentially SLOW folder traversal but distinguish error/not existing
-Opt<ItemType> getItemTypeIfExists(const Zstring& itemPath); //throw FileError
-
-struct PathStatus
-{
-    ItemType existingType;
-    Zstring existingPath;         //itemPath =: existingPath + relPath
-    std::vector<Zstring> relPath; //
-};
-PathStatus getPathStatus(const Zstring& itemPath); //throw FileError
-
-enum class ProcSymlink
-{
-    DIRECT,
-    FOLLOW
-};
-void setFileTime(const Zstring& filePath, int64_t modificationTime, ProcSymlink procSl); //throw FileError
-
-//symlink handling: always evaluate target
-uint64_t getFileSize(const Zstring& filePath); //throw FileError
-uint64_t getFreeDiskSpace(const Zstring& path); //throw FileError, returns 0 if not available
-VolumeId getVolumeId(const Zstring& itemPath); //throw FileError
-//get per-user directory designated for temporary files:
-Zstring getTempFolderPath(); //throw FileError
-
-void removeFilePlain     (const Zstring& filePath);         //throw FileError; ERROR if not existing
-void removeSymlinkPlain  (const Zstring& linkPath);         //throw FileError; ERROR if not existing
-void removeDirectoryPlain(const Zstring& dirPath );         //throw FileError; ERROR if not existing
-void removeDirectoryPlainRecursion(const Zstring& dirPath); //throw FileError; ERROR if not existing
-
-//rename file or directory: no copying!!!
-void renameFile(const Zstring& itemPathOld, const Zstring& itemPathNew); //throw FileError, ErrorDifferentVolume, ErrorTargetExisting
-
-bool supportsPermissions(const Zstring& dirPath); //throw FileError, dereferences symlinks
-
-//- no error if already existing
-//- create recursively if parent directory is not existing
-void createDirectoryIfMissingRecursion(const Zstring& dirPath); //throw FileError
-
-//fail if already existing or parent directory not existing:
-//source path is optional (may be empty)
-void copyNewDirectory(const Zstring& sourcePath, const Zstring& targetPath, bool copyFilePermissions); //throw FileError, ErrorTargetExisting
-
-void copySymlink(const Zstring& sourceLink, const Zstring& targetLink, bool copyFilePermissions); //throw FileError
-
-struct InSyncAttributes
-{
-    uint64_t fileSize = 0;
-    int64_t modificationTime = 0; //time_t UTC compatible
-    FileId sourceFileId;
-    FileId targetFileId;
-};
-
-InSyncAttributes copyNewFile(const Zstring& sourceFile, const Zstring& targetFile, bool copyFilePermissions, //throw FileError, ErrorTargetExisting, ErrorFileLocked
-                             //accummulated delta != file size! consider ADS, sparse, compressed files
-                             const IOCallback& notifyUnbufferedIO); //may be nullptr; throw X!
-}
-
-#endif //FILE_ACCESS_H_8017341345614857
+// *****************************************************************************
+// * This file is part of the FreeFileSync project. It is distributed under    *
+// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
+// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
+// *****************************************************************************
+
+#ifndef FILE_ACCESS_H_8017341345614857
+#define FILE_ACCESS_H_8017341345614857
+
+#include <functional>
+#include "zstring.h"
+#include "file_error.h"
+#include "file_id_def.h"
+#include "serialize.h"
+
+namespace zen
+{
+//note: certain functions require COM initialization! (vista_file_op.h)
+
+struct PathComponents
+{
+    Zstring rootPath; //itemPath = rootPath + (FILE_NAME_SEPARATOR?) + relPath
+    Zstring relPath;  //
+};
+Opt<PathComponents> parsePathComponents(const Zstring& itemPath); //no value on failure
+
+Opt<Zstring> getParentFolderPath(const Zstring& itemPath);
+
+//POSITIVE existence checks; if false: 1. item not existing 2. different type 3.device access error or similar
+bool fileAvailable(const Zstring& filePath); //noexcept
+bool dirAvailable (const Zstring& dirPath ); //
+//NEGATIVE existence checks; if false: 1. item existing 2.device access error or similar
+bool itemNotExisting(const Zstring& itemPath);
+
+enum class ItemType
+{
+    FILE,
+    FOLDER,
+    SYMLINK,
+};
+//(hopefully) fast: does not distinguish between error/not existing
+ItemType      getItemType        (const Zstring& itemPath); //throw FileError
+//execute potentially SLOW folder traversal but distinguish error/not existing
+Opt<ItemType> getItemTypeIfExists(const Zstring& itemPath); //throw FileError
+
+struct PathStatus
+{
+    ItemType existingType;
+    Zstring existingPath;         //itemPath =: existingPath + relPath
+    std::vector<Zstring> relPath; //
+};
+PathStatus getPathStatus(const Zstring& itemPath); //throw FileError
+
+enum class ProcSymlink
+{
+    DIRECT,
+    FOLLOW
+};
+void setFileTime(const Zstring& filePath, int64_t modificationTime, ProcSymlink procSl); //throw FileError
+
+//symlink handling: always evaluate target
+uint64_t getFileSize(const Zstring& filePath); //throw FileError
+uint64_t getFreeDiskSpace(const Zstring& path); //throw FileError, returns 0 if not available
+VolumeId getVolumeId(const Zstring& itemPath); //throw FileError
+//get per-user directory designated for temporary files:
+Zstring getTempFolderPath(); //throw FileError
+
+void removeFilePlain     (const Zstring& filePath);         //throw FileError; ERROR if not existing
+void removeSymlinkPlain  (const Zstring& linkPath);         //throw FileError; ERROR if not existing
+void removeDirectoryPlain(const Zstring& dirPath );         //throw FileError; ERROR if not existing
+void removeDirectoryPlainRecursion(const Zstring& dirPath); //throw FileError; ERROR if not existing
+
+//rename file or directory: no copying!!!
+void renameFile(const Zstring& itemPathOld, const Zstring& itemPathNew); //throw FileError, ErrorDifferentVolume, ErrorTargetExisting
+
+bool supportsPermissions(const Zstring& dirPath); //throw FileError, dereferences symlinks
+
+//- no error if already existing
+//- create recursively if parent directory is not existing
+void createDirectoryIfMissingRecursion(const Zstring& dirPath); //throw FileError
+
+//fail if already existing or parent directory not existing:
+//source path is optional (may be empty)
+void copyNewDirectory(const Zstring& sourcePath, const Zstring& targetPath, bool copyFilePermissions); //throw FileError, ErrorTargetExisting
+
+void copySymlink(const Zstring& sourceLink, const Zstring& targetLink, bool copyFilePermissions); //throw FileError
+
+struct InSyncAttributes
+{
+    uint64_t fileSize = 0;
+    int64_t modificationTime = 0; //time_t UTC compatible
+    FileId sourceFileId;
+    FileId targetFileId;
+};
+
+InSyncAttributes copyNewFile(const Zstring& sourceFile, const Zstring& targetFile, bool copyFilePermissions, //throw FileError, ErrorTargetExisting, ErrorFileLocked
+                             //accummulated delta != file size! consider ADS, sparse, compressed files
+                             const IOCallback& notifyUnbufferedIO); //may be nullptr; throw X!
+}
+
+#endif //FILE_ACCESS_H_8017341345614857
diff --git a/zen/file_error.h b/zen/file_error.h
index 949c644f..b318e708 100755
--- a/zen/file_error.h
+++ b/zen/file_error.h
@@ -1,53 +1,53 @@
-// *****************************************************************************
-// * This file is part of the FreeFileSync project. It is distributed under    *
-// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
-// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
-// *****************************************************************************
-
-#ifndef FILE_ERROR_H_839567308565656789
-#define FILE_ERROR_H_839567308565656789
-
-#include <string>
-#include "zstring.h"
-#include "utf.h"
-#include "sys_error.h" //we'll need this later anyway!
-
-namespace zen
-{
-//A high-level exception class giving detailed context information for end users
-class FileError
-{
-public:
-    explicit FileError(const std::wstring& msg) : msg_(msg) {}
-    FileError(const std::wstring& msg, const std::wstring& details) : msg_(msg + L"\n\n" + details) {}
-    virtual ~FileError() {}
-
-    const std::wstring& toString() const { return msg_; }
-
-private:
-    std::wstring msg_;
-};
-
-#define DEFINE_NEW_FILE_ERROR(X) struct X : public FileError { X(const std::wstring& msg) : FileError(msg) {} X(const std::wstring& msg, const std::wstring& descr) : FileError(msg, descr) {} };
-
-DEFINE_NEW_FILE_ERROR(ErrorTargetExisting);
-//DEFINE_NEW_FILE_ERROR(ErrorTargetPathMissing);
-DEFINE_NEW_FILE_ERROR(ErrorFileLocked);
-DEFINE_NEW_FILE_ERROR(ErrorDifferentVolume);
-
-
-//CAVEAT: thread-local Win32 error code is easily overwritten => evaluate *before* making any (indirect) system calls:
-//-> MinGW + Win XP: "throw" statement allocates memory to hold the exception object => error code is cleared
-//-> VC 2015, Debug: std::wstring allocator internally calls ::FlsGetValue()         => error code is cleared
-//      https://connect.microsoft.com/VisualStudio/feedback/details/1775690/calling-operator-new-may-set-lasterror-to-0
-#define THROW_LAST_FILE_ERROR(msg, functionName)                           \
-    do { const ErrorCode ecInternal = getLastError(); throw FileError(msg, formatSystemError(functionName, ecInternal)); } while (false)
-
-//----------- facilitate usage of std::wstring for error messages --------------------
-
-inline std::wstring fmtPath(const std::wstring& displayPath) { return L'\"' + displayPath + L'\"'; }
-inline std::wstring fmtPath(const Zstring& displayPath) { return fmtPath(utfTo<std::wstring>(displayPath)); }
-inline std::wstring fmtPath(const wchar_t* displayPath) { return fmtPath(std::wstring(displayPath)); } //resolve overload ambiguity
-}
-
-#endif //FILE_ERROR_H_839567308565656789
+// *****************************************************************************
+// * This file is part of the FreeFileSync project. It is distributed under    *
+// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
+// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
+// *****************************************************************************
+
+#ifndef FILE_ERROR_H_839567308565656789
+#define FILE_ERROR_H_839567308565656789
+
+#include <string>
+#include "zstring.h"
+#include "utf.h"
+#include "sys_error.h" //we'll need this later anyway!
+
+namespace zen
+{
+//A high-level exception class giving detailed context information for end users
+class FileError
+{
+public:
+    explicit FileError(const std::wstring& msg) : msg_(msg) {}
+    FileError(const std::wstring& msg, const std::wstring& details) : msg_(msg + L"\n\n" + details) {}
+    virtual ~FileError() {}
+
+    const std::wstring& toString() const { return msg_; }
+
+private:
+    std::wstring msg_;
+};
+
+#define DEFINE_NEW_FILE_ERROR(X) struct X : public FileError { X(const std::wstring& msg) : FileError(msg) {} X(const std::wstring& msg, const std::wstring& descr) : FileError(msg, descr) {} };
+
+DEFINE_NEW_FILE_ERROR(ErrorTargetExisting);
+//DEFINE_NEW_FILE_ERROR(ErrorTargetPathMissing);
+DEFINE_NEW_FILE_ERROR(ErrorFileLocked);
+DEFINE_NEW_FILE_ERROR(ErrorDifferentVolume);
+
+
+//CAVEAT: thread-local Win32 error code is easily overwritten => evaluate *before* making any (indirect) system calls:
+//-> MinGW + Win XP: "throw" statement allocates memory to hold the exception object => error code is cleared
+//-> VC 2015, Debug: std::wstring allocator internally calls ::FlsGetValue()         => error code is cleared
+//      https://connect.microsoft.com/VisualStudio/feedback/details/1775690/calling-operator-new-may-set-lasterror-to-0
+#define THROW_LAST_FILE_ERROR(msg, functionName)                           \
+    do { const ErrorCode ecInternal = getLastError(); throw FileError(msg, formatSystemError(functionName, ecInternal)); } while (false)
+
+//----------- facilitate usage of std::wstring for error messages --------------------
+
+inline std::wstring fmtPath(const std::wstring& displayPath) { return L'\"' + displayPath + L'\"'; }
+inline std::wstring fmtPath(const Zstring& displayPath) { return fmtPath(utfTo<std::wstring>(displayPath)); }
+inline std::wstring fmtPath(const wchar_t* displayPath) { return fmtPath(std::wstring(displayPath)); } //resolve overload ambiguity
+}
+
+#endif //FILE_ERROR_H_839567308565656789
diff --git a/zen/file_id_def.h b/zen/file_id_def.h
index 87a5b199..3dcd21b9 100755
--- a/zen/file_id_def.h
+++ b/zen/file_id_def.h
@@ -1,41 +1,41 @@
-// *****************************************************************************
-// * This file is part of the FreeFileSync project. It is distributed under    *
-// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
-// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
-// *****************************************************************************
-
-#ifndef FILE_ID_DEF_H_013287632486321493
-#define FILE_ID_DEF_H_013287632486321493
-
-#include <utility>
-
-    #include <sys/stat.h>
-
-
-namespace zen
-{
-namespace impl { typedef struct ::stat StatDummy; } //sigh...
-
-using VolumeId  = decltype(impl::StatDummy::st_dev);
-using FileIndex = decltype(impl::StatDummy::st_ino);
-
-
-struct FileId  //always available on Linux, and *generally* available on Windows)
-{
-    FileId() {}
-    FileId(VolumeId volId, FileIndex fIdx) : volumeId(volId), fileIndex(fIdx) {}
-    VolumeId  volumeId  = 0;
-    FileIndex fileIndex = 0;
-};
-inline bool operator==(const FileId& lhs, const FileId& rhs) { return lhs.volumeId == rhs.volumeId && lhs.fileIndex == rhs.fileIndex; }
-
-
-inline
-FileId extractFileId(const struct ::stat& fileInfo)
-{
-    return fileInfo.st_dev != 0 && fileInfo.st_ino != 0 ?
-           FileId(fileInfo.st_dev, fileInfo.st_ino) : FileId();
-}
-}
-
-#endif //FILE_ID_DEF_H_013287632486321493
+// *****************************************************************************
+// * This file is part of the FreeFileSync project. It is distributed under    *
+// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
+// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
+// *****************************************************************************
+
+#ifndef FILE_ID_DEF_H_013287632486321493
+#define FILE_ID_DEF_H_013287632486321493
+
+#include <utility>
+
+    #include <sys/stat.h>
+
+
+namespace zen
+{
+namespace impl { typedef struct ::stat StatDummy; } //sigh...
+
+using VolumeId  = decltype(impl::StatDummy::st_dev);
+using FileIndex = decltype(impl::StatDummy::st_ino);
+
+
+struct FileId  //always available on Linux, and *generally* available on Windows)
+{
+    FileId() {}
+    FileId(VolumeId volId, FileIndex fIdx) : volumeId(volId), fileIndex(fIdx) {}
+    VolumeId  volumeId  = 0;
+    FileIndex fileIndex = 0;
+};
+inline bool operator==(const FileId& lhs, const FileId& rhs) { return lhs.volumeId == rhs.volumeId && lhs.fileIndex == rhs.fileIndex; }
+
+
+inline
+FileId extractFileId(const struct ::stat& fileInfo)
+{
+    return fileInfo.st_dev != 0 && fileInfo.st_ino != 0 ?
+           FileId(fileInfo.st_dev, fileInfo.st_ino) : FileId();
+}
+}
+
+#endif //FILE_ID_DEF_H_013287632486321493
diff --git a/zen/file_io.cpp b/zen/file_io.cpp
index 0c5ff490..d291e741 100755
--- a/zen/file_io.cpp
+++ b/zen/file_io.cpp
@@ -1,274 +1,274 @@
-// *****************************************************************************
-// * This file is part of the FreeFileSync project. It is distributed under    *
-// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
-// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
-// *****************************************************************************
-
-#include "file_io.h"
-#include "file_access.h"
-
-    #include <sys/stat.h>
-    #include <fcntl.h>  //open, close
-    #include <unistd.h> //read, write
-
-using namespace zen;
-
-
-namespace
-{
-//- "filePath" could be a named pipe which *blocks* forever for open()!
-//- open() with O_NONBLOCK avoids the block, but opens successfully
-//- create sample pipe: "sudo mkfifo named_pipe"
-void checkForUnsupportedType(const Zstring& filePath) //throw FileError
-{
-    struct ::stat fileInfo = {};
-    if (::stat(filePath.c_str(), &fileInfo) != 0) //follows symlinks
-        return; //let the caller handle errors like "not existing"
-
-    if (!S_ISREG(fileInfo.st_mode) &&
-        !S_ISLNK(fileInfo.st_mode) &&
-        !S_ISDIR(fileInfo.st_mode))
-    {
-        auto getTypeName = [](mode_t m) -> std::wstring
-        {
-            const wchar_t* name =
-            S_ISCHR (m) ? L"character device":
-            S_ISBLK (m) ? L"block device" :
-            S_ISFIFO(m) ? L"FIFO, named pipe" :
-            S_ISSOCK(m) ? L"socket" : nullptr;
-            const std::wstring numFmt = printNumber<std::wstring>(L"0%06o", m & S_IFMT);
-            return name ? numFmt + L", " + name : numFmt;
-        };
-        throw FileError(replaceCpy(_("Type of item %x is not supported:"), L"%x", fmtPath(filePath)) + L" " + getTypeName(fileInfo.st_mode));
-    }
-}
-}
-
-
-    const FileBase::FileHandle FileBase::invalidHandleValue = -1;
-
-
-FileBase::~FileBase()
-{
-    if (fileHandle_ != invalidHandleValue)
-        try
-        {
-            close(); //throw FileError
-        }
-        catch (FileError&) { assert(false); }
-}
-
-
-void FileBase::close() //throw FileError
-{
-    if (fileHandle_ == invalidHandleValue)
-        throw FileError(replaceCpy(_("Cannot write file %x."), L"%x", fmtPath(getFilePath())), L"Contract error: close() called more than once.");
-    ZEN_ON_SCOPE_EXIT(fileHandle_ = invalidHandleValue);
-
-    //no need to clean-up on failure here (just like there is no clean on FileOutput::write failure!) => FileOutput is not transactional!
-
-    if (::close(fileHandle_) != 0)
-        THROW_LAST_FILE_ERROR(replaceCpy(_("Cannot write file %x."), L"%x", fmtPath(getFilePath())), L"close");
-}
-
-//----------------------------------------------------------------------------------------------------
-
-namespace
-{
-FileBase::FileHandle openHandleForRead(const Zstring& filePath) //throw FileError, ErrorFileLocked
-{
-    checkForUnsupportedType(filePath); //throw FileError; opening a named pipe would block forever!
-
-    //don't use O_DIRECT: http://yarchive.net/comp/linux/o_direct.html
-    const FileBase::FileHandle fileHandle = ::open(filePath.c_str(), O_RDONLY);
-    if (fileHandle == -1) //don't check "< 0" -> docu seems to allow "-2" to be a valid file handle
-        THROW_LAST_FILE_ERROR(replaceCpy(_("Cannot open file %x."), L"%x", fmtPath(filePath)), L"open");
-    return fileHandle; //pass ownership
-}
-}
-
-
-FileInput::FileInput(FileHandle handle, const Zstring& filePath, const IOCallback& notifyUnbufferedIO) :
-    FileBase(handle, filePath), notifyUnbufferedIO_(notifyUnbufferedIO) {}
-
-
-FileInput::FileInput(const Zstring& filePath, const IOCallback& notifyUnbufferedIO) :
-    FileBase(openHandleForRead(filePath), filePath), //throw FileError, ErrorFileLocked
-    notifyUnbufferedIO_(notifyUnbufferedIO)
-{
-    //optimize read-ahead on input file:
-    if (::posix_fadvise(getHandle(), 0, 0, POSIX_FADV_SEQUENTIAL) != 0)
-        THROW_LAST_FILE_ERROR(replaceCpy(_("Cannot read file %x."), L"%x", fmtPath(filePath)), L"posix_fadvise");
-
-}
-
-
-size_t FileInput::tryRead(void* buffer, size_t bytesToRead) //throw FileError; may return short, only 0 means EOF!
-{
-    if (bytesToRead == 0) //"read() with a count of 0 returns zero" => indistinguishable from end of file! => check!
-        throw std::logic_error("Contract violation! " + std::string(__FILE__) + ":" + numberTo<std::string>(__LINE__));
-    assert(bytesToRead == getBlockSize());
-
-    ssize_t bytesRead = 0;
-    do
-    {
-        bytesRead = ::read(getHandle(), buffer, bytesToRead);
-    }
-    while (bytesRead < 0 && errno == EINTR); //Compare copy_reg() in copy.c: ftp://ftp.gnu.org/gnu/coreutils/coreutils-8.23.tar.xz
-
-    if (bytesRead < 0)
-        THROW_LAST_FILE_ERROR(replaceCpy(_("Cannot read file %x."), L"%x", fmtPath(getFilePath())), L"read");
-    if (static_cast<size_t>(bytesRead) > bytesToRead) //better safe than sorry
-        throw FileError(replaceCpy(_("Cannot read file %x."), L"%x", fmtPath(getFilePath())), L"ReadFile: buffer overflow."); //user should never see this
-
-    //if ::read is interrupted (EINTR) right in the middle, it will return successfully with "bytesRead < bytesToRead"
-
-    return bytesRead; //"zero indicates end of file"
-}
-
-
-size_t FileInput::read(void* buffer, size_t bytesToRead) //throw FileError, X; return "bytesToRead" bytes unless end of stream!
-{
-    const size_t blockSize = getBlockSize();
-
-    while (memBuf_.size() < bytesToRead)
-    {
-        memBuf_.resize(memBuf_.size() + blockSize);
-        const size_t bytesRead = tryRead(&*(memBuf_.end() - blockSize), blockSize); //throw FileError; may return short, only 0 means EOF! => CONTRACT: bytesToRead > 0
-        memBuf_.resize(memBuf_.size() - blockSize + bytesRead); //caveat: unsigned arithmetics
-
-        if (notifyUnbufferedIO_) notifyUnbufferedIO_(bytesRead); //throw X
-
-        if (bytesRead == 0) //end of file
-            bytesToRead = std::min(bytesToRead, memBuf_.size());
-    }
-
-    std::copy(memBuf_.begin(), memBuf_.begin() + bytesToRead, static_cast<char*>(buffer));
-    memBuf_.erase(memBuf_.begin(), memBuf_.begin() + bytesToRead);
-    return bytesToRead;
-}
-
-//----------------------------------------------------------------------------------------------------
-
-namespace
-{
-FileBase::FileHandle openHandleForWrite(const Zstring& filePath, FileOutput::AccessFlag access) //throw FileError, ErrorTargetExisting
-{
-    //checkForUnsupportedType(filePath); -> not needed, open() + O_WRONLY should fail fast
-
-    const FileBase::FileHandle fileHandle = ::open(filePath.c_str(), O_WRONLY | O_CREAT | (access == FileOutput::ACC_CREATE_NEW ? O_EXCL : O_TRUNC),
-                                                   S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH); //0666
-    if (fileHandle == -1)
-    {
-        const int ec = errno; //copy before making other system calls!
-        const std::wstring errorMsg = replaceCpy(_("Cannot write file %x."), L"%x", fmtPath(filePath));
-        const std::wstring errorDescr = formatSystemError(L"open", ec);
-
-        if (ec == EEXIST)
-            throw ErrorTargetExisting(errorMsg, errorDescr);
-        //if (ec == ENOENT) throw ErrorTargetPathMissing(errorMsg, errorDescr);
-
-        throw FileError(errorMsg, errorDescr);
-    }
-    return fileHandle; //pass ownership
-}
-}
-
-
-FileOutput::FileOutput(FileHandle handle, const Zstring& filePath, const IOCallback& notifyUnbufferedIO) :
-    FileBase(handle, filePath), notifyUnbufferedIO_(notifyUnbufferedIO) {}
-
-
-FileOutput::FileOutput(const Zstring& filePath, AccessFlag access, const IOCallback& notifyUnbufferedIO) :
-    FileBase(openHandleForWrite(filePath, access), filePath), notifyUnbufferedIO_(notifyUnbufferedIO) {} //throw FileError, ErrorTargetExisting
-
-
-FileOutput::~FileOutput()
-{
-    notifyUnbufferedIO_ = nullptr; //no call-backs during destruction!!!
-    try
-    {
-        flushBuffers(); //throw FileError, (X)
-    }
-    catch (...) { assert(false); }
-}
-
-
-size_t FileOutput::tryWrite(const void* buffer, size_t bytesToWrite) //throw FileError; may return short! CONTRACT: bytesToWrite > 0
-{
-    if (bytesToWrite == 0)
-        throw std::logic_error("Contract violation! " + std::string(__FILE__) + ":" + numberTo<std::string>(__LINE__));
-    assert(bytesToWrite <= getBlockSize());
-
-    ssize_t bytesWritten = 0;
-    do
-    {
-        bytesWritten = ::write(getHandle(), buffer, bytesToWrite);
-    }
-    while (bytesWritten < 0 && errno == EINTR);
-
-    if (bytesWritten <= 0)
-    {
-        if (bytesWritten == 0) //comment in safe-read.c suggests to treat this as an error due to buggy drivers
-            errno = ENOSPC;
-
-        THROW_LAST_FILE_ERROR(replaceCpy(_("Cannot write file %x."), L"%x", fmtPath(getFilePath())), L"write");
-    }
-    if (bytesWritten > static_cast<ssize_t>(bytesToWrite)) //better safe than sorry
-        throw FileError(replaceCpy(_("Cannot write file %x."), L"%x", fmtPath(getFilePath())), L"write: buffer overflow."); //user should never see this
-
-    //if ::write() is interrupted (EINTR) right in the middle, it will return successfully with "bytesWritten < bytesToWrite"!
-    return bytesWritten;
-}
-
-
-void FileOutput::write(const void* buffer, size_t bytesToWrite) //throw FileError, X
-{
-    auto bufFirst = static_cast<const char*>(buffer);
-    memBuf_.insert(memBuf_.end(), bufFirst, bufFirst + bytesToWrite);
-
-    const size_t blockSize = getBlockSize();
-    size_t bytesRemaining = memBuf_.size();
-    ZEN_ON_SCOPE_EXIT(memBuf_.erase(memBuf_.begin(), memBuf_.end() - bytesRemaining));
-    while (bytesRemaining >= blockSize)
-    {
-        const size_t bytesWritten = tryWrite(&*(memBuf_.end() - bytesRemaining), blockSize); //throw FileError; may return short! CONTRACT: bytesToWrite > 0
-        bytesRemaining -= bytesWritten;
-        if (notifyUnbufferedIO_) notifyUnbufferedIO_(bytesWritten); //throw X!
-    }
-}
-
-
-void FileOutput::flushBuffers() //throw FileError, X
-{
-    size_t bytesRemaining = memBuf_.size();
-    ZEN_ON_SCOPE_EXIT(memBuf_.erase(memBuf_.begin(), memBuf_.end() - bytesRemaining));
-    while (bytesRemaining > 0)
-    {
-        const size_t bytesWritten = tryWrite(&*(memBuf_.end() - bytesRemaining), bytesRemaining); //throw FileError; may return short! CONTRACT: bytesToWrite > 0
-        bytesRemaining -= bytesWritten;
-        if (notifyUnbufferedIO_) notifyUnbufferedIO_(bytesWritten); //throw X!
-    }
-}
-
-
-void FileOutput::finalize() //throw FileError, X
-{
-    flushBuffers(); //throw FileError, X
-    //~FileBase() calls this one, too, but we want to propagate errors if any:
-    close(); //throw FileError
-}
-
-
-void FileOutput::preAllocateSpaceBestEffort(uint64_t expectedSize) //throw FileError
-{
-    const FileHandle fh = getHandle();
-    //don't use potentially inefficient ::posix_fallocate!
-    const int rv = ::fallocate(fh,            //int fd,
-                               0,             //int mode,
-                               0,             //off_t offset
-                               expectedSize); //off_t len
-    if (rv != 0)
-        return; //may fail with EOPNOTSUPP, unlike posix_fallocate
-
-}
+// *****************************************************************************
+// * This file is part of the FreeFileSync project. It is distributed under    *
+// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
+// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
+// *****************************************************************************
+
+#include "file_io.h"
+#include "file_access.h"
+
+    #include <sys/stat.h>
+    #include <fcntl.h>  //open, close
+    #include <unistd.h> //read, write
+
+using namespace zen;
+
+
+namespace
+{
+//- "filePath" could be a named pipe which *blocks* forever for open()!
+//- open() with O_NONBLOCK avoids the block, but opens successfully
+//- create sample pipe: "sudo mkfifo named_pipe"
+void checkForUnsupportedType(const Zstring& filePath) //throw FileError
+{
+    struct ::stat fileInfo = {};
+    if (::stat(filePath.c_str(), &fileInfo) != 0) //follows symlinks
+        return; //let the caller handle errors like "not existing"
+
+    if (!S_ISREG(fileInfo.st_mode) &&
+        !S_ISLNK(fileInfo.st_mode) &&
+        !S_ISDIR(fileInfo.st_mode))
+    {
+        auto getTypeName = [](mode_t m) -> std::wstring
+        {
+            const wchar_t* name =
+            S_ISCHR (m) ? L"character device":
+            S_ISBLK (m) ? L"block device" :
+            S_ISFIFO(m) ? L"FIFO, named pipe" :
+            S_ISSOCK(m) ? L"socket" : nullptr;
+            const std::wstring numFmt = printNumber<std::wstring>(L"0%06o", m & S_IFMT);
+            return name ? numFmt + L", " + name : numFmt;
+        };
+        throw FileError(replaceCpy(_("Type of item %x is not supported:"), L"%x", fmtPath(filePath)) + L" " + getTypeName(fileInfo.st_mode));
+    }
+}
+}
+
+
+    const FileBase::FileHandle FileBase::invalidHandleValue = -1;
+
+
+FileBase::~FileBase()
+{
+    if (fileHandle_ != invalidHandleValue)
+        try
+        {
+            close(); //throw FileError
+        }
+        catch (FileError&) { assert(false); }
+}
+
+
+void FileBase::close() //throw FileError
+{
+    if (fileHandle_ == invalidHandleValue)
+        throw FileError(replaceCpy(_("Cannot write file %x."), L"%x", fmtPath(getFilePath())), L"Contract error: close() called more than once.");
+    ZEN_ON_SCOPE_EXIT(fileHandle_ = invalidHandleValue);
+
+    //no need to clean-up on failure here (just like there is no clean on FileOutput::write failure!) => FileOutput is not transactional!
+
+    if (::close(fileHandle_) != 0)
+        THROW_LAST_FILE_ERROR(replaceCpy(_("Cannot write file %x."), L"%x", fmtPath(getFilePath())), L"close");
+}
+
+//----------------------------------------------------------------------------------------------------
+
+namespace
+{
+FileBase::FileHandle openHandleForRead(const Zstring& filePath) //throw FileError, ErrorFileLocked
+{
+    checkForUnsupportedType(filePath); //throw FileError; opening a named pipe would block forever!
+
+    //don't use O_DIRECT: http://yarchive.net/comp/linux/o_direct.html
+    const FileBase::FileHandle fileHandle = ::open(filePath.c_str(), O_RDONLY);
+    if (fileHandle == -1) //don't check "< 0" -> docu seems to allow "-2" to be a valid file handle
+        THROW_LAST_FILE_ERROR(replaceCpy(_("Cannot open file %x."), L"%x", fmtPath(filePath)), L"open");
+    return fileHandle; //pass ownership
+}
+}
+
+
+FileInput::FileInput(FileHandle handle, const Zstring& filePath, const IOCallback& notifyUnbufferedIO) :
+    FileBase(handle, filePath), notifyUnbufferedIO_(notifyUnbufferedIO) {}
+
+
+FileInput::FileInput(const Zstring& filePath, const IOCallback& notifyUnbufferedIO) :
+    FileBase(openHandleForRead(filePath), filePath), //throw FileError, ErrorFileLocked
+    notifyUnbufferedIO_(notifyUnbufferedIO)
+{
+    //optimize read-ahead on input file:
+    if (::posix_fadvise(getHandle(), 0, 0, POSIX_FADV_SEQUENTIAL) != 0)
+        THROW_LAST_FILE_ERROR(replaceCpy(_("Cannot read file %x."), L"%x", fmtPath(filePath)), L"posix_fadvise");
+
+}
+
+
+size_t FileInput::tryRead(void* buffer, size_t bytesToRead) //throw FileError; may return short, only 0 means EOF!
+{
+    if (bytesToRead == 0) //"read() with a count of 0 returns zero" => indistinguishable from end of file! => check!
+        throw std::logic_error("Contract violation! " + std::string(__FILE__) + ":" + numberTo<std::string>(__LINE__));
+    assert(bytesToRead == getBlockSize());
+
+    ssize_t bytesRead = 0;
+    do
+    {
+        bytesRead = ::read(getHandle(), buffer, bytesToRead);
+    }
+    while (bytesRead < 0 && errno == EINTR); //Compare copy_reg() in copy.c: ftp://ftp.gnu.org/gnu/coreutils/coreutils-8.23.tar.xz
+
+    if (bytesRead < 0)
+        THROW_LAST_FILE_ERROR(replaceCpy(_("Cannot read file %x."), L"%x", fmtPath(getFilePath())), L"read");
+    if (static_cast<size_t>(bytesRead) > bytesToRead) //better safe than sorry
+        throw FileError(replaceCpy(_("Cannot read file %x."), L"%x", fmtPath(getFilePath())), L"ReadFile: buffer overflow."); //user should never see this
+
+    //if ::read is interrupted (EINTR) right in the middle, it will return successfully with "bytesRead < bytesToRead"
+
+    return bytesRead; //"zero indicates end of file"
+}
+
+
+size_t FileInput::read(void* buffer, size_t bytesToRead) //throw FileError, X; return "bytesToRead" bytes unless end of stream!
+{
+    const size_t blockSize = getBlockSize();
+
+    while (memBuf_.size() < bytesToRead)
+    {
+        memBuf_.resize(memBuf_.size() + blockSize);
+        const size_t bytesRead = tryRead(&*(memBuf_.end() - blockSize), blockSize); //throw FileError; may return short, only 0 means EOF! => CONTRACT: bytesToRead > 0
+        memBuf_.resize(memBuf_.size() - blockSize + bytesRead); //caveat: unsigned arithmetics
+
+        if (notifyUnbufferedIO_) notifyUnbufferedIO_(bytesRead); //throw X
+
+        if (bytesRead == 0) //end of file
+            bytesToRead = std::min(bytesToRead, memBuf_.size());
+    }
+
+    std::copy(memBuf_.begin(), memBuf_.begin() + bytesToRead, static_cast<char*>(buffer));
+    memBuf_.erase(memBuf_.begin(), memBuf_.begin() + bytesToRead);
+    return bytesToRead;
+}
+
+//----------------------------------------------------------------------------------------------------
+
+namespace
+{
+FileBase::FileHandle openHandleForWrite(const Zstring& filePath, FileOutput::AccessFlag access) //throw FileError, ErrorTargetExisting
+{
+    //checkForUnsupportedType(filePath); -> not needed, open() + O_WRONLY should fail fast
+
+    const FileBase::FileHandle fileHandle = ::open(filePath.c_str(), O_WRONLY | O_CREAT | (access == FileOutput::ACC_CREATE_NEW ? O_EXCL : O_TRUNC),
+                                                   S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH); //0666
+    if (fileHandle == -1)
+    {
+        const int ec = errno; //copy before making other system calls!
+        const std::wstring errorMsg = replaceCpy(_("Cannot write file %x."), L"%x", fmtPath(filePath));
+        const std::wstring errorDescr = formatSystemError(L"open", ec);
+
+        if (ec == EEXIST)
+            throw ErrorTargetExisting(errorMsg, errorDescr);
+        //if (ec == ENOENT) throw ErrorTargetPathMissing(errorMsg, errorDescr);
+
+        throw FileError(errorMsg, errorDescr);
+    }
+    return fileHandle; //pass ownership
+}
+}
+
+
+FileOutput::FileOutput(FileHandle handle, const Zstring& filePath, const IOCallback& notifyUnbufferedIO) :
+    FileBase(handle, filePath), notifyUnbufferedIO_(notifyUnbufferedIO) {}
+
+
+FileOutput::FileOutput(const Zstring& filePath, AccessFlag access, const IOCallback& notifyUnbufferedIO) :
+    FileBase(openHandleForWrite(filePath, access), filePath), notifyUnbufferedIO_(notifyUnbufferedIO) {} //throw FileError, ErrorTargetExisting
+
+
+FileOutput::~FileOutput()
+{
+    notifyUnbufferedIO_ = nullptr; //no call-backs during destruction!!!
+    try
+    {
+        flushBuffers(); //throw FileError, (X)
+    }
+    catch (...) { assert(false); }
+}
+
+
+size_t FileOutput::tryWrite(const void* buffer, size_t bytesToWrite) //throw FileError; may return short! CONTRACT: bytesToWrite > 0
+{
+    if (bytesToWrite == 0)
+        throw std::logic_error("Contract violation! " + std::string(__FILE__) + ":" + numberTo<std::string>(__LINE__));
+    assert(bytesToWrite <= getBlockSize());
+
+    ssize_t bytesWritten = 0;
+    do
+    {
+        bytesWritten = ::write(getHandle(), buffer, bytesToWrite);
+    }
+    while (bytesWritten < 0 && errno == EINTR);
+
+    if (bytesWritten <= 0)
+    {
+        if (bytesWritten == 0) //comment in safe-read.c suggests to treat this as an error due to buggy drivers
+            errno = ENOSPC;
+
+        THROW_LAST_FILE_ERROR(replaceCpy(_("Cannot write file %x."), L"%x", fmtPath(getFilePath())), L"write");
+    }
+    if (bytesWritten > static_cast<ssize_t>(bytesToWrite)) //better safe than sorry
+        throw FileError(replaceCpy(_("Cannot write file %x."), L"%x", fmtPath(getFilePath())), L"write: buffer overflow."); //user should never see this
+
+    //if ::write() is interrupted (EINTR) right in the middle, it will return successfully with "bytesWritten < bytesToWrite"!
+    return bytesWritten;
+}
+
+
+void FileOutput::write(const void* buffer, size_t bytesToWrite) //throw FileError, X
+{
+    auto bufFirst = static_cast<const char*>(buffer);
+    memBuf_.insert(memBuf_.end(), bufFirst, bufFirst + bytesToWrite);
+
+    const size_t blockSize = getBlockSize();
+    size_t bytesRemaining = memBuf_.size();
+    ZEN_ON_SCOPE_EXIT(memBuf_.erase(memBuf_.begin(), memBuf_.end() - bytesRemaining));
+    while (bytesRemaining >= blockSize)
+    {
+        const size_t bytesWritten = tryWrite(&*(memBuf_.end() - bytesRemaining), blockSize); //throw FileError; may return short! CONTRACT: bytesToWrite > 0
+        bytesRemaining -= bytesWritten;
+        if (notifyUnbufferedIO_) notifyUnbufferedIO_(bytesWritten); //throw X!
+    }
+}
+
+
+void FileOutput::flushBuffers() //throw FileError, X
+{
+    size_t bytesRemaining = memBuf_.size();
+    ZEN_ON_SCOPE_EXIT(memBuf_.erase(memBuf_.begin(), memBuf_.end() - bytesRemaining));
+    while (bytesRemaining > 0)
+    {
+        const size_t bytesWritten = tryWrite(&*(memBuf_.end() - bytesRemaining), bytesRemaining); //throw FileError; may return short! CONTRACT: bytesToWrite > 0
+        bytesRemaining -= bytesWritten;
+        if (notifyUnbufferedIO_) notifyUnbufferedIO_(bytesWritten); //throw X!
+    }
+}
+
+
+void FileOutput::finalize() //throw FileError, X
+{
+    flushBuffers(); //throw FileError, X
+    //~FileBase() calls this one, too, but we want to propagate errors if any:
+    close(); //throw FileError
+}
+
+
+void FileOutput::preAllocateSpaceBestEffort(uint64_t expectedSize) //throw FileError
+{
+    const FileHandle fh = getHandle();
+    //don't use potentially inefficient ::posix_fallocate!
+    const int rv = ::fallocate(fh,            //int fd,
+                               0,             //int mode,
+                               0,             //off_t offset
+                               expectedSize); //off_t len
+    if (rv != 0)
+        return; //may fail with EOPNOTSUPP, unlike posix_fallocate
+
+}
diff --git a/zen/file_io.h b/zen/file_io.h
index 827abd9e..6b0665a1 100755
--- a/zen/file_io.h
+++ b/zen/file_io.h
@@ -1,123 +1,123 @@
-// *****************************************************************************
-// * This file is part of the FreeFileSync project. It is distributed under    *
-// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
-// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
-// *****************************************************************************
-
-#ifndef FILE_IO_H_89578342758342572345
-#define FILE_IO_H_89578342758342572345
-
-#include "file_error.h"
-#include "serialize.h"
-
-
-namespace zen
-{
-    const char LINE_BREAK[] = "\n"; //since OS X apple uses newline, too
-
-/*
-OS-buffered file IO optimized for
-    - sequential read/write accesses
-    - better error reporting
-    - long path support
-    - follows symlinks
-    */
-class FileBase
-{
-public:
-    const Zstring& getFilePath() const { return filePath_; }
-
-    using FileHandle = int;
-
-    FileHandle getHandle() { return fileHandle_; }
-
-    //Windows: use 64kB ?? https://technet.microsoft.com/en-us/library/cc938632
-    //Linux: use st_blksize?
-    static size_t getBlockSize() { return 128 * 1024; };
-
-protected:
-    FileBase(FileHandle handle, const Zstring& filePath) : fileHandle_(handle), filePath_(filePath) {}
-    ~FileBase();
-
-    void close(); //throw FileError -> optional, but good place to catch errors when closing stream!
-    static const FileHandle invalidHandleValue;
-
-private:
-    FileBase           (const FileBase&) = delete;
-    FileBase& operator=(const FileBase&) = delete;
-
-    FileHandle fileHandle_ = invalidHandleValue;
-    const Zstring filePath_;
-};
-
-//-----------------------------------------------------------------------------------------------
-
-class FileInput : public FileBase
-{
-public:
-    FileInput(const Zstring& filePath, const IOCallback& notifyUnbufferedIO); //throw FileError, ErrorFileLocked
-    FileInput(FileHandle handle, const Zstring& filePath, const IOCallback& notifyUnbufferedIO); //takes ownership!
-
-    size_t read(void* buffer, size_t bytesToRead); //throw FileError, X; return "bytesToRead" bytes unless end of stream!
-
-private:
-    size_t tryRead(void* buffer, size_t bytesToRead); //throw FileError; may return short, only 0 means EOF! =>  CONTRACT: bytesToRead > 0!
-
-    std::vector<char> memBuf_;
-    const IOCallback notifyUnbufferedIO_; //throw X
-};
-
-
-class FileOutput : public FileBase
-{
-public:
-    enum AccessFlag
-    {
-        ACC_OVERWRITE,
-        ACC_CREATE_NEW
-    };
-    FileOutput(const Zstring& filePath, AccessFlag access, const IOCallback& notifyUnbufferedIO); //throw FileError, ErrorTargetExisting
-    FileOutput(FileHandle handle, const Zstring& filePath, const IOCallback& notifyUnbufferedIO); //takes ownership!
-    ~FileOutput();
-
-    void preAllocateSpaceBestEffort(uint64_t expectedSize); //throw FileError
-
-    void write(const void* buffer, size_t bytesToWrite); //throw FileError, X
-    void flushBuffers();                                 //throw FileError, X
-    void finalize(); /*= flushBuffers() + close()*/      //throw FileError, X
-
-private:
-    size_t tryWrite(const void* buffer, size_t bytesToWrite); //throw FileError; may return short! CONTRACT: bytesToWrite > 0
-
-    std::vector<char> memBuf_;
-    IOCallback notifyUnbufferedIO_; //throw X
-};
-
-//-----------------------------------------------------------------------------------------------
-
-//native stream I/O convenience functions:
-
-template <class BinContainer> inline
-BinContainer loadBinContainer(const Zstring& filePath, //throw FileError
-                              const IOCallback& notifyUnbufferedIO)
-{
-    FileInput streamIn(filePath, notifyUnbufferedIO); //throw FileError, ErrorFileLocked
-    return bufferedLoad<BinContainer>(streamIn); //throw FileError, X;
-}
-
-
-template <class BinContainer> inline
-void saveBinContainer(const Zstring& filePath, const BinContainer& buffer, //throw FileError
-                      const IOCallback& notifyUnbufferedIO)
-{
-    FileOutput fileOut(filePath, FileOutput::ACC_OVERWRITE, notifyUnbufferedIO); //throw FileError, (ErrorTargetExisting)
-    if (!buffer.empty())
-    {
-        /*snake oil?*/ fileOut.preAllocateSpaceBestEffort(buffer.size()); //throw FileError
-        fileOut.write(&*buffer.begin(), buffer.size()); //throw FileError, X
-    }
-    fileOut.finalize();                                 //throw FileError, X
-}
-}
-
-#endif //FILE_IO_H_89578342758342572345
+// *****************************************************************************
+// * This file is part of the FreeFileSync project. It is distributed under    *
+// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
+// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
+// *****************************************************************************
+
+#ifndef FILE_IO_H_89578342758342572345
+#define FILE_IO_H_89578342758342572345
+
+#include "file_error.h"
+#include "serialize.h"
+
+
+namespace zen
+{
+    const char LINE_BREAK[] = "\n"; //since OS X apple uses newline, too
+
+/*
+OS-buffered file IO optimized for
+    - sequential read/write accesses
+    - better error reporting
+    - long path support
+    - follows symlinks
+    */
+class FileBase
+{
+public:
+    const Zstring& getFilePath() const { return filePath_; }
+
+    using FileHandle = int;
+
+    FileHandle getHandle() { return fileHandle_; }
+
+    //Windows: use 64kB ?? https://technet.microsoft.com/en-us/library/cc938632
+    //Linux: use st_blksize?
+    static size_t getBlockSize() { return 128 * 1024; };
+
+protected:
+    FileBase(FileHandle handle, const Zstring& filePath) : fileHandle_(handle), filePath_(filePath) {}
+    ~FileBase();
+
+    void close(); //throw FileError -> optional, but good place to catch errors when closing stream!
+    static const FileHandle invalidHandleValue;
+
+private:
+    FileBase           (const FileBase&) = delete;
+    FileBase& operator=(const FileBase&) = delete;
+
+    FileHandle fileHandle_ = invalidHandleValue;
+    const Zstring filePath_;
+};
+
+//-----------------------------------------------------------------------------------------------
+
+class FileInput : public FileBase
+{
+public:
+    FileInput(const Zstring& filePath, const IOCallback& notifyUnbufferedIO); //throw FileError, ErrorFileLocked
+    FileInput(FileHandle handle, const Zstring& filePath, const IOCallback& notifyUnbufferedIO); //takes ownership!
+
+    size_t read(void* buffer, size_t bytesToRead); //throw FileError, X; return "bytesToRead" bytes unless end of stream!
+
+private:
+    size_t tryRead(void* buffer, size_t bytesToRead); //throw FileError; may return short, only 0 means EOF! =>  CONTRACT: bytesToRead > 0!
+
+    std::vector<char> memBuf_;
+    const IOCallback notifyUnbufferedIO_; //throw X
+};
+
+
+class FileOutput : public FileBase
+{
+public:
+    enum AccessFlag
+    {
+        ACC_OVERWRITE,
+        ACC_CREATE_NEW
+    };
+    FileOutput(const Zstring& filePath, AccessFlag access, const IOCallback& notifyUnbufferedIO); //throw FileError, ErrorTargetExisting
+    FileOutput(FileHandle handle, const Zstring& filePath, const IOCallback& notifyUnbufferedIO); //takes ownership!
+    ~FileOutput();
+
+    void preAllocateSpaceBestEffort(uint64_t expectedSize); //throw FileError
+
+    void write(const void* buffer, size_t bytesToWrite); //throw FileError, X
+    void flushBuffers();                                 //throw FileError, X
+    void finalize(); /*= flushBuffers() + close()*/      //throw FileError, X
+
+private:
+    size_t tryWrite(const void* buffer, size_t bytesToWrite); //throw FileError; may return short! CONTRACT: bytesToWrite > 0
+
+    std::vector<char> memBuf_;
+    IOCallback notifyUnbufferedIO_; //throw X
+};
+
+//-----------------------------------------------------------------------------------------------
+
+//native stream I/O convenience functions:
+
+template <class BinContainer> inline
+BinContainer loadBinContainer(const Zstring& filePath, //throw FileError
+                              const IOCallback& notifyUnbufferedIO)
+{
+    FileInput streamIn(filePath, notifyUnbufferedIO); //throw FileError, ErrorFileLocked
+    return bufferedLoad<BinContainer>(streamIn); //throw FileError, X;
+}
+
+
+template <class BinContainer> inline
+void saveBinContainer(const Zstring& filePath, const BinContainer& buffer, //throw FileError
+                      const IOCallback& notifyUnbufferedIO)
+{
+    FileOutput fileOut(filePath, FileOutput::ACC_OVERWRITE, notifyUnbufferedIO); //throw FileError, (ErrorTargetExisting)
+    if (!buffer.empty())
+    {
+        /*snake oil?*/ fileOut.preAllocateSpaceBestEffort(buffer.size()); //throw FileError
+        fileOut.write(&*buffer.begin(), buffer.size()); //throw FileError, X
+    }
+    fileOut.finalize();                                 //throw FileError, X
+}
+}
+
+#endif //FILE_IO_H_89578342758342572345
diff --git a/zen/file_traverser.cpp b/zen/file_traverser.cpp
index d5e3912b..916b6e8d 100755
--- a/zen/file_traverser.cpp
+++ b/zen/file_traverser.cpp
@@ -1,105 +1,105 @@
-// *****************************************************************************
-// * This file is part of the FreeFileSync project. It is distributed under    *
-// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
-// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
-// *****************************************************************************
-
-#include "file_traverser.h"
-#include "file_error.h"
-
-
-    #include <cstddef> //offsetof
-    #include <unistd.h> //::pathconf()
-    #include <sys/stat.h>
-    #include <dirent.h>
-
-using namespace zen;
-
-
-void zen::traverseFolder(const Zstring& dirPath,
-                         const std::function<void (const FileInfo&    fi)>& onFile,
-                         const std::function<void (const FolderInfo&  fi)>& onFolder,
-                         const std::function<void (const SymlinkInfo& si)>& onSymlink,
-                         const std::function<void (const std::wstring& errorMsg)>& onError)
-{
-    try
-    {
-        /* quote: "Since POSIX.1 does not specify the size of the d_name field, and other nonstandard fields may precede
-                   that field within the dirent structure, portable applications that use readdir_r() should allocate
-                   the buffer whose address is passed in entry as follows:
-                       len = offsetof(struct dirent, d_name) + pathconf(dirPath, _PC_NAME_MAX) + 1
-                       entryp = malloc(len); */
-        const size_t nameMax = std::max<long>(::pathconf(dirPath.c_str(), _PC_NAME_MAX), 10000); //::pathconf may return long(-1)
-        std::vector<char> buffer(offsetof(struct ::dirent, d_name) + nameMax + 1);
-
-        DIR* folder = ::opendir(dirPath.c_str()); //directory must NOT end with path separator, except "/"
-        if (!folder)
-            THROW_LAST_FILE_ERROR(replaceCpy(_("Cannot open directory %x."), L"%x", fmtPath(dirPath)), L"opendir");
-        ZEN_ON_SCOPE_EXIT(::closedir(folder)); //never close nullptr handles! -> crash
-
-        for (;;)
-        {
-            struct ::dirent* dirEntry = nullptr;
-            if (::readdir_r(folder, reinterpret_cast< ::dirent*>(&buffer[0]), &dirEntry) != 0)
-                THROW_LAST_FILE_ERROR(replaceCpy(_("Cannot read directory %x."), L"%x", fmtPath(dirPath)), L"readdir_r");
-            //don't retry but restart dir traversal on error! https://blogs.msdn.microsoft.com/oldnewthing/20140612-00/?p=753/
-
-            if (!dirEntry) //no more items
-                return;
-
-            //don't return "." and ".."
-            const char* itemNameRaw = dirEntry->d_name;
-
-            if (itemNameRaw[0] == '.' &&
-                (itemNameRaw[1] == 0 || (itemNameRaw[1] == '.' && itemNameRaw[2] == 0)))
-                continue;
-
-            const Zstring& itemName = itemNameRaw;
-            if (itemName.empty()) //checks result of osx::normalizeUtfForPosix, too!
-                throw FileError(replaceCpy(_("Cannot read directory %x."), L"%x", fmtPath(dirPath)), L"readdir_r: Data corruption; item with empty name.");
-
-            const Zstring& itemPath = appendSeparator(dirPath) + itemName;
-
-            struct ::stat statData = {};
-            try
-            {
-                if (::lstat(itemPath.c_str(), &statData) != 0) //lstat() does not resolve symlinks
-                    THROW_LAST_FILE_ERROR(replaceCpy(_("Cannot read file attributes of %x."), L"%x", fmtPath(itemPath)), L"lstat");
-            }
-            catch (const FileError& e)
-            {
-                if (onError)
-                    onError(e.toString());
-                continue; //ignore error: skip file
-            }
-
-            if (S_ISLNK(statData.st_mode)) //on Linux there is no distinction between file and directory symlinks!
-            {
-                if (onSymlink)
-                    onSymlink({ itemName, itemPath, statData.st_mtime});
-            }
-            else if (S_ISDIR(statData.st_mode)) //a directory
-            {
-                if (onFolder)
-                    onFolder({ itemName, itemPath });
-            }
-            else //a file or named pipe, ect.
-            {
-                if (onFile)
-                    onFile({ itemName, itemPath, makeUnsigned(statData.st_size), statData.st_mtime });
-            }
-            /*
-            It may be a good idea to not check "S_ISREG(statData.st_mode)" explicitly and to not issue an error message on other types to support these scenarios:
-            - RTS setup watch (essentially wants to read directories only)
-            - removeDirectory (wants to delete everything; pipes can be deleted just like files via "unlink")
-
-            However an "open" on a pipe will block (https://sourceforge.net/p/freefilesync/bugs/221/), so the copy routines need to be smarter!!
-            */
-        }
-    }
-    catch (const FileError& e)
-    {
-        if (onError)
-            onError(e.toString());
-    }
-}
+// *****************************************************************************
+// * This file is part of the FreeFileSync project. It is distributed under    *
+// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
+// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
+// *****************************************************************************
+
+#include "file_traverser.h"
+#include "file_error.h"
+
+
+    #include <cstddef> //offsetof
+    #include <unistd.h> //::pathconf()
+    #include <sys/stat.h>
+    #include <dirent.h>
+
+using namespace zen;
+
+
+void zen::traverseFolder(const Zstring& dirPath,
+                         const std::function<void (const FileInfo&    fi)>& onFile,
+                         const std::function<void (const FolderInfo&  fi)>& onFolder,
+                         const std::function<void (const SymlinkInfo& si)>& onSymlink,
+                         const std::function<void (const std::wstring& errorMsg)>& onError)
+{
+    try
+    {
+        /* quote: "Since POSIX.1 does not specify the size of the d_name field, and other nonstandard fields may precede
+                   that field within the dirent structure, portable applications that use readdir_r() should allocate
+                   the buffer whose address is passed in entry as follows:
+                       len = offsetof(struct dirent, d_name) + pathconf(dirPath, _PC_NAME_MAX) + 1
+                       entryp = malloc(len); */
+        const size_t nameMax = std::max<long>(::pathconf(dirPath.c_str(), _PC_NAME_MAX), 10000); //::pathconf may return long(-1)
+        std::vector<char> buffer(offsetof(struct ::dirent, d_name) + nameMax + 1);
+
+        DIR* folder = ::opendir(dirPath.c_str()); //directory must NOT end with path separator, except "/"
+        if (!folder)
+            THROW_LAST_FILE_ERROR(replaceCpy(_("Cannot open directory %x."), L"%x", fmtPath(dirPath)), L"opendir");
+        ZEN_ON_SCOPE_EXIT(::closedir(folder)); //never close nullptr handles! -> crash
+
+        for (;;)
+        {
+            struct ::dirent* dirEntry = nullptr;
+            if (::readdir_r(folder, reinterpret_cast< ::dirent*>(&buffer[0]), &dirEntry) != 0)
+                THROW_LAST_FILE_ERROR(replaceCpy(_("Cannot read directory %x."), L"%x", fmtPath(dirPath)), L"readdir_r");
+            //don't retry but restart dir traversal on error! https://blogs.msdn.microsoft.com/oldnewthing/20140612-00/?p=753/
+
+            if (!dirEntry) //no more items
+                return;
+
+            //don't return "." and ".."
+            const char* itemNameRaw = dirEntry->d_name;
+
+            if (itemNameRaw[0] == '.' &&
+                (itemNameRaw[1] == 0 || (itemNameRaw[1] == '.' && itemNameRaw[2] == 0)))
+                continue;
+
+            const Zstring& itemName = itemNameRaw;
+            if (itemName.empty()) //checks result of osx::normalizeUtfForPosix, too!
+                throw FileError(replaceCpy(_("Cannot read directory %x."), L"%x", fmtPath(dirPath)), L"readdir_r: Data corruption; item with empty name.");
+
+            const Zstring& itemPath = appendSeparator(dirPath) + itemName;
+
+            struct ::stat statData = {};
+            try
+            {
+                if (::lstat(itemPath.c_str(), &statData) != 0) //lstat() does not resolve symlinks
+                    THROW_LAST_FILE_ERROR(replaceCpy(_("Cannot read file attributes of %x."), L"%x", fmtPath(itemPath)), L"lstat");
+            }
+            catch (const FileError& e)
+            {
+                if (onError)
+                    onError(e.toString());
+                continue; //ignore error: skip file
+            }
+
+            if (S_ISLNK(statData.st_mode)) //on Linux there is no distinction between file and directory symlinks!
+            {
+                if (onSymlink)
+                    onSymlink({ itemName, itemPath, statData.st_mtime});
+            }
+            else if (S_ISDIR(statData.st_mode)) //a directory
+            {
+                if (onFolder)
+                    onFolder({ itemName, itemPath });
+            }
+            else //a file or named pipe, ect.
+            {
+                if (onFile)
+                    onFile({ itemName, itemPath, makeUnsigned(statData.st_size), statData.st_mtime });
+            }
+            /*
+            It may be a good idea to not check "S_ISREG(statData.st_mode)" explicitly and to not issue an error message on other types to support these scenarios:
+            - RTS setup watch (essentially wants to read directories only)
+            - removeDirectory (wants to delete everything; pipes can be deleted just like files via "unlink")
+
+            However an "open" on a pipe will block (https://sourceforge.net/p/freefilesync/bugs/221/), so the copy routines need to be smarter!!
+            */
+        }
+    }
+    catch (const FileError& e)
+    {
+        if (onError)
+            onError(e.toString());
+    }
+}
diff --git a/zen/file_traverser.h b/zen/file_traverser.h
index 0eb3bbee..79bcae11 100755
--- a/zen/file_traverser.h
+++ b/zen/file_traverser.h
@@ -1,47 +1,47 @@
-// *****************************************************************************
-// * This file is part of the FreeFileSync project. It is distributed under    *
-// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
-// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
-// *****************************************************************************
-
-#ifndef FILER_TRAVERSER_H_127463214871234
-#define FILER_TRAVERSER_H_127463214871234
-
-#include <cstdint>
-#include <functional>
-#include "zstring.h"
-
-
-namespace zen
-{
-struct FileInfo
-{
-    Zstring itemName;
-    Zstring fullPath;
-    uint64_t fileSize;     //[bytes]
-    int64_t lastWriteTime; //number of seconds since Jan. 1st 1970 UTC
-};
-
-struct FolderInfo
-{
-    Zstring itemName;
-    Zstring fullPath;
-};
-
-struct SymlinkInfo
-{
-    Zstring itemName;
-    Zstring fullPath;
-    int64_t lastWriteTime; //number of seconds since Jan. 1st 1970 UTC
-};
-
-//- non-recursive
-//- directory path may end with PATH_SEPARATOR
-void traverseFolder(const Zstring& dirPath, //noexcept
-                    const std::function<void (const FileInfo&    fi)>& onFile,          //
-                    const std::function<void (const FolderInfo&  fi)>& onFolder,        //optional
-                    const std::function<void (const SymlinkInfo& si)>& onSymlink,       //
-                    const std::function<void (const std::wstring& errorMsg)>& onError); //
-}
-
-#endif //FILER_TRAVERSER_H_127463214871234
+// *****************************************************************************
+// * This file is part of the FreeFileSync project. It is distributed under    *
+// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
+// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
+// *****************************************************************************
+
+#ifndef FILER_TRAVERSER_H_127463214871234
+#define FILER_TRAVERSER_H_127463214871234
+
+#include <cstdint>
+#include <functional>
+#include "zstring.h"
+
+
+namespace zen
+{
+struct FileInfo
+{
+    Zstring itemName;
+    Zstring fullPath;
+    uint64_t fileSize;     //[bytes]
+    int64_t lastWriteTime; //number of seconds since Jan. 1st 1970 UTC
+};
+
+struct FolderInfo
+{
+    Zstring itemName;
+    Zstring fullPath;
+};
+
+struct SymlinkInfo
+{
+    Zstring itemName;
+    Zstring fullPath;
+    int64_t lastWriteTime; //number of seconds since Jan. 1st 1970 UTC
+};
+
+//- non-recursive
+//- directory path may end with PATH_SEPARATOR
+void traverseFolder(const Zstring& dirPath, //noexcept
+                    const std::function<void (const FileInfo&    fi)>& onFile,          //
+                    const std::function<void (const FolderInfo&  fi)>& onFolder,        //optional
+                    const std::function<void (const SymlinkInfo& si)>& onSymlink,       //
+                    const std::function<void (const std::wstring& errorMsg)>& onError); //
+}
+
+#endif //FILER_TRAVERSER_H_127463214871234
diff --git a/zen/fixed_list.h b/zen/fixed_list.h
index e143c7b7..27eb488c 100755
--- a/zen/fixed_list.h
+++ b/zen/fixed_list.h
@@ -1,239 +1,239 @@
-// *****************************************************************************
-// * This file is part of the FreeFileSync project. It is distributed under    *
-// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
-// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
-// *****************************************************************************
-
-#ifndef FIXED_LIST_H_01238467085684139453534
-#define FIXED_LIST_H_01238467085684139453534
-
-#include <cassert>
-#include <iterator>
-#include "stl_tools.h"
-
-namespace zen
-{
-//std::list(C++11)-like class for inplace element construction supporting non-copyable/non-movable types
-//-> no iterator invalidation after emplace_back()
-
-template <class T>
-class FixedList
-{
-    struct Node
-    {
-        template <class... Args>
-        Node(Args&& ... args) : val(std::forward<Args>(args)...) {}
-
-        Node* next = nullptr; //singly-linked list is sufficient
-        T val;
-    };
-
-public:
-    FixedList() {}
-
-    ~FixedList() { clear(); }
-
-    template <class NodeT, class U>
-    class FixedIterator : public std::iterator<std::forward_iterator_tag, U>
-    {
-    public:
-        FixedIterator(NodeT* it = nullptr) : it_(it) {}
-        FixedIterator& operator++() { it_ = it_->next; return *this; }
-        inline friend bool operator==(const FixedIterator& lhs, const FixedIterator& rhs) { return lhs.it_ == rhs.it_; }
-        inline friend bool operator!=(const FixedIterator& lhs, const FixedIterator& rhs) { return !(lhs == rhs); }
-        U& operator* () const { return  it_->val; }
-        U* operator->() const { return &it_->val; }
-    private:
-        NodeT* it_;
-    };
-
-    using value_type      = T;
-    using iterator        = FixedIterator<      Node,       T>;
-    using const_iterator  = FixedIterator<const Node, const T>;
-    using reference       = T&;
-    using const_reference = const T&;
-
-    iterator begin() { return firstInsert_; }
-    iterator end  () { return iterator(); }
-
-    const_iterator begin() const { return firstInsert_; }
-    const_iterator end  () const { return const_iterator(); }
-
-    //const_iterator cbegin() const { return firstInsert_; }
-    //const_iterator cend  () const { return const_iterator(); }
-
-    reference       front()       { return firstInsert_->val; }
-    const_reference front() const { return firstInsert_->val; }
-
-    reference&       back()       { return lastInsert_->val; }
-    const_reference& back() const { return lastInsert_->val; }
-
-    template <class... Args>
-    void emplace_back(Args&& ... args)
-    {
-        Node* newNode = new Node(std::forward<Args>(args)...);
-
-        if (!lastInsert_)
-        {
-            assert(!firstInsert_ && sz_ == 0);
-            firstInsert_ = lastInsert_ = newNode;
-        }
-        else
-        {
-            assert(lastInsert_->next == nullptr);
-            lastInsert_->next = newNode;
-            lastInsert_ = newNode;
-        }
-        ++sz_;
-    }
-
-    template <class Predicate>
-    void remove_if(Predicate pred)
-    {
-        Node* prev = nullptr;
-        Node* ptr = firstInsert_;
-
-        while (ptr)
-            if (pred(ptr->val))
-            {
-                Node* next = ptr->next;
-
-                delete ptr;
-                assert(sz_ > 0);
-                --sz_;
-
-                ptr = next;
-
-                if (prev)
-                    prev->next = next;
-                else
-                    firstInsert_ = next;
-                if (!next)
-                    lastInsert_ = prev;
-            }
-            else
-            {
-                prev = ptr;
-                ptr = ptr->next;
-            }
-    }
-
-    void clear()
-    {
-        Node* ptr = firstInsert_;
-        while (ptr)
-        {
-            Node* next = ptr->next;
-            delete ptr;
-            ptr = next;
-        }
-
-        sz_ = 0;
-        firstInsert_ = lastInsert_ = nullptr;
-    }
-
-    bool empty() const { return sz_ == 0; }
-
-    size_t size() const { return sz_; }
-
-    void swap(FixedList& other)
-    {
-        std::swap(firstInsert_, other.firstInsert_);
-        std::swap(lastInsert_,  other.lastInsert_);
-        std::swap(sz_,          other.sz_);
-    }
-
-private:
-    FixedList           (const FixedList&) = delete;
-    FixedList& operator=(const FixedList&) = delete;
-
-    Node* firstInsert_ = nullptr;
-    Node* lastInsert_  = nullptr; //point to last insertion; required by efficient emplace_back()
-    size_t sz_ = 0;
-};
-
-
-//just as fast as FixedList, but simpler, more CPU-cache-friendly => superseeds FixedList!
-template <class T>
-class FixedVector
-{
-public:
-    FixedVector() {}
-
-    /*
-    class EndIterator {}; //just like FixedList: no iterator invalidation after emplace_back()
-
-    template <class V>
-    class FixedIterator : public std::iterator<std::forward_iterator_tag, V> //could make this random-access if needed
-    {
-    public:
-        FixedIterator(std::vector<std::unique_ptr<T>>& cont, size_t pos) : cont_(cont), pos_(pos) {}
-        FixedIterator& operator++() { ++pos_; return *this; }
-        inline friend bool operator==(const FixedIterator& lhs, EndIterator) { return lhs.pos_ == lhs.cont_.size(); }
-        inline friend bool operator!=(const FixedIterator& lhs, EndIterator) { return !(lhs == EndIterator()); }
-        V& operator* () const { return  *cont_[pos_]; }
-        V* operator->() const { return &*cont_[pos_]; }
-    private:
-        std::vector<std::unique_ptr<T>>& cont_;
-        size_t pos_ = 0;
-    };
-    */
-
-    template <class IterImpl, class V>
-    class FixedIterator : public std::iterator<std::forward_iterator_tag, V> //could make this bidirectional if needed
-    {
-    public:
-        FixedIterator(IterImpl it) : it_(it) {}
-        FixedIterator& operator++() { ++it_; return *this; }
-        inline friend bool operator==(const FixedIterator& lhs, const FixedIterator& rhs) { return lhs.it_ == rhs.it_; }
-        inline friend bool operator!=(const FixedIterator& lhs, const FixedIterator& rhs) { return !(lhs == rhs); }
-        V& operator* () const { return  **it_; }
-        V* operator->() const { return &** it_; }
-    private:
-        IterImpl it_;  //TODO: avoid iterator invalidation after emplace_back(); caveat: end() must not store old length!
-    };
-
-    using value_type      = T;
-    using iterator        = FixedIterator<typename std::vector<std::unique_ptr<T>>::iterator,             T>;
-    using const_iterator  = FixedIterator<typename std::vector<std::unique_ptr<T>>::const_iterator, const T>;
-    using reference       =       T&;
-    using const_reference = const T&;
-
-    iterator begin() { return items_.begin(); }
-    iterator end  () { return items_.end  (); }
-
-    const_iterator begin() const { return items_.begin(); }
-    const_iterator end  () const { return items_.end  (); }
-
-    reference       front()       { return *items_.front(); }
-    const_reference front() const { return *items_.front(); }
-
-    reference&       back()       { return *items_.back(); }
-    const_reference& back() const { return *items_.back(); }
-
-    template <class... Args>
-    void emplace_back(Args&& ... args)
-    {
-        items_.push_back(std::make_unique<T>(std::forward<Args>(args)...));
-    }
-
-    template <class Predicate>
-    void remove_if(Predicate pred)
-    {
-        erase_if(items_, [&](const std::unique_ptr<T>& p) { return pred(*p); });
-    }
-
-    void   clear() { items_.clear(); }
-    bool   empty() const { return items_.empty(); }
-    size_t size () const { return items_.size(); }
-    void swap(FixedVector& other) { items_.swap(other.items_); }
-
-private:
-    FixedVector           (const FixedVector&) = delete;
-    FixedVector& operator=(const FixedVector&) = delete;
-
-    std::vector<std::unique_ptr<T>> items_;
-};
-}
-
-#endif //FIXED_LIST_H_01238467085684139453534
+// *****************************************************************************
+// * This file is part of the FreeFileSync project. It is distributed under    *
+// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
+// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
+// *****************************************************************************
+
+#ifndef FIXED_LIST_H_01238467085684139453534
+#define FIXED_LIST_H_01238467085684139453534
+
+#include <cassert>
+#include <iterator>
+#include "stl_tools.h"
+
+namespace zen
+{
+//std::list(C++11)-like class for inplace element construction supporting non-copyable/non-movable types
+//-> no iterator invalidation after emplace_back()
+
+template <class T>
+class FixedList
+{
+    struct Node
+    {
+        template <class... Args>
+        Node(Args&& ... args) : val(std::forward<Args>(args)...) {}
+
+        Node* next = nullptr; //singly-linked list is sufficient
+        T val;
+    };
+
+public:
+    FixedList() {}
+
+    ~FixedList() { clear(); }
+
+    template <class NodeT, class U>
+    class FixedIterator : public std::iterator<std::forward_iterator_tag, U>
+    {
+    public:
+        FixedIterator(NodeT* it = nullptr) : it_(it) {}
+        FixedIterator& operator++() { it_ = it_->next; return *this; }
+        inline friend bool operator==(const FixedIterator& lhs, const FixedIterator& rhs) { return lhs.it_ == rhs.it_; }
+        inline friend bool operator!=(const FixedIterator& lhs, const FixedIterator& rhs) { return !(lhs == rhs); }
+        U& operator* () const { return  it_->val; }
+        U* operator->() const { return &it_->val; }
+    private:
+        NodeT* it_;
+    };
+
+    using value_type      = T;
+    using iterator        = FixedIterator<      Node,       T>;
+    using const_iterator  = FixedIterator<const Node, const T>;
+    using reference       = T&;
+    using const_reference = const T&;
+
+    iterator begin() { return firstInsert_; }
+    iterator end  () { return iterator(); }
+
+    const_iterator begin() const { return firstInsert_; }
+    const_iterator end  () const { return const_iterator(); }
+
+    //const_iterator cbegin() const { return firstInsert_; }
+    //const_iterator cend  () const { return const_iterator(); }
+
+    reference       front()       { return firstInsert_->val; }
+    const_reference front() const { return firstInsert_->val; }
+
+    reference&       back()       { return lastInsert_->val; }
+    const_reference& back() const { return lastInsert_->val; }
+
+    template <class... Args>
+    void emplace_back(Args&& ... args)
+    {
+        Node* newNode = new Node(std::forward<Args>(args)...);
+
+        if (!lastInsert_)
+        {
+            assert(!firstInsert_ && sz_ == 0);
+            firstInsert_ = lastInsert_ = newNode;
+        }
+        else
+        {
+            assert(lastInsert_->next == nullptr);
+            lastInsert_->next = newNode;
+            lastInsert_ = newNode;
+        }
+        ++sz_;
+    }
+
+    template <class Predicate>
+    void remove_if(Predicate pred)
+    {
+        Node* prev = nullptr;
+        Node* ptr = firstInsert_;
+
+        while (ptr)
+            if (pred(ptr->val))
+            {
+                Node* next = ptr->next;
+
+                delete ptr;
+                assert(sz_ > 0);
+                --sz_;
+
+                ptr = next;
+
+                if (prev)
+                    prev->next = next;
+                else
+                    firstInsert_ = next;
+                if (!next)
+                    lastInsert_ = prev;
+            }
+            else
+            {
+                prev = ptr;
+                ptr = ptr->next;
+            }
+    }
+
+    void clear()
+    {
+        Node* ptr = firstInsert_;
+        while (ptr)
+        {
+            Node* next = ptr->next;
+            delete ptr;
+            ptr = next;
+        }
+
+        sz_ = 0;
+        firstInsert_ = lastInsert_ = nullptr;
+    }
+
+    bool empty() const { return sz_ == 0; }
+
+    size_t size() const { return sz_; }
+
+    void swap(FixedList& other)
+    {
+        std::swap(firstInsert_, other.firstInsert_);
+        std::swap(lastInsert_,  other.lastInsert_);
+        std::swap(sz_,          other.sz_);
+    }
+
+private:
+    FixedList           (const FixedList&) = delete;
+    FixedList& operator=(const FixedList&) = delete;
+
+    Node* firstInsert_ = nullptr;
+    Node* lastInsert_  = nullptr; //point to last insertion; required by efficient emplace_back()
+    size_t sz_ = 0;
+};
+
+
+//just as fast as FixedList, but simpler, more CPU-cache-friendly => superseeds FixedList!
+template <class T>
+class FixedVector
+{
+public:
+    FixedVector() {}
+
+    /*
+    class EndIterator {}; //just like FixedList: no iterator invalidation after emplace_back()
+
+    template <class V>
+    class FixedIterator : public std::iterator<std::forward_iterator_tag, V> //could make this random-access if needed
+    {
+    public:
+        FixedIterator(std::vector<std::unique_ptr<T>>& cont, size_t pos) : cont_(cont), pos_(pos) {}
+        FixedIterator& operator++() { ++pos_; return *this; }
+        inline friend bool operator==(const FixedIterator& lhs, EndIterator) { return lhs.pos_ == lhs.cont_.size(); }
+        inline friend bool operator!=(const FixedIterator& lhs, EndIterator) { return !(lhs == EndIterator()); }
+        V& operator* () const { return  *cont_[pos_]; }
+        V* operator->() const { return &*cont_[pos_]; }
+    private:
+        std::vector<std::unique_ptr<T>>& cont_;
+        size_t pos_ = 0;
+    };
+    */
+
+    template <class IterImpl, class V>
+    class FixedIterator : public std::iterator<std::forward_iterator_tag, V> //could make this bidirectional if needed
+    {
+    public:
+        FixedIterator(IterImpl it) : it_(it) {}
+        FixedIterator& operator++() { ++it_; return *this; }
+        inline friend bool operator==(const FixedIterator& lhs, const FixedIterator& rhs) { return lhs.it_ == rhs.it_; }
+        inline friend bool operator!=(const FixedIterator& lhs, const FixedIterator& rhs) { return !(lhs == rhs); }
+        V& operator* () const { return  **it_; }
+        V* operator->() const { return &** it_; }
+    private:
+        IterImpl it_;  //TODO: avoid iterator invalidation after emplace_back(); caveat: end() must not store old length!
+    };
+
+    using value_type      = T;
+    using iterator        = FixedIterator<typename std::vector<std::unique_ptr<T>>::iterator,             T>;
+    using const_iterator  = FixedIterator<typename std::vector<std::unique_ptr<T>>::const_iterator, const T>;
+    using reference       =       T&;
+    using const_reference = const T&;
+
+    iterator begin() { return items_.begin(); }
+    iterator end  () { return items_.end  (); }
+
+    const_iterator begin() const { return items_.begin(); }
+    const_iterator end  () const { return items_.end  (); }
+
+    reference       front()       { return *items_.front(); }
+    const_reference front() const { return *items_.front(); }
+
+    reference&       back()       { return *items_.back(); }
+    const_reference& back() const { return *items_.back(); }
+
+    template <class... Args>
+    void emplace_back(Args&& ... args)
+    {
+        items_.push_back(std::make_unique<T>(std::forward<Args>(args)...));
+    }
+
+    template <class Predicate>
+    void remove_if(Predicate pred)
+    {
+        erase_if(items_, [&](const std::unique_ptr<T>& p) { return pred(*p); });
+    }
+
+    void   clear() { items_.clear(); }
+    bool   empty() const { return items_.empty(); }
+    size_t size () const { return items_.size(); }
+    void swap(FixedVector& other) { items_.swap(other.items_); }
+
+private:
+    FixedVector           (const FixedVector&) = delete;
+    FixedVector& operator=(const FixedVector&) = delete;
+
+    std::vector<std::unique_ptr<T>> items_;
+};
+}
+
+#endif //FIXED_LIST_H_01238467085684139453534
diff --git a/zen/format_unit.cpp b/zen/format_unit.cpp
index a2208b3e..c0667fb1 100755
--- a/zen/format_unit.cpp
+++ b/zen/format_unit.cpp
@@ -1,201 +1,201 @@
-// *****************************************************************************
-// * This file is part of the FreeFileSync project. It is distributed under    *
-// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
-// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
-// *****************************************************************************
-
-#include "format_unit.h"
-//#include <cwchar> //swprintf
-#include <ctime>
-#include <cstdio>
-#include "basic_math.h"
-#include "i18n.h"
-#include "time.h"
-#include "globals.h"
-
-    #include <clocale> //thousands separator
-    #include "utf.h"   //
-
-using namespace zen;
-
-
-std::wstring zen::formatTwoDigitPrecision(double value)
-{
-    //print two digits: 0,1 | 1,1 | 11
-    if (numeric::abs(value) < 9.95) //9.99 must not be formatted as "10.0"
-        return printNumber<std::wstring>(L"%.1f", value);
-    return numberTo<std::wstring>(numeric::round(value));
-}
-
-
-std::wstring zen::formatThreeDigitPrecision(double value)
-{
-    //print three digits: 0,01 | 0,11 | 1,11 | 11,1 | 111
-    if (numeric::abs(value) < 9.995) //9.999 must not be formatted as "10.00"
-        return printNumber<std::wstring>(L"%.2f", value);
-    if (numeric::abs(value) < 99.95) //99.99 must not be formatted as "100.0"
-        return printNumber<std::wstring>(L"%.1f", value);
-    return numberTo<std::wstring>(numeric::round(value));
-}
-
-
-std::wstring zen::filesizeToShortString(int64_t size)
-{
-    //if (size < 0) return _("Error"); -> really?
-
-    if (numeric::abs(size) <= 999)
-        return _P("1 byte", "%x bytes", static_cast<int>(size));
-
-    double sizeInUnit = static_cast<double>(size);
-
-    auto formatUnit = [&](const std::wstring& unitTxt) { return replaceCpy(unitTxt, L"%x", formatThreeDigitPrecision(sizeInUnit)); };
-
-    sizeInUnit /= 1024;
-    if (numeric::abs(sizeInUnit) < 999.5)
-        return formatUnit(_("%x KB"));
-
-    sizeInUnit /= 1024;
-    if (numeric::abs(sizeInUnit) < 999.5)
-        return formatUnit(_("%x MB"));
-
-    sizeInUnit /= 1024;
-    if (numeric::abs(sizeInUnit) < 999.5)
-        return formatUnit(_("%x GB"));
-
-    sizeInUnit /= 1024;
-    if (numeric::abs(sizeInUnit) < 999.5)
-        return formatUnit(_("%x TB"));
-
-    sizeInUnit /= 1024;
-    return formatUnit(_("%x PB"));
-}
-
-
-namespace
-{
-enum UnitRemTime
-{
-    URT_SEC,
-    URT_MIN,
-    URT_HOUR,
-    URT_DAY
-};
-
-
-std::wstring formatUnitTime(int val, UnitRemTime unit)
-{
-    switch (unit)
-    {
-        case URT_SEC:
-            return _P("1 sec", "%x sec", val);
-        case URT_MIN:
-            return _P("1 min", "%x min", val);
-        case URT_HOUR:
-            return _P("1 hour", "%x hours", val);
-        case URT_DAY:
-            return _P("1 day", "%x days", val);
-    }
-    assert(false);
-    return _("Error");
-}
-
-
-template <int M, int N>
-std::wstring roundToBlock(double timeInHigh,
-                          UnitRemTime unitHigh, const int (&stepsHigh)[M],
-                          int unitLowPerHigh,
-                          UnitRemTime unitLow, const int (&stepsLow)[N])
-{
-    assert(unitLowPerHigh > 0);
-    const double granularity = 0.1;
-    const double timeInLow = timeInHigh * unitLowPerHigh;
-    const int blockSizeLow = granularity * timeInHigh < 1 ?
-                             numeric::nearMatch(granularity * timeInLow,  std::begin(stepsLow),  std::end(stepsLow)):
-                             numeric::nearMatch(granularity * timeInHigh, std::begin(stepsHigh), std::end(stepsHigh)) * unitLowPerHigh;
-    const int roundedtimeInLow = numeric::round(timeInLow / blockSizeLow) * blockSizeLow;
-
-    std::wstring output = formatUnitTime(roundedtimeInLow / unitLowPerHigh, unitHigh);
-    if (unitLowPerHigh > blockSizeLow)
-        output += L" " + formatUnitTime(roundedtimeInLow % unitLowPerHigh, unitLow);
-    return output;
-};
-}
-
-
-std::wstring zen::remainingTimeToString(double timeInSec)
-{
-    const int steps10[] = { 1, 2, 5, 10 };
-    const int steps24[] = { 1, 2, 3, 4, 6, 8, 12, 24 };
-    const int steps60[] = { 1, 2, 5, 10, 15, 20, 30, 60 };
-
-    //determine preferred unit
-    double timeInUnit = timeInSec;
-    if (timeInUnit <= 60)
-        return roundToBlock(timeInUnit, URT_SEC, steps60, 1, URT_SEC, steps60);
-
-    timeInUnit /= 60;
-    if (timeInUnit <= 60)
-        return roundToBlock(timeInUnit, URT_MIN, steps60, 60, URT_SEC, steps60);
-
-    timeInUnit /= 60;
-    if (timeInUnit <= 24)
-        return roundToBlock(timeInUnit, URT_HOUR, steps24, 60, URT_MIN, steps60);
-
-    timeInUnit /= 24;
-    return roundToBlock(timeInUnit, URT_DAY, steps10, 24, URT_HOUR, steps24);
-    //note: for 10% granularity steps10 yields a valid blocksize only up to timeInUnit == 100!
-    //for larger time sizes this results in a finer granularity than expected: 10 days -> should not be a problem considering "usual" remaining time for synchronization
-}
-
-
-//std::wstring zen::fractionToString1Dec(double fraction)
-//{
-//    return printNumber<std::wstring>(L"%.1f", fraction * 100.0) + L'%'; //no need to internationalize fraction!?
-//}
-
-
-std::wstring zen::fractionToString(double fraction)
-{
-    return printNumber<std::wstring>(L"%.2f", fraction * 100.0) + L'%'; //no need to internationalize fraction!?
-}
-
-
-
-
-std::wstring zen::ffs_Impl::includeNumberSeparator(const std::wstring& number)
-{
-    //we have to include thousands separator ourselves; this doesn't work for all countries (e.g india), but is better than nothing
-
-    //::setlocale (LC_ALL, ""); -> implicitly called by wxLocale
-    const lconv* localInfo = ::localeconv(); //always bound according to doc
-    const std::wstring& thousandSep = utfTo<std::wstring>(localInfo->thousands_sep);
-
-    // THOUSANDS_SEPARATOR = std::use_facet<std::numpunct<wchar_t>>(std::locale("")).thousands_sep(); - why not working?
-    // DECIMAL_POINT       = std::use_facet<std::numpunct<wchar_t>>(std::locale("")).decimal_point();
-
-    std::wstring output(number);
-    size_t i = output.size();
-    for (;;)
-    {
-        if (i <= 3)
-            break;
-        i -= 3;
-        if (!isDigit(output[i - 1])) //stop on +, - signs
-            break;
-        output.insert(i, thousandSep);
-    }
-    return output;
-}
-
-
-std::wstring zen::utcToLocalTimeString(int64_t utcTime)
-{
-    auto errorMsg = [&] { return _("Error") + L" (time_t: " + numberTo<std::wstring>(utcTime) + L")"; };
-
-    TimeComp loc = getLocalTime(utcTime);
-
-    std::wstring dateString = formatTime<std::wstring>(L"%x  %X", loc);
-    return !dateString.empty() ? dateString : errorMsg();
-}
-
-
+// *****************************************************************************
+// * This file is part of the FreeFileSync project. It is distributed under    *
+// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
+// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
+// *****************************************************************************
+
+#include "format_unit.h"
+//#include <cwchar> //swprintf
+#include <ctime>
+#include <cstdio>
+#include "basic_math.h"
+#include "i18n.h"
+#include "time.h"
+#include "globals.h"
+
+    #include <clocale> //thousands separator
+    #include "utf.h"   //
+
+using namespace zen;
+
+
+std::wstring zen::formatTwoDigitPrecision(double value)
+{
+    //print two digits: 0,1 | 1,1 | 11
+    if (numeric::abs(value) < 9.95) //9.99 must not be formatted as "10.0"
+        return printNumber<std::wstring>(L"%.1f", value);
+    return numberTo<std::wstring>(numeric::round(value));
+}
+
+
+std::wstring zen::formatThreeDigitPrecision(double value)
+{
+    //print three digits: 0,01 | 0,11 | 1,11 | 11,1 | 111
+    if (numeric::abs(value) < 9.995) //9.999 must not be formatted as "10.00"
+        return printNumber<std::wstring>(L"%.2f", value);
+    if (numeric::abs(value) < 99.95) //99.99 must not be formatted as "100.0"
+        return printNumber<std::wstring>(L"%.1f", value);
+    return numberTo<std::wstring>(numeric::round(value));
+}
+
+
+std::wstring zen::filesizeToShortString(int64_t size)
+{
+    //if (size < 0) return _("Error"); -> really?
+
+    if (numeric::abs(size) <= 999)
+        return _P("1 byte", "%x bytes", static_cast<int>(size));
+
+    double sizeInUnit = static_cast<double>(size);
+
+    auto formatUnit = [&](const std::wstring& unitTxt) { return replaceCpy(unitTxt, L"%x", formatThreeDigitPrecision(sizeInUnit)); };
+
+    sizeInUnit /= 1024;
+    if (numeric::abs(sizeInUnit) < 999.5)
+        return formatUnit(_("%x KB"));
+
+    sizeInUnit /= 1024;
+    if (numeric::abs(sizeInUnit) < 999.5)
+        return formatUnit(_("%x MB"));
+
+    sizeInUnit /= 1024;
+    if (numeric::abs(sizeInUnit) < 999.5)
+        return formatUnit(_("%x GB"));
+
+    sizeInUnit /= 1024;
+    if (numeric::abs(sizeInUnit) < 999.5)
+        return formatUnit(_("%x TB"));
+
+    sizeInUnit /= 1024;
+    return formatUnit(_("%x PB"));
+}
+
+
+namespace
+{
+enum UnitRemTime
+{
+    URT_SEC,
+    URT_MIN,
+    URT_HOUR,
+    URT_DAY
+};
+
+
+std::wstring formatUnitTime(int val, UnitRemTime unit)
+{
+    switch (unit)
+    {
+        case URT_SEC:
+            return _P("1 sec", "%x sec", val);
+        case URT_MIN:
+            return _P("1 min", "%x min", val);
+        case URT_HOUR:
+            return _P("1 hour", "%x hours", val);
+        case URT_DAY:
+            return _P("1 day", "%x days", val);
+    }
+    assert(false);
+    return _("Error");
+}
+
+
+template <int M, int N>
+std::wstring roundToBlock(double timeInHigh,
+                          UnitRemTime unitHigh, const int (&stepsHigh)[M],
+                          int unitLowPerHigh,
+                          UnitRemTime unitLow, const int (&stepsLow)[N])
+{
+    assert(unitLowPerHigh > 0);
+    const double granularity = 0.1;
+    const double timeInLow = timeInHigh * unitLowPerHigh;
+    const int blockSizeLow = granularity * timeInHigh < 1 ?
+                             numeric::nearMatch(granularity * timeInLow,  std::begin(stepsLow),  std::end(stepsLow)):
+                             numeric::nearMatch(granularity * timeInHigh, std::begin(stepsHigh), std::end(stepsHigh)) * unitLowPerHigh;
+    const int roundedtimeInLow = numeric::round(timeInLow / blockSizeLow) * blockSizeLow;
+
+    std::wstring output = formatUnitTime(roundedtimeInLow / unitLowPerHigh, unitHigh);
+    if (unitLowPerHigh > blockSizeLow)
+        output += L" " + formatUnitTime(roundedtimeInLow % unitLowPerHigh, unitLow);
+    return output;
+};
+}
+
+
+std::wstring zen::remainingTimeToString(double timeInSec)
+{
+    const int steps10[] = { 1, 2, 5, 10 };
+    const int steps24[] = { 1, 2, 3, 4, 6, 8, 12, 24 };
+    const int steps60[] = { 1, 2, 5, 10, 15, 20, 30, 60 };
+
+    //determine preferred unit
+    double timeInUnit = timeInSec;
+    if (timeInUnit <= 60)
+        return roundToBlock(timeInUnit, URT_SEC, steps60, 1, URT_SEC, steps60);
+
+    timeInUnit /= 60;
+    if (timeInUnit <= 60)
+        return roundToBlock(timeInUnit, URT_MIN, steps60, 60, URT_SEC, steps60);
+
+    timeInUnit /= 60;
+    if (timeInUnit <= 24)
+        return roundToBlock(timeInUnit, URT_HOUR, steps24, 60, URT_MIN, steps60);
+
+    timeInUnit /= 24;
+    return roundToBlock(timeInUnit, URT_DAY, steps10, 24, URT_HOUR, steps24);
+    //note: for 10% granularity steps10 yields a valid blocksize only up to timeInUnit == 100!
+    //for larger time sizes this results in a finer granularity than expected: 10 days -> should not be a problem considering "usual" remaining time for synchronization
+}
+
+
+//std::wstring zen::fractionToString1Dec(double fraction)
+//{
+//    return printNumber<std::wstring>(L"%.1f", fraction * 100.0) + L'%'; //no need to internationalize fraction!?
+//}
+
+
+std::wstring zen::fractionToString(double fraction)
+{
+    return printNumber<std::wstring>(L"%.2f", fraction * 100.0) + L'%'; //no need to internationalize fraction!?
+}
+
+
+
+
+std::wstring zen::ffs_Impl::includeNumberSeparator(const std::wstring& number)
+{
+    //we have to include thousands separator ourselves; this doesn't work for all countries (e.g india), but is better than nothing
+
+    //::setlocale (LC_ALL, ""); -> implicitly called by wxLocale
+    const lconv* localInfo = ::localeconv(); //always bound according to doc
+    const std::wstring& thousandSep = utfTo<std::wstring>(localInfo->thousands_sep);
+
+    // THOUSANDS_SEPARATOR = std::use_facet<std::numpunct<wchar_t>>(std::locale("")).thousands_sep(); - why not working?
+    // DECIMAL_POINT       = std::use_facet<std::numpunct<wchar_t>>(std::locale("")).decimal_point();
+
+    std::wstring output(number);
+    size_t i = output.size();
+    for (;;)
+    {
+        if (i <= 3)
+            break;
+        i -= 3;
+        if (!isDigit(output[i - 1])) //stop on +, - signs
+            break;
+        output.insert(i, thousandSep);
+    }
+    return output;
+}
+
+
+std::wstring zen::utcToLocalTimeString(int64_t utcTime)
+{
+    auto errorMsg = [&] { return _("Error") + L" (time_t: " + numberTo<std::wstring>(utcTime) + L")"; };
+
+    TimeComp loc = getLocalTime(utcTime);
+
+    std::wstring dateString = formatTime<std::wstring>(L"%x  %X", loc);
+    return !dateString.empty() ? dateString : errorMsg();
+}
+
+
diff --git a/zen/format_unit.h b/zen/format_unit.h
index fc79738a..336df74c 100755
--- a/zen/format_unit.h
+++ b/zen/format_unit.h
@@ -1,53 +1,53 @@
-// *****************************************************************************
-// * This file is part of the FreeFileSync project. It is distributed under    *
-// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
-// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
-// *****************************************************************************
-
-#ifndef FMT_UNIT_8702184019487324
-#define FMT_UNIT_8702184019487324
-
-#include <string>
-#include <cstdint>
-#include "optional.h"
-#include "string_tools.h"
-
-
-namespace zen
-{
-std::wstring filesizeToShortString(int64_t filesize);
-std::wstring remainingTimeToString(double timeInSec);
-std::wstring fractionToString(double fraction); //within [0, 1]
-std::wstring utcToLocalTimeString(int64_t utcTime); //like Windows Explorer would...
-
-std::wstring formatTwoDigitPrecision  (double value); //format with fixed number of digits
-std::wstring formatThreeDigitPrecision(double value); //(unless value is too large)
-
-template <class NumberType>
-std::wstring toGuiString(NumberType number); //format integer number including thousands separator
-
-
-
-
-
-
-
-
-
-
-
-//--------------- inline impelementation -------------------------------------------
-namespace ffs_Impl
-{
-std::wstring includeNumberSeparator(const std::wstring& number);
-}
-
-template <class NumberType> inline
-std::wstring toGuiString(NumberType number)
-{
-    static_assert(IsInteger<NumberType>::value, "");
-    return ffs_Impl::includeNumberSeparator(zen::numberTo<std::wstring>(number));
-}
-}
-
-#endif
+// *****************************************************************************
+// * This file is part of the FreeFileSync project. It is distributed under    *
+// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
+// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
+// *****************************************************************************
+
+#ifndef FMT_UNIT_8702184019487324
+#define FMT_UNIT_8702184019487324
+
+#include <string>
+#include <cstdint>
+#include "optional.h"
+#include "string_tools.h"
+
+
+namespace zen
+{
+std::wstring filesizeToShortString(int64_t filesize);
+std::wstring remainingTimeToString(double timeInSec);
+std::wstring fractionToString(double fraction); //within [0, 1]
+std::wstring utcToLocalTimeString(int64_t utcTime); //like Windows Explorer would...
+
+std::wstring formatTwoDigitPrecision  (double value); //format with fixed number of digits
+std::wstring formatThreeDigitPrecision(double value); //(unless value is too large)
+
+template <class NumberType>
+std::wstring toGuiString(NumberType number); //format integer number including thousands separator
+
+
+
+
+
+
+
+
+
+
+
+//--------------- inline impelementation -------------------------------------------
+namespace ffs_Impl
+{
+std::wstring includeNumberSeparator(const std::wstring& number);
+}
+
+template <class NumberType> inline
+std::wstring toGuiString(NumberType number)
+{
+    static_assert(IsInteger<NumberType>::value, "");
+    return ffs_Impl::includeNumberSeparator(zen::numberTo<std::wstring>(number));
+}
+}
+
+#endif
diff --git a/zen/globals.h b/zen/globals.h
index b6c5dd28..b85d5f77 100755
--- a/zen/globals.h
+++ b/zen/globals.h
@@ -1,65 +1,65 @@
-// *****************************************************************************
-// * This file is part of the FreeFileSync project. It is distributed under    *
-// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
-// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
-// *****************************************************************************
-
-#ifndef GLOBALS_H_8013740213748021573485
-#define GLOBALS_H_8013740213748021573485
-
-#include <atomic>
-#include <memory>
-#include "scope_guard.h"
-
-namespace zen
-{
-//solve static destruction order fiasco by providing shared ownership and serialized access to global variables
-template <class T>
-class Global
-{
-public:
-    Global()
-    {
-        static_assert(std::is_trivially_destructible<Pod>::value, "this memory needs to live forever");
-        assert(!pod.inst && !pod.spinLock); //we depend on static zero-initialization!
-    }
-    explicit Global(std::unique_ptr<T>&& newInst) { set(std::move(newInst)); }
-    ~Global() { set(nullptr); }
-
-    std::shared_ptr<T> get() //=> return std::shared_ptr to let instance life time be handled by caller (MT usage!)
-    {
-        while (pod.spinLock.exchange(true)) ;
-        ZEN_ON_SCOPE_EXIT(pod.spinLock = false);
-        if (pod.inst)
-            return *pod.inst;
-        return nullptr;
-    }
-
-    void set(std::unique_ptr<T>&& newInst)
-    {
-        std::shared_ptr<T>* tmpInst = nullptr;
-        if (newInst)
-            tmpInst = new std::shared_ptr<T>(std::move(newInst));
-        {
-            while (pod.spinLock.exchange(true)) ;
-            ZEN_ON_SCOPE_EXIT(pod.spinLock = false);
-            std::swap(pod.inst, tmpInst);
-        }
-        delete tmpInst;
-    }
-
-private:
-    //avoid static destruction order fiasco: there may be accesses to "Global<T>::get()" during process shutdown
-    //e.g. _("") used by message in debug_minidump.cpp or by some detached thread assembling an error message!
-    //=> use trivially-destructible POD only!!!
-    struct Pod
-    {
-        std::shared_ptr<T>* inst;   // = nullptr;
-        std::atomic<bool> spinLock; // { false }; rely entirely on static zero-initialization! => avoid potential contention with worker thread during Global<> construction!
-        //serialize access; can't use std::mutex: has non-trival destructor
-    } pod;
-};
-
-}
-
-#endif //GLOBALS_H_8013740213748021573485
+// *****************************************************************************
+// * This file is part of the FreeFileSync project. It is distributed under    *
+// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
+// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
+// *****************************************************************************
+
+#ifndef GLOBALS_H_8013740213748021573485
+#define GLOBALS_H_8013740213748021573485
+
+#include <atomic>
+#include <memory>
+#include "scope_guard.h"
+
+namespace zen
+{
+//solve static destruction order fiasco by providing shared ownership and serialized access to global variables
+template <class T>
+class Global
+{
+public:
+    Global()
+    {
+        static_assert(std::is_trivially_destructible<Pod>::value, "this memory needs to live forever");
+        assert(!pod.inst && !pod.spinLock); //we depend on static zero-initialization!
+    }
+    explicit Global(std::unique_ptr<T>&& newInst) { set(std::move(newInst)); }
+    ~Global() { set(nullptr); }
+
+    std::shared_ptr<T> get() //=> return std::shared_ptr to let instance life time be handled by caller (MT usage!)
+    {
+        while (pod.spinLock.exchange(true)) ;
+        ZEN_ON_SCOPE_EXIT(pod.spinLock = false);
+        if (pod.inst)
+            return *pod.inst;
+        return nullptr;
+    }
+
+    void set(std::unique_ptr<T>&& newInst)
+    {
+        std::shared_ptr<T>* tmpInst = nullptr;
+        if (newInst)
+            tmpInst = new std::shared_ptr<T>(std::move(newInst));
+        {
+            while (pod.spinLock.exchange(true)) ;
+            ZEN_ON_SCOPE_EXIT(pod.spinLock = false);
+            std::swap(pod.inst, tmpInst);
+        }
+        delete tmpInst;
+    }
+
+private:
+    //avoid static destruction order fiasco: there may be accesses to "Global<T>::get()" during process shutdown
+    //e.g. _("") used by message in debug_minidump.cpp or by some detached thread assembling an error message!
+    //=> use trivially-destructible POD only!!!
+    struct Pod
+    {
+        std::shared_ptr<T>* inst;   // = nullptr;
+        std::atomic<bool> spinLock; // { false }; rely entirely on static zero-initialization! => avoid potential contention with worker thread during Global<> construction!
+        //serialize access; can't use std::mutex: has non-trival destructor
+    } pod;
+};
+
+}
+
+#endif //GLOBALS_H_8013740213748021573485
diff --git a/zen/guid.h b/zen/guid.h
index 052f3fdc..d88578a6 100755
--- a/zen/guid.h
+++ b/zen/guid.h
@@ -1,30 +1,30 @@
-// *****************************************************************************
-// * This file is part of the FreeFileSync project. It is distributed under    *
-// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
-// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
-// *****************************************************************************
-
-#ifndef GUID_H_80425780237502345
-#define GUID_H_80425780237502345
-
-#include <string>
-
-    #pragma GCC diagnostic push
-    #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-#include <boost/uuid/uuid_generators.hpp>
-    #pragma GCC diagnostic pop
-
-
-namespace zen
-{
-inline
-std::string generateGUID() //creates a 16-byte GUID
-{
-    boost::uuids::uuid nativeRep = boost::uuids::random_generator()();
-    //generator is only thread-safe like an int, so we keep it local until we need to optimize perf
-    //perf: generator: 0.22ms per call; retrieve GUID: 0.12�s per call
-    return std::string(nativeRep.begin(), nativeRep.end());
-}
-}
-
-#endif //GUID_H_80425780237502345
+// *****************************************************************************
+// * This file is part of the FreeFileSync project. It is distributed under    *
+// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
+// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
+// *****************************************************************************
+
+#ifndef GUID_H_80425780237502345
+#define GUID_H_80425780237502345
+
+#include <string>
+
+    #pragma GCC diagnostic push
+    #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#include <boost/uuid/uuid_generators.hpp>
+    #pragma GCC diagnostic pop
+
+
+namespace zen
+{
+inline
+std::string generateGUID() //creates a 16-byte GUID
+{
+    boost::uuids::uuid nativeRep = boost::uuids::random_generator()();
+    //generator is only thread-safe like an int, so we keep it local until we need to optimize perf
+    //perf: generator: 0.22ms per call; retrieve GUID: 0.12�s per call
+    return std::string(nativeRep.begin(), nativeRep.end());
+}
+}
+
+#endif //GUID_H_80425780237502345
diff --git a/zen/i18n.h b/zen/i18n.h
index ef3f3706..c7d1d5dc 100755
--- a/zen/i18n.h
+++ b/zen/i18n.h
@@ -1,119 +1,119 @@
-// *****************************************************************************
-// * This file is part of the FreeFileSync project. It is distributed under    *
-// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
-// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
-// *****************************************************************************
-
-#ifndef I18_N_H_3843489325044253425456
-#define I18_N_H_3843489325044253425456
-
-#include <string>
-#include <cstdint>
-#include "globals.h"
-#include "string_tools.h"
-#include "format_unit.h"
-
-//minimal layer enabling text translation - without platform/library dependencies!
-
-#define ZEN_TRANS_CONCAT_SUB(X, Y) X ## Y
-#define _(s) zen::implementation::translate(ZEN_TRANS_CONCAT_SUB(L, s))
-#define _P(s, p, n) zen::implementation::translate(ZEN_TRANS_CONCAT_SUB(L, s), ZEN_TRANS_CONCAT_SUB(L, p), n)
-//source and translation are required to use %x as number placeholder
-//for plural form, which will be substituted automatically!!!
-
-namespace zen
-{
-//implement handler to enable program-wide localizations:
-struct TranslationHandler
-{
-    //THREAD-SAFETY: "const" member must model thread-safe access!
-    TranslationHandler() {}
-    virtual ~TranslationHandler() {}
-
-    //C++11: std::wstring should be thread-safe like an int
-    virtual std::wstring translate(const std::wstring& text) const = 0; //simple translation
-    virtual std::wstring translate(const std::wstring& singular, const std::wstring& plural, int64_t n) const = 0;
-
-private:
-    TranslationHandler           (const TranslationHandler&) = delete;
-    TranslationHandler& operator=(const TranslationHandler&) = delete;
-};
-
-void setTranslator(std::unique_ptr<const TranslationHandler>&& newHandler); //take ownership
-std::shared_ptr<const TranslationHandler> getTranslator();
-
-
-
-
-
-
-
-
-
-
-
-
-
-//######################## implementation ##############################
-namespace implementation
-{
-inline
-std::wstring translate(const std::wstring& text)
-{
-    if (std::shared_ptr<const TranslationHandler> t = getTranslator()) //std::shared_ptr => temporarily take (shared) ownership while using the interface!
-        return t->translate(text);
-    return text;
-}
-
-
-//translate plural forms: "%x day" "%x days"
-//returns "1 day" if n == 1; "123 days" if n == 123 for english language
-inline
-std::wstring translate(const std::wstring& singular, const std::wstring& plural, int64_t n)
-{
-    assert(contains(plural, L"%x"));
-
-    if (std::shared_ptr<const TranslationHandler> t = getTranslator())
-    {
-        std::wstring translation = t->translate(singular, plural, n);
-        assert(!contains(translation, L"%x"));
-        return translation;
-    }
-
-    return replaceCpy(std::abs(n) == 1 ? singular : plural, L"%x", toGuiString(n));
-}
-
-
-template <class T> inline
-std::wstring translate(const std::wstring& singular, const std::wstring& plural, T n)
-{
-    static_assert(sizeof(n) <= sizeof(int64_t), "");
-    return translate(singular, plural, static_cast<int64_t>(n));
-}
-
-
-inline
-Global<const TranslationHandler>& refGlobalTranslationHandler()
-{
-    //getTranslator() may be called even after static objects of this translation unit are destroyed!
-    static Global<const TranslationHandler> inst; //external linkage even in header!
-    return inst;
-}
-}
-
-
-inline
-void setTranslator(std::unique_ptr<const TranslationHandler>&& newHandler)
-{
-    implementation::refGlobalTranslationHandler().set(std::move(newHandler));
-}
-
-
-inline
-std::shared_ptr<const TranslationHandler> getTranslator()
-{
-    return implementation::refGlobalTranslationHandler().get();
-}
-}
-
-#endif //I18_N_H_3843489325044253425456
+// *****************************************************************************
+// * This file is part of the FreeFileSync project. It is distributed under    *
+// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
+// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
+// *****************************************************************************
+
+#ifndef I18_N_H_3843489325044253425456
+#define I18_N_H_3843489325044253425456
+
+#include <string>
+#include <cstdint>
+#include "globals.h"
+#include "string_tools.h"
+#include "format_unit.h"
+
+//minimal layer enabling text translation - without platform/library dependencies!
+
+#define ZEN_TRANS_CONCAT_SUB(X, Y) X ## Y
+#define _(s) zen::implementation::translate(ZEN_TRANS_CONCAT_SUB(L, s))
+#define _P(s, p, n) zen::implementation::translate(ZEN_TRANS_CONCAT_SUB(L, s), ZEN_TRANS_CONCAT_SUB(L, p), n)
+//source and translation are required to use %x as number placeholder
+//for plural form, which will be substituted automatically!!!
+
+namespace zen
+{
+//implement handler to enable program-wide localizations:
+struct TranslationHandler
+{
+    //THREAD-SAFETY: "const" member must model thread-safe access!
+    TranslationHandler() {}
+    virtual ~TranslationHandler() {}
+
+    //C++11: std::wstring should be thread-safe like an int
+    virtual std::wstring translate(const std::wstring& text) const = 0; //simple translation
+    virtual std::wstring translate(const std::wstring& singular, const std::wstring& plural, int64_t n) const = 0;
+
+private:
+    TranslationHandler           (const TranslationHandler&) = delete;
+    TranslationHandler& operator=(const TranslationHandler&) = delete;
+};
+
+void setTranslator(std::unique_ptr<const TranslationHandler>&& newHandler); //take ownership
+std::shared_ptr<const TranslationHandler> getTranslator();
+
+
+
+
+
+
+
+
+
+
+
+
+
+//######################## implementation ##############################
+namespace implementation
+{
+inline
+std::wstring translate(const std::wstring& text)
+{
+    if (std::shared_ptr<const TranslationHandler> t = getTranslator()) //std::shared_ptr => temporarily take (shared) ownership while using the interface!
+        return t->translate(text);
+    return text;
+}
+
+
+//translate plural forms: "%x day" "%x days"
+//returns "1 day" if n == 1; "123 days" if n == 123 for english language
+inline
+std::wstring translate(const std::wstring& singular, const std::wstring& plural, int64_t n)
+{
+    assert(contains(plural, L"%x"));
+
+    if (std::shared_ptr<const TranslationHandler> t = getTranslator())
+    {
+        std::wstring translation = t->translate(singular, plural, n);
+        assert(!contains(translation, L"%x"));
+        return translation;
+    }
+
+    return replaceCpy(std::abs(n) == 1 ? singular : plural, L"%x", toGuiString(n));
+}
+
+
+template <class T> inline
+std::wstring translate(const std::wstring& singular, const std::wstring& plural, T n)
+{
+    static_assert(sizeof(n) <= sizeof(int64_t), "");
+    return translate(singular, plural, static_cast<int64_t>(n));
+}
+
+
+inline
+Global<const TranslationHandler>& refGlobalTranslationHandler()
+{
+    //getTranslator() may be called even after static objects of this translation unit are destroyed!
+    static Global<const TranslationHandler> inst; //external linkage even in header!
+    return inst;
+}
+}
+
+
+inline
+void setTranslator(std::unique_ptr<const TranslationHandler>&& newHandler)
+{
+    implementation::refGlobalTranslationHandler().set(std::move(newHandler));
+}
+
+
+inline
+std::shared_ptr<const TranslationHandler> getTranslator()
+{
+    return implementation::refGlobalTranslationHandler().get();
+}
+}
+
+#endif //I18_N_H_3843489325044253425456
diff --git a/zen/optional.h b/zen/optional.h
index a4c67984..0efc34fe 100755
--- a/zen/optional.h
+++ b/zen/optional.h
@@ -1,100 +1,100 @@
-// *****************************************************************************
-// * This file is part of the FreeFileSync project. It is distributed under    *
-// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
-// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
-// *****************************************************************************
-
-#ifndef OPTIONAL_H_2857428578342203589
-#define OPTIONAL_H_2857428578342203589
-
-#include <cassert>
-#include <type_traits>
-
-namespace zen
-{
-/*
-Optional return value without heap memory allocation!
- -> interface like a pointer, performance like a value
-
- Usage:
- ------
- Opt<MyEnum> someFunction();
-{
-   if (allIsWell)
-       return enumVal;
-   else
-       return NoValue();
-}
-
- Opt<MyEnum> optValue = someFunction();
- if (optValue)
-       ... use *optValue ...
-*/
-
-struct NoValue {};
-
-template <class T>
-class Opt
-{
-public:
-    Opt()        {}
-    Opt(NoValue) {}
-    Opt(const T& val) : valid_(true) { new (&rawMem_) T(val); } //throw X
-    Opt(     T&& tmp) : valid_(true) { new (&rawMem_) T(std::move(tmp)); }
-
-    Opt(const Opt& other) : valid_(other.valid_)
-    {
-        if (const T* val = other.get())
-            new (&rawMem_) T(*val); //throw X
-    }
-
-    ~Opt() { if (T* val = get()) val->~T(); }
-
-    Opt& operator=(NoValue) //support assignment to Opt<const T>
-    {
-        if (T* val = get())
-        {
-            valid_ = false;
-            val->~T();
-        }
-        return *this;
-    }
-
-    Opt& operator=(const Opt& other) //strong exception-safety iff T::operator=() is strongly exception-safe
-    {
-        if (T* val = get())
-        {
-            if (const T* valOther = other.get())
-                *val = *valOther; //throw X
-            else
-            {
-                valid_ = false;
-                val->~T();
-            }
-        }
-        else if (const T* valOther = other.get())
-        {
-            new (&rawMem_) T(*valOther); //throw X
-            valid_ = true;
-        }
-        return *this;
-    }
-
-    explicit operator bool() const { return valid_; } //thank you, C++11!!!
-
-    const T* get() const { return valid_ ? reinterpret_cast<const T*>(&rawMem_) : nullptr; }
-    T*       get()       { return valid_ ? reinterpret_cast<      T*>(&rawMem_) : nullptr; }
-
-    const T& operator*() const { return *get(); }
-    /**/  T& operator*()       { return *get(); }
-
-    const T* operator->() const { return get(); }
-    /**/  T* operator->()       { return get(); }
-
-private:
-    std::aligned_storage_t<sizeof(T), alignof(T)> rawMem_; //don't require T to be default-constructible!
-    bool valid_ = false;
-};
-}
-
-#endif //OPTIONAL_H_2857428578342203589
+// *****************************************************************************
+// * This file is part of the FreeFileSync project. It is distributed under    *
+// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
+// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
+// *****************************************************************************
+
+#ifndef OPTIONAL_H_2857428578342203589
+#define OPTIONAL_H_2857428578342203589
+
+#include <cassert>
+#include <type_traits>
+
+namespace zen
+{
+/*
+Optional return value without heap memory allocation!
+ -> interface like a pointer, performance like a value
+
+ Usage:
+ ------
+ Opt<MyEnum> someFunction();
+{
+   if (allIsWell)
+       return enumVal;
+   else
+       return NoValue();
+}
+
+ Opt<MyEnum> optValue = someFunction();
+ if (optValue)
+       ... use *optValue ...
+*/
+
+struct NoValue {};
+
+template <class T>
+class Opt
+{
+public:
+    Opt()        {}
+    Opt(NoValue) {}
+    Opt(const T& val) : valid_(true) { new (&rawMem_) T(val); } //throw X
+    Opt(     T&& tmp) : valid_(true) { new (&rawMem_) T(std::move(tmp)); }
+
+    Opt(const Opt& other) : valid_(other.valid_)
+    {
+        if (const T* val = other.get())
+            new (&rawMem_) T(*val); //throw X
+    }
+
+    ~Opt() { if (T* val = get()) val->~T(); }
+
+    Opt& operator=(NoValue) //support assignment to Opt<const T>
+    {
+        if (T* val = get())
+        {
+            valid_ = false;
+            val->~T();
+        }
+        return *this;
+    }
+
+    Opt& operator=(const Opt& other) //strong exception-safety iff T::operator=() is strongly exception-safe
+    {
+        if (T* val = get())
+        {
+            if (const T* valOther = other.get())
+                *val = *valOther; //throw X
+            else
+            {
+                valid_ = false;
+                val->~T();
+            }
+        }
+        else if (const T* valOther = other.get())
+        {
+            new (&rawMem_) T(*valOther); //throw X
+            valid_ = true;
+        }
+        return *this;
+    }
+
+    explicit operator bool() const { return valid_; } //thank you, C++11!!!
+
+    const T* get() const { return valid_ ? reinterpret_cast<const T*>(&rawMem_) : nullptr; }
+    T*       get()       { return valid_ ? reinterpret_cast<      T*>(&rawMem_) : nullptr; }
+
+    const T& operator*() const { return *get(); }
+    /**/  T& operator*()       { return *get(); }
+
+    const T* operator->() const { return get(); }
+    /**/  T* operator->()       { return get(); }
+
+private:
+    std::aligned_storage_t<sizeof(T), alignof(T)> rawMem_; //don't require T to be default-constructible!
+    bool valid_ = false;
+};
+}
+
+#endif //OPTIONAL_H_2857428578342203589
diff --git a/zen/perf.h b/zen/perf.h
index ada59691..bd21159c 100755
--- a/zen/perf.h
+++ b/zen/perf.h
@@ -1,83 +1,83 @@
-// *****************************************************************************
-// * This file is part of the FreeFileSync project. It is distributed under    *
-// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
-// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
-// *****************************************************************************
-
-#ifndef PERF_H_83947184145342652456
-#define PERF_H_83947184145342652456
-
-#include <chrono>
-#include "deprecate.h"
-#include "scope_guard.h"
-
-    #include <iostream>
-
-
-//############# two macros for quick performance measurements ###############
-#define PERF_START zen::PerfTimer perfTest;
-#define PERF_STOP  perfTest.showResult();
-//###########################################################################
-
-namespace zen
-{
-class PerfTimer
-{
-public:
-    ZEN_DEPRECATE PerfTimer() {}
-
-    ~PerfTimer() { if (!resultShown_) showResult(); }
-
-    void pause()
-    {
-        if (!paused_)
-        {
-            paused_ = true;
-            elapsedUntilPause_ += std::chrono::steady_clock::now() - startTime_; //ignore potential ::QueryPerformanceCounter() wrap-around!
-        }
-    }
-
-    void resume()
-    {
-        if (paused_)
-        {
-            paused_ = false;
-            startTime_ = std::chrono::steady_clock::now();
-        }
-    }
-
-    void restart()
-    {
-        paused_ = false;
-        startTime_ = std::chrono::steady_clock::now();
-        elapsedUntilPause_ = std::chrono::nanoseconds::zero();
-    }
-
-    int64_t timeMs() const
-    {
-        auto elapsedTotal = elapsedUntilPause_;
-        if (!paused_)
-            elapsedTotal += std::chrono::steady_clock::now() - startTime_;
-
-        return std::chrono::duration_cast<std::chrono::milliseconds>(elapsedTotal).count();
-    }
-
-    void showResult()
-    {
-        const bool wasRunning = !paused_;
-        if (wasRunning) pause(); //don't include call to MessageBox()!
-        ZEN_ON_SCOPE_EXIT(if (wasRunning) resume());
-
-        std::clog << "Perf: duration: " << timeMs() << " ms\n";
-        resultShown_ = true;
-    }
-
-private:
-    bool resultShown_ = false;
-    bool paused_      = false;
-    std::chrono::steady_clock::time_point startTime_ = std::chrono::steady_clock::now(); //uses ::QueryPerformanceCounter()
-    std::chrono::nanoseconds elapsedUntilPause_{}; //std::chrono::duration is uninitialized by default! WTF! When will this stupidity end???
-};
-}
-
-#endif //PERF_H_83947184145342652456
+// *****************************************************************************
+// * This file is part of the FreeFileSync project. It is distributed under    *
+// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
+// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
+// *****************************************************************************
+
+#ifndef PERF_H_83947184145342652456
+#define PERF_H_83947184145342652456
+
+#include <chrono>
+#include "deprecate.h"
+#include "scope_guard.h"
+
+    #include <iostream>
+
+
+//############# two macros for quick performance measurements ###############
+#define PERF_START zen::PerfTimer perfTest;
+#define PERF_STOP  perfTest.showResult();
+//###########################################################################
+
+namespace zen
+{
+class PerfTimer
+{
+public:
+    ZEN_DEPRECATE PerfTimer() {}
+
+    ~PerfTimer() { if (!resultShown_) showResult(); }
+
+    void pause()
+    {
+        if (!paused_)
+        {
+            paused_ = true;
+            elapsedUntilPause_ += std::chrono::steady_clock::now() - startTime_; //ignore potential ::QueryPerformanceCounter() wrap-around!
+        }
+    }
+
+    void resume()
+    {
+        if (paused_)
+        {
+            paused_ = false;
+            startTime_ = std::chrono::steady_clock::now();
+        }
+    }
+
+    void restart()
+    {
+        paused_ = false;
+        startTime_ = std::chrono::steady_clock::now();
+        elapsedUntilPause_ = std::chrono::nanoseconds::zero();
+    }
+
+    int64_t timeMs() const
+    {
+        auto elapsedTotal = elapsedUntilPause_;
+        if (!paused_)
+            elapsedTotal += std::chrono::steady_clock::now() - startTime_;
+
+        return std::chrono::duration_cast<std::chrono::milliseconds>(elapsedTotal).count();
+    }
+
+    void showResult()
+    {
+        const bool wasRunning = !paused_;
+        if (wasRunning) pause(); //don't include call to MessageBox()!
+        ZEN_ON_SCOPE_EXIT(if (wasRunning) resume());
+
+        std::clog << "Perf: duration: " << timeMs() << " ms\n";
+        resultShown_ = true;
+    }
+
+private:
+    bool resultShown_ = false;
+    bool paused_      = false;
+    std::chrono::steady_clock::time_point startTime_ = std::chrono::steady_clock::now(); //uses ::QueryPerformanceCounter()
+    std::chrono::nanoseconds elapsedUntilPause_{}; //std::chrono::duration is uninitialized by default! WTF! When will this stupidity end???
+};
+}
+
+#endif //PERF_H_83947184145342652456
diff --git a/zen/process_priority.cpp b/zen/process_priority.cpp
index 50c975fe..5767e60c 100755
--- a/zen/process_priority.cpp
+++ b/zen/process_priority.cpp
@@ -1,54 +1,54 @@
-// *****************************************************************************
-// * This file is part of the FreeFileSync project. It is distributed under    *
-// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
-// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
-// *****************************************************************************
-
-#include "process_priority.h"
-#include "i18n.h"
-
-
-using namespace zen;
-
-
-struct PreventStandby::Impl {};
-PreventStandby::PreventStandby() {}
-PreventStandby::~PreventStandby() {}
-
-//solution for GNOME?: http://people.gnome.org/~mccann/gnome-session/docs/gnome-session.html#org.gnome.SessionManager.Inhibit
-
-struct ScheduleForBackgroundProcessing::Impl {};
-ScheduleForBackgroundProcessing::ScheduleForBackgroundProcessing() {};
-ScheduleForBackgroundProcessing::~ScheduleForBackgroundProcessing() {};
-
-/*
-struct ScheduleForBackgroundProcessing
-{
-    - required functions ioprio_get/ioprio_set are not part of glibc: http://linux.die.net/man/2/ioprio_set
-    - and probably never will: http://sourceware.org/bugzilla/show_bug.cgi?id=4464
-    - /usr/include/linux/ioprio.h not available on Ubuntu, so we can't use it instead
-
-    ScheduleForBackgroundProcessing() : oldIoPrio(getIoPriority(IOPRIO_WHO_PROCESS, ::getpid()))
-    {
-        if (oldIoPrio != -1)
-            setIoPriority(::getpid(), IOPRIO_PRIO_VALUE(IOPRIO_CLASS_IDLE, 0));
-    }
-    ~ScheduleForBackgroundProcessing()
-    {
-        if (oldIoPrio != -1)
-            setIoPriority(::getpid(), oldIoPrio);
-    }
-
-private:
-    static int getIoPriority(pid_t pid)
-    {
-        return ::syscall(SYS_ioprio_get, IOPRIO_WHO_PROCESS, pid);
-    }
-    static int setIoPriority(pid_t pid, int ioprio)
-    {
-        return ::syscall(SYS_ioprio_set, IOPRIO_WHO_PROCESS, pid, ioprio);
-    }
-
-    const int oldIoPrio;
-};
-*/
+// *****************************************************************************
+// * This file is part of the FreeFileSync project. It is distributed under    *
+// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
+// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
+// *****************************************************************************
+
+#include "process_priority.h"
+#include "i18n.h"
+
+
+using namespace zen;
+
+
+struct PreventStandby::Impl {};
+PreventStandby::PreventStandby() {}
+PreventStandby::~PreventStandby() {}
+
+//solution for GNOME?: http://people.gnome.org/~mccann/gnome-session/docs/gnome-session.html#org.gnome.SessionManager.Inhibit
+
+struct ScheduleForBackgroundProcessing::Impl {};
+ScheduleForBackgroundProcessing::ScheduleForBackgroundProcessing() {};
+ScheduleForBackgroundProcessing::~ScheduleForBackgroundProcessing() {};
+
+/*
+struct ScheduleForBackgroundProcessing
+{
+    - required functions ioprio_get/ioprio_set are not part of glibc: http://linux.die.net/man/2/ioprio_set
+    - and probably never will: http://sourceware.org/bugzilla/show_bug.cgi?id=4464
+    - /usr/include/linux/ioprio.h not available on Ubuntu, so we can't use it instead
+
+    ScheduleForBackgroundProcessing() : oldIoPrio(getIoPriority(IOPRIO_WHO_PROCESS, ::getpid()))
+    {
+        if (oldIoPrio != -1)
+            setIoPriority(::getpid(), IOPRIO_PRIO_VALUE(IOPRIO_CLASS_IDLE, 0));
+    }
+    ~ScheduleForBackgroundProcessing()
+    {
+        if (oldIoPrio != -1)
+            setIoPriority(::getpid(), oldIoPrio);
+    }
+
+private:
+    static int getIoPriority(pid_t pid)
+    {
+        return ::syscall(SYS_ioprio_get, IOPRIO_WHO_PROCESS, pid);
+    }
+    static int setIoPriority(pid_t pid, int ioprio)
+    {
+        return ::syscall(SYS_ioprio_set, IOPRIO_WHO_PROCESS, pid, ioprio);
+    }
+
+    const int oldIoPrio;
+};
+*/
diff --git a/zen/process_priority.h b/zen/process_priority.h
index b876dc92..07679b0c 100755
--- a/zen/process_priority.h
+++ b/zen/process_priority.h
@@ -1,38 +1,38 @@
-// *****************************************************************************
-// * This file is part of the FreeFileSync project. It is distributed under    *
-// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
-// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
-// *****************************************************************************
-#ifndef PROCESS_PRIORITY_H_83421759082143245
-#define PROCESS_PRIORITY_H_83421759082143245
-
-#include <memory>
-#include "file_error.h"
-
-
-namespace zen
-{
-//signal a "busy" state to the operating system
-class PreventStandby
-{
-public:
-    PreventStandby(); //throw FileError
-    ~PreventStandby();
-private:
-    struct Impl;
-    const std::unique_ptr<Impl> pimpl;
-};
-
-//lower CPU and file I/O priorities
-class ScheduleForBackgroundProcessing
-{
-public:
-    ScheduleForBackgroundProcessing(); //throw FileError
-    ~ScheduleForBackgroundProcessing();
-private:
-    struct Impl;
-    const std::unique_ptr<Impl> pimpl;
-};
-}
-
-#endif //PROCESS_PRIORITY_H_83421759082143245
+// *****************************************************************************
+// * This file is part of the FreeFileSync project. It is distributed under    *
+// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
+// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
+// *****************************************************************************
+#ifndef PROCESS_PRIORITY_H_83421759082143245
+#define PROCESS_PRIORITY_H_83421759082143245
+
+#include <memory>
+#include "file_error.h"
+
+
+namespace zen
+{
+//signal a "busy" state to the operating system
+class PreventStandby
+{
+public:
+    PreventStandby(); //throw FileError
+    ~PreventStandby();
+private:
+    struct Impl;
+    const std::unique_ptr<Impl> pimpl;
+};
+
+//lower CPU and file I/O priorities
+class ScheduleForBackgroundProcessing
+{
+public:
+    ScheduleForBackgroundProcessing(); //throw FileError
+    ~ScheduleForBackgroundProcessing();
+private:
+    struct Impl;
+    const std::unique_ptr<Impl> pimpl;
+};
+}
+
+#endif //PROCESS_PRIORITY_H_83421759082143245
diff --git a/zen/recycler.cpp b/zen/recycler.cpp
index 0c71bf3b..c84ef8f3 100755
--- a/zen/recycler.cpp
+++ b/zen/recycler.cpp
@@ -1,72 +1,72 @@
-// *****************************************************************************
-// * This file is part of the FreeFileSync project. It is distributed under    *
-// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
-// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
-// *****************************************************************************
-
-#include "recycler.h"
-#include "file_access.h"
-
-    #include <sys/stat.h>
-    #include <gio/gio.h>
-    #include "scope_guard.h"
-
-
-using namespace zen;
-
-
-
-
-bool zen::recycleOrDeleteIfExists(const Zstring& itemPath) //throw FileError
-{
-    GFile* file = ::g_file_new_for_path(itemPath.c_str()); //never fails according to docu
-    ZEN_ON_SCOPE_EXIT(g_object_unref(file);)
-
-    GError* error = nullptr;
-    ZEN_ON_SCOPE_EXIT(if (error) ::g_error_free(error););
-
-    if (!::g_file_trash(file, nullptr, &error))
-    {
-        const Opt<ItemType> type = getItemTypeIfExists(itemPath); //throw FileError
-        if (!type)
-            return false;
-
-        const std::wstring errorMsg = replaceCpy(_("Unable to move %x to the recycle bin."), L"%x", fmtPath(itemPath));
-        if (!error)
-            throw FileError(errorMsg, L"g_file_trash: unknown error."); //user should never see this
-
-        //implement same behavior as in Windows: if recycler is not existing, delete permanently
-        if (error->code == G_IO_ERROR_NOT_SUPPORTED)
-        {
-            if (*type == ItemType::FOLDER)
-                removeDirectoryPlainRecursion(itemPath); //throw FileError
-            else
-                removeFilePlain(itemPath); //throw FileError
-            return true;
-        }
-
-        throw FileError(errorMsg, formatSystemError(L"g_file_trash", L"Glib Error Code " + numberTo<std::wstring>(error->code), utfTo<std::wstring>(error->message)));
-        //g_quark_to_string(error->domain)
-    }
-    return true;
-
-}
-
-
-/*
-We really need access to a similar function to check whether a directory supports trashing and emit a warning if it does not!
-
-The following function looks perfect, alas it is restricted to local files and to the implementation of GIO only:
-
-    gboolean _g_local_file_has_trash_dir(const char* dirpath, dev_t dir_dev);
-    See: http://www.netmite.com/android/mydroid/2.0/external/bluetooth/glib/gio/glocalfileinfo.h
-
-    Just checking for "G_FILE_ATTRIBUTE_ACCESS_CAN_TRASH" is not correct, since we find in
-    http://www.netmite.com/android/mydroid/2.0/external/bluetooth/glib/gio/glocalfileinfo.c
-
-            g_file_info_set_attribute_boolean (info, G_FILE_ATTRIBUTE_ACCESS_CAN_TRASH,
-                                           writable && parent_info->has_trash_dir);
-
-    => We're NOT interested in whether the specified folder can be trashed, but whether it supports thrashing its child elements! (Only support, not actual write access!)
-    This renders G_FILE_ATTRIBUTE_ACCESS_CAN_TRASH useless for this purpose.
-*/
+// *****************************************************************************
+// * This file is part of the FreeFileSync project. It is distributed under    *
+// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
+// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
+// *****************************************************************************
+
+#include "recycler.h"
+#include "file_access.h"
+
+    #include <sys/stat.h>
+    #include <gio/gio.h>
+    #include "scope_guard.h"
+
+
+using namespace zen;
+
+
+
+
+bool zen::recycleOrDeleteIfExists(const Zstring& itemPath) //throw FileError
+{
+    GFile* file = ::g_file_new_for_path(itemPath.c_str()); //never fails according to docu
+    ZEN_ON_SCOPE_EXIT(g_object_unref(file);)
+
+    GError* error = nullptr;
+    ZEN_ON_SCOPE_EXIT(if (error) ::g_error_free(error););
+
+    if (!::g_file_trash(file, nullptr, &error))
+    {
+        const Opt<ItemType> type = getItemTypeIfExists(itemPath); //throw FileError
+        if (!type)
+            return false;
+
+        const std::wstring errorMsg = replaceCpy(_("Unable to move %x to the recycle bin."), L"%x", fmtPath(itemPath));
+        if (!error)
+            throw FileError(errorMsg, L"g_file_trash: unknown error."); //user should never see this
+
+        //implement same behavior as in Windows: if recycler is not existing, delete permanently
+        if (error->code == G_IO_ERROR_NOT_SUPPORTED)
+        {
+            if (*type == ItemType::FOLDER)
+                removeDirectoryPlainRecursion(itemPath); //throw FileError
+            else
+                removeFilePlain(itemPath); //throw FileError
+            return true;
+        }
+
+        throw FileError(errorMsg, formatSystemError(L"g_file_trash", L"Glib Error Code " + numberTo<std::wstring>(error->code), utfTo<std::wstring>(error->message)));
+        //g_quark_to_string(error->domain)
+    }
+    return true;
+
+}
+
+
+/*
+We really need access to a similar function to check whether a directory supports trashing and emit a warning if it does not!
+
+The following function looks perfect, alas it is restricted to local files and to the implementation of GIO only:
+
+    gboolean _g_local_file_has_trash_dir(const char* dirpath, dev_t dir_dev);
+    See: http://www.netmite.com/android/mydroid/2.0/external/bluetooth/glib/gio/glocalfileinfo.h
+
+    Just checking for "G_FILE_ATTRIBUTE_ACCESS_CAN_TRASH" is not correct, since we find in
+    http://www.netmite.com/android/mydroid/2.0/external/bluetooth/glib/gio/glocalfileinfo.c
+
+            g_file_info_set_attribute_boolean (info, G_FILE_ATTRIBUTE_ACCESS_CAN_TRASH,
+                                           writable && parent_info->has_trash_dir);
+
+    => We're NOT interested in whether the specified folder can be trashed, but whether it supports thrashing its child elements! (Only support, not actual write access!)
+    This renders G_FILE_ATTRIBUTE_ACCESS_CAN_TRASH useless for this purpose.
+*/
diff --git a/zen/recycler.h b/zen/recycler.h
index 0f1b0023..54dd75ca 100755
--- a/zen/recycler.h
+++ b/zen/recycler.h
@@ -1,43 +1,43 @@
-// *****************************************************************************
-// * This file is part of the FreeFileSync project. It is distributed under    *
-// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
-// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
-// *****************************************************************************
-
-#ifndef RECYCLER_H_18345067341545
-#define RECYCLER_H_18345067341545
-
-#include <vector>
-#include <functional>
-#include "file_error.h"
-
-
-namespace zen
-{
-/*
---------------------
-|Recycle Bin Access|
---------------------
-
-Windows
--------
--> Recycler API always available: during runtime either SHFileOperation or IFileOperation (since Vista) will be dynamically selected
--> COM needs to be initialized before calling any of these functions! CoInitializeEx/CoUninitialize
-
-Linux
------
-Compiler flags: `pkg-config --cflags gio-2.0`
-Linker   flags: `pkg-config --libs gio-2.0`
-
-Already included in package "gtk+-2.0"!
-*/
-
-
-
-//move a file or folder to Recycle Bin (deletes permanently if recycler is not available) -> crappy semantics, but we have no choice thanks to Windows' design
-bool recycleOrDeleteIfExists(const Zstring& itemPath); //throw FileError, return "true" if file/dir was actually deleted
-
-
-}
-
-#endif //RECYCLER_H_18345067341545
+// *****************************************************************************
+// * This file is part of the FreeFileSync project. It is distributed under    *
+// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
+// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
+// *****************************************************************************
+
+#ifndef RECYCLER_H_18345067341545
+#define RECYCLER_H_18345067341545
+
+#include <vector>
+#include <functional>
+#include "file_error.h"
+
+
+namespace zen
+{
+/*
+--------------------
+|Recycle Bin Access|
+--------------------
+
+Windows
+-------
+-> Recycler API always available: during runtime either SHFileOperation or IFileOperation (since Vista) will be dynamically selected
+-> COM needs to be initialized before calling any of these functions! CoInitializeEx/CoUninitialize
+
+Linux
+-----
+Compiler flags: `pkg-config --cflags gio-2.0`
+Linker   flags: `pkg-config --libs gio-2.0`
+
+Already included in package "gtk+-2.0"!
+*/
+
+
+
+//move a file or folder to Recycle Bin (deletes permanently if recycler is not available) -> crappy semantics, but we have no choice thanks to Windows' design
+bool recycleOrDeleteIfExists(const Zstring& itemPath); //throw FileError, return "true" if file/dir was actually deleted
+
+
+}
+
+#endif //RECYCLER_H_18345067341545
diff --git a/zen/scope_guard.h b/zen/scope_guard.h
index 62552f7b..b336ad53 100755
--- a/zen/scope_guard.h
+++ b/zen/scope_guard.h
@@ -1,121 +1,121 @@
-// *****************************************************************************
-// * This file is part of the FreeFileSync project. It is distributed under    *
-// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
-// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
-// *****************************************************************************
-
-#ifndef SCOPE_GUARD_H_8971632487321434
-#define SCOPE_GUARD_H_8971632487321434
-
-#include <cassert>
-#include <exception>
-#include "type_tools.h"
-
-
-//std::uncaught_exceptions() currently unsupported on GCC and Clang => clean up ASAP
-    static_assert(__GNUC__ < 6 || (__GNUC__ == 6 && (__GNUC_MINOR__ < 3 || (__GNUC_MINOR__ == 3 && __GNUC_PATCHLEVEL__ <= 1))), "check std::uncaught_exceptions support");
-
-namespace __cxxabiv1
-{
-struct __cxa_eh_globals;
-extern "C" __cxa_eh_globals* __cxa_get_globals() noexcept;
-}
-
-inline int getUncaughtExceptionCount()
-{
-    return *(reinterpret_cast<unsigned int*>(static_cast<char*>(static_cast<void*>(__cxxabiv1::__cxa_get_globals())) + sizeof(void*)));
-}
-
-//best of Zen, Loki and C++17
-
-namespace zen
-{
-//Scope Guard
-/*
-    auto guardAio = zen::makeGuard<ScopeGuardRunMode::ON_EXIT>([&] { ::CloseHandle(hDir); });
-        ...
-    guardAio.dismiss();
-
-Scope Exit:
-    ZEN_ON_SCOPE_EXIT(::CloseHandle(hDir));
-    ZEN_ON_SCOPE_FAIL(UndoPreviousWork());
-    ZEN_ON_SCOPE_SUCCESS(NotifySuccess());
-*/
-
-enum class ScopeGuardRunMode
-{
-    ON_EXIT,
-    ON_SUCCESS,
-    ON_FAIL
-};
-
-
-//partially specialize scope guard destructor code and get rid of those pesky MSVC "4127 conditional expression is constant"
-template <typename F> inline
-void runScopeGuardDestructor(F& fun, int /*exeptionCountOld*/, StaticEnum<ScopeGuardRunMode, ScopeGuardRunMode::ON_EXIT>)
-{
-    try { fun(); }
-    catch (...) { assert(false); } //consistency: don't expect exceptions for ON_EXIT even if "!failed"!
-}
-
-
-template <typename F> inline
-void runScopeGuardDestructor(F& fun, int exeptionCountOld, StaticEnum<ScopeGuardRunMode, ScopeGuardRunMode::ON_SUCCESS>)
-{
-    const bool failed = getUncaughtExceptionCount() > exeptionCountOld;
-    if (!failed)
-        fun(); //throw X
-}
-
-
-template <typename F> inline
-void runScopeGuardDestructor(F& fun, int exeptionCountOld, StaticEnum<ScopeGuardRunMode, ScopeGuardRunMode::ON_FAIL>)
-{
-    const bool failed = getUncaughtExceptionCount() > exeptionCountOld;
-    if (failed)
-        try { fun(); }
-        catch (...) { assert(false); }
-}
-
-
-template <ScopeGuardRunMode runMode, typename F>
-class ScopeGuard
-{
-public:
-    explicit ScopeGuard(const F&  fun) : fun_(fun) {}
-    explicit ScopeGuard(      F&& fun) : fun_(std::move(fun)) {}
-
-    ScopeGuard(ScopeGuard&& other) : fun_(std::move(other.fun_)),
-        exeptionCount_(other.exeptionCount_),
-        dismissed_(other.dismissed_) { other.dismissed_ = true; }
-
-    ~ScopeGuard() noexcept(runMode != ScopeGuardRunMode::ON_SUCCESS)
-    {
-        if (!dismissed_)
-            runScopeGuardDestructor(fun_, exeptionCount_, StaticEnum<ScopeGuardRunMode, runMode>());
-    }
-
-    void dismiss() { dismissed_ = true; }
-
-private:
-    ScopeGuard           (const ScopeGuard&) = delete;
-    ScopeGuard& operator=(const ScopeGuard&) = delete;
-
-    F fun_;
-    const int exeptionCount_ = getUncaughtExceptionCount();
-    bool dismissed_ = false;
-};
-
-
-template <ScopeGuardRunMode runMode, class F> inline
-auto makeGuard(F&& fun) { return ScopeGuard<runMode, std::decay_t<F>>(std::forward<F>(fun)); }
-}
-
-#define ZEN_CONCAT_SUB(X, Y) X ## Y
-#define ZEN_CONCAT(X, Y) ZEN_CONCAT_SUB(X, Y)
-
-#define ZEN_ON_SCOPE_EXIT(X)    auto ZEN_CONCAT(dummy, __LINE__) = zen::makeGuard<zen::ScopeGuardRunMode::ON_EXIT   >([&]{ X; }); (void)ZEN_CONCAT(dummy, __LINE__);
-#define ZEN_ON_SCOPE_FAIL(X)    auto ZEN_CONCAT(dummy, __LINE__) = zen::makeGuard<zen::ScopeGuardRunMode::ON_FAIL   >([&]{ X; }); (void)ZEN_CONCAT(dummy, __LINE__);
-#define ZEN_ON_SCOPE_SUCCESS(X) auto ZEN_CONCAT(dummy, __LINE__) = zen::makeGuard<zen::ScopeGuardRunMode::ON_SUCCESS>([&]{ X; }); (void)ZEN_CONCAT(dummy, __LINE__);
-
-#endif //SCOPE_GUARD_H_8971632487321434
+// *****************************************************************************
+// * This file is part of the FreeFileSync project. It is distributed under    *
+// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
+// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
+// *****************************************************************************
+
+#ifndef SCOPE_GUARD_H_8971632487321434
+#define SCOPE_GUARD_H_8971632487321434
+
+#include <cassert>
+#include <exception>
+#include "type_tools.h"
+
+
+//std::uncaught_exceptions() currently unsupported on GCC and Clang => clean up ASAP
+    static_assert(__GNUC__ < 6 || (__GNUC__ == 6 && (__GNUC_MINOR__ < 3 || (__GNUC_MINOR__ == 3 && __GNUC_PATCHLEVEL__ <= 1))), "check std::uncaught_exceptions support");
+
+namespace __cxxabiv1
+{
+struct __cxa_eh_globals;
+extern "C" __cxa_eh_globals* __cxa_get_globals() noexcept;
+}
+
+inline int getUncaughtExceptionCount()
+{
+    return *(reinterpret_cast<unsigned int*>(static_cast<char*>(static_cast<void*>(__cxxabiv1::__cxa_get_globals())) + sizeof(void*)));
+}
+
+//best of Zen, Loki and C++17
+
+namespace zen
+{
+//Scope Guard
+/*
+    auto guardAio = zen::makeGuard<ScopeGuardRunMode::ON_EXIT>([&] { ::CloseHandle(hDir); });
+        ...
+    guardAio.dismiss();
+
+Scope Exit:
+    ZEN_ON_SCOPE_EXIT(::CloseHandle(hDir));
+    ZEN_ON_SCOPE_FAIL(UndoPreviousWork());
+    ZEN_ON_SCOPE_SUCCESS(NotifySuccess());
+*/
+
+enum class ScopeGuardRunMode
+{
+    ON_EXIT,
+    ON_SUCCESS,
+    ON_FAIL
+};
+
+
+//partially specialize scope guard destructor code and get rid of those pesky MSVC "4127 conditional expression is constant"
+template <typename F> inline
+void runScopeGuardDestructor(F& fun, int /*exeptionCountOld*/, StaticEnum<ScopeGuardRunMode, ScopeGuardRunMode::ON_EXIT>)
+{
+    try { fun(); }
+    catch (...) { assert(false); } //consistency: don't expect exceptions for ON_EXIT even if "!failed"!
+}
+
+
+template <typename F> inline
+void runScopeGuardDestructor(F& fun, int exeptionCountOld, StaticEnum<ScopeGuardRunMode, ScopeGuardRunMode::ON_SUCCESS>)
+{
+    const bool failed = getUncaughtExceptionCount() > exeptionCountOld;
+    if (!failed)
+        fun(); //throw X
+}
+
+
+template <typename F> inline
+void runScopeGuardDestructor(F& fun, int exeptionCountOld, StaticEnum<ScopeGuardRunMode, ScopeGuardRunMode::ON_FAIL>)
+{
+    const bool failed = getUncaughtExceptionCount() > exeptionCountOld;
+    if (failed)
+        try { fun(); }
+        catch (...) { assert(false); }
+}
+
+
+template <ScopeGuardRunMode runMode, typename F>
+class ScopeGuard
+{
+public:
+    explicit ScopeGuard(const F&  fun) : fun_(fun) {}
+    explicit ScopeGuard(      F&& fun) : fun_(std::move(fun)) {}
+
+    ScopeGuard(ScopeGuard&& other) : fun_(std::move(other.fun_)),
+        exeptionCount_(other.exeptionCount_),
+        dismissed_(other.dismissed_) { other.dismissed_ = true; }
+
+    ~ScopeGuard() noexcept(runMode != ScopeGuardRunMode::ON_SUCCESS)
+    {
+        if (!dismissed_)
+            runScopeGuardDestructor(fun_, exeptionCount_, StaticEnum<ScopeGuardRunMode, runMode>());
+    }
+
+    void dismiss() { dismissed_ = true; }
+
+private:
+    ScopeGuard           (const ScopeGuard&) = delete;
+    ScopeGuard& operator=(const ScopeGuard&) = delete;
+
+    F fun_;
+    const int exeptionCount_ = getUncaughtExceptionCount();
+    bool dismissed_ = false;
+};
+
+
+template <ScopeGuardRunMode runMode, class F> inline
+auto makeGuard(F&& fun) { return ScopeGuard<runMode, std::decay_t<F>>(std::forward<F>(fun)); }
+}
+
+#define ZEN_CONCAT_SUB(X, Y) X ## Y
+#define ZEN_CONCAT(X, Y) ZEN_CONCAT_SUB(X, Y)
+
+#define ZEN_ON_SCOPE_EXIT(X)    auto ZEN_CONCAT(dummy, __LINE__) = zen::makeGuard<zen::ScopeGuardRunMode::ON_EXIT   >([&]{ X; }); (void)ZEN_CONCAT(dummy, __LINE__);
+#define ZEN_ON_SCOPE_FAIL(X)    auto ZEN_CONCAT(dummy, __LINE__) = zen::makeGuard<zen::ScopeGuardRunMode::ON_FAIL   >([&]{ X; }); (void)ZEN_CONCAT(dummy, __LINE__);
+#define ZEN_ON_SCOPE_SUCCESS(X) auto ZEN_CONCAT(dummy, __LINE__) = zen::makeGuard<zen::ScopeGuardRunMode::ON_SUCCESS>([&]{ X; }); (void)ZEN_CONCAT(dummy, __LINE__);
+
+#endif //SCOPE_GUARD_H_8971632487321434
diff --git a/zen/serialize.h b/zen/serialize.h
index c8dfb96d..81d2d1ef 100755
--- a/zen/serialize.h
+++ b/zen/serialize.h
@@ -1,281 +1,281 @@
-// *****************************************************************************
-// * This file is part of the FreeFileSync project. It is distributed under    *
-// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
-// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
-// *****************************************************************************
-
-#ifndef SERIALIZE_H_839405783574356
-#define SERIALIZE_H_839405783574356
-
-#include <functional>
-#include <cstdint>
-#include "string_base.h"
-//keep header clean from specific stream implementations! (e.g.file_io.h)! used by abstract.h!
-
-
-namespace zen
-{
-//high-performance unformatted serialization (avoiding wxMemoryOutputStream/wxMemoryInputStream inefficiencies)
-
-/*
---------------------------
-|Binary Container Concept|
---------------------------
-binary container for data storage: must support "basic" std::vector interface (e.g. std::vector<char>, std::string, Zbase<char>)
-*/
-
-//binary container reference implementations
-using Utf8String = Zbase<char>; //ref-counted + COW text stream + guaranteed performance: exponential growth
-class ByteArray;                //ref-counted       byte stream + guaranteed performance: exponential growth -> no COW, but 12% faster than Utf8String (due to no null-termination?)
-
-
-class ByteArray //essentially a std::vector<char> with ref-counted semantics, but no COW! => *almost* value type semantics, but not quite
-{
-public:
-    using value_type     = std::vector<char>::value_type;
-    using iterator       = std::vector<char>::iterator;
-    using const_iterator = std::vector<char>::const_iterator;
-
-    iterator begin() { return buffer->begin(); }
-    iterator end  () { return buffer->end  (); }
-
-    const_iterator begin() const { return buffer->begin(); }
-    const_iterator end  () const { return buffer->end  (); }
-
-    void resize(size_t len) { buffer->resize(len); }
-    size_t size() const { return buffer->size(); }
-    bool  empty() const { return buffer->empty(); }
-
-    inline friend bool operator==(const ByteArray& lhs, const ByteArray& rhs) { return *lhs.buffer == *rhs.buffer; }
-
-private:
-    std::shared_ptr<std::vector<char>> buffer { std::make_shared<std::vector<char>>() }; //always bound!
-    //perf: shared_ptr indirection irrelevant: less than 1% slower!
-};
-
-/*
--------------------------------
-|Buffered Input Stream Concept|
--------------------------------
-struct BufferedInputStream
-{
-    size_t read(void* buffer, size_t bytesToRead); //throw X; return "bytesToRead" bytes unless end of stream!
-
-Optional: support stream-copying
---------------------------------
-    size_t getBlockSize() const;
-    const IOCallback& notifyUnbufferedIO
-};
-
---------------------------------
-|Buffered Output Stream Concept|
---------------------------------
-struct BufferedOutputStream
-{
-    void write(const void* buffer, size_t bytesToWrite); //throw X
-
-Optional: support stream-copying
---------------------------------
-    const IOCallback& notifyUnbufferedIO
-};
-*/
-using IOCallback = std::function<void(int64_t bytesDelta)>; //throw X
-
-
-//functions based on buffered stream abstraction
-template <class BufferedInputStream, class BufferedOutputStream>
-void bufferedStreamCopy(BufferedInputStream& streamIn, BufferedOutputStream& streamOut); //throw X
-
-template <class BinContainer, class BufferedInputStream> BinContainer
-bufferedLoad(BufferedInputStream& streamIn); //throw X
-
-template <class N, class BufferedOutputStream> void writeNumber   (BufferedOutputStream& stream, const N& num);                   //
-template <class C, class BufferedOutputStream> void writeContainer(BufferedOutputStream& stream, const C& str);                   //throw ()
-template <         class BufferedOutputStream> void writeArray    (BufferedOutputStream& stream, const void* buffer, size_t len); //
-//----------------------------------------------------------------------
-class UnexpectedEndOfStreamError {};
-template <class N, class BufferedInputStream> N    readNumber   (BufferedInputStream& stream); //throw UnexpectedEndOfStreamError (corrupted data)
-template <class C, class BufferedInputStream> C    readContainer(BufferedInputStream& stream); //
-template <         class BufferedInputStream> void readArray    (BufferedInputStream& stream, void* buffer, size_t len); //
-
-
-struct IOCallbackDivider
-{
-    IOCallbackDivider(const IOCallback& notifyUnbufferedIO, int64_t& totalUnbufferedIO) : totalUnbufferedIO_(totalUnbufferedIO), notifyUnbufferedIO_(notifyUnbufferedIO) {}
-
-    void operator()(int64_t bytesDelta)
-    {
-        if (notifyUnbufferedIO_) notifyUnbufferedIO_((totalUnbufferedIO_ - totalUnbufferedIO_ / 2 * 2 + bytesDelta) / 2); //throw X!
-        totalUnbufferedIO_ += bytesDelta;
-    }
-
-private:
-    int64_t& totalUnbufferedIO_;
-    const IOCallback& notifyUnbufferedIO_;
-};
-
-//buffered input/output stream reference implementations:
-template <class BinContainer>
-struct MemoryStreamIn
-{
-    MemoryStreamIn(const BinContainer& cont) : buffer_(cont) {} //this better be cheap!
-
-    size_t read(void* buffer, size_t bytesToRead) //return "bytesToRead" bytes unless end of stream!
-    {
-        static_assert(sizeof(typename BinContainer::value_type) == 1, ""); //expect: bytes
-        const size_t bytesRead = std::min(bytesToRead, buffer_.size() - pos_);
-        auto itFirst = buffer_.begin() + pos_;
-        std::copy(itFirst, itFirst + bytesRead, static_cast<char*>(buffer));
-        pos_ += bytesRead;
-        return bytesRead;
-    }
-
-    size_t pos() const { return pos_; }
-
-private:
-    MemoryStreamIn           (const MemoryStreamIn&) = delete;
-    MemoryStreamIn& operator=(const MemoryStreamIn&) = delete;
-
-    const BinContainer buffer_;
-    size_t pos_ = 0;
-};
-
-template <class BinContainer>
-struct MemoryStreamOut
-{
-    MemoryStreamOut() = default;
-
-    void write(const void* buffer, size_t bytesToWrite)
-    {
-        static_assert(sizeof(typename BinContainer::value_type) == 1, ""); //expect: bytes
-        const size_t oldSize = buffer_.size();
-        buffer_.resize(oldSize + bytesToWrite);
-        std::copy(static_cast<const char*>(buffer), static_cast<const char*>(buffer) + bytesToWrite, buffer_.begin() + oldSize);
-    }
-
-    const BinContainer& ref() const { return buffer_; }
-
-private:
-    MemoryStreamOut           (const MemoryStreamOut&) = delete;
-    MemoryStreamOut& operator=(const MemoryStreamOut&) = delete;
-
-    BinContainer buffer_;
-};
-
-
-
-
-
-
-
-
-//-----------------------implementation-------------------------------
-template <class BufferedInputStream, class BufferedOutputStream> inline
-void bufferedStreamCopy(BufferedInputStream& streamIn,   //throw X
-                        BufferedOutputStream& streamOut) //
-{
-    const size_t blockSize = streamIn.getBlockSize();
-    if (blockSize == 0)
-        throw std::logic_error("Contract violation! " + std::string(__FILE__) + ":" + numberTo<std::string>(__LINE__));
-
-    std::vector<char> buffer(blockSize);
-    for (;;)
-    {
-        const size_t bytesRead = streamIn.read(&buffer[0], blockSize); //throw X; return "bytesToRead" bytes unless end of stream!
-        streamOut.write(&buffer[0], bytesRead); //throw X
-
-        if (bytesRead < blockSize) //end of file
-            break;
-    }
-}
-
-
-template <class BinContainer, class BufferedInputStream> inline
-BinContainer bufferedLoad(BufferedInputStream& streamIn) //throw X
-{
-    static_assert(sizeof(typename BinContainer::value_type) == 1, ""); //expect: bytes
-
-    const size_t blockSize = streamIn.getBlockSize();
-    if (blockSize == 0)
-        throw std::logic_error("Contract violation! " + std::string(__FILE__) + ":" + numberTo<std::string>(__LINE__));
-
-    BinContainer buffer;
-    for (;;)
-    {
-        buffer.resize(buffer.size() + blockSize);
-        const size_t bytesRead = streamIn.read(&*(buffer.end() - blockSize), blockSize); //throw X; return "bytesToRead" bytes unless end of stream!
-        buffer.resize(buffer.size() - blockSize + bytesRead); //caveat: unsigned arithmetics
-
-        if (bytesRead < blockSize) //end of file
-            return buffer;
-    }
-}
-
-
-template <class BufferedOutputStream> inline
-void writeArray(BufferedOutputStream& stream, const void* buffer, size_t len)
-{
-    stream.write(buffer, len);
-}
-
-
-template <class N, class BufferedOutputStream> inline
-void writeNumber(BufferedOutputStream& stream, const N& num)
-{
-    static_assert(IsArithmetic<N>::value || IsSameType<N, bool>::value, "not a number!");
-    writeArray(stream, &num, sizeof(N));
-}
-
-
-template <class C, class BufferedOutputStream> inline
-void writeContainer(BufferedOutputStream& stream, const C& cont) //don't even consider UTF8 conversions here, we're handling arbitrary binary data!
-{
-    const auto len = cont.size();
-    writeNumber(stream, static_cast<uint32_t>(len));
-    if (len > 0)
-        writeArray(stream, &*cont.begin(), sizeof(typename C::value_type) * len); //don't use c_str(), but access uniformly via STL interface
-}
-
-
-template <class BufferedInputStream> inline
-void readArray(BufferedInputStream& stream, void* buffer, size_t len) //throw UnexpectedEndOfStreamError
-{
-    const size_t bytesRead = stream.read(buffer, len);
-    assert(bytesRead <= len); //buffer overflow otherwise not always detected!
-    if (bytesRead < len)
-        throw UnexpectedEndOfStreamError();
-}
-
-
-template <class N, class BufferedInputStream> inline
-N readNumber(BufferedInputStream& stream) //throw UnexpectedEndOfStreamError
-{
-    static_assert(IsArithmetic<N>::value || IsSameType<N, bool>::value, "");
-    N num = 0;
-    readArray(stream, &num, sizeof(N)); //throw UnexpectedEndOfStreamError
-    return num;
-}
-
-
-template <class C, class BufferedInputStream> inline
-C readContainer(BufferedInputStream& stream) //throw UnexpectedEndOfStreamError
-{
-    C cont;
-    auto strLength = readNumber<uint32_t>(stream); //throw UnexpectedEndOfStreamError
-    if (strLength > 0)
-    {
-        try
-        {
-            cont.resize(strLength); //throw std::bad_alloc
-        }
-        catch (std::bad_alloc&) //most likely this is due to data corruption!
-        {
-            throw UnexpectedEndOfStreamError();
-        }
-        readArray(stream, &*cont.begin(), sizeof(typename C::value_type) * strLength); //throw UnexpectedEndOfStreamError
-    }
-    return cont;
-}
-}
-
-#endif //SERIALIZE_H_839405783574356
+// *****************************************************************************
+// * This file is part of the FreeFileSync project. It is distributed under    *
+// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
+// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
+// *****************************************************************************
+
+#ifndef SERIALIZE_H_839405783574356
+#define SERIALIZE_H_839405783574356
+
+#include <functional>
+#include <cstdint>
+#include "string_base.h"
+//keep header clean from specific stream implementations! (e.g.file_io.h)! used by abstract.h!
+
+
+namespace zen
+{
+//high-performance unformatted serialization (avoiding wxMemoryOutputStream/wxMemoryInputStream inefficiencies)
+
+/*
+--------------------------
+|Binary Container Concept|
+--------------------------
+binary container for data storage: must support "basic" std::vector interface (e.g. std::vector<char>, std::string, Zbase<char>)
+*/
+
+//binary container reference implementations
+using Utf8String = Zbase<char>; //ref-counted + COW text stream + guaranteed performance: exponential growth
+class ByteArray;                //ref-counted       byte stream + guaranteed performance: exponential growth -> no COW, but 12% faster than Utf8String (due to no null-termination?)
+
+
+class ByteArray //essentially a std::vector<char> with ref-counted semantics, but no COW! => *almost* value type semantics, but not quite
+{
+public:
+    using value_type     = std::vector<char>::value_type;
+    using iterator       = std::vector<char>::iterator;
+    using const_iterator = std::vector<char>::const_iterator;
+
+    iterator begin() { return buffer->begin(); }
+    iterator end  () { return buffer->end  (); }
+
+    const_iterator begin() const { return buffer->begin(); }
+    const_iterator end  () const { return buffer->end  (); }
+
+    void resize(size_t len) { buffer->resize(len); }
+    size_t size() const { return buffer->size(); }
+    bool  empty() const { return buffer->empty(); }
+
+    inline friend bool operator==(const ByteArray& lhs, const ByteArray& rhs) { return *lhs.buffer == *rhs.buffer; }
+
+private:
+    std::shared_ptr<std::vector<char>> buffer { std::make_shared<std::vector<char>>() }; //always bound!
+    //perf: shared_ptr indirection irrelevant: less than 1% slower!
+};
+
+/*
+-------------------------------
+|Buffered Input Stream Concept|
+-------------------------------
+struct BufferedInputStream
+{
+    size_t read(void* buffer, size_t bytesToRead); //throw X; return "bytesToRead" bytes unless end of stream!
+
+Optional: support stream-copying
+--------------------------------
+    size_t getBlockSize() const;
+    const IOCallback& notifyUnbufferedIO
+};
+
+--------------------------------
+|Buffered Output Stream Concept|
+--------------------------------
+struct BufferedOutputStream
+{
+    void write(const void* buffer, size_t bytesToWrite); //throw X
+
+Optional: support stream-copying
+--------------------------------
+    const IOCallback& notifyUnbufferedIO
+};
+*/
+using IOCallback = std::function<void(int64_t bytesDelta)>; //throw X
+
+
+//functions based on buffered stream abstraction
+template <class BufferedInputStream, class BufferedOutputStream>
+void bufferedStreamCopy(BufferedInputStream& streamIn, BufferedOutputStream& streamOut); //throw X
+
+template <class BinContainer, class BufferedInputStream> BinContainer
+bufferedLoad(BufferedInputStream& streamIn); //throw X
+
+template <class N, class BufferedOutputStream> void writeNumber   (BufferedOutputStream& stream, const N& num);                   //
+template <class C, class BufferedOutputStream> void writeContainer(BufferedOutputStream& stream, const C& str);                   //throw ()
+template <         class BufferedOutputStream> void writeArray    (BufferedOutputStream& stream, const void* buffer, size_t len); //
+//----------------------------------------------------------------------
+class UnexpectedEndOfStreamError {};
+template <class N, class BufferedInputStream> N    readNumber   (BufferedInputStream& stream); //throw UnexpectedEndOfStreamError (corrupted data)
+template <class C, class BufferedInputStream> C    readContainer(BufferedInputStream& stream); //
+template <         class BufferedInputStream> void readArray    (BufferedInputStream& stream, void* buffer, size_t len); //
+
+
+struct IOCallbackDivider
+{
+    IOCallbackDivider(const IOCallback& notifyUnbufferedIO, int64_t& totalUnbufferedIO) : totalUnbufferedIO_(totalUnbufferedIO), notifyUnbufferedIO_(notifyUnbufferedIO) {}
+
+    void operator()(int64_t bytesDelta)
+    {
+        if (notifyUnbufferedIO_) notifyUnbufferedIO_((totalUnbufferedIO_ - totalUnbufferedIO_ / 2 * 2 + bytesDelta) / 2); //throw X!
+        totalUnbufferedIO_ += bytesDelta;
+    }
+
+private:
+    int64_t& totalUnbufferedIO_;
+    const IOCallback& notifyUnbufferedIO_;
+};
+
+//buffered input/output stream reference implementations:
+template <class BinContainer>
+struct MemoryStreamIn
+{
+    MemoryStreamIn(const BinContainer& cont) : buffer_(cont) {} //this better be cheap!
+
+    size_t read(void* buffer, size_t bytesToRead) //return "bytesToRead" bytes unless end of stream!
+    {
+        static_assert(sizeof(typename BinContainer::value_type) == 1, ""); //expect: bytes
+        const size_t bytesRead = std::min(bytesToRead, buffer_.size() - pos_);
+        auto itFirst = buffer_.begin() + pos_;
+        std::copy(itFirst, itFirst + bytesRead, static_cast<char*>(buffer));
+        pos_ += bytesRead;
+        return bytesRead;
+    }
+
+    size_t pos() const { return pos_; }
+
+private:
+    MemoryStreamIn           (const MemoryStreamIn&) = delete;
+    MemoryStreamIn& operator=(const MemoryStreamIn&) = delete;
+
+    const BinContainer buffer_;
+    size_t pos_ = 0;
+};
+
+template <class BinContainer>
+struct MemoryStreamOut
+{
+    MemoryStreamOut() = default;
+
+    void write(const void* buffer, size_t bytesToWrite)
+    {
+        static_assert(sizeof(typename BinContainer::value_type) == 1, ""); //expect: bytes
+        const size_t oldSize = buffer_.size();
+        buffer_.resize(oldSize + bytesToWrite);
+        std::copy(static_cast<const char*>(buffer), static_cast<const char*>(buffer) + bytesToWrite, buffer_.begin() + oldSize);
+    }
+
+    const BinContainer& ref() const { return buffer_; }
+
+private:
+    MemoryStreamOut           (const MemoryStreamOut&) = delete;
+    MemoryStreamOut& operator=(const MemoryStreamOut&) = delete;
+
+    BinContainer buffer_;
+};
+
+
+
+
+
+
+
+
+//-----------------------implementation-------------------------------
+template <class BufferedInputStream, class BufferedOutputStream> inline
+void bufferedStreamCopy(BufferedInputStream& streamIn,   //throw X
+                        BufferedOutputStream& streamOut) //
+{
+    const size_t blockSize = streamIn.getBlockSize();
+    if (blockSize == 0)
+        throw std::logic_error("Contract violation! " + std::string(__FILE__) + ":" + numberTo<std::string>(__LINE__));
+
+    std::vector<char> buffer(blockSize);
+    for (;;)
+    {
+        const size_t bytesRead = streamIn.read(&buffer[0], blockSize); //throw X; return "bytesToRead" bytes unless end of stream!
+        streamOut.write(&buffer[0], bytesRead); //throw X
+
+        if (bytesRead < blockSize) //end of file
+            break;
+    }
+}
+
+
+template <class BinContainer, class BufferedInputStream> inline
+BinContainer bufferedLoad(BufferedInputStream& streamIn) //throw X
+{
+    static_assert(sizeof(typename BinContainer::value_type) == 1, ""); //expect: bytes
+
+    const size_t blockSize = streamIn.getBlockSize();
+    if (blockSize == 0)
+        throw std::logic_error("Contract violation! " + std::string(__FILE__) + ":" + numberTo<std::string>(__LINE__));
+
+    BinContainer buffer;
+    for (;;)
+    {
+        buffer.resize(buffer.size() + blockSize);
+        const size_t bytesRead = streamIn.read(&*(buffer.end() - blockSize), blockSize); //throw X; return "bytesToRead" bytes unless end of stream!
+        buffer.resize(buffer.size() - blockSize + bytesRead); //caveat: unsigned arithmetics
+
+        if (bytesRead < blockSize) //end of file
+            return buffer;
+    }
+}
+
+
+template <class BufferedOutputStream> inline
+void writeArray(BufferedOutputStream& stream, const void* buffer, size_t len)
+{
+    stream.write(buffer, len);
+}
+
+
+template <class N, class BufferedOutputStream> inline
+void writeNumber(BufferedOutputStream& stream, const N& num)
+{
+    static_assert(IsArithmetic<N>::value || IsSameType<N, bool>::value, "not a number!");
+    writeArray(stream, &num, sizeof(N));
+}
+
+
+template <class C, class BufferedOutputStream> inline
+void writeContainer(BufferedOutputStream& stream, const C& cont) //don't even consider UTF8 conversions here, we're handling arbitrary binary data!
+{
+    const auto len = cont.size();
+    writeNumber(stream, static_cast<uint32_t>(len));
+    if (len > 0)
+        writeArray(stream, &*cont.begin(), sizeof(typename C::value_type) * len); //don't use c_str(), but access uniformly via STL interface
+}
+
+
+template <class BufferedInputStream> inline
+void readArray(BufferedInputStream& stream, void* buffer, size_t len) //throw UnexpectedEndOfStreamError
+{
+    const size_t bytesRead = stream.read(buffer, len);
+    assert(bytesRead <= len); //buffer overflow otherwise not always detected!
+    if (bytesRead < len)
+        throw UnexpectedEndOfStreamError();
+}
+
+
+template <class N, class BufferedInputStream> inline
+N readNumber(BufferedInputStream& stream) //throw UnexpectedEndOfStreamError
+{
+    static_assert(IsArithmetic<N>::value || IsSameType<N, bool>::value, "");
+    N num = 0;
+    readArray(stream, &num, sizeof(N)); //throw UnexpectedEndOfStreamError
+    return num;
+}
+
+
+template <class C, class BufferedInputStream> inline
+C readContainer(BufferedInputStream& stream) //throw UnexpectedEndOfStreamError
+{
+    C cont;
+    auto strLength = readNumber<uint32_t>(stream); //throw UnexpectedEndOfStreamError
+    if (strLength > 0)
+    {
+        try
+        {
+            cont.resize(strLength); //throw std::bad_alloc
+        }
+        catch (std::bad_alloc&) //most likely this is due to data corruption!
+        {
+            throw UnexpectedEndOfStreamError();
+        }
+        readArray(stream, &*cont.begin(), sizeof(typename C::value_type) * strLength); //throw UnexpectedEndOfStreamError
+    }
+    return cont;
+}
+}
+
+#endif //SERIALIZE_H_839405783574356
diff --git a/zen/shell_execute.h b/zen/shell_execute.h
index 5e4ddf1a..7dcd6653 100755
--- a/zen/shell_execute.h
+++ b/zen/shell_execute.h
@@ -1,52 +1,52 @@
-// *****************************************************************************
-// * This file is part of the FreeFileSync project. It is distributed under    *
-// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
-// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
-// *****************************************************************************
-
-#ifndef SHELL_EXECUTE_H_23482134578134134
-#define SHELL_EXECUTE_H_23482134578134134
-
-#include "file_error.h"
-
-    #include "thread.h"
-    #include <stdlib.h> //::system()
-
-
-namespace zen
-{
-//launch commandline and report errors via popup dialog
-//windows: COM needs to be initialized before calling this function!
-enum ExecutionType
-{
-    EXEC_TYPE_SYNC,
-    EXEC_TYPE_ASYNC
-};
-
-namespace
-{
-
-
-void shellExecute(const Zstring& command, ExecutionType type) //throw FileError
-{
-    /*
-    we cannot use wxExecute due to various issues:
-    - screws up encoding on OS X for non-ASCII characters
-    - does not provide any reasonable error information
-    - uses a zero-sized dummy window as a hack to keep focus which leaves a useless empty icon in ALT-TAB list in Windows
-    */
-
-    if (type == EXEC_TYPE_SYNC)
-    {
-        //Posix::system - execute a shell command
-        int rv = ::system(command.c_str()); //do NOT use std::system as its documentation says nothing about "WEXITSTATUS(rv)", ect...
-        if (rv == -1 || WEXITSTATUS(rv) == 127) //http://linux.die.net/man/3/system    "In case /bin/sh could not be executed, the exit status will be that of a command that does exit(127)"
-            throw FileError(_("Incorrect command line:") + L"\n" + utfTo<std::wstring>(command));
-    }
-    else
-        runAsync([=] { int rv = ::system(command.c_str()); (void)rv; });
-}
-}
-}
-
-#endif //SHELL_EXECUTE_H_23482134578134134
+// *****************************************************************************
+// * This file is part of the FreeFileSync project. It is distributed under    *
+// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
+// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
+// *****************************************************************************
+
+#ifndef SHELL_EXECUTE_H_23482134578134134
+#define SHELL_EXECUTE_H_23482134578134134
+
+#include "file_error.h"
+
+    #include "thread.h"
+    #include <stdlib.h> //::system()
+
+
+namespace zen
+{
+//launch commandline and report errors via popup dialog
+//windows: COM needs to be initialized before calling this function!
+enum ExecutionType
+{
+    EXEC_TYPE_SYNC,
+    EXEC_TYPE_ASYNC
+};
+
+namespace
+{
+
+
+void shellExecute(const Zstring& command, ExecutionType type) //throw FileError
+{
+    /*
+    we cannot use wxExecute due to various issues:
+    - screws up encoding on OS X for non-ASCII characters
+    - does not provide any reasonable error information
+    - uses a zero-sized dummy window as a hack to keep focus which leaves a useless empty icon in ALT-TAB list in Windows
+    */
+
+    if (type == EXEC_TYPE_SYNC)
+    {
+        //Posix::system - execute a shell command
+        int rv = ::system(command.c_str()); //do NOT use std::system as its documentation says nothing about "WEXITSTATUS(rv)", ect...
+        if (rv == -1 || WEXITSTATUS(rv) == 127) //http://linux.die.net/man/3/system    "In case /bin/sh could not be executed, the exit status will be that of a command that does exit(127)"
+            throw FileError(_("Incorrect command line:") + L"\n" + utfTo<std::wstring>(command));
+    }
+    else
+        runAsync([=] { int rv = ::system(command.c_str()); (void)rv; });
+}
+}
+}
+
+#endif //SHELL_EXECUTE_H_23482134578134134
diff --git a/zen/stl_tools.h b/zen/stl_tools.h
index 74a2b360..b03d7533 100755
--- a/zen/stl_tools.h
+++ b/zen/stl_tools.h
@@ -1,244 +1,244 @@
-// *****************************************************************************
-// * This file is part of the FreeFileSync project. It is distributed under    *
-// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
-// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
-// *****************************************************************************
-
-#ifndef STL_TOOLS_H_84567184321434
-#define STL_TOOLS_H_84567184321434
-
-#include <set>
-#include <map>
-#include <vector>
-#include <memory>
-#include <algorithm>
-#include "type_tools.h"
-#include "build_info.h"
-
-
-//enhancements for <algorithm>
-namespace zen
-{
-//erase selected elements from any container:
-template <class T, class Alloc, class Predicate>
-void erase_if(std::vector<T, Alloc>& v, Predicate p);
-
-template <class T, class LessType, class Alloc, class Predicate>
-void erase_if(std::set<T, LessType, Alloc>& s, Predicate p);
-
-template <class KeyType, class ValueType, class LessType, class Alloc, class Predicate>
-void erase_if(std::map<KeyType, ValueType, LessType, Alloc>& m, Predicate p);
-
-//append STL containers
-template <class T, class Alloc, class C>
-void append(std::vector<T, Alloc>& v, const C& c);
-
-template <class T, class LessType, class Alloc, class C>
-void append(std::set<T, LessType, Alloc>& s, const C& c);
-
-template <class KeyType, class ValueType, class LessType, class Alloc, class C>
-void append(std::map<KeyType, ValueType, LessType, Alloc>& m, const C& c);
-
-template <class M, class K, class V>
-V& map_add_or_update(M& map, const K& key, const V& value); //efficient add or update without "default-constructible" requirement (Effective STL, item 24)
-
-template <class T, class Alloc>
-void removeDuplicates(std::vector<T, Alloc>& v);
-
-//binary search returning an iterator
-template <class ForwardIterator, class T, typename CompLess>
-ForwardIterator binary_search(ForwardIterator first, ForwardIterator last, const T& value, CompLess less);
-
-template <class BidirectionalIterator, class T>
-BidirectionalIterator find_last(BidirectionalIterator first, BidirectionalIterator last, const T& value);
-
-//replacement for std::find_end taking advantage of bidirectional iterators (and giving the algorithm a reasonable name)
-template <class BidirectionalIterator1, class BidirectionalIterator2>
-BidirectionalIterator1 search_last(BidirectionalIterator1 first1, BidirectionalIterator1 last1,
-                                   BidirectionalIterator2 first2, BidirectionalIterator2 last2);
-
-template <class InputIterator1, class InputIterator2>
-bool equal(InputIterator1 first1, InputIterator1 last1,
-           InputIterator2 first2, InputIterator2 last2);
-
-template <class ByteIterator> size_t hashBytes                      (ByteIterator first, ByteIterator last);
-template <class ByteIterator> size_t hashBytesAppend(size_t hashVal, ByteIterator first, ByteIterator last);
-
-
-//support for custom string classes in std::unordered_set/map
-struct StringHash
-{
-    template <class String>
-    size_t operator()(const String& str) const
-    {
-        const auto* strFirst = strBegin(str);
-        return hashBytes(reinterpret_cast<const char*>(strFirst),
-                         reinterpret_cast<const char*>(strFirst + strLength(str)));
-    }
-};
-
-
-
-
-
-
-//######################## implementation ########################
-
-template <class T, class Alloc, class Predicate> inline
-void erase_if(std::vector<T, Alloc>& v, Predicate p)
-{
-    v.erase(std::remove_if(v.begin(), v.end(), p), v.end());
-}
-
-
-namespace impl
-{
-template <class S, class Predicate> inline
-void set_or_map_erase_if(S& s, Predicate p)
-{
-    for (auto it = s.begin(); it != s.end();)
-        if (p(*it))
-            s.erase(it++);
-        else
-            ++it;
-}
-}
-
-
-template <class T, class LessType, class Alloc, class Predicate> inline
-void erase_if(std::set<T, LessType, Alloc>& s, Predicate p) { impl::set_or_map_erase_if(s, p); } //don't make this any more generic! e.g. must not compile for std::vector!!!
-
-
-template <class KeyType, class ValueType, class LessType, class Alloc, class Predicate> inline
-void erase_if(std::map<KeyType, ValueType, LessType, Alloc>& m, Predicate p) { impl::set_or_map_erase_if(m, p); }
-
-
-template <class T, class Alloc, class C> inline
-void append(std::vector<T, Alloc>& v, const C& c) { v.insert(v.end(), c.begin(), c.end()); }
-
-
-template <class T, class LessType, class Alloc, class C> inline
-void append(std::set<T, LessType, Alloc>& s, const C& c) { s.insert(c.begin(), c.end()); }
-
-
-template <class KeyType, class ValueType, class LessType, class Alloc, class C> inline
-void append(std::map<KeyType, ValueType, LessType, Alloc>& m, const C& c) { m.insert(c.begin(), c.end()); }
-
-
-template <class M, class K, class V> inline
-V& map_add_or_update(M& map, const K& key, const V& value) //efficient add or update without "default-constructible" requirement (Effective STL, item 24)
-{
-    auto it = map.lower_bound(key);
-    if (it != map.end() && !(map.key_comp()(key, it->first)))
-    {
-        it->second = value;
-        return it->second;
-    }
-    else
-        return map.insert(it, typename M::value_type(key, value))->second;
-}
-
-
-template <class T, class Alloc> inline
-void removeDuplicates(std::vector<T, Alloc>& v)
-{
-    std::sort(v.begin(), v.end());
-    v.erase(std::unique(v.begin(), v.end()), v.end());
-}
-
-
-template <class ForwardIterator, class T, typename CompLess> inline
-ForwardIterator binary_search(ForwardIterator first, ForwardIterator last, const T& value, CompLess less)
-{
-    first = std::lower_bound(first, last, value, less);
-    if (first != last && !less(value, *first))
-        return first;
-    else
-        return last;
-}
-
-
-template <class BidirectionalIterator, class T> inline
-BidirectionalIterator find_last(const BidirectionalIterator first, const BidirectionalIterator last, const T& value)
-{
-    for (BidirectionalIterator it = last; it != first;) //reverse iteration: 1. check 2. decrement 3. evaluate
-    {
-        --it; //
-
-        if (*it == value)
-            return it;
-    }
-    return last;
-}
-
-
-template <class BidirectionalIterator1, class BidirectionalIterator2> inline
-BidirectionalIterator1 search_last(const BidirectionalIterator1 first1,       BidirectionalIterator1 last1,
-                                   const BidirectionalIterator2 first2, const BidirectionalIterator2 last2)
-{
-    const BidirectionalIterator1 itNotFound = last1;
-
-    //reverse iteration: 1. check 2. decrement 3. evaluate
-    for (;;)
-    {
-        BidirectionalIterator1 it1 = last1;
-        BidirectionalIterator2 it2 = last2;
-
-        for (;;)
-        {
-            if (it2 == first2) return it1;
-            if (it1 == first1) return itNotFound;
-
-            --it1;
-            --it2;
-
-            if (*it1 != *it2) break;
-        }
-        --last1;
-    }
-}
-
-
-template <class InputIterator1, class InputIterator2> inline
-bool equal(InputIterator1 first1, InputIterator1 last1,
-           InputIterator2 first2, InputIterator2 last2)
-{
-    return last1 - first1 == last2 - first2 && std::equal(first1, last1, first2);
-}
-
-
-
-
-template <class ByteIterator> inline
-size_t hashBytes(ByteIterator first, ByteIterator last)
-{
-    //FNV-1a: http://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function
-#ifdef ZEN_BUILD_32BIT
-    const size_t basis = 2166136261U;
-#elif defined ZEN_BUILD_64BIT
-    const size_t basis = 14695981039346656037ULL;
-#endif
-    return hashBytesAppend(basis, first, last);
-}
-
-
-template <class ByteIterator> inline
-size_t hashBytesAppend(size_t hashVal, ByteIterator first, ByteIterator last)
-{
-#ifdef ZEN_BUILD_32BIT
-    const size_t prime = 16777619U;
-#elif defined ZEN_BUILD_64BIT
-    const size_t prime = 1099511628211ULL;
-#endif
-    static_assert(sizeof(typename std::iterator_traits<ByteIterator>::value_type) == 1, "");
-
-    for (; first != last; ++first)
-    {
-        hashVal ^= static_cast<size_t>(*first);
-        hashVal *= prime;
-    }
-    return hashVal;
-}
-}
-
-#endif //STL_TOOLS_H_84567184321434
+// *****************************************************************************
+// * This file is part of the FreeFileSync project. It is distributed under    *
+// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
+// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
+// *****************************************************************************
+
+#ifndef STL_TOOLS_H_84567184321434
+#define STL_TOOLS_H_84567184321434
+
+#include <set>
+#include <map>
+#include <vector>
+#include <memory>
+#include <algorithm>
+#include "type_tools.h"
+#include "build_info.h"
+
+
+//enhancements for <algorithm>
+namespace zen
+{
+//erase selected elements from any container:
+template <class T, class Alloc, class Predicate>
+void erase_if(std::vector<T, Alloc>& v, Predicate p);
+
+template <class T, class LessType, class Alloc, class Predicate>
+void erase_if(std::set<T, LessType, Alloc>& s, Predicate p);
+
+template <class KeyType, class ValueType, class LessType, class Alloc, class Predicate>
+void erase_if(std::map<KeyType, ValueType, LessType, Alloc>& m, Predicate p);
+
+//append STL containers
+template <class T, class Alloc, class C>
+void append(std::vector<T, Alloc>& v, const C& c);
+
+template <class T, class LessType, class Alloc, class C>
+void append(std::set<T, LessType, Alloc>& s, const C& c);
+
+template <class KeyType, class ValueType, class LessType, class Alloc, class C>
+void append(std::map<KeyType, ValueType, LessType, Alloc>& m, const C& c);
+
+template <class M, class K, class V>
+V& map_add_or_update(M& map, const K& key, const V& value); //efficient add or update without "default-constructible" requirement (Effective STL, item 24)
+
+template <class T, class Alloc>
+void removeDuplicates(std::vector<T, Alloc>& v);
+
+//binary search returning an iterator
+template <class ForwardIterator, class T, typename CompLess>
+ForwardIterator binary_search(ForwardIterator first, ForwardIterator last, const T& value, CompLess less);
+
+template <class BidirectionalIterator, class T>
+BidirectionalIterator find_last(BidirectionalIterator first, BidirectionalIterator last, const T& value);
+
+//replacement for std::find_end taking advantage of bidirectional iterators (and giving the algorithm a reasonable name)
+template <class BidirectionalIterator1, class BidirectionalIterator2>
+BidirectionalIterator1 search_last(BidirectionalIterator1 first1, BidirectionalIterator1 last1,
+                                   BidirectionalIterator2 first2, BidirectionalIterator2 last2);
+
+template <class InputIterator1, class InputIterator2>
+bool equal(InputIterator1 first1, InputIterator1 last1,
+           InputIterator2 first2, InputIterator2 last2);
+
+template <class ByteIterator> size_t hashBytes                      (ByteIterator first, ByteIterator last);
+template <class ByteIterator> size_t hashBytesAppend(size_t hashVal, ByteIterator first, ByteIterator last);
+
+
+//support for custom string classes in std::unordered_set/map
+struct StringHash
+{
+    template <class String>
+    size_t operator()(const String& str) const
+    {
+        const auto* strFirst = strBegin(str);
+        return hashBytes(reinterpret_cast<const char*>(strFirst),
+                         reinterpret_cast<const char*>(strFirst + strLength(str)));
+    }
+};
+
+
+
+
+
+
+//######################## implementation ########################
+
+template <class T, class Alloc, class Predicate> inline
+void erase_if(std::vector<T, Alloc>& v, Predicate p)
+{
+    v.erase(std::remove_if(v.begin(), v.end(), p), v.end());
+}
+
+
+namespace impl
+{
+template <class S, class Predicate> inline
+void set_or_map_erase_if(S& s, Predicate p)
+{
+    for (auto it = s.begin(); it != s.end();)
+        if (p(*it))
+            s.erase(it++);
+        else
+            ++it;
+}
+}
+
+
+template <class T, class LessType, class Alloc, class Predicate> inline
+void erase_if(std::set<T, LessType, Alloc>& s, Predicate p) { impl::set_or_map_erase_if(s, p); } //don't make this any more generic! e.g. must not compile for std::vector!!!
+
+
+template <class KeyType, class ValueType, class LessType, class Alloc, class Predicate> inline
+void erase_if(std::map<KeyType, ValueType, LessType, Alloc>& m, Predicate p) { impl::set_or_map_erase_if(m, p); }
+
+
+template <class T, class Alloc, class C> inline
+void append(std::vector<T, Alloc>& v, const C& c) { v.insert(v.end(), c.begin(), c.end()); }
+
+
+template <class T, class LessType, class Alloc, class C> inline
+void append(std::set<T, LessType, Alloc>& s, const C& c) { s.insert(c.begin(), c.end()); }
+
+
+template <class KeyType, class ValueType, class LessType, class Alloc, class C> inline
+void append(std::map<KeyType, ValueType, LessType, Alloc>& m, const C& c) { m.insert(c.begin(), c.end()); }
+
+
+template <class M, class K, class V> inline
+V& map_add_or_update(M& map, const K& key, const V& value) //efficient add or update without "default-constructible" requirement (Effective STL, item 24)
+{
+    auto it = map.lower_bound(key);
+    if (it != map.end() && !(map.key_comp()(key, it->first)))
+    {
+        it->second = value;
+        return it->second;
+    }
+    else
+        return map.insert(it, typename M::value_type(key, value))->second;
+}
+
+
+template <class T, class Alloc> inline
+void removeDuplicates(std::vector<T, Alloc>& v)
+{
+    std::sort(v.begin(), v.end());
+    v.erase(std::unique(v.begin(), v.end()), v.end());
+}
+
+
+template <class ForwardIterator, class T, typename CompLess> inline
+ForwardIterator binary_search(ForwardIterator first, ForwardIterator last, const T& value, CompLess less)
+{
+    first = std::lower_bound(first, last, value, less);
+    if (first != last && !less(value, *first))
+        return first;
+    else
+        return last;
+}
+
+
+template <class BidirectionalIterator, class T> inline
+BidirectionalIterator find_last(const BidirectionalIterator first, const BidirectionalIterator last, const T& value)
+{
+    for (BidirectionalIterator it = last; it != first;) //reverse iteration: 1. check 2. decrement 3. evaluate
+    {
+        --it; //
+
+        if (*it == value)
+            return it;
+    }
+    return last;
+}
+
+
+template <class BidirectionalIterator1, class BidirectionalIterator2> inline
+BidirectionalIterator1 search_last(const BidirectionalIterator1 first1,       BidirectionalIterator1 last1,
+                                   const BidirectionalIterator2 first2, const BidirectionalIterator2 last2)
+{
+    const BidirectionalIterator1 itNotFound = last1;
+
+    //reverse iteration: 1. check 2. decrement 3. evaluate
+    for (;;)
+    {
+        BidirectionalIterator1 it1 = last1;
+        BidirectionalIterator2 it2 = last2;
+
+        for (;;)
+        {
+            if (it2 == first2) return it1;
+            if (it1 == first1) return itNotFound;
+
+            --it1;
+            --it2;
+
+            if (*it1 != *it2) break;
+        }
+        --last1;
+    }
+}
+
+
+template <class InputIterator1, class InputIterator2> inline
+bool equal(InputIterator1 first1, InputIterator1 last1,
+           InputIterator2 first2, InputIterator2 last2)
+{
+    return last1 - first1 == last2 - first2 && std::equal(first1, last1, first2);
+}
+
+
+
+
+template <class ByteIterator> inline
+size_t hashBytes(ByteIterator first, ByteIterator last)
+{
+    //FNV-1a: http://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function
+#ifdef ZEN_BUILD_32BIT
+    const size_t basis = 2166136261U;
+#elif defined ZEN_BUILD_64BIT
+    const size_t basis = 14695981039346656037ULL;
+#endif
+    return hashBytesAppend(basis, first, last);
+}
+
+
+template <class ByteIterator> inline
+size_t hashBytesAppend(size_t hashVal, ByteIterator first, ByteIterator last)
+{
+#ifdef ZEN_BUILD_32BIT
+    const size_t prime = 16777619U;
+#elif defined ZEN_BUILD_64BIT
+    const size_t prime = 1099511628211ULL;
+#endif
+    static_assert(sizeof(typename std::iterator_traits<ByteIterator>::value_type) == 1, "");
+
+    for (; first != last; ++first)
+    {
+        hashVal ^= static_cast<size_t>(*first);
+        hashVal *= prime;
+    }
+    return hashVal;
+}
+}
+
+#endif //STL_TOOLS_H_84567184321434
diff --git a/zen/string_base.h b/zen/string_base.h
index b5e45c0e..2ec2e894 100755
--- a/zen/string_base.h
+++ b/zen/string_base.h
@@ -1,613 +1,613 @@
-// *****************************************************************************
-// * This file is part of the FreeFileSync project. It is distributed under    *
-// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
-// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
-// *****************************************************************************
-
-#ifndef STRING_BASE_H_083217454562342526
-#define STRING_BASE_H_083217454562342526
-
-#include <algorithm>
-#include <cassert>
-#include <cstdint>
-#include <atomic>
-#include "string_tools.h"
-
-//Zbase - a policy based string class optimizing performance and flexibility
-
-namespace zen
-{
-/*
-Allocator Policy:
------------------
-    void* allocate(size_t size) //throw std::bad_alloc
-    void deallocate(void* ptr)
-    size_t calcCapacity(size_t length)
-*/
-class AllocatorOptimalSpeed //exponential growth + min size
-{
-protected:
-    //::operator new/ ::operator delete show same performance characterisics like malloc()/free()!
-    static void* allocate(size_t size) { return ::malloc(size); } //throw std::bad_alloc
-    static void  deallocate(void* ptr) { ::free(ptr); }
-    static size_t calcCapacity(size_t length) { return std::max<size_t>(16, std::max(length + length / 2, length)); }
-    //- size_t might overflow! => better catch here than return a too small size covering up the real error: a way too large length!
-    //- any growth rate should not exceed golden ratio: 1.618033989
-};
-
-
-class AllocatorOptimalMemory //no wasted memory, but more reallocations required when manipulating string
-{
-protected:
-    static void* allocate(size_t size) { return ::malloc(size); } //throw std::bad_alloc
-    static void  deallocate(void* ptr) { ::free(ptr); }
-    static size_t calcCapacity(size_t length) { return length; }
-};
-
-/*
-Storage Policy:
----------------
-template <typename Char, //Character Type
-         class AP>       //Allocator Policy
-
-    Char* create(size_t size)
-    Char* create(size_t size, size_t minCapacity)
-    Char* clone(Char* ptr)
-    void destroy(Char* ptr) //must handle "destroy(nullptr)"!
-    bool canWrite(const Char* ptr, size_t minCapacity) //needs to be checked before writing to "ptr"
-    size_t length(const Char* ptr)
-    void setLength(Char* ptr, size_t newLength)
-*/
-
-template <class Char, //Character Type
-          class AP>   //Allocator Policy
-class StorageDeepCopy : public AP
-{
-protected:
-    ~StorageDeepCopy() {}
-
-    Char* create(size_t size) { return create(size, size); }
-    Char* create(size_t size, size_t minCapacity)
-    {
-        assert(size <= minCapacity);
-        const size_t newCapacity = AP::calcCapacity(minCapacity);
-        assert(newCapacity >= minCapacity);
-
-        Descriptor* const newDescr = static_cast<Descriptor*>(this->allocate(sizeof(Descriptor) + (newCapacity + 1) * sizeof(Char))); //throw std::bad_alloc
-        new (newDescr) Descriptor(size, newCapacity);
-
-        return reinterpret_cast<Char*>(newDescr + 1); //alignment note: "newDescr + 1" is Descriptor-aligned, which is larger than alignment for Char-array! => no problem!
-    }
-
-    Char* clone(Char* ptr)
-    {
-        const size_t len = length(ptr);
-        Char* newData = create(len); //throw std::bad_alloc
-        std::copy(ptr, ptr + len + 1, newData);
-        return newData;
-    }
-
-    void destroy(Char* ptr)
-    {
-        if (!ptr) return; //support "destroy(nullptr)"
-
-        Descriptor* const d = descr(ptr);
-        d->~Descriptor();
-        this->deallocate(d);
-    }
-
-    //this needs to be checked before writing to "ptr"
-    static bool canWrite(const Char* ptr, size_t minCapacity) { return minCapacity <= descr(ptr)->capacity; }
-    static size_t length(const Char* ptr) { return descr(ptr)->length; }
-
-    static void setLength(Char* ptr, size_t newLength)
-    {
-        assert(canWrite(ptr, newLength));
-        descr(ptr)->length = newLength;
-    }
-
-private:
-    struct Descriptor
-    {
-        Descriptor(size_t len, size_t cap) :
-            length  (static_cast<uint32_t>(len)),
-            capacity(static_cast<uint32_t>(cap)) {}
-
-        uint32_t length;
-        uint32_t capacity; //allocated size without null-termination
-    };
-
-    static       Descriptor* descr(      Char* ptr) { return reinterpret_cast<      Descriptor*>(ptr) - 1; }
-    static const Descriptor* descr(const Char* ptr) { return reinterpret_cast<const Descriptor*>(ptr) - 1; }
-};
-
-
-template <class Char, //Character Type
-          class AP>   //Allocator Policy
-class StorageRefCountThreadSafe : public AP
-{
-protected:
-    ~StorageRefCountThreadSafe() {}
-
-    Char* create(size_t size) { return create(size, size); }
-    Char* create(size_t size, size_t minCapacity)
-    {
-        assert(size <= minCapacity);
-
-        const size_t newCapacity = AP::calcCapacity(minCapacity);
-        assert(newCapacity >= minCapacity);
-
-        Descriptor* const newDescr = static_cast<Descriptor*>(this->allocate(sizeof(Descriptor) + (newCapacity + 1) * sizeof(Char))); //throw std::bad_alloc
-        new (newDescr) Descriptor(size, newCapacity);
-
-        return reinterpret_cast<Char*>(newDescr + 1);
-    }
-
-    static Char* clone(Char* ptr)
-    {
-        ++descr(ptr)->refCount;
-        return ptr;
-    }
-
-    void destroy(Char* ptr)
-    {
-        assert(ptr != reinterpret_cast<Char*>(0x1)); //detect double-deletion
-
-        if (!ptr) //support "destroy(nullptr)"
-        {
-            return;
-        }
-
-        Descriptor* const d = descr(ptr);
-
-        if (--(d->refCount) == 0) //operator--() is overloaded to decrement and evaluate in a single atomic operation!
-        {
-            d->~Descriptor();
-            this->deallocate(d);
-        }
-    }
-
-    static bool canWrite(const Char* ptr, size_t minCapacity) //needs to be checked before writing to "ptr"
-    {
-        const Descriptor* const d = descr(ptr);
-        assert(d->refCount > 0);
-        return d->refCount == 1 && minCapacity <= d->capacity;
-    }
-
-    static size_t length(const Char* ptr) { return descr(ptr)->length; }
-
-    static void setLength(Char* ptr, size_t newLength)
-    {
-        assert(canWrite(ptr, newLength));
-        descr(ptr)->length = static_cast<uint32_t>(newLength);
-    }
-
-private:
-    struct Descriptor
-    {
-        Descriptor(size_t len, size_t cap) :
-            length  (static_cast<uint32_t>(len)),
-            capacity(static_cast<uint32_t>(cap)) { static_assert(ATOMIC_INT_LOCK_FREE == 2, ""); } //2: "The atomic type is always lock-free"
-
-        std::atomic<unsigned int> refCount { 1 }; //std:atomic is uninitialized by default!
-        uint32_t length;
-        uint32_t capacity; //allocated size without null-termination
-    };
-
-    static       Descriptor* descr(      Char* ptr) { return reinterpret_cast<      Descriptor*>(ptr) - 1; }
-    static const Descriptor* descr(const Char* ptr) { return reinterpret_cast<const Descriptor*>(ptr) - 1; }
-};
-
-
-template <class Char>
-using DefaultStoragePolicy = StorageRefCountThreadSafe<Char, AllocatorOptimalSpeed>;
-
-
-//################################################################################################################################################################
-
-//perf note: interestingly StorageDeepCopy and StorageRefCountThreadSafe show same performance in FFS comparison
-
-template <class Char,                                       //Character Type
-          template <class> class SP = DefaultStoragePolicy> //Storage Policy
-class Zbase : public SP<Char>
-{
-public:
-    Zbase();
-    Zbase(const Char* str) : Zbase(str, str + strLength(str)) {} //implicit conversion from a C-string!
-    Zbase(const Char* str, size_t len) : Zbase(str, str + len) {}
-    Zbase(const Zbase& str);
-    Zbase(Zbase&& tmp) noexcept;
-    template <class InputIterator>
-    Zbase(InputIterator first, InputIterator last);
-    //explicit Zbase(Char ch); //dangerous if implicit: Char buffer[]; return buffer[0]; ups... forgot &, but not a compiler error! //-> non-standard extension!!!
-
-    ~Zbase();
-
-    //operator const Char* () const; //NO implicit conversion to a C-string!! Many problems... one of them: if we forget to provide operator overloads, it'll just work with a Char*...
-
-    //STL accessors
-    using iterator        = Char*;
-    using const_iterator  = const Char*;
-    using reference       = Char&;
-    using const_reference = const Char&;
-    using value_type      = Char;
-
-    iterator begin();
-    iterator end  ();
-    const_iterator begin () const { return rawStr_; }
-    const_iterator end   () const { return rawStr_ + length(); }
-    const_iterator cbegin() const { return begin(); }
-    const_iterator cend  () const { return end  (); }
-
-    //std::string functions
-    size_t length() const;
-    size_t size  () const { return length(); }
-    const Char* c_str() const { return rawStr_; } //C-string format with 0-termination
-    const Char operator[](size_t pos) const;
-    bool empty() const { return length() == 0; }
-    void clear();
-    size_t find (const Zbase& str, size_t pos = 0)    const; //
-    size_t find (const Char* str,  size_t pos = 0)    const; //
-    size_t find (Char  ch,         size_t pos = 0)    const; //returns "npos" if not found
-    size_t rfind(Char  ch,         size_t pos = npos) const; //
-    size_t rfind(const Char* str,  size_t pos = npos) const; //
-    //Zbase& replace(size_t pos1, size_t n1, const Zbase& str);
-    void reserve(size_t minCapacity);
-    Zbase& assign(const Char* str, size_t len) { return assign(str, str + len); }
-    Zbase& append(const Char* str, size_t len) { return append(str, str + len); }
-
-    template <class InputIterator> Zbase& assign(InputIterator first, InputIterator last);
-    template <class InputIterator> Zbase& append(InputIterator first, InputIterator last);
-
-    void resize(size_t newSize, Char fillChar = 0);
-    void swap(Zbase& str) { std::swap(rawStr_, str.rawStr_); }
-    void push_back(Char val) { operator+=(val); } //STL access
-    void pop_back();
-
-    Zbase& operator=(Zbase&& tmp) noexcept;
-    Zbase& operator=(const Zbase& str);
-    Zbase& operator=(const Char* str)   { return assign(str, strLength(str)); }
-    Zbase& operator=(Char ch)           { return assign(&ch, 1); }
-    Zbase& operator+=(const Zbase& str) { return append(str.c_str(), str.length()); }
-    Zbase& operator+=(const Char* str)  { return append(str, strLength(str)); }
-    Zbase& operator+=(Char ch)          { return append(&ch, 1); }
-
-    static const size_t npos = static_cast<size_t>(-1);
-
-private:
-    Zbase            (int) = delete; //
-    Zbase& operator= (int) = delete; //detect usage errors by creating an intentional ambiguity with "Char"
-    Zbase& operator+=(int) = delete; //
-    void   push_back (int) = delete; //
-
-    Char* rawStr_;
-};
-
-template <class Char, template <class> class SP>        bool operator==(const Zbase<Char, SP>& lhs, const Zbase<Char, SP>& rhs);
-template <class Char, template <class> class SP>        bool operator==(const Zbase<Char, SP>& lhs, const Char*            rhs);
-template <class Char, template <class> class SP> inline bool operator==(const Char*            lhs, const Zbase<Char, SP>& rhs) { return operator==(rhs, lhs); }
-
-template <class Char, template <class> class SP> inline bool operator!=(const Zbase<Char, SP>& lhs, const Zbase<Char, SP>& rhs) { return !operator==(lhs, rhs); }
-template <class Char, template <class> class SP> inline bool operator!=(const Zbase<Char, SP>& lhs, const Char*            rhs) { return !operator==(lhs, rhs); }
-template <class Char, template <class> class SP> inline bool operator!=(const Char*            lhs, const Zbase<Char, SP>& rhs) { return !operator==(lhs, rhs); }
-
-template <class Char, template <class> class SP> bool operator<(const Zbase<Char, SP>& lhs, const Zbase<Char, SP>& rhs);
-template <class Char, template <class> class SP> bool operator<(const Zbase<Char, SP>& lhs, const Char*            rhs);
-template <class Char, template <class> class SP> bool operator<(const Char*            lhs, const Zbase<Char, SP>& rhs);
-
-template <class Char, template <class> class SP> inline Zbase<Char, SP> operator+(const Zbase<Char, SP>& lhs, const Zbase<Char, SP>& rhs) { return Zbase<Char, SP>(lhs) += rhs; }
-template <class Char, template <class> class SP> inline Zbase<Char, SP> operator+(const Zbase<Char, SP>& lhs, const Char*            rhs) { return Zbase<Char, SP>(lhs) += rhs; }
-template <class Char, template <class> class SP> inline Zbase<Char, SP> operator+(const Zbase<Char, SP>& lhs,       Char             rhs) { return Zbase<Char, SP>(lhs) += rhs; }
-
-//don't use unified first argument but save one move-construction in the r-value case instead!
-template <class Char, template <class> class SP> inline Zbase<Char, SP> operator+(Zbase<Char, SP>&& lhs, const Zbase<Char, SP>& rhs) { return std::move(lhs += rhs); } //the move *is* needed!!!
-template <class Char, template <class> class SP> inline Zbase<Char, SP> operator+(Zbase<Char, SP>&& lhs, const Char*            rhs) { return std::move(lhs += rhs); } //lhs, is an l-value parameter...
-template <class Char, template <class> class SP> inline Zbase<Char, SP> operator+(Zbase<Char, SP>&& lhs,       Char             rhs) { return std::move(lhs += rhs); } //and not a local variable => no copy elision
-
-template <class Char, template <class> class SP> inline Zbase<Char, SP> operator+(      Char        lhs, const Zbase<Char, SP>& rhs) { return Zbase<Char, SP>(&lhs, 1) += rhs; }
-template <class Char, template <class> class SP> inline Zbase<Char, SP> operator+(const Char*       lhs, const Zbase<Char, SP>& rhs) { return Zbase<Char, SP>(lhs    ) += rhs; }
-
-
-
-
-
-
-
-
-
-
-
-
-
-//################################# implementation ########################################
-template <class Char, template <class> class SP> inline
-Zbase<Char, SP>::Zbase()
-{
-    //resist the temptation to avoid this allocation by referening a static global: NO performance advantage, MT issues!
-    rawStr_    = this->create(0);
-    rawStr_[0] = 0;
-}
-
-
-template <class Char, template <class> class SP>
-template <class InputIterator> inline
-Zbase<Char, SP>::Zbase(InputIterator first, InputIterator last)
-{
-    rawStr_ = this->create(std::distance(first, last));
-    *std::copy(first, last, rawStr_) = 0;
-}
-
-
-template <class Char, template <class> class SP> inline
-Zbase<Char, SP>::Zbase(const Zbase<Char, SP>& str)
-{
-    rawStr_ = this->clone(str.rawStr_);
-}
-
-
-template <class Char, template <class> class SP> inline
-Zbase<Char, SP>::Zbase(Zbase<Char, SP>&& tmp) noexcept
-{
-    rawStr_ = tmp.rawStr_;
-    tmp.rawStr_ = nullptr; //usually nullptr would violate the class invarants, but it is good enough for the destructor!
-    //caveat: do not increment ref-count of an unshared string! We'd lose optimization opportunity of reusing its memory!
-}
-
-
-template <class Char, template <class> class SP> inline
-Zbase<Char, SP>::~Zbase()
-{
-    static_assert(noexcept(this->~Zbase()), ""); //has exception spec of compiler-generated destructor by default
-
-    this->destroy(rawStr_); //rawStr_ may be nullptr; see move constructor!
-}
-
-
-template <class Char, template <class> class SP> inline
-size_t Zbase<Char, SP>::find(const Zbase& str, size_t pos) const
-{
-    assert(pos <= length());
-    const size_t len = length();
-    const Char* thisEnd = begin() + len; //respect embedded 0
-    const Char* it = std::search(begin() + std::min(pos, len), thisEnd,
-                                 str.begin(), str.end());
-    return it == thisEnd ? npos : it - begin();
-}
-
-
-template <class Char, template <class> class SP> inline
-size_t Zbase<Char, SP>::find(const Char* str, size_t pos) const
-{
-    assert(pos <= length());
-    const size_t len = length();
-    const Char* thisEnd = begin() + len; //respect embedded 0
-    const Char* it = std::search(begin() + std::min(pos, len), thisEnd,
-                                 str, str + strLength(str));
-    return it == thisEnd ? npos : it - begin();
-}
-
-
-template <class Char, template <class> class SP> inline
-size_t Zbase<Char, SP>::find(Char ch, size_t pos) const
-{
-    assert(pos <= length());
-    const size_t len = length();
-    const Char* thisEnd = begin() + len; //respect embedded 0
-    const Char* it = std::find(begin() + std::min(pos, len), thisEnd, ch);
-    return it == thisEnd ? npos : it - begin();
-}
-
-
-template <class Char, template <class> class SP> inline
-size_t Zbase<Char, SP>::rfind(Char ch, size_t pos) const
-{
-    assert(pos == npos || pos <= length());
-    const size_t len = length();
-    const Char* currEnd = begin() + (pos == npos ? len : std::min(pos + 1, len));
-    const Char* it = find_last(begin(), currEnd, ch);
-    return it == currEnd ? npos : it - begin();
-}
-
-
-template <class Char, template <class> class SP> inline
-size_t Zbase<Char, SP>::rfind(const Char* str, size_t pos) const
-{
-    assert(pos == npos || pos <= length());
-    const size_t strLen = strLength(str);
-    const size_t len = length();
-    const Char* currEnd = begin() + (pos == npos ? len : std::min(pos + strLen, len));
-    const Char* it = search_last(begin(), currEnd,
-                                 str, str + strLen);
-    return it == currEnd ? npos : it - begin();
-}
-
-
-template <class Char, template <class> class SP> inline
-void Zbase<Char, SP>::resize(size_t newSize, Char fillChar)
-{
-    const size_t oldSize = length();
-    if (this->canWrite(rawStr_, newSize))
-    {
-        if (oldSize < newSize)
-            std::fill(rawStr_ + oldSize, rawStr_ + newSize, fillChar);
-        rawStr_[newSize] = 0;
-        this->setLength(rawStr_, newSize);
-    }
-    else
-    {
-        Char* newStr = this->create(newSize);
-        if (oldSize < newSize)
-        {
-            std::copy(rawStr_, rawStr_ + oldSize, newStr);
-            std::fill(newStr + oldSize, newStr + newSize, fillChar);
-        }
-        else
-            std::copy(rawStr_, rawStr_ + newSize, newStr);
-        newStr[newSize] = 0;
-
-        this->destroy(rawStr_);
-        rawStr_ = newStr;
-    }
-}
-
-
-template <class Char, template <class> class SP> inline
-bool operator==(const Zbase<Char, SP>& lhs, const Zbase<Char, SP>& rhs)
-{
-    return lhs.length() == rhs.length() && std::equal(lhs.begin(), lhs.end(), rhs.begin()); //respect embedded 0
-}
-
-
-template <class Char, template <class> class SP> inline
-bool operator==(const Zbase<Char, SP>& lhs, const Char* rhs)
-{
-    return lhs.length() == strLength(rhs) && std::equal(lhs.begin(), lhs.end(), rhs); //respect embedded 0
-}
-
-
-template <class Char, template <class> class SP> inline
-bool operator<(const Zbase<Char, SP>& lhs, const Zbase<Char, SP>& rhs)
-{
-    return std::lexicographical_compare(lhs.begin(), lhs.end(), //respect embedded 0
-                                        rhs.begin(), rhs.end());
-}
-
-
-template <class Char, template <class> class SP> inline
-bool operator<(const Zbase<Char, SP>& lhs, const Char* rhs)
-{
-    return std::lexicographical_compare(lhs.begin(), lhs.end(), //respect embedded 0
-                                        rhs, rhs + strLength(rhs));
-}
-
-
-template <class Char, template <class> class SP> inline
-bool operator<(const Char* lhs, const Zbase<Char, SP>& rhs)
-{
-    return std::lexicographical_compare(lhs, lhs + strLength(lhs), //respect embedded 0
-                                        rhs.begin(), rhs.end());
-}
-
-
-template <class Char, template <class> class SP> inline
-size_t Zbase<Char, SP>::length() const
-{
-    return SP<Char>::length(rawStr_);
-}
-
-
-template <class Char, template <class> class SP> inline
-const Char Zbase<Char, SP>::operator[](size_t pos) const
-{
-    assert(pos < length()); //design by contract! no runtime check!
-    return rawStr_[pos];
-}
-
-
-template <class Char, template <class> class SP> inline
-auto Zbase<Char, SP>::begin() -> iterator
-{
-    reserve(length()); //make unshared!
-    return rawStr_;
-}
-
-
-template <class Char, template <class> class SP> inline
-auto Zbase<Char, SP>::end() -> iterator
-{
-    return begin() + length();
-}
-
-
-template <class Char, template <class> class SP> inline
-void Zbase<Char, SP>::clear()
-{
-    if (!empty())
-    {
-        if (this->canWrite(rawStr_, 0))
-        {
-            rawStr_[0] = 0;              //keep allocated memory
-            this->setLength(rawStr_, 0); //
-        }
-        else
-            *this = Zbase();
-    }
-}
-
-
-template <class Char, template <class> class SP> inline
-void Zbase<Char, SP>::reserve(size_t minCapacity) //make unshared and check capacity
-{
-    if (!this->canWrite(rawStr_, minCapacity))
-    {
-        //allocate a new string
-        const size_t len = length();
-        Char* newStr = this->create(len, std::max(len, minCapacity)); //reserve() must NEVER shrink the string: logical const!
-        std::copy(rawStr_, rawStr_ + len + 1, newStr); //include 0-termination
-
-        this->destroy(rawStr_);
-        rawStr_ = newStr;
-    }
-}
-
-
-template <class Char, template <class> class SP>
-template <class InputIterator> inline
-Zbase<Char, SP>& Zbase<Char, SP>::assign(InputIterator first, InputIterator last)
-{
-    const size_t len = std::distance(first, last);
-    if (this->canWrite(rawStr_, len))
-    {
-        *std::copy(first, last, rawStr_) = 0;
-        this->setLength(rawStr_, len);
-    }
-    else
-        *this = Zbase(first, last);
-
-    return *this;
-}
-
-
-template <class Char, template <class> class SP>
-template <class InputIterator> inline
-Zbase<Char, SP>& Zbase<Char, SP>::append(InputIterator first, InputIterator last)
-{
-    const size_t len = std::distance(first, last);
-	if (len > 0) //avoid making this string unshared for no reason
-	{
-		const size_t thisLen = length();
-		reserve(thisLen + len); //make unshared and check capacity
-
-		*std::copy(first, last, rawStr_ + thisLen) = 0;
-		this->setLength(rawStr_, thisLen + len);
-	}
-    return *this;
-}
-
-
-template <class Char, template <class> class SP> inline
-Zbase<Char, SP>& Zbase<Char, SP>::operator=(const Zbase<Char, SP>& str)
-{
-    Zbase<Char, SP>(str).swap(*this);
-    return *this;
-}
-
-
-template <class Char, template <class> class SP> inline
-Zbase<Char, SP>& Zbase<Char, SP>::operator=(Zbase<Char, SP>&& tmp) noexcept
-{
-    swap(tmp); //don't use unifying assignment but save one move-construction in the r-value case instead!
-    return *this;
-}
-
-template <class Char, template <class> class SP> inline
-void Zbase<Char, SP>::pop_back()
-{
-    const size_t len = length();
-    assert(len > 0);
-    if (len > 0)
-        resize(len - 1);
-}
-}
-
-#endif //STRING_BASE_H_083217454562342526
+// *****************************************************************************
+// * This file is part of the FreeFileSync project. It is distributed under    *
+// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
+// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
+// *****************************************************************************
+
+#ifndef STRING_BASE_H_083217454562342526
+#define STRING_BASE_H_083217454562342526
+
+#include <algorithm>
+#include <cassert>
+#include <cstdint>
+#include <atomic>
+#include "string_tools.h"
+
+//Zbase - a policy based string class optimizing performance and flexibility
+
+namespace zen
+{
+/*
+Allocator Policy:
+-----------------
+    void* allocate(size_t size) //throw std::bad_alloc
+    void deallocate(void* ptr)
+    size_t calcCapacity(size_t length)
+*/
+class AllocatorOptimalSpeed //exponential growth + min size
+{
+protected:
+    //::operator new/ ::operator delete show same performance characterisics like malloc()/free()!
+    static void* allocate(size_t size) { return ::malloc(size); } //throw std::bad_alloc
+    static void  deallocate(void* ptr) { ::free(ptr); }
+    static size_t calcCapacity(size_t length) { return std::max<size_t>(16, std::max(length + length / 2, length)); }
+    //- size_t might overflow! => better catch here than return a too small size covering up the real error: a way too large length!
+    //- any growth rate should not exceed golden ratio: 1.618033989
+};
+
+
+class AllocatorOptimalMemory //no wasted memory, but more reallocations required when manipulating string
+{
+protected:
+    static void* allocate(size_t size) { return ::malloc(size); } //throw std::bad_alloc
+    static void  deallocate(void* ptr) { ::free(ptr); }
+    static size_t calcCapacity(size_t length) { return length; }
+};
+
+/*
+Storage Policy:
+---------------
+template <typename Char, //Character Type
+         class AP>       //Allocator Policy
+
+    Char* create(size_t size)
+    Char* create(size_t size, size_t minCapacity)
+    Char* clone(Char* ptr)
+    void destroy(Char* ptr) //must handle "destroy(nullptr)"!
+    bool canWrite(const Char* ptr, size_t minCapacity) //needs to be checked before writing to "ptr"
+    size_t length(const Char* ptr)
+    void setLength(Char* ptr, size_t newLength)
+*/
+
+template <class Char, //Character Type
+          class AP>   //Allocator Policy
+class StorageDeepCopy : public AP
+{
+protected:
+    ~StorageDeepCopy() {}
+
+    Char* create(size_t size) { return create(size, size); }
+    Char* create(size_t size, size_t minCapacity)
+    {
+        assert(size <= minCapacity);
+        const size_t newCapacity = AP::calcCapacity(minCapacity);
+        assert(newCapacity >= minCapacity);
+
+        Descriptor* const newDescr = static_cast<Descriptor*>(this->allocate(sizeof(Descriptor) + (newCapacity + 1) * sizeof(Char))); //throw std::bad_alloc
+        new (newDescr) Descriptor(size, newCapacity);
+
+        return reinterpret_cast<Char*>(newDescr + 1); //alignment note: "newDescr + 1" is Descriptor-aligned, which is larger than alignment for Char-array! => no problem!
+    }
+
+    Char* clone(Char* ptr)
+    {
+        const size_t len = length(ptr);
+        Char* newData = create(len); //throw std::bad_alloc
+        std::copy(ptr, ptr + len + 1, newData);
+        return newData;
+    }
+
+    void destroy(Char* ptr)
+    {
+        if (!ptr) return; //support "destroy(nullptr)"
+
+        Descriptor* const d = descr(ptr);
+        d->~Descriptor();
+        this->deallocate(d);
+    }
+
+    //this needs to be checked before writing to "ptr"
+    static bool canWrite(const Char* ptr, size_t minCapacity) { return minCapacity <= descr(ptr)->capacity; }
+    static size_t length(const Char* ptr) { return descr(ptr)->length; }
+
+    static void setLength(Char* ptr, size_t newLength)
+    {
+        assert(canWrite(ptr, newLength));
+        descr(ptr)->length = newLength;
+    }
+
+private:
+    struct Descriptor
+    {
+        Descriptor(size_t len, size_t cap) :
+            length  (static_cast<uint32_t>(len)),
+            capacity(static_cast<uint32_t>(cap)) {}
+
+        uint32_t length;
+        uint32_t capacity; //allocated size without null-termination
+    };
+
+    static       Descriptor* descr(      Char* ptr) { return reinterpret_cast<      Descriptor*>(ptr) - 1; }
+    static const Descriptor* descr(const Char* ptr) { return reinterpret_cast<const Descriptor*>(ptr) - 1; }
+};
+
+
+template <class Char, //Character Type
+          class AP>   //Allocator Policy
+class StorageRefCountThreadSafe : public AP
+{
+protected:
+    ~StorageRefCountThreadSafe() {}
+
+    Char* create(size_t size) { return create(size, size); }
+    Char* create(size_t size, size_t minCapacity)
+    {
+        assert(size <= minCapacity);
+
+        const size_t newCapacity = AP::calcCapacity(minCapacity);
+        assert(newCapacity >= minCapacity);
+
+        Descriptor* const newDescr = static_cast<Descriptor*>(this->allocate(sizeof(Descriptor) + (newCapacity + 1) * sizeof(Char))); //throw std::bad_alloc
+        new (newDescr) Descriptor(size, newCapacity);
+
+        return reinterpret_cast<Char*>(newDescr + 1);
+    }
+
+    static Char* clone(Char* ptr)
+    {
+        ++descr(ptr)->refCount;
+        return ptr;
+    }
+
+    void destroy(Char* ptr)
+    {
+        assert(ptr != reinterpret_cast<Char*>(0x1)); //detect double-deletion
+
+        if (!ptr) //support "destroy(nullptr)"
+        {
+            return;
+        }
+
+        Descriptor* const d = descr(ptr);
+
+        if (--(d->refCount) == 0) //operator--() is overloaded to decrement and evaluate in a single atomic operation!
+        {
+            d->~Descriptor();
+            this->deallocate(d);
+        }
+    }
+
+    static bool canWrite(const Char* ptr, size_t minCapacity) //needs to be checked before writing to "ptr"
+    {
+        const Descriptor* const d = descr(ptr);
+        assert(d->refCount > 0);
+        return d->refCount == 1 && minCapacity <= d->capacity;
+    }
+
+    static size_t length(const Char* ptr) { return descr(ptr)->length; }
+
+    static void setLength(Char* ptr, size_t newLength)
+    {
+        assert(canWrite(ptr, newLength));
+        descr(ptr)->length = static_cast<uint32_t>(newLength);
+    }
+
+private:
+    struct Descriptor
+    {
+        Descriptor(size_t len, size_t cap) :
+            length  (static_cast<uint32_t>(len)),
+            capacity(static_cast<uint32_t>(cap)) { static_assert(ATOMIC_INT_LOCK_FREE == 2, ""); } //2: "The atomic type is always lock-free"
+
+        std::atomic<unsigned int> refCount { 1 }; //std:atomic is uninitialized by default!
+        uint32_t length;
+        uint32_t capacity; //allocated size without null-termination
+    };
+
+    static       Descriptor* descr(      Char* ptr) { return reinterpret_cast<      Descriptor*>(ptr) - 1; }
+    static const Descriptor* descr(const Char* ptr) { return reinterpret_cast<const Descriptor*>(ptr) - 1; }
+};
+
+
+template <class Char>
+using DefaultStoragePolicy = StorageRefCountThreadSafe<Char, AllocatorOptimalSpeed>;
+
+
+//################################################################################################################################################################
+
+//perf note: interestingly StorageDeepCopy and StorageRefCountThreadSafe show same performance in FFS comparison
+
+template <class Char,                                       //Character Type
+          template <class> class SP = DefaultStoragePolicy> //Storage Policy
+class Zbase : public SP<Char>
+{
+public:
+    Zbase();
+    Zbase(const Char* str) : Zbase(str, str + strLength(str)) {} //implicit conversion from a C-string!
+    Zbase(const Char* str, size_t len) : Zbase(str, str + len) {}
+    Zbase(const Zbase& str);
+    Zbase(Zbase&& tmp) noexcept;
+    template <class InputIterator>
+    Zbase(InputIterator first, InputIterator last);
+    //explicit Zbase(Char ch); //dangerous if implicit: Char buffer[]; return buffer[0]; ups... forgot &, but not a compiler error! //-> non-standard extension!!!
+
+    ~Zbase();
+
+    //operator const Char* () const; //NO implicit conversion to a C-string!! Many problems... one of them: if we forget to provide operator overloads, it'll just work with a Char*...
+
+    //STL accessors
+    using iterator        = Char*;
+    using const_iterator  = const Char*;
+    using reference       = Char&;
+    using const_reference = const Char&;
+    using value_type      = Char;
+
+    iterator begin();
+    iterator end  ();
+    const_iterator begin () const { return rawStr_; }
+    const_iterator end   () const { return rawStr_ + length(); }
+    const_iterator cbegin() const { return begin(); }
+    const_iterator cend  () const { return end  (); }
+
+    //std::string functions
+    size_t length() const;
+    size_t size  () const { return length(); }
+    const Char* c_str() const { return rawStr_; } //C-string format with 0-termination
+    const Char operator[](size_t pos) const;
+    bool empty() const { return length() == 0; }
+    void clear();
+    size_t find (const Zbase& str, size_t pos = 0)    const; //
+    size_t find (const Char* str,  size_t pos = 0)    const; //
+    size_t find (Char  ch,         size_t pos = 0)    const; //returns "npos" if not found
+    size_t rfind(Char  ch,         size_t pos = npos) const; //
+    size_t rfind(const Char* str,  size_t pos = npos) const; //
+    //Zbase& replace(size_t pos1, size_t n1, const Zbase& str);
+    void reserve(size_t minCapacity);
+    Zbase& assign(const Char* str, size_t len) { return assign(str, str + len); }
+    Zbase& append(const Char* str, size_t len) { return append(str, str + len); }
+
+    template <class InputIterator> Zbase& assign(InputIterator first, InputIterator last);
+    template <class InputIterator> Zbase& append(InputIterator first, InputIterator last);
+
+    void resize(size_t newSize, Char fillChar = 0);
+    void swap(Zbase& str) { std::swap(rawStr_, str.rawStr_); }
+    void push_back(Char val) { operator+=(val); } //STL access
+    void pop_back();
+
+    Zbase& operator=(Zbase&& tmp) noexcept;
+    Zbase& operator=(const Zbase& str);
+    Zbase& operator=(const Char* str)   { return assign(str, strLength(str)); }
+    Zbase& operator=(Char ch)           { return assign(&ch, 1); }
+    Zbase& operator+=(const Zbase& str) { return append(str.c_str(), str.length()); }
+    Zbase& operator+=(const Char* str)  { return append(str, strLength(str)); }
+    Zbase& operator+=(Char ch)          { return append(&ch, 1); }
+
+    static const size_t npos = static_cast<size_t>(-1);
+
+private:
+    Zbase            (int) = delete; //
+    Zbase& operator= (int) = delete; //detect usage errors by creating an intentional ambiguity with "Char"
+    Zbase& operator+=(int) = delete; //
+    void   push_back (int) = delete; //
+
+    Char* rawStr_;
+};
+
+template <class Char, template <class> class SP>        bool operator==(const Zbase<Char, SP>& lhs, const Zbase<Char, SP>& rhs);
+template <class Char, template <class> class SP>        bool operator==(const Zbase<Char, SP>& lhs, const Char*            rhs);
+template <class Char, template <class> class SP> inline bool operator==(const Char*            lhs, const Zbase<Char, SP>& rhs) { return operator==(rhs, lhs); }
+
+template <class Char, template <class> class SP> inline bool operator!=(const Zbase<Char, SP>& lhs, const Zbase<Char, SP>& rhs) { return !operator==(lhs, rhs); }
+template <class Char, template <class> class SP> inline bool operator!=(const Zbase<Char, SP>& lhs, const Char*            rhs) { return !operator==(lhs, rhs); }
+template <class Char, template <class> class SP> inline bool operator!=(const Char*            lhs, const Zbase<Char, SP>& rhs) { return !operator==(lhs, rhs); }
+
+template <class Char, template <class> class SP> bool operator<(const Zbase<Char, SP>& lhs, const Zbase<Char, SP>& rhs);
+template <class Char, template <class> class SP> bool operator<(const Zbase<Char, SP>& lhs, const Char*            rhs);
+template <class Char, template <class> class SP> bool operator<(const Char*            lhs, const Zbase<Char, SP>& rhs);
+
+template <class Char, template <class> class SP> inline Zbase<Char, SP> operator+(const Zbase<Char, SP>& lhs, const Zbase<Char, SP>& rhs) { return Zbase<Char, SP>(lhs) += rhs; }
+template <class Char, template <class> class SP> inline Zbase<Char, SP> operator+(const Zbase<Char, SP>& lhs, const Char*            rhs) { return Zbase<Char, SP>(lhs) += rhs; }
+template <class Char, template <class> class SP> inline Zbase<Char, SP> operator+(const Zbase<Char, SP>& lhs,       Char             rhs) { return Zbase<Char, SP>(lhs) += rhs; }
+
+//don't use unified first argument but save one move-construction in the r-value case instead!
+template <class Char, template <class> class SP> inline Zbase<Char, SP> operator+(Zbase<Char, SP>&& lhs, const Zbase<Char, SP>& rhs) { return std::move(lhs += rhs); } //the move *is* needed!!!
+template <class Char, template <class> class SP> inline Zbase<Char, SP> operator+(Zbase<Char, SP>&& lhs, const Char*            rhs) { return std::move(lhs += rhs); } //lhs, is an l-value parameter...
+template <class Char, template <class> class SP> inline Zbase<Char, SP> operator+(Zbase<Char, SP>&& lhs,       Char             rhs) { return std::move(lhs += rhs); } //and not a local variable => no copy elision
+
+template <class Char, template <class> class SP> inline Zbase<Char, SP> operator+(      Char        lhs, const Zbase<Char, SP>& rhs) { return Zbase<Char, SP>(&lhs, 1) += rhs; }
+template <class Char, template <class> class SP> inline Zbase<Char, SP> operator+(const Char*       lhs, const Zbase<Char, SP>& rhs) { return Zbase<Char, SP>(lhs    ) += rhs; }
+
+
+
+
+
+
+
+
+
+
+
+
+
+//################################# implementation ########################################
+template <class Char, template <class> class SP> inline
+Zbase<Char, SP>::Zbase()
+{
+    //resist the temptation to avoid this allocation by referening a static global: NO performance advantage, MT issues!
+    rawStr_    = this->create(0);
+    rawStr_[0] = 0;
+}
+
+
+template <class Char, template <class> class SP>
+template <class InputIterator> inline
+Zbase<Char, SP>::Zbase(InputIterator first, InputIterator last)
+{
+    rawStr_ = this->create(std::distance(first, last));
+    *std::copy(first, last, rawStr_) = 0;
+}
+
+
+template <class Char, template <class> class SP> inline
+Zbase<Char, SP>::Zbase(const Zbase<Char, SP>& str)
+{
+    rawStr_ = this->clone(str.rawStr_);
+}
+
+
+template <class Char, template <class> class SP> inline
+Zbase<Char, SP>::Zbase(Zbase<Char, SP>&& tmp) noexcept
+{
+    rawStr_ = tmp.rawStr_;
+    tmp.rawStr_ = nullptr; //usually nullptr would violate the class invarants, but it is good enough for the destructor!
+    //caveat: do not increment ref-count of an unshared string! We'd lose optimization opportunity of reusing its memory!
+}
+
+
+template <class Char, template <class> class SP> inline
+Zbase<Char, SP>::~Zbase()
+{
+    static_assert(noexcept(this->~Zbase()), ""); //has exception spec of compiler-generated destructor by default
+
+    this->destroy(rawStr_); //rawStr_ may be nullptr; see move constructor!
+}
+
+
+template <class Char, template <class> class SP> inline
+size_t Zbase<Char, SP>::find(const Zbase& str, size_t pos) const
+{
+    assert(pos <= length());
+    const size_t len = length();
+    const Char* thisEnd = begin() + len; //respect embedded 0
+    const Char* it = std::search(begin() + std::min(pos, len), thisEnd,
+                                 str.begin(), str.end());
+    return it == thisEnd ? npos : it - begin();
+}
+
+
+template <class Char, template <class> class SP> inline
+size_t Zbase<Char, SP>::find(const Char* str, size_t pos) const
+{
+    assert(pos <= length());
+    const size_t len = length();
+    const Char* thisEnd = begin() + len; //respect embedded 0
+    const Char* it = std::search(begin() + std::min(pos, len), thisEnd,
+                                 str, str + strLength(str));
+    return it == thisEnd ? npos : it - begin();
+}
+
+
+template <class Char, template <class> class SP> inline
+size_t Zbase<Char, SP>::find(Char ch, size_t pos) const
+{
+    assert(pos <= length());
+    const size_t len = length();
+    const Char* thisEnd = begin() + len; //respect embedded 0
+    const Char* it = std::find(begin() + std::min(pos, len), thisEnd, ch);
+    return it == thisEnd ? npos : it - begin();
+}
+
+
+template <class Char, template <class> class SP> inline
+size_t Zbase<Char, SP>::rfind(Char ch, size_t pos) const
+{
+    assert(pos == npos || pos <= length());
+    const size_t len = length();
+    const Char* currEnd = begin() + (pos == npos ? len : std::min(pos + 1, len));
+    const Char* it = find_last(begin(), currEnd, ch);
+    return it == currEnd ? npos : it - begin();
+}
+
+
+template <class Char, template <class> class SP> inline
+size_t Zbase<Char, SP>::rfind(const Char* str, size_t pos) const
+{
+    assert(pos == npos || pos <= length());
+    const size_t strLen = strLength(str);
+    const size_t len = length();
+    const Char* currEnd = begin() + (pos == npos ? len : std::min(pos + strLen, len));
+    const Char* it = search_last(begin(), currEnd,
+                                 str, str + strLen);
+    return it == currEnd ? npos : it - begin();
+}
+
+
+template <class Char, template <class> class SP> inline
+void Zbase<Char, SP>::resize(size_t newSize, Char fillChar)
+{
+    const size_t oldSize = length();
+    if (this->canWrite(rawStr_, newSize))
+    {
+        if (oldSize < newSize)
+            std::fill(rawStr_ + oldSize, rawStr_ + newSize, fillChar);
+        rawStr_[newSize] = 0;
+        this->setLength(rawStr_, newSize);
+    }
+    else
+    {
+        Char* newStr = this->create(newSize);
+        if (oldSize < newSize)
+        {
+            std::copy(rawStr_, rawStr_ + oldSize, newStr);
+            std::fill(newStr + oldSize, newStr + newSize, fillChar);
+        }
+        else
+            std::copy(rawStr_, rawStr_ + newSize, newStr);
+        newStr[newSize] = 0;
+
+        this->destroy(rawStr_);
+        rawStr_ = newStr;
+    }
+}
+
+
+template <class Char, template <class> class SP> inline
+bool operator==(const Zbase<Char, SP>& lhs, const Zbase<Char, SP>& rhs)
+{
+    return lhs.length() == rhs.length() && std::equal(lhs.begin(), lhs.end(), rhs.begin()); //respect embedded 0
+}
+
+
+template <class Char, template <class> class SP> inline
+bool operator==(const Zbase<Char, SP>& lhs, const Char* rhs)
+{
+    return lhs.length() == strLength(rhs) && std::equal(lhs.begin(), lhs.end(), rhs); //respect embedded 0
+}
+
+
+template <class Char, template <class> class SP> inline
+bool operator<(const Zbase<Char, SP>& lhs, const Zbase<Char, SP>& rhs)
+{
+    return std::lexicographical_compare(lhs.begin(), lhs.end(), //respect embedded 0
+                                        rhs.begin(), rhs.end());
+}
+
+
+template <class Char, template <class> class SP> inline
+bool operator<(const Zbase<Char, SP>& lhs, const Char* rhs)
+{
+    return std::lexicographical_compare(lhs.begin(), lhs.end(), //respect embedded 0
+                                        rhs, rhs + strLength(rhs));
+}
+
+
+template <class Char, template <class> class SP> inline
+bool operator<(const Char* lhs, const Zbase<Char, SP>& rhs)
+{
+    return std::lexicographical_compare(lhs, lhs + strLength(lhs), //respect embedded 0
+                                        rhs.begin(), rhs.end());
+}
+
+
+template <class Char, template <class> class SP> inline
+size_t Zbase<Char, SP>::length() const
+{
+    return SP<Char>::length(rawStr_);
+}
+
+
+template <class Char, template <class> class SP> inline
+const Char Zbase<Char, SP>::operator[](size_t pos) const
+{
+    assert(pos < length()); //design by contract! no runtime check!
+    return rawStr_[pos];
+}
+
+
+template <class Char, template <class> class SP> inline
+auto Zbase<Char, SP>::begin() -> iterator
+{
+    reserve(length()); //make unshared!
+    return rawStr_;
+}
+
+
+template <class Char, template <class> class SP> inline
+auto Zbase<Char, SP>::end() -> iterator
+{
+    return begin() + length();
+}
+
+
+template <class Char, template <class> class SP> inline
+void Zbase<Char, SP>::clear()
+{
+    if (!empty())
+    {
+        if (this->canWrite(rawStr_, 0))
+        {
+            rawStr_[0] = 0;              //keep allocated memory
+            this->setLength(rawStr_, 0); //
+        }
+        else
+            *this = Zbase();
+    }
+}
+
+
+template <class Char, template <class> class SP> inline
+void Zbase<Char, SP>::reserve(size_t minCapacity) //make unshared and check capacity
+{
+    if (!this->canWrite(rawStr_, minCapacity))
+    {
+        //allocate a new string
+        const size_t len = length();
+        Char* newStr = this->create(len, std::max(len, minCapacity)); //reserve() must NEVER shrink the string: logical const!
+        std::copy(rawStr_, rawStr_ + len + 1, newStr); //include 0-termination
+
+        this->destroy(rawStr_);
+        rawStr_ = newStr;
+    }
+}
+
+
+template <class Char, template <class> class SP>
+template <class InputIterator> inline
+Zbase<Char, SP>& Zbase<Char, SP>::assign(InputIterator first, InputIterator last)
+{
+    const size_t len = std::distance(first, last);
+    if (this->canWrite(rawStr_, len))
+    {
+        *std::copy(first, last, rawStr_) = 0;
+        this->setLength(rawStr_, len);
+    }
+    else
+        *this = Zbase(first, last);
+
+    return *this;
+}
+
+
+template <class Char, template <class> class SP>
+template <class InputIterator> inline
+Zbase<Char, SP>& Zbase<Char, SP>::append(InputIterator first, InputIterator last)
+{
+    const size_t len = std::distance(first, last);
+	if (len > 0) //avoid making this string unshared for no reason
+	{
+		const size_t thisLen = length();
+		reserve(thisLen + len); //make unshared and check capacity
+
+		*std::copy(first, last, rawStr_ + thisLen) = 0;
+		this->setLength(rawStr_, thisLen + len);
+	}
+    return *this;
+}
+
+
+template <class Char, template <class> class SP> inline
+Zbase<Char, SP>& Zbase<Char, SP>::operator=(const Zbase<Char, SP>& str)
+{
+    Zbase<Char, SP>(str).swap(*this);
+    return *this;
+}
+
+
+template <class Char, template <class> class SP> inline
+Zbase<Char, SP>& Zbase<Char, SP>::operator=(Zbase<Char, SP>&& tmp) noexcept
+{
+    swap(tmp); //don't use unifying assignment but save one move-construction in the r-value case instead!
+    return *this;
+}
+
+template <class Char, template <class> class SP> inline
+void Zbase<Char, SP>::pop_back()
+{
+    const size_t len = length();
+    assert(len > 0);
+    if (len > 0)
+        resize(len - 1);
+}
+}
+
+#endif //STRING_BASE_H_083217454562342526
diff --git a/zen/string_tools.h b/zen/string_tools.h
index 236f8df6..bfa14257 100755
--- a/zen/string_tools.h
+++ b/zen/string_tools.h
@@ -1,763 +1,763 @@
-// *****************************************************************************
-// * This file is part of the FreeFileSync project. It is distributed under    *
-// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
-// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
-// *****************************************************************************
-
-#ifndef STRING_TOOLS_H_213458973046
-#define STRING_TOOLS_H_213458973046
-
-#include <cctype>  //isspace
-#include <cwctype> //iswspace
-#include <cstdio>  //sprintf
-#include <cwchar>  //swprintf
-#include <algorithm>
-#include <cassert>
-#include <vector>
-#include <sstream>
-#include "stl_tools.h"
-#include "string_traits.h"
-
-
-//enhance arbitray string class with useful non-member functions:
-namespace zen
-{
-template <class Char> bool isWhiteSpace(Char ch);
-template <class Char> bool isDigit     (Char ch); //not exactly the same as "std::isdigit" -> we consider '0'-'9' only!
-template <class Char> bool isHexDigit  (Char ch);
-template <class Char> bool isAsciiAlpha(Char ch);
-
-//case-sensitive comparison (compile-time correctness:  use different number of arguments as STL comparison predicates!)
-struct CmpBinary { template <class Char> int operator()(const Char* lhs, size_t lhsLen, const Char* rhs, size_t rhsLen) const; };
-
-//basic case-insensitive comparison (considering A-Z only!)
-struct CmpAsciiNoCase { template <class Char> int operator()(const Char* lhs, size_t lhsLen, const Char* rhs, size_t rhsLen) const; };
-
-struct LessAsciiNoCase
-{
-    template <class S> //don't support heterogenous input! => use as container predicate only!
-    bool operator()(const S& lhs, const S& rhs) const { return CmpAsciiNoCase()(strBegin(lhs), strLength(lhs), strBegin(rhs), strLength(rhs)) < 0; }
-};
-
-//both S and T can be strings or char/wchar_t arrays or simple char/wchar_t
-template <class S, class T> bool contains(const S& str, const T& term);
-
-template <class S, class T>                 bool startsWith(const S& str, const T& prefix);
-template <class S, class T, class Function> bool startsWith(const S& str, const T& prefix,  Function cmpStringFun);
-
-template <class S, class T>                 bool endsWith  (const S& str, const T& postfix);
-template <class S, class T, class Function> bool endsWith  (const S& str, const T& postfix, Function cmpStringFun);
-
-template <class S, class T>                 bool strEqual(const S& lhs, const T& rhs);
-template <class S, class T, class Function> bool strEqual(const S& lhs, const T& rhs, Function cmpStringFun);
-
-enum FailureReturnVal
-{
-    IF_MISSING_RETURN_ALL,
-    IF_MISSING_RETURN_NONE
-};
-
-template <class S, class T> S afterLast  (const S& str, const T& term, FailureReturnVal rv);
-template <class S, class T> S beforeLast (const S& str, const T& term, FailureReturnVal rv);
-template <class S, class T> S afterFirst (const S& str, const T& term, FailureReturnVal rv);
-template <class S, class T> S beforeFirst(const S& str, const T& term, FailureReturnVal rv);
-
-enum class SplitType
-{
-    ALLOW_EMPTY,
-    SKIP_EMPTY
-};
-template <class S, class T> std::vector<S> split(const S& str, const T& delimiter, SplitType st);
-
-template <class S>                 S    trimCpy(S  str, bool fromLeft = true, bool fromRight = true);
-template <class S>                 void trim   (S& str, bool fromLeft = true, bool fromRight = true);
-template <class S, class Function> void trim(S& str, bool fromLeft, bool fromRight, Function trimThisChar);
-
-template <class S, class T, class U> void replace   (      S& str, const T& oldTerm, const U& newTerm, bool replaceAll = true);
-template <class S, class T, class U> S    replaceCpy(const S& str, const T& oldTerm, const U& newTerm, bool replaceAll = true);
-
-//high-performance conversion between numbers and strings
-template <class S,   class Num> S   numberTo(const Num& number);
-template <class Num, class S>   Num stringTo(const S&   str);
-
-std::pair<char, char> hexify  (unsigned char c, bool upperCase = true);
-char                  unhexify(char high, char low);
-
-template <class S, class T, class Num> S printNumber(const T& format, const Num& number); //format a single number using std::snprintf()
-
-//string to string conversion: converts string-like type into char-compatible target string class
-template <class T, class S> T copyStringTo(S&& str);
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-//---------------------- implementation ----------------------
-template <> inline
-bool isWhiteSpace(char ch)
-{
-    assert(ch != 0); //std C++ does not consider 0 as white space
-    //caveat 1: std::isspace() takes an int, but expects an unsigned char
-    //caveat 2: some parts of UTF-8 chars are erroneously seen as whitespace, e.g. the a0 from "\xec\x8b\xa0" (MSVC)
-    return static_cast<unsigned char>(ch) < 128 &&
-           std::isspace(static_cast<unsigned char>(ch)) != 0;
-}
-
-template <> inline
-bool isWhiteSpace(wchar_t ch)
-{
-    assert(ch != 0); //std C++ does not consider 0 as white space
-    return std::iswspace(ch) != 0;
-}
-
-
-template <class Char> inline
-bool isDigit(Char ch) //similar to implmenetation of std::isdigit()!
-{
-    static_assert(IsSameType<Char, char>::value || IsSameType<Char, wchar_t>::value, "");
-    return static_cast<Char>('0') <= ch && ch <= static_cast<Char>('9');
-}
-
-
-template <class Char> inline
-bool isHexDigit(Char c)
-{
-    static_assert(IsSameType<Char, char>::value || IsSameType<Char, wchar_t>::value, "");
-    return (static_cast<Char>('0') <= c && c <= static_cast<Char>('9')) ||
-           (static_cast<Char>('A') <= c && c <= static_cast<Char>('F')) ||
-           (static_cast<Char>('a') <= c && c <= static_cast<Char>('f'));
-}
-
-
-template <class Char> inline
-bool isAsciiAlpha(Char c)
-{
-    static_assert(IsSameType<Char, char>::value || IsSameType<Char, wchar_t>::value, "");
-    return (static_cast<Char>('A') <= c && c <= static_cast<Char>('Z')) ||
-           (static_cast<Char>('a') <= c && c <= static_cast<Char>('z'));
-}
-
-
-template <class S, class T, class Function> inline
-bool startsWith(const S& str, const T& prefix, Function cmpStringFun)
-{
-    const size_t pfLen = strLength(prefix);
-    if (strLength(str) < pfLen)
-        return false;
-
-    return cmpStringFun(strBegin(str),    pfLen,
-                        strBegin(prefix), pfLen) == 0;
-}
-
-
-template <class S, class T, class Function> inline
-bool endsWith(const S& str, const T& postfix, Function cmpStringFun)
-{
-    const size_t strLen = strLength(str);
-    const size_t pfLen  = strLength(postfix);
-    if (strLen < pfLen)
-        return false;
-
-    return cmpStringFun(strBegin(str) + strLen - pfLen, pfLen,
-                        strBegin(postfix), pfLen) == 0;
-}
-
-
-template <class S, class T, class Function> inline
-bool strEqual(const S& lhs, const T& rhs, Function cmpStringFun)
-{
-    return cmpStringFun(strBegin(lhs), strLength(lhs), strBegin(rhs), strLength(rhs)) == 0;
-}
-
-
-template <class S, class T> inline bool startsWith(const S& str, const T& prefix ) { return startsWith(str, prefix,  CmpBinary()); }
-template <class S, class T> inline bool endsWith  (const S& str, const T& postfix) { return endsWith  (str, postfix, CmpBinary()); }
-template <class S, class T> inline bool strEqual  (const S& lhs, const T& rhs    ) { return strEqual  (lhs, rhs,     CmpBinary()); }
-
-
-template <class S, class T> inline
-bool contains(const S& str, const T& term)
-{
-    static_assert(IsSameType<typename GetCharType<S>::Type, typename GetCharType<T>::Type>::value, "");
-    const size_t strLen  = strLength(str);
-    const size_t termLen = strLength(term);
-    if (strLen < termLen)
-        return false;
-
-    const auto* const strFirst  = strBegin(str);
-    const auto* const strLast   = strFirst + strLen;
-    const auto* const termFirst = strBegin(term);
-
-    return std::search(strFirst, strLast,
-                       termFirst, termFirst + termLen) != strLast;
-}
-
-
-template <class S, class T> inline
-S afterLast(const S& str, const T& term, FailureReturnVal rv)
-{
-    static_assert(IsSameType<typename GetCharType<S>::Type, typename GetCharType<T>::Type>::value, "");
-    const size_t termLen = strLength(term);
-    assert(termLen > 0);
-
-    const auto* const strFirst  = strBegin(str);
-    const auto* const strLast   = strFirst + strLength(str);
-    const auto* const termFirst = strBegin(term);
-
-    const auto* it = search_last(strFirst, strLast,
-                                 termFirst, termFirst + termLen);
-    if (it == strLast)
-        return rv == IF_MISSING_RETURN_ALL ? str : S();
-
-    it += termLen;
-    return S(it, strLast - it);
-}
-
-
-template <class S, class T> inline
-S beforeLast(const S& str, const T& term, FailureReturnVal rv)
-{
-    static_assert(IsSameType<typename GetCharType<S>::Type, typename GetCharType<T>::Type>::value, "");
-    const size_t termLen = strLength(term);
-    assert(termLen > 0);
-
-    const auto* const strFirst  = strBegin(str);
-    const auto* const strLast   = strFirst + strLength(str);
-    const auto* const termFirst = strBegin(term);
-
-    const auto* it = search_last(strFirst, strLast,
-                                 termFirst, termFirst + termLen);
-    if (it == strLast)
-        return rv == IF_MISSING_RETURN_ALL ? str : S();
-
-    return S(strFirst, it - strFirst);
-}
-
-
-template <class S, class T> inline
-S afterFirst(const S& str, const T& term, FailureReturnVal rv)
-{
-    static_assert(IsSameType<typename GetCharType<S>::Type, typename GetCharType<T>::Type>::value, "");
-    const size_t termLen = strLength(term);
-    assert(termLen > 0);
-
-    const auto* const strFirst  = strBegin(str);
-    const auto* const strLast   = strFirst + strLength(str);
-    const auto* const termFirst = strBegin(term);
-
-    const auto* it = std::search(strFirst, strLast,
-                                 termFirst, termFirst + termLen);
-    if (it == strLast)
-        return rv == IF_MISSING_RETURN_ALL ? str : S();
-
-    it += termLen;
-    return S(it, strLast - it);
-}
-
-
-template <class S, class T> inline
-S beforeFirst(const S& str, const T& term, FailureReturnVal rv)
-{
-    static_assert(IsSameType<typename GetCharType<S>::Type, typename GetCharType<T>::Type>::value, "");
-    const size_t termLen = strLength(term);
-    assert(termLen > 0);
-
-    const auto* const strFirst  = strBegin(str);
-    const auto* const strLast   = strFirst + strLength(str);
-    const auto* const termFirst = strBegin(term);
-
-    auto it = std::search(strFirst, strLast,
-                          termFirst,  termFirst  + termLen);
-    if (it == strLast)
-        return rv == IF_MISSING_RETURN_ALL ? str : S();
-
-    return S(strFirst, it - strFirst);
-}
-
-
-template <class S, class T> inline
-std::vector<S> split(const S& str, const T& delimiter, SplitType st)
-{
-    static_assert(IsSameType<typename GetCharType<S>::Type, typename GetCharType<T>::Type>::value, "");
-    const size_t delimLen = strLength(delimiter);
-    assert(delimLen > 0);
-    if (delimLen == 0)
-    {
-        if (str.empty() && st == SplitType::SKIP_EMPTY)
-            return {};
-        return { str };
-    }
-
-    const auto* const delimFirst = strBegin(delimiter);
-    const auto* const delimLast  = delimFirst + delimLen;
-
-    const auto* blockStart    = strBegin(str);
-    const auto* const strLast = blockStart + strLength(str);
-
-    std::vector<S> output;
-    for (;;)
-    {
-        const auto* const blockEnd = std::search(blockStart, strLast,
-                                                 delimFirst, delimLast);
-        if (blockStart != blockEnd || st == SplitType::ALLOW_EMPTY)
-            output.emplace_back(blockStart, blockEnd - blockStart);
-
-        if (blockEnd == strLast)
-            return output;
-        blockStart = blockEnd + delimLen;
-    }
-}
-
-
-namespace impl
-{
-ZEN_INIT_DETECT_MEMBER(append);
-
-//either call operator+=(S(str, len)) or append(str, len)
-template <class S, class InputIterator> inline
-typename EnableIf<HasMember_append<S>::value>::Type stringAppend(S& str, InputIterator first, InputIterator last) { str.append(first, last);  }
-
-template <class S, class InputIterator> inline
-typename EnableIf<!HasMember_append<S>::value>::Type stringAppend(S& str, InputIterator first, InputIterator last) { str += S(first, last); }
-}
-
-
-template <class S, class T, class U> inline
-S replaceCpy(const S& str, const T& oldTerm, const U& newTerm, bool replaceAll)
-{
-    static_assert(IsSameType<typename GetCharType<S>::Type, typename GetCharType<T>::Type>::value, "");
-    static_assert(IsSameType<typename GetCharType<T>::Type, typename GetCharType<U>::Type>::value, "");
-    const size_t oldLen = strLength(oldTerm);
-    if (oldLen == 0)
-        return str;
-
-    const auto* const oldBegin = strBegin(oldTerm);
-    const auto* const oldEnd   = oldBegin + oldLen;
-
-    const auto* const newBegin = strBegin(newTerm);
-    const auto* const newEnd   = newBegin + strLength(newTerm);
-
-    S output;
-
-    for (auto it = str.begin();;)
-    {
-        const auto itFound = std::search(it, str.end(),
-                                         oldBegin, oldEnd);
-        if (itFound == str.end() && it == str.begin())
-            return str; //optimize "oldTerm not found": return ref-counted copy
-
-        impl::stringAppend(output, it, itFound);
-        if (itFound == str.end())
-            return output;
-
-        impl::stringAppend(output, newBegin, newEnd);
-        it = itFound + oldLen;
-
-        if (!replaceAll)
-        {
-            impl::stringAppend(output, it, str.end());
-            return output;
-        }
-    }
-}
-
-
-template <class S, class T, class U> inline
-void replace(S& str, const T& oldTerm, const U& newTerm, bool replaceAll)
-{
-    str = replaceCpy(str, oldTerm, newTerm, replaceAll);
-}
-
-
-template <class S, class Function> inline
-void trim(S& str, bool fromLeft, bool fromRight, Function trimThisChar)
-{
-    assert(fromLeft || fromRight);
-
-    const auto* const oldBegin = strBegin(str);
-    const auto*       newBegin = oldBegin;
-    const auto*       newEnd   = oldBegin + strLength(str);
-
-    if (fromRight)
-        while (newBegin != newEnd && trimThisChar(newEnd[-1]))
-            --newEnd;
-
-    if (fromLeft)
-        while (newBegin != newEnd && trimThisChar(*newBegin))
-            ++newBegin;
-
-    if (newBegin != oldBegin)
-        str = S(newBegin, newEnd - newBegin); //minor inefficiency: in case "str" is not shared, we could save an allocation and do a memory move only
-    else
-        str.resize(newEnd - newBegin);
-}
-
-
-template <class S> inline
-void trim(S& str, bool fromLeft, bool fromRight)
-{
-    using CharType = typename GetCharType<S>::Type;
-    trim(str, fromLeft, fromRight, [](CharType c) { return isWhiteSpace(c); });
-}
-
-
-template <class S> inline
-S trimCpy(S str, bool fromLeft, bool fromRight)
-{
-    //implementing trimCpy() in terms of trim(), instead of the other way round, avoids memory allocations when trimming from right!
-    trim(str, fromLeft, fromRight);
-    return std::move(str); //"str" is an l-value parameter => no copy elision!
-}
-
-
-namespace impl
-{
-template <class S, class T>
-struct CopyStringToString
-{
-    T copy(const S& src) const { return T(strBegin(src), strLength(src)); }
-};
-
-template <class T>
-struct CopyStringToString<T, T> //perf: we don't need a deep copy if string types match
-{
-    template <class S>
-    T copy(S&& str) const { return std::forward<S>(str); }
-};
-
-inline int strcmpWithNulls(const char*    ptr1, const char*    ptr2, size_t num) { return std::memcmp (ptr1, ptr2, num); }
-inline int strcmpWithNulls(const wchar_t* ptr1, const wchar_t* ptr2, size_t num) { return std::wmemcmp(ptr1, ptr2, num); }
-}
-
-template <class T, class S> inline
-T copyStringTo(S&& str) { return impl::CopyStringToString<std::decay_t<S>, T>().copy(std::forward<S>(str)); }
-
-
-template <class Char> inline
-int CmpBinary::operator()(const Char* lhs, size_t lhsLen, const Char* rhs, size_t rhsLen) const
-{
-    //support embedded 0, unlike strncmp/wcsncmp!
-    const int rv = impl::strcmpWithNulls(lhs, rhs, std::min(lhsLen, rhsLen));
-    if (rv != 0)
-        return rv;
-    return static_cast<int>(lhsLen) - static_cast<int>(rhsLen);
-}
-
-
-template <class Char> inline
-int CmpAsciiNoCase::operator()(const Char* lhs, size_t lhsLen, const Char* rhs, size_t rhsLen) const
-{
-    auto asciiToLower = [](Char c) //ordering: lower-case chars have higher code points than uppper-case
-    {
-        if (static_cast<Char>('A') <= c && c <= static_cast<Char>('Z'))
-            return static_cast<Char>(c - static_cast<Char>('A') + static_cast<Char>('a'));
-        return c;
-    };
-
-    const auto* const lhsLast = lhs + std::min(lhsLen, rhsLen);
-
-    while (lhs != lhsLast)
-    {
-        const Char charL = asciiToLower(*lhs++);
-        const Char charR = asciiToLower(*rhs++);
-        if (charL != charR)
-            return static_cast<unsigned int>(charL) - static_cast<unsigned int>(charR); //unsigned char-comparison is the convention!
-        //unsigned underflow is well-defined!
-    }
-    return static_cast<int>(lhsLen) - static_cast<int>(rhsLen);
-}
-
-
-namespace impl
-{
-template <class Num> inline
-int saferPrintf(char* buffer, size_t bufferSize, const char* format, const Num& number) //there is no such thing as a "safe" printf ;)
-{
-    return std::snprintf(buffer, bufferSize, format, number); //C99: returns number of chars written if successful, < 0 or >= bufferSize on failure
-}
-
-template <class Num> inline
-int saferPrintf(wchar_t* buffer, size_t bufferSize, const wchar_t* format, const Num& number)
-{
-    return std::swprintf(buffer, bufferSize, format, number); //C99: returns number of chars written if successful, < 0 on failure (including buffer too small)
-}
-}
-
-template <class S, class T, class Num> inline
-S printNumber(const T& format, const Num& number) //format a single number using ::sprintf
-{
-    static_assert(IsSameType<typename GetCharType<S>::Type, typename GetCharType<T>::Type>::value, "");
-    using CharType = typename GetCharType<S>::Type;
-
-    const int BUFFER_SIZE = 128;
-    CharType buffer[BUFFER_SIZE]; //zero-initialize?
-    const int charsWritten = impl::saferPrintf(buffer, BUFFER_SIZE, strBegin(format), number);
-
-    return 0 < charsWritten && charsWritten < BUFFER_SIZE ? S(buffer, charsWritten) : S();
-}
-
-
-namespace impl
-{
-enum NumberType
-{
-    NUM_TYPE_SIGNED_INT,
-    NUM_TYPE_UNSIGNED_INT,
-    NUM_TYPE_FLOATING_POINT,
-    NUM_TYPE_OTHER,
-};
-
-
-template <class S, class Num> inline
-S numberTo(const Num& number, Int2Type<NUM_TYPE_OTHER>) //default number to string conversion using streams: convenient, but SLOW, SLOW, SLOW!!!! (~ factor of 20)
-{
-    using CharType = typename GetCharType<S>::Type;
-
-    std::basic_ostringstream<CharType> ss;
-    ss << number;
-    return copyStringTo<S>(ss.str());
-}
-
-
-template <class S, class Num> inline S floatToString(const Num& number, char   ) { return printNumber<S>( "%g", static_cast<double>(number)); }
-template <class S, class Num> inline S floatToString(const Num& number, wchar_t) { return printNumber<S>(L"%g", static_cast<double>(number)); }
-
-template <class S, class Num> inline
-S numberTo(const Num& number, Int2Type<NUM_TYPE_FLOATING_POINT>)
-{
-    return floatToString<S>(number, typename GetCharType<S>::Type());
-}
-
-
-/*
-perf: integer to string: (executed 10 mio. times)
-    std::stringstream - 14796 ms
-    std::sprintf      -  3086 ms
-    formatInteger     -   778 ms
-*/
-
-template <class OutputIterator, class Num> inline
-void formatNegativeInteger(Num n, OutputIterator& it)
-{
-    assert(n < 0);
-    using CharType = typename std::iterator_traits<OutputIterator>::value_type;
-    do
-    {
-        const Num tmp = n / 10;
-        *--it = static_cast<CharType>('0' + (tmp * 10 - n)); //8% faster than using modulus operator!
-        n = tmp;
-    }
-    while (n != 0);
-
-    *--it = static_cast<CharType>('-');
-}
-
-template <class OutputIterator, class Num> inline
-void formatPositiveInteger(Num n, OutputIterator& it)
-{
-    assert(n >= 0);
-    using CharType = typename std::iterator_traits<OutputIterator>::value_type;
-    do
-    {
-        const Num tmp = n / 10;
-        *--it = static_cast<CharType>('0' + (n - tmp * 10)); //8% faster than using modulus operator!
-        n = tmp;
-    }
-    while (n != 0);
-}
-
-
-template <class S, class Num> inline
-S numberTo(const Num& number, Int2Type<NUM_TYPE_SIGNED_INT>)
-{
-    using CharType = typename GetCharType<S>::Type;
-    CharType buffer[2 + sizeof(Num) * 241 / 100]; //zero-initialize?
-    //it's generally faster to use a buffer than to rely on String::operator+=() (in)efficiency
-    //required chars (+ sign char): 1 + ceil(ln_10(256^sizeof(n) / 2 + 1))    -> divide by 2 for signed half-range; second +1 since one half starts with 1!
-    // <= 1 + ceil(ln_10(256^sizeof(n))) =~ 1 + ceil(sizeof(n) * 2.4082) <= 2 + floor(sizeof(n) * 2.41)
-
-    //caveat: consider INT_MIN: technically -INT_MIN == INT_MIN
-    auto it = std::end(buffer);
-    if (number < 0)
-        formatNegativeInteger(number, it);
-    else
-        formatPositiveInteger(number, it);
-    assert(it >= std::begin(buffer));
-
-    return S(&*it, std::end(buffer) - it);
-}
-
-
-template <class S, class Num> inline
-S numberTo(const Num& number, Int2Type<NUM_TYPE_UNSIGNED_INT>)
-{
-    using CharType = typename GetCharType<S>::Type;
-    CharType buffer[1 + sizeof(Num) * 241 / 100]; //zero-initialize?
-    //required chars: ceil(ln_10(256^sizeof(n))) =~ ceil(sizeof(n) * 2.4082) <= 1 + floor(sizeof(n) * 2.41)
-
-    auto it = std::end(buffer);
-    formatPositiveInteger(number, it);
-    assert(it >= std::begin(buffer));
-
-    return S(&*it, std::end(buffer) - it);
-}
-
-//--------------------------------------------------------------------------------
-
-template <class Num, class S> inline
-Num stringTo(const S& str, Int2Type<NUM_TYPE_OTHER>) //default string to number conversion using streams: convenient, but SLOW
-{
-    using CharType = typename GetCharType<S>::Type;
-    Num number = 0;
-    std::basic_istringstream<CharType>(copyStringTo<std::basic_string<CharType>>(str)) >> number;
-    return number;
-}
-
-
-template <class Num> inline Num stringToFloat(const char*    str) { return std::strtod(str, nullptr); }
-template <class Num> inline Num stringToFloat(const wchar_t* str) { return std::wcstod(str, nullptr); }
-
-template <class Num, class S> inline
-Num stringTo(const S& str, Int2Type<NUM_TYPE_FLOATING_POINT>)
-{
-    return stringToFloat<Num>(strBegin(str));
-}
-
-template <class Num, class S>
-Num extractInteger(const S& str, bool& hasMinusSign) //very fast conversion to integers: slightly faster than std::atoi, but more importantly: generic
-{
-    using CharType = typename GetCharType<S>::Type;
-
-    const CharType* first = strBegin(str);
-    const CharType* last  = first + strLength(str);
-
-    while (first != last && isWhiteSpace(*first)) //skip leading whitespace
-        ++first;
-
-    //handle minus sign
-    hasMinusSign = false;
-    if (first != last)
-    {
-        if (*first == static_cast<CharType>('-'))
-        {
-            hasMinusSign = true;
-            ++first;
-        }
-        else if (*first == static_cast<CharType>('+'))
-            ++first;
-    }
-
-    Num number = 0;
-    for (const CharType* it = first; it != last; ++it)
-    {
-        const CharType c = *it;
-        if (static_cast<CharType>('0') <= c && c <= static_cast<CharType>('9'))
-        {
-            number *= 10;
-            number += c - static_cast<CharType>('0');
-        }
-        else //rest of string should contain whitespace only, it's NOT a bug if there is something else!
-            break; //assert(std::all_of(iter, last, &isWhiteSpace<CharType>)); -> this is NO assert situation
-    }
-    return number;
-}
-
-
-template <class Num, class S> inline
-Num stringTo(const S& str, Int2Type<NUM_TYPE_SIGNED_INT>)
-{
-    bool hasMinusSign = false; //handle minus sign
-    const Num number = extractInteger<Num>(str, hasMinusSign);
-    return hasMinusSign ? -number : number;
-}
-
-
-template <class Num, class S> inline
-Num stringTo(const S& str, Int2Type<NUM_TYPE_UNSIGNED_INT>) //very fast conversion to integers: slightly faster than std::atoi, but more importantly: generic
-{
-    bool hasMinusSign = false; //handle minus sign
-    const Num number = extractInteger<Num>(str, hasMinusSign);
-    if (hasMinusSign)
-    {
-        assert(false);
-        return 0U;
-    }
-    return number;
-}
-}
-
-
-template <class S, class Num> inline
-S numberTo(const Num& number)
-{
-    using TypeTag = Int2Type<
-                    IsSignedInt  <Num>::value ? impl::NUM_TYPE_SIGNED_INT :
-                    IsUnsignedInt<Num>::value ? impl::NUM_TYPE_UNSIGNED_INT :
-                    IsFloat      <Num>::value ? impl::NUM_TYPE_FLOATING_POINT :
-                    impl::NUM_TYPE_OTHER>;
-
-    return impl::numberTo<S>(number, TypeTag());
-}
-
-
-template <class Num, class S> inline
-Num stringTo(const S& str)
-{
-    using TypeTag = Int2Type<
-                    IsSignedInt  <Num>::value ? impl::NUM_TYPE_SIGNED_INT :
-                    IsUnsignedInt<Num>::value ? impl::NUM_TYPE_UNSIGNED_INT :
-                    IsFloat      <Num>::value ? impl::NUM_TYPE_FLOATING_POINT :
-                    impl::NUM_TYPE_OTHER>;
-
-    return impl::stringTo<Num>(str, TypeTag());
-}
-
-
-inline //hexify beats "printNumber<std::string>("%02X", c)" by a nice factor of 3!
-std::pair<char, char> hexify(unsigned char c, bool upperCase)
-{
-    auto hexifyDigit = [upperCase](int num) -> char //input [0, 15], output 0-9, A-F
-    {
-        assert(0 <= num&& num <= 15);  //guaranteed by design below!
-        if (num <= 9)
-            return static_cast<char>('0' + num); //no signed/unsigned char problem here!
-
-        if (upperCase)
-            return static_cast<char>('A' + (num - 10));
-        else
-            return static_cast<char>('a' + (num - 10));
-    };
-    return std::make_pair(hexifyDigit(c / 16), hexifyDigit(c % 16));
-}
-
-
-inline //unhexify beats "::sscanf(&it[3], "%02X", &tmp)" by a factor of 3000 for ~250000 calls!!!
-char unhexify(char high, char low)
-{
-    auto unhexifyDigit = [](char hex) -> int //input 0-9, a-f, A-F; output range: [0, 15]
-    {
-        if ('0' <= hex && hex <= '9') //no signed/unsigned char problem here!
-            return hex - '0';
-        else if ('A' <= hex && hex <= 'F')
-            return (hex - 'A') + 10;
-        else if ('a' <= hex && hex <= 'f')
-            return (hex - 'a') + 10;
-        assert(false);
-        return 0;
-    };
-    return static_cast<unsigned char>(16 * unhexifyDigit(high) + unhexifyDigit(low)); //[!] convert to unsigned char first, then to char (which may be signed)
-}
-}
-
-#endif //STRING_TOOLS_H_213458973046
+// *****************************************************************************
+// * This file is part of the FreeFileSync project. It is distributed under    *
+// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
+// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
+// *****************************************************************************
+
+#ifndef STRING_TOOLS_H_213458973046
+#define STRING_TOOLS_H_213458973046
+
+#include <cctype>  //isspace
+#include <cwctype> //iswspace
+#include <cstdio>  //sprintf
+#include <cwchar>  //swprintf
+#include <algorithm>
+#include <cassert>
+#include <vector>
+#include <sstream>
+#include "stl_tools.h"
+#include "string_traits.h"
+
+
+//enhance arbitray string class with useful non-member functions:
+namespace zen
+{
+template <class Char> bool isWhiteSpace(Char ch);
+template <class Char> bool isDigit     (Char ch); //not exactly the same as "std::isdigit" -> we consider '0'-'9' only!
+template <class Char> bool isHexDigit  (Char ch);
+template <class Char> bool isAsciiAlpha(Char ch);
+
+//case-sensitive comparison (compile-time correctness:  use different number of arguments as STL comparison predicates!)
+struct CmpBinary { template <class Char> int operator()(const Char* lhs, size_t lhsLen, const Char* rhs, size_t rhsLen) const; };
+
+//basic case-insensitive comparison (considering A-Z only!)
+struct CmpAsciiNoCase { template <class Char> int operator()(const Char* lhs, size_t lhsLen, const Char* rhs, size_t rhsLen) const; };
+
+struct LessAsciiNoCase
+{
+    template <class S> //don't support heterogenous input! => use as container predicate only!
+    bool operator()(const S& lhs, const S& rhs) const { return CmpAsciiNoCase()(strBegin(lhs), strLength(lhs), strBegin(rhs), strLength(rhs)) < 0; }
+};
+
+//both S and T can be strings or char/wchar_t arrays or simple char/wchar_t
+template <class S, class T> bool contains(const S& str, const T& term);
+
+template <class S, class T>                 bool startsWith(const S& str, const T& prefix);
+template <class S, class T, class Function> bool startsWith(const S& str, const T& prefix,  Function cmpStringFun);
+
+template <class S, class T>                 bool endsWith  (const S& str, const T& postfix);
+template <class S, class T, class Function> bool endsWith  (const S& str, const T& postfix, Function cmpStringFun);
+
+template <class S, class T>                 bool strEqual(const S& lhs, const T& rhs);
+template <class S, class T, class Function> bool strEqual(const S& lhs, const T& rhs, Function cmpStringFun);
+
+enum FailureReturnVal
+{
+    IF_MISSING_RETURN_ALL,
+    IF_MISSING_RETURN_NONE
+};
+
+template <class S, class T> S afterLast  (const S& str, const T& term, FailureReturnVal rv);
+template <class S, class T> S beforeLast (const S& str, const T& term, FailureReturnVal rv);
+template <class S, class T> S afterFirst (const S& str, const T& term, FailureReturnVal rv);
+template <class S, class T> S beforeFirst(const S& str, const T& term, FailureReturnVal rv);
+
+enum class SplitType
+{
+    ALLOW_EMPTY,
+    SKIP_EMPTY
+};
+template <class S, class T> std::vector<S> split(const S& str, const T& delimiter, SplitType st);
+
+template <class S>                 S    trimCpy(S  str, bool fromLeft = true, bool fromRight = true);
+template <class S>                 void trim   (S& str, bool fromLeft = true, bool fromRight = true);
+template <class S, class Function> void trim(S& str, bool fromLeft, bool fromRight, Function trimThisChar);
+
+template <class S, class T, class U> void replace   (      S& str, const T& oldTerm, const U& newTerm, bool replaceAll = true);
+template <class S, class T, class U> S    replaceCpy(const S& str, const T& oldTerm, const U& newTerm, bool replaceAll = true);
+
+//high-performance conversion between numbers and strings
+template <class S,   class Num> S   numberTo(const Num& number);
+template <class Num, class S>   Num stringTo(const S&   str);
+
+std::pair<char, char> hexify  (unsigned char c, bool upperCase = true);
+char                  unhexify(char high, char low);
+
+template <class S, class T, class Num> S printNumber(const T& format, const Num& number); //format a single number using std::snprintf()
+
+//string to string conversion: converts string-like type into char-compatible target string class
+template <class T, class S> T copyStringTo(S&& str);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+//---------------------- implementation ----------------------
+template <> inline
+bool isWhiteSpace(char ch)
+{
+    assert(ch != 0); //std C++ does not consider 0 as white space
+    //caveat 1: std::isspace() takes an int, but expects an unsigned char
+    //caveat 2: some parts of UTF-8 chars are erroneously seen as whitespace, e.g. the a0 from "\xec\x8b\xa0" (MSVC)
+    return static_cast<unsigned char>(ch) < 128 &&
+           std::isspace(static_cast<unsigned char>(ch)) != 0;
+}
+
+template <> inline
+bool isWhiteSpace(wchar_t ch)
+{
+    assert(ch != 0); //std C++ does not consider 0 as white space
+    return std::iswspace(ch) != 0;
+}
+
+
+template <class Char> inline
+bool isDigit(Char ch) //similar to implmenetation of std::isdigit()!
+{
+    static_assert(IsSameType<Char, char>::value || IsSameType<Char, wchar_t>::value, "");
+    return static_cast<Char>('0') <= ch && ch <= static_cast<Char>('9');
+}
+
+
+template <class Char> inline
+bool isHexDigit(Char c)
+{
+    static_assert(IsSameType<Char, char>::value || IsSameType<Char, wchar_t>::value, "");
+    return (static_cast<Char>('0') <= c && c <= static_cast<Char>('9')) ||
+           (static_cast<Char>('A') <= c && c <= static_cast<Char>('F')) ||
+           (static_cast<Char>('a') <= c && c <= static_cast<Char>('f'));
+}
+
+
+template <class Char> inline
+bool isAsciiAlpha(Char c)
+{
+    static_assert(IsSameType<Char, char>::value || IsSameType<Char, wchar_t>::value, "");
+    return (static_cast<Char>('A') <= c && c <= static_cast<Char>('Z')) ||
+           (static_cast<Char>('a') <= c && c <= static_cast<Char>('z'));
+}
+
+
+template <class S, class T, class Function> inline
+bool startsWith(const S& str, const T& prefix, Function cmpStringFun)
+{
+    const size_t pfLen = strLength(prefix);
+    if (strLength(str) < pfLen)
+        return false;
+
+    return cmpStringFun(strBegin(str),    pfLen,
+                        strBegin(prefix), pfLen) == 0;
+}
+
+
+template <class S, class T, class Function> inline
+bool endsWith(const S& str, const T& postfix, Function cmpStringFun)
+{
+    const size_t strLen = strLength(str);
+    const size_t pfLen  = strLength(postfix);
+    if (strLen < pfLen)
+        return false;
+
+    return cmpStringFun(strBegin(str) + strLen - pfLen, pfLen,
+                        strBegin(postfix), pfLen) == 0;
+}
+
+
+template <class S, class T, class Function> inline
+bool strEqual(const S& lhs, const T& rhs, Function cmpStringFun)
+{
+    return cmpStringFun(strBegin(lhs), strLength(lhs), strBegin(rhs), strLength(rhs)) == 0;
+}
+
+
+template <class S, class T> inline bool startsWith(const S& str, const T& prefix ) { return startsWith(str, prefix,  CmpBinary()); }
+template <class S, class T> inline bool endsWith  (const S& str, const T& postfix) { return endsWith  (str, postfix, CmpBinary()); }
+template <class S, class T> inline bool strEqual  (const S& lhs, const T& rhs    ) { return strEqual  (lhs, rhs,     CmpBinary()); }
+
+
+template <class S, class T> inline
+bool contains(const S& str, const T& term)
+{
+    static_assert(IsSameType<typename GetCharType<S>::Type, typename GetCharType<T>::Type>::value, "");
+    const size_t strLen  = strLength(str);
+    const size_t termLen = strLength(term);
+    if (strLen < termLen)
+        return false;
+
+    const auto* const strFirst  = strBegin(str);
+    const auto* const strLast   = strFirst + strLen;
+    const auto* const termFirst = strBegin(term);
+
+    return std::search(strFirst, strLast,
+                       termFirst, termFirst + termLen) != strLast;
+}
+
+
+template <class S, class T> inline
+S afterLast(const S& str, const T& term, FailureReturnVal rv)
+{
+    static_assert(IsSameType<typename GetCharType<S>::Type, typename GetCharType<T>::Type>::value, "");
+    const size_t termLen = strLength(term);
+    assert(termLen > 0);
+
+    const auto* const strFirst  = strBegin(str);
+    const auto* const strLast   = strFirst + strLength(str);
+    const auto* const termFirst = strBegin(term);
+
+    const auto* it = search_last(strFirst, strLast,
+                                 termFirst, termFirst + termLen);
+    if (it == strLast)
+        return rv == IF_MISSING_RETURN_ALL ? str : S();
+
+    it += termLen;
+    return S(it, strLast - it);
+}
+
+
+template <class S, class T> inline
+S beforeLast(const S& str, const T& term, FailureReturnVal rv)
+{
+    static_assert(IsSameType<typename GetCharType<S>::Type, typename GetCharType<T>::Type>::value, "");
+    const size_t termLen = strLength(term);
+    assert(termLen > 0);
+
+    const auto* const strFirst  = strBegin(str);
+    const auto* const strLast   = strFirst + strLength(str);
+    const auto* const termFirst = strBegin(term);
+
+    const auto* it = search_last(strFirst, strLast,
+                                 termFirst, termFirst + termLen);
+    if (it == strLast)
+        return rv == IF_MISSING_RETURN_ALL ? str : S();
+
+    return S(strFirst, it - strFirst);
+}
+
+
+template <class S, class T> inline
+S afterFirst(const S& str, const T& term, FailureReturnVal rv)
+{
+    static_assert(IsSameType<typename GetCharType<S>::Type, typename GetCharType<T>::Type>::value, "");
+    const size_t termLen = strLength(term);
+    assert(termLen > 0);
+
+    const auto* const strFirst  = strBegin(str);
+    const auto* const strLast   = strFirst + strLength(str);
+    const auto* const termFirst = strBegin(term);
+
+    const auto* it = std::search(strFirst, strLast,
+                                 termFirst, termFirst + termLen);
+    if (it == strLast)
+        return rv == IF_MISSING_RETURN_ALL ? str : S();
+
+    it += termLen;
+    return S(it, strLast - it);
+}
+
+
+template <class S, class T> inline
+S beforeFirst(const S& str, const T& term, FailureReturnVal rv)
+{
+    static_assert(IsSameType<typename GetCharType<S>::Type, typename GetCharType<T>::Type>::value, "");
+    const size_t termLen = strLength(term);
+    assert(termLen > 0);
+
+    const auto* const strFirst  = strBegin(str);
+    const auto* const strLast   = strFirst + strLength(str);
+    const auto* const termFirst = strBegin(term);
+
+    auto it = std::search(strFirst, strLast,
+                          termFirst,  termFirst  + termLen);
+    if (it == strLast)
+        return rv == IF_MISSING_RETURN_ALL ? str : S();
+
+    return S(strFirst, it - strFirst);
+}
+
+
+template <class S, class T> inline
+std::vector<S> split(const S& str, const T& delimiter, SplitType st)
+{
+    static_assert(IsSameType<typename GetCharType<S>::Type, typename GetCharType<T>::Type>::value, "");
+    const size_t delimLen = strLength(delimiter);
+    assert(delimLen > 0);
+    if (delimLen == 0)
+    {
+        if (str.empty() && st == SplitType::SKIP_EMPTY)
+            return {};
+        return { str };
+    }
+
+    const auto* const delimFirst = strBegin(delimiter);
+    const auto* const delimLast  = delimFirst + delimLen;
+
+    const auto* blockStart    = strBegin(str);
+    const auto* const strLast = blockStart + strLength(str);
+
+    std::vector<S> output;
+    for (;;)
+    {
+        const auto* const blockEnd = std::search(blockStart, strLast,
+                                                 delimFirst, delimLast);
+        if (blockStart != blockEnd || st == SplitType::ALLOW_EMPTY)
+            output.emplace_back(blockStart, blockEnd - blockStart);
+
+        if (blockEnd == strLast)
+            return output;
+        blockStart = blockEnd + delimLen;
+    }
+}
+
+
+namespace impl
+{
+ZEN_INIT_DETECT_MEMBER(append);
+
+//either call operator+=(S(str, len)) or append(str, len)
+template <class S, class InputIterator> inline
+typename EnableIf<HasMember_append<S>::value>::Type stringAppend(S& str, InputIterator first, InputIterator last) { str.append(first, last);  }
+
+template <class S, class InputIterator> inline
+typename EnableIf<!HasMember_append<S>::value>::Type stringAppend(S& str, InputIterator first, InputIterator last) { str += S(first, last); }
+}
+
+
+template <class S, class T, class U> inline
+S replaceCpy(const S& str, const T& oldTerm, const U& newTerm, bool replaceAll)
+{
+    static_assert(IsSameType<typename GetCharType<S>::Type, typename GetCharType<T>::Type>::value, "");
+    static_assert(IsSameType<typename GetCharType<T>::Type, typename GetCharType<U>::Type>::value, "");
+    const size_t oldLen = strLength(oldTerm);
+    if (oldLen == 0)
+        return str;
+
+    const auto* const oldBegin = strBegin(oldTerm);
+    const auto* const oldEnd   = oldBegin + oldLen;
+
+    const auto* const newBegin = strBegin(newTerm);
+    const auto* const newEnd   = newBegin + strLength(newTerm);
+
+    S output;
+
+    for (auto it = str.begin();;)
+    {
+        const auto itFound = std::search(it, str.end(),
+                                         oldBegin, oldEnd);
+        if (itFound == str.end() && it == str.begin())
+            return str; //optimize "oldTerm not found": return ref-counted copy
+
+        impl::stringAppend(output, it, itFound);
+        if (itFound == str.end())
+            return output;
+
+        impl::stringAppend(output, newBegin, newEnd);
+        it = itFound + oldLen;
+
+        if (!replaceAll)
+        {
+            impl::stringAppend(output, it, str.end());
+            return output;
+        }
+    }
+}
+
+
+template <class S, class T, class U> inline
+void replace(S& str, const T& oldTerm, const U& newTerm, bool replaceAll)
+{
+    str = replaceCpy(str, oldTerm, newTerm, replaceAll);
+}
+
+
+template <class S, class Function> inline
+void trim(S& str, bool fromLeft, bool fromRight, Function trimThisChar)
+{
+    assert(fromLeft || fromRight);
+
+    const auto* const oldBegin = strBegin(str);
+    const auto*       newBegin = oldBegin;
+    const auto*       newEnd   = oldBegin + strLength(str);
+
+    if (fromRight)
+        while (newBegin != newEnd && trimThisChar(newEnd[-1]))
+            --newEnd;
+
+    if (fromLeft)
+        while (newBegin != newEnd && trimThisChar(*newBegin))
+            ++newBegin;
+
+    if (newBegin != oldBegin)
+        str = S(newBegin, newEnd - newBegin); //minor inefficiency: in case "str" is not shared, we could save an allocation and do a memory move only
+    else
+        str.resize(newEnd - newBegin);
+}
+
+
+template <class S> inline
+void trim(S& str, bool fromLeft, bool fromRight)
+{
+    using CharType = typename GetCharType<S>::Type;
+    trim(str, fromLeft, fromRight, [](CharType c) { return isWhiteSpace(c); });
+}
+
+
+template <class S> inline
+S trimCpy(S str, bool fromLeft, bool fromRight)
+{
+    //implementing trimCpy() in terms of trim(), instead of the other way round, avoids memory allocations when trimming from right!
+    trim(str, fromLeft, fromRight);
+    return std::move(str); //"str" is an l-value parameter => no copy elision!
+}
+
+
+namespace impl
+{
+template <class S, class T>
+struct CopyStringToString
+{
+    T copy(const S& src) const { return T(strBegin(src), strLength(src)); }
+};
+
+template <class T>
+struct CopyStringToString<T, T> //perf: we don't need a deep copy if string types match
+{
+    template <class S>
+    T copy(S&& str) const { return std::forward<S>(str); }
+};
+
+inline int strcmpWithNulls(const char*    ptr1, const char*    ptr2, size_t num) { return std::memcmp (ptr1, ptr2, num); }
+inline int strcmpWithNulls(const wchar_t* ptr1, const wchar_t* ptr2, size_t num) { return std::wmemcmp(ptr1, ptr2, num); }
+}
+
+template <class T, class S> inline
+T copyStringTo(S&& str) { return impl::CopyStringToString<std::decay_t<S>, T>().copy(std::forward<S>(str)); }
+
+
+template <class Char> inline
+int CmpBinary::operator()(const Char* lhs, size_t lhsLen, const Char* rhs, size_t rhsLen) const
+{
+    //support embedded 0, unlike strncmp/wcsncmp!
+    const int rv = impl::strcmpWithNulls(lhs, rhs, std::min(lhsLen, rhsLen));
+    if (rv != 0)
+        return rv;
+    return static_cast<int>(lhsLen) - static_cast<int>(rhsLen);
+}
+
+
+template <class Char> inline
+int CmpAsciiNoCase::operator()(const Char* lhs, size_t lhsLen, const Char* rhs, size_t rhsLen) const
+{
+    auto asciiToLower = [](Char c) //ordering: lower-case chars have higher code points than uppper-case
+    {
+        if (static_cast<Char>('A') <= c && c <= static_cast<Char>('Z'))
+            return static_cast<Char>(c - static_cast<Char>('A') + static_cast<Char>('a'));
+        return c;
+    };
+
+    const auto* const lhsLast = lhs + std::min(lhsLen, rhsLen);
+
+    while (lhs != lhsLast)
+    {
+        const Char charL = asciiToLower(*lhs++);
+        const Char charR = asciiToLower(*rhs++);
+        if (charL != charR)
+            return static_cast<unsigned int>(charL) - static_cast<unsigned int>(charR); //unsigned char-comparison is the convention!
+        //unsigned underflow is well-defined!
+    }
+    return static_cast<int>(lhsLen) - static_cast<int>(rhsLen);
+}
+
+
+namespace impl
+{
+template <class Num> inline
+int saferPrintf(char* buffer, size_t bufferSize, const char* format, const Num& number) //there is no such thing as a "safe" printf ;)
+{
+    return std::snprintf(buffer, bufferSize, format, number); //C99: returns number of chars written if successful, < 0 or >= bufferSize on failure
+}
+
+template <class Num> inline
+int saferPrintf(wchar_t* buffer, size_t bufferSize, const wchar_t* format, const Num& number)
+{
+    return std::swprintf(buffer, bufferSize, format, number); //C99: returns number of chars written if successful, < 0 on failure (including buffer too small)
+}
+}
+
+template <class S, class T, class Num> inline
+S printNumber(const T& format, const Num& number) //format a single number using ::sprintf
+{
+    static_assert(IsSameType<typename GetCharType<S>::Type, typename GetCharType<T>::Type>::value, "");
+    using CharType = typename GetCharType<S>::Type;
+
+    const int BUFFER_SIZE = 128;
+    CharType buffer[BUFFER_SIZE]; //zero-initialize?
+    const int charsWritten = impl::saferPrintf(buffer, BUFFER_SIZE, strBegin(format), number);
+
+    return 0 < charsWritten && charsWritten < BUFFER_SIZE ? S(buffer, charsWritten) : S();
+}
+
+
+namespace impl
+{
+enum NumberType
+{
+    NUM_TYPE_SIGNED_INT,
+    NUM_TYPE_UNSIGNED_INT,
+    NUM_TYPE_FLOATING_POINT,
+    NUM_TYPE_OTHER,
+};
+
+
+template <class S, class Num> inline
+S numberTo(const Num& number, Int2Type<NUM_TYPE_OTHER>) //default number to string conversion using streams: convenient, but SLOW, SLOW, SLOW!!!! (~ factor of 20)
+{
+    using CharType = typename GetCharType<S>::Type;
+
+    std::basic_ostringstream<CharType> ss;
+    ss << number;
+    return copyStringTo<S>(ss.str());
+}
+
+
+template <class S, class Num> inline S floatToString(const Num& number, char   ) { return printNumber<S>( "%g", static_cast<double>(number)); }
+template <class S, class Num> inline S floatToString(const Num& number, wchar_t) { return printNumber<S>(L"%g", static_cast<double>(number)); }
+
+template <class S, class Num> inline
+S numberTo(const Num& number, Int2Type<NUM_TYPE_FLOATING_POINT>)
+{
+    return floatToString<S>(number, typename GetCharType<S>::Type());
+}
+
+
+/*
+perf: integer to string: (executed 10 mio. times)
+    std::stringstream - 14796 ms
+    std::sprintf      -  3086 ms
+    formatInteger     -   778 ms
+*/
+
+template <class OutputIterator, class Num> inline
+void formatNegativeInteger(Num n, OutputIterator& it)
+{
+    assert(n < 0);
+    using CharType = typename std::iterator_traits<OutputIterator>::value_type;
+    do
+    {
+        const Num tmp = n / 10;
+        *--it = static_cast<CharType>('0' + (tmp * 10 - n)); //8% faster than using modulus operator!
+        n = tmp;
+    }
+    while (n != 0);
+
+    *--it = static_cast<CharType>('-');
+}
+
+template <class OutputIterator, class Num> inline
+void formatPositiveInteger(Num n, OutputIterator& it)
+{
+    assert(n >= 0);
+    using CharType = typename std::iterator_traits<OutputIterator>::value_type;
+    do
+    {
+        const Num tmp = n / 10;
+        *--it = static_cast<CharType>('0' + (n - tmp * 10)); //8% faster than using modulus operator!
+        n = tmp;
+    }
+    while (n != 0);
+}
+
+
+template <class S, class Num> inline
+S numberTo(const Num& number, Int2Type<NUM_TYPE_SIGNED_INT>)
+{
+    using CharType = typename GetCharType<S>::Type;
+    CharType buffer[2 + sizeof(Num) * 241 / 100]; //zero-initialize?
+    //it's generally faster to use a buffer than to rely on String::operator+=() (in)efficiency
+    //required chars (+ sign char): 1 + ceil(ln_10(256^sizeof(n) / 2 + 1))    -> divide by 2 for signed half-range; second +1 since one half starts with 1!
+    // <= 1 + ceil(ln_10(256^sizeof(n))) =~ 1 + ceil(sizeof(n) * 2.4082) <= 2 + floor(sizeof(n) * 2.41)
+
+    //caveat: consider INT_MIN: technically -INT_MIN == INT_MIN
+    auto it = std::end(buffer);
+    if (number < 0)
+        formatNegativeInteger(number, it);
+    else
+        formatPositiveInteger(number, it);
+    assert(it >= std::begin(buffer));
+
+    return S(&*it, std::end(buffer) - it);
+}
+
+
+template <class S, class Num> inline
+S numberTo(const Num& number, Int2Type<NUM_TYPE_UNSIGNED_INT>)
+{
+    using CharType = typename GetCharType<S>::Type;
+    CharType buffer[1 + sizeof(Num) * 241 / 100]; //zero-initialize?
+    //required chars: ceil(ln_10(256^sizeof(n))) =~ ceil(sizeof(n) * 2.4082) <= 1 + floor(sizeof(n) * 2.41)
+
+    auto it = std::end(buffer);
+    formatPositiveInteger(number, it);
+    assert(it >= std::begin(buffer));
+
+    return S(&*it, std::end(buffer) - it);
+}
+
+//--------------------------------------------------------------------------------
+
+template <class Num, class S> inline
+Num stringTo(const S& str, Int2Type<NUM_TYPE_OTHER>) //default string to number conversion using streams: convenient, but SLOW
+{
+    using CharType = typename GetCharType<S>::Type;
+    Num number = 0;
+    std::basic_istringstream<CharType>(copyStringTo<std::basic_string<CharType>>(str)) >> number;
+    return number;
+}
+
+
+template <class Num> inline Num stringToFloat(const char*    str) { return std::strtod(str, nullptr); }
+template <class Num> inline Num stringToFloat(const wchar_t* str) { return std::wcstod(str, nullptr); }
+
+template <class Num, class S> inline
+Num stringTo(const S& str, Int2Type<NUM_TYPE_FLOATING_POINT>)
+{
+    return stringToFloat<Num>(strBegin(str));
+}
+
+template <class Num, class S>
+Num extractInteger(const S& str, bool& hasMinusSign) //very fast conversion to integers: slightly faster than std::atoi, but more importantly: generic
+{
+    using CharType = typename GetCharType<S>::Type;
+
+    const CharType* first = strBegin(str);
+    const CharType* last  = first + strLength(str);
+
+    while (first != last && isWhiteSpace(*first)) //skip leading whitespace
+        ++first;
+
+    //handle minus sign
+    hasMinusSign = false;
+    if (first != last)
+    {
+        if (*first == static_cast<CharType>('-'))
+        {
+            hasMinusSign = true;
+            ++first;
+        }
+        else if (*first == static_cast<CharType>('+'))
+            ++first;
+    }
+
+    Num number = 0;
+    for (const CharType* it = first; it != last; ++it)
+    {
+        const CharType c = *it;
+        if (static_cast<CharType>('0') <= c && c <= static_cast<CharType>('9'))
+        {
+            number *= 10;
+            number += c - static_cast<CharType>('0');
+        }
+        else //rest of string should contain whitespace only, it's NOT a bug if there is something else!
+            break; //assert(std::all_of(iter, last, &isWhiteSpace<CharType>)); -> this is NO assert situation
+    }
+    return number;
+}
+
+
+template <class Num, class S> inline
+Num stringTo(const S& str, Int2Type<NUM_TYPE_SIGNED_INT>)
+{
+    bool hasMinusSign = false; //handle minus sign
+    const Num number = extractInteger<Num>(str, hasMinusSign);
+    return hasMinusSign ? -number : number;
+}
+
+
+template <class Num, class S> inline
+Num stringTo(const S& str, Int2Type<NUM_TYPE_UNSIGNED_INT>) //very fast conversion to integers: slightly faster than std::atoi, but more importantly: generic
+{
+    bool hasMinusSign = false; //handle minus sign
+    const Num number = extractInteger<Num>(str, hasMinusSign);
+    if (hasMinusSign)
+    {
+        assert(false);
+        return 0U;
+    }
+    return number;
+}
+}
+
+
+template <class S, class Num> inline
+S numberTo(const Num& number)
+{
+    using TypeTag = Int2Type<
+                    IsSignedInt  <Num>::value ? impl::NUM_TYPE_SIGNED_INT :
+                    IsUnsignedInt<Num>::value ? impl::NUM_TYPE_UNSIGNED_INT :
+                    IsFloat      <Num>::value ? impl::NUM_TYPE_FLOATING_POINT :
+                    impl::NUM_TYPE_OTHER>;
+
+    return impl::numberTo<S>(number, TypeTag());
+}
+
+
+template <class Num, class S> inline
+Num stringTo(const S& str)
+{
+    using TypeTag = Int2Type<
+                    IsSignedInt  <Num>::value ? impl::NUM_TYPE_SIGNED_INT :
+                    IsUnsignedInt<Num>::value ? impl::NUM_TYPE_UNSIGNED_INT :
+                    IsFloat      <Num>::value ? impl::NUM_TYPE_FLOATING_POINT :
+                    impl::NUM_TYPE_OTHER>;
+
+    return impl::stringTo<Num>(str, TypeTag());
+}
+
+
+inline //hexify beats "printNumber<std::string>("%02X", c)" by a nice factor of 3!
+std::pair<char, char> hexify(unsigned char c, bool upperCase)
+{
+    auto hexifyDigit = [upperCase](int num) -> char //input [0, 15], output 0-9, A-F
+    {
+        assert(0 <= num&& num <= 15);  //guaranteed by design below!
+        if (num <= 9)
+            return static_cast<char>('0' + num); //no signed/unsigned char problem here!
+
+        if (upperCase)
+            return static_cast<char>('A' + (num - 10));
+        else
+            return static_cast<char>('a' + (num - 10));
+    };
+    return std::make_pair(hexifyDigit(c / 16), hexifyDigit(c % 16));
+}
+
+
+inline //unhexify beats "::sscanf(&it[3], "%02X", &tmp)" by a factor of 3000 for ~250000 calls!!!
+char unhexify(char high, char low)
+{
+    auto unhexifyDigit = [](char hex) -> int //input 0-9, a-f, A-F; output range: [0, 15]
+    {
+        if ('0' <= hex && hex <= '9') //no signed/unsigned char problem here!
+            return hex - '0';
+        else if ('A' <= hex && hex <= 'F')
+            return (hex - 'A') + 10;
+        else if ('a' <= hex && hex <= 'f')
+            return (hex - 'a') + 10;
+        assert(false);
+        return 0;
+    };
+    return static_cast<unsigned char>(16 * unhexifyDigit(high) + unhexifyDigit(low)); //[!] convert to unsigned char first, then to char (which may be signed)
+}
+}
+
+#endif //STRING_TOOLS_H_213458973046
diff --git a/zen/string_traits.h b/zen/string_traits.h
index 5ae5733c..f17e5e0d 100755
--- a/zen/string_traits.h
+++ b/zen/string_traits.h
@@ -1,216 +1,216 @@
-// *****************************************************************************
-// * This file is part of the FreeFileSync project. It is distributed under    *
-// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
-// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
-// *****************************************************************************
-
-#ifndef STRING_TRAITS_H_813274321443234
-#define STRING_TRAITS_H_813274321443234
-
-#include <cstring> //strlen
-#include "type_tools.h"
-
-
-//uniform access to string-like types, both classes and character arrays
-namespace zen
-{
-/*
-IsStringLike<>::value:
-    IsStringLike<const wchar_t*>::value; //equals "true"
-    IsStringLike<const int*>    ::value; //equals "false"
-
-GetCharType<>::Type:
-    GetCharType<std::wstring>::Type  //equals wchar_t
-    GetCharType<wchar_t[5]>  ::Type  //equals wchar_t
-
-strLength():
-    strLength(str);   //equals str.length()
-    strLength(array); //equals cStringLength(array)
-
-strBegin():         -> not null-terminated! -> may be nullptr if length is 0!
-    std::wstring str(L"dummy");
-    char array[] = "dummy";
-    strBegin(str);   //returns str.c_str()
-    strBegin(array); //returns array
-*/
-
-//reference a sub-string for consumption by zen string_tools
-template <class Char>
-class StringRef
-{
-public:
-    template <class Iterator>
-    StringRef(Iterator first, Iterator last) : len_(last - first), str_(first != last ? &*first : nullptr) {}
-    //StringRef(const Char* str, size_t len) : str_(str), len_(len) {} -> needless constraint! Char* not available for empty range!
-
-    Char*  data  () const { return str_; } //1. no null-termination! 2. may be nullptr!
-    size_t length() const { return len_; }
-
-private:
-    const size_t len_;
-    Char* str_;
-};
-
-
-
-
-
-
-
-
-
-
-
-
-//---------------------- implementation ----------------------
-namespace implementation
-{
-template<class S, class Char> //test if result of S::c_str() can convert to const Char*
-class HasConversion
-{
-    using Yes = char[1];
-    using No  = char[2];
-
-    static Yes& hasConversion(const Char*);
-    static  No& hasConversion(...);
-
-public:
-    enum { value = sizeof(hasConversion(std::declval<S>().c_str())) == sizeof(Yes) };
-};
-
-
-template <class S, bool isStringClass>  struct GetCharTypeImpl : ResultType<NullType> {};
-
-template <class S>
-struct GetCharTypeImpl<S, true> :
-    ResultType<
-    typename SelectIf<HasConversion<S, wchar_t>::value, wchar_t,
-    typename SelectIf<HasConversion<S, char   >::value, char, NullType>::Type
-    >::Type>
-{
-    //using Type = typename S::value_type;
-    /*DON'T use S::value_type:
-        1. support Glib::ustring: value_type is "unsigned int" but c_str() returns "const char*"
-        2. wxString, wxWidgets v2.9, has some questionable string design: wxString::c_str() returns a proxy (wxCStrData) which
-           is implicitly convertible to *both* "const char*" and "const wchar_t*" while wxString::value_type is a wrapper around an unsigned int
-    */
-};
-
-template <> struct GetCharTypeImpl<char,    false> : ResultType<char   > {};
-template <> struct GetCharTypeImpl<wchar_t, false> : ResultType<wchar_t> {};
-
-template <> struct GetCharTypeImpl<StringRef<char         >, false> : ResultType<char   > {};
-template <> struct GetCharTypeImpl<StringRef<wchar_t      >, false> : ResultType<wchar_t> {};
-template <> struct GetCharTypeImpl<StringRef<const char   >, false> : ResultType<char   > {};
-template <> struct GetCharTypeImpl<StringRef<const wchar_t>, false> : ResultType<wchar_t> {};
-
-
-ZEN_INIT_DETECT_MEMBER_TYPE(value_type);
-ZEN_INIT_DETECT_MEMBER(c_str);  //we don't know the exact declaration of the member attribute and it may be in a base class!
-ZEN_INIT_DETECT_MEMBER(length); //
-
-template <class S>
-class StringTraits
-{
-    using NonRefType      = typename RemoveRef    <S           >::Type;
-    using NonConstType    = typename RemoveConst  <NonRefType  >::Type;
-    using NonArrayType    = typename RemoveArray  <NonConstType>::Type;
-    using NonPtrType      = typename RemovePointer<NonArrayType>::Type;
-    using UndecoratedType = typename RemoveConst  <NonPtrType  >::Type ; //handle "const char* const"
-
-public:
-    enum
-    {
-        isStringClass = HasMemberType_value_type<NonConstType>::value &&
-                        HasMember_c_str         <NonConstType>::value &&
-                        HasMember_length        <NonConstType>::value
-    };
-
-    using CharType = typename GetCharTypeImpl<UndecoratedType, isStringClass>::Type;
-
-    enum
-    {
-        isStringLike = IsSameType<CharType, char>::value ||
-        IsSameType<CharType, wchar_t>::value
-    };
-};
-}
-
-template <class T>
-struct IsStringLike : StaticBool<implementation::StringTraits<T>::isStringLike> {};
-
-template <class T>
-struct GetCharType : ResultType<typename implementation::StringTraits<T>::CharType> {};
-
-
-namespace implementation
-{
-//strlen/wcslen are vectorized since VS14 CTP3
-inline size_t cStringLength(const char*    str) { return std::strlen(str); }
-inline size_t cStringLength(const wchar_t* str) { return std::wcslen(str); }
-
-//no significant perf difference for "comparison" test case between cStringLength/wcslen:
-#if 0
-template <class C> inline
-size_t cStringLength(const C* str)
-{
-    static_assert(IsSameType<C, char>::value || IsSameType<C, wchar_t>::value, "");
-    size_t len = 0;
-    while (*str++ != 0)
-        ++len;
-    return len;
-}
-#endif
-
-template <class S, typename = typename EnableIf<implementation::StringTraits<S>::isStringClass>::Type> inline
-const typename GetCharType<S>::Type* strBegin(const S& str) //SFINAE: T must be a "string"
-{
-    return str.c_str();
-}
-
-inline const char*    strBegin(const char*    str) { return str; }
-inline const wchar_t* strBegin(const wchar_t* str) { return str; }
-inline const char*    strBegin(const char&    ch)  { return &ch; }
-inline const wchar_t* strBegin(const wchar_t& ch)  { return &ch; }
-
-inline const char*    strBegin(const StringRef<char         >& ref) { return ref.data(); }
-inline const wchar_t* strBegin(const StringRef<wchar_t      >& ref) { return ref.data(); }
-inline const char*    strBegin(const StringRef<const char   >& ref) { return ref.data(); }
-inline const wchar_t* strBegin(const StringRef<const wchar_t>& ref) { return ref.data(); }
-
-
-template <class S, typename = typename EnableIf<implementation::StringTraits<S>::isStringClass>::Type> inline
-size_t strLength(const S& str) //SFINAE: T must be a "string"
-{
-    return str.length();
-}
-
-inline size_t strLength(const char*    str) { return cStringLength(str); }
-inline size_t strLength(const wchar_t* str) { return cStringLength(str); }
-inline size_t strLength(char)               { return 1; }
-inline size_t strLength(wchar_t)            { return 1; }
-
-inline size_t strLength(const StringRef<char         >& ref) { return ref.length(); }
-inline size_t strLength(const StringRef<wchar_t      >& ref) { return ref.length(); }
-inline size_t strLength(const StringRef<const char   >& ref) { return ref.length(); }
-inline size_t strLength(const StringRef<const wchar_t>& ref) { return ref.length(); }
-}
-
-
-template <class S> inline
-auto strBegin(S&& str) -> const typename GetCharType<S>::Type*
-{
-    static_assert(IsStringLike<S>::value, "");
-    return implementation::strBegin(std::forward<S>(str));
-}
-
-
-template <class S> inline
-size_t strLength(S&& str)
-{
-    static_assert(IsStringLike<S>::value, "");
-    return implementation::strLength(std::forward<S>(str));
-}
-}
-
-#endif //STRING_TRAITS_H_813274321443234
+// *****************************************************************************
+// * This file is part of the FreeFileSync project. It is distributed under    *
+// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
+// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
+// *****************************************************************************
+
+#ifndef STRING_TRAITS_H_813274321443234
+#define STRING_TRAITS_H_813274321443234
+
+#include <cstring> //strlen
+#include "type_tools.h"
+
+
+//uniform access to string-like types, both classes and character arrays
+namespace zen
+{
+/*
+IsStringLike<>::value:
+    IsStringLike<const wchar_t*>::value; //equals "true"
+    IsStringLike<const int*>    ::value; //equals "false"
+
+GetCharType<>::Type:
+    GetCharType<std::wstring>::Type  //equals wchar_t
+    GetCharType<wchar_t[5]>  ::Type  //equals wchar_t
+
+strLength():
+    strLength(str);   //equals str.length()
+    strLength(array); //equals cStringLength(array)
+
+strBegin():         -> not null-terminated! -> may be nullptr if length is 0!
+    std::wstring str(L"dummy");
+    char array[] = "dummy";
+    strBegin(str);   //returns str.c_str()
+    strBegin(array); //returns array
+*/
+
+//reference a sub-string for consumption by zen string_tools
+template <class Char>
+class StringRef
+{
+public:
+    template <class Iterator>
+    StringRef(Iterator first, Iterator last) : len_(last - first), str_(first != last ? &*first : nullptr) {}
+    //StringRef(const Char* str, size_t len) : str_(str), len_(len) {} -> needless constraint! Char* not available for empty range!
+
+    Char*  data  () const { return str_; } //1. no null-termination! 2. may be nullptr!
+    size_t length() const { return len_; }
+
+private:
+    const size_t len_;
+    Char* str_;
+};
+
+
+
+
+
+
+
+
+
+
+
+
+//---------------------- implementation ----------------------
+namespace implementation
+{
+template<class S, class Char> //test if result of S::c_str() can convert to const Char*
+class HasConversion
+{
+    using Yes = char[1];
+    using No  = char[2];
+
+    static Yes& hasConversion(const Char*);
+    static  No& hasConversion(...);
+
+public:
+    enum { value = sizeof(hasConversion(std::declval<S>().c_str())) == sizeof(Yes) };
+};
+
+
+template <class S, bool isStringClass>  struct GetCharTypeImpl : ResultType<NullType> {};
+
+template <class S>
+struct GetCharTypeImpl<S, true> :
+    ResultType<
+    typename SelectIf<HasConversion<S, wchar_t>::value, wchar_t,
+    typename SelectIf<HasConversion<S, char   >::value, char, NullType>::Type
+    >::Type>
+{
+    //using Type = typename S::value_type;
+    /*DON'T use S::value_type:
+        1. support Glib::ustring: value_type is "unsigned int" but c_str() returns "const char*"
+        2. wxString, wxWidgets v2.9, has some questionable string design: wxString::c_str() returns a proxy (wxCStrData) which
+           is implicitly convertible to *both* "const char*" and "const wchar_t*" while wxString::value_type is a wrapper around an unsigned int
+    */
+};
+
+template <> struct GetCharTypeImpl<char,    false> : ResultType<char   > {};
+template <> struct GetCharTypeImpl<wchar_t, false> : ResultType<wchar_t> {};
+
+template <> struct GetCharTypeImpl<StringRef<char         >, false> : ResultType<char   > {};
+template <> struct GetCharTypeImpl<StringRef<wchar_t      >, false> : ResultType<wchar_t> {};
+template <> struct GetCharTypeImpl<StringRef<const char   >, false> : ResultType<char   > {};
+template <> struct GetCharTypeImpl<StringRef<const wchar_t>, false> : ResultType<wchar_t> {};
+
+
+ZEN_INIT_DETECT_MEMBER_TYPE(value_type);
+ZEN_INIT_DETECT_MEMBER(c_str);  //we don't know the exact declaration of the member attribute and it may be in a base class!
+ZEN_INIT_DETECT_MEMBER(length); //
+
+template <class S>
+class StringTraits
+{
+    using NonRefType      = typename RemoveRef    <S           >::Type;
+    using NonConstType    = typename RemoveConst  <NonRefType  >::Type;
+    using NonArrayType    = typename RemoveArray  <NonConstType>::Type;
+    using NonPtrType      = typename RemovePointer<NonArrayType>::Type;
+    using UndecoratedType = typename RemoveConst  <NonPtrType  >::Type ; //handle "const char* const"
+
+public:
+    enum
+    {
+        isStringClass = HasMemberType_value_type<NonConstType>::value &&
+                        HasMember_c_str         <NonConstType>::value &&
+                        HasMember_length        <NonConstType>::value
+    };
+
+    using CharType = typename GetCharTypeImpl<UndecoratedType, isStringClass>::Type;
+
+    enum
+    {
+        isStringLike = IsSameType<CharType, char>::value ||
+        IsSameType<CharType, wchar_t>::value
+    };
+};
+}
+
+template <class T>
+struct IsStringLike : StaticBool<implementation::StringTraits<T>::isStringLike> {};
+
+template <class T>
+struct GetCharType : ResultType<typename implementation::StringTraits<T>::CharType> {};
+
+
+namespace implementation
+{
+//strlen/wcslen are vectorized since VS14 CTP3
+inline size_t cStringLength(const char*    str) { return std::strlen(str); }
+inline size_t cStringLength(const wchar_t* str) { return std::wcslen(str); }
+
+//no significant perf difference for "comparison" test case between cStringLength/wcslen:
+#if 0
+template <class C> inline
+size_t cStringLength(const C* str)
+{
+    static_assert(IsSameType<C, char>::value || IsSameType<C, wchar_t>::value, "");
+    size_t len = 0;
+    while (*str++ != 0)
+        ++len;
+    return len;
+}
+#endif
+
+template <class S, typename = typename EnableIf<implementation::StringTraits<S>::isStringClass>::Type> inline
+const typename GetCharType<S>::Type* strBegin(const S& str) //SFINAE: T must be a "string"
+{
+    return str.c_str();
+}
+
+inline const char*    strBegin(const char*    str) { return str; }
+inline const wchar_t* strBegin(const wchar_t* str) { return str; }
+inline const char*    strBegin(const char&    ch)  { return &ch; }
+inline const wchar_t* strBegin(const wchar_t& ch)  { return &ch; }
+
+inline const char*    strBegin(const StringRef<char         >& ref) { return ref.data(); }
+inline const wchar_t* strBegin(const StringRef<wchar_t      >& ref) { return ref.data(); }
+inline const char*    strBegin(const StringRef<const char   >& ref) { return ref.data(); }
+inline const wchar_t* strBegin(const StringRef<const wchar_t>& ref) { return ref.data(); }
+
+
+template <class S, typename = typename EnableIf<implementation::StringTraits<S>::isStringClass>::Type> inline
+size_t strLength(const S& str) //SFINAE: T must be a "string"
+{
+    return str.length();
+}
+
+inline size_t strLength(const char*    str) { return cStringLength(str); }
+inline size_t strLength(const wchar_t* str) { return cStringLength(str); }
+inline size_t strLength(char)               { return 1; }
+inline size_t strLength(wchar_t)            { return 1; }
+
+inline size_t strLength(const StringRef<char         >& ref) { return ref.length(); }
+inline size_t strLength(const StringRef<wchar_t      >& ref) { return ref.length(); }
+inline size_t strLength(const StringRef<const char   >& ref) { return ref.length(); }
+inline size_t strLength(const StringRef<const wchar_t>& ref) { return ref.length(); }
+}
+
+
+template <class S> inline
+auto strBegin(S&& str) -> const typename GetCharType<S>::Type*
+{
+    static_assert(IsStringLike<S>::value, "");
+    return implementation::strBegin(std::forward<S>(str));
+}
+
+
+template <class S> inline
+size_t strLength(S&& str)
+{
+    static_assert(IsStringLike<S>::value, "");
+    return implementation::strLength(std::forward<S>(str));
+}
+}
+
+#endif //STRING_TRAITS_H_813274321443234
diff --git a/zen/symlink_target.h b/zen/symlink_target.h
index 4620e7cc..84b8452a 100755
--- a/zen/symlink_target.h
+++ b/zen/symlink_target.h
@@ -1,75 +1,75 @@
-// *****************************************************************************
-// * This file is part of the FreeFileSync project. It is distributed under    *
-// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
-// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
-// *****************************************************************************
-
-#ifndef SYMLINK_TARGET_H_801783470198357483
-#define SYMLINK_TARGET_H_801783470198357483
-
-#include "scope_guard.h"
-#include "file_error.h"
-
-    #include <unistd.h>
-    #include <stdlib.h> //realpath
-
-
-namespace zen
-{
-
-Zstring getResolvedSymlinkPath(const Zstring& linkPath); //throw FileError; Win: requires Vista or later!
-Zstring getSymlinkTargetRaw   (const Zstring& linkPath); //throw FileError
-}
-
-
-
-
-
-
-
-
-
-//################################ implementation ################################
-
-namespace
-{
-//retrieve raw target data of symlink or junction
-Zstring getSymlinkRawTargetString_impl(const Zstring& linkPath) //throw FileError
-{
-    using namespace zen;
-    const size_t BUFFER_SIZE = 10000;
-    std::vector<char> buffer(BUFFER_SIZE);
-
-    const ssize_t bytesWritten = ::readlink(linkPath.c_str(), &buffer[0], BUFFER_SIZE);
-    if (bytesWritten < 0)
-        THROW_LAST_FILE_ERROR(replaceCpy(_("Cannot resolve symbolic link %x."), L"%x", fmtPath(linkPath)), L"readlink");
-    if (bytesWritten >= static_cast<ssize_t>(BUFFER_SIZE)) //detect truncation, not an error for readlink!
-        throw FileError(replaceCpy(_("Cannot resolve symbolic link %x."), L"%x", fmtPath(linkPath)), L"readlink: buffer truncated.");
-
-    return Zstring(&buffer[0], bytesWritten); //readlink does not append 0-termination!
-}
-
-
-Zstring getResolvedSymlinkPath_impl(const Zstring& linkPath) //throw FileError
-{
-    using namespace zen;
-    char* targetPath = ::realpath(linkPath.c_str(), nullptr);
-    if (!targetPath)
-        THROW_LAST_FILE_ERROR(replaceCpy(_("Cannot determine final path for %x."), L"%x", fmtPath(linkPath)), L"realpath");
-    ZEN_ON_SCOPE_EXIT(::free(targetPath));
-    return targetPath;
-}
-}
-
-
-namespace zen
-{
-inline
-Zstring getSymlinkTargetRaw(const Zstring& linkPath) { return getSymlinkRawTargetString_impl(linkPath); }
-
-inline
-Zstring getResolvedSymlinkPath(const Zstring& linkPath) { return getResolvedSymlinkPath_impl(linkPath); }
-
-}
-
-#endif //SYMLINK_TARGET_H_801783470198357483
+// *****************************************************************************
+// * This file is part of the FreeFileSync project. It is distributed under    *
+// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
+// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
+// *****************************************************************************
+
+#ifndef SYMLINK_TARGET_H_801783470198357483
+#define SYMLINK_TARGET_H_801783470198357483
+
+#include "scope_guard.h"
+#include "file_error.h"
+
+    #include <unistd.h>
+    #include <stdlib.h> //realpath
+
+
+namespace zen
+{
+
+Zstring getResolvedSymlinkPath(const Zstring& linkPath); //throw FileError; Win: requires Vista or later!
+Zstring getSymlinkTargetRaw   (const Zstring& linkPath); //throw FileError
+}
+
+
+
+
+
+
+
+
+
+//################################ implementation ################################
+
+namespace
+{
+//retrieve raw target data of symlink or junction
+Zstring getSymlinkRawTargetString_impl(const Zstring& linkPath) //throw FileError
+{
+    using namespace zen;
+    const size_t BUFFER_SIZE = 10000;
+    std::vector<char> buffer(BUFFER_SIZE);
+
+    const ssize_t bytesWritten = ::readlink(linkPath.c_str(), &buffer[0], BUFFER_SIZE);
+    if (bytesWritten < 0)
+        THROW_LAST_FILE_ERROR(replaceCpy(_("Cannot resolve symbolic link %x."), L"%x", fmtPath(linkPath)), L"readlink");
+    if (bytesWritten >= static_cast<ssize_t>(BUFFER_SIZE)) //detect truncation, not an error for readlink!
+        throw FileError(replaceCpy(_("Cannot resolve symbolic link %x."), L"%x", fmtPath(linkPath)), L"readlink: buffer truncated.");
+
+    return Zstring(&buffer[0], bytesWritten); //readlink does not append 0-termination!
+}
+
+
+Zstring getResolvedSymlinkPath_impl(const Zstring& linkPath) //throw FileError
+{
+    using namespace zen;
+    char* targetPath = ::realpath(linkPath.c_str(), nullptr);
+    if (!targetPath)
+        THROW_LAST_FILE_ERROR(replaceCpy(_("Cannot determine final path for %x."), L"%x", fmtPath(linkPath)), L"realpath");
+    ZEN_ON_SCOPE_EXIT(::free(targetPath));
+    return targetPath;
+}
+}
+
+
+namespace zen
+{
+inline
+Zstring getSymlinkTargetRaw(const Zstring& linkPath) { return getSymlinkRawTargetString_impl(linkPath); }
+
+inline
+Zstring getResolvedSymlinkPath(const Zstring& linkPath) { return getResolvedSymlinkPath_impl(linkPath); }
+
+}
+
+#endif //SYMLINK_TARGET_H_801783470198357483
diff --git a/zen/sys_error.h b/zen/sys_error.h
index f7c128ef..026a3be5 100755
--- a/zen/sys_error.h
+++ b/zen/sys_error.h
@@ -1,105 +1,105 @@
-// *****************************************************************************
-// * This file is part of the FreeFileSync project. It is distributed under    *
-// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
-// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
-// *****************************************************************************
-
-#ifndef SYS_ERROR_H_3284791347018951324534
-#define SYS_ERROR_H_3284791347018951324534
-
-#include <string>
-#include "utf.h"
-#include "i18n.h"
-#include "scope_guard.h"
-
-    #include <cstring>
-    #include <cerrno>
-
-
-namespace zen
-{
-//evaluate GetLastError()/errno and assemble specific error message
-    using ErrorCode = int;
-
-ErrorCode getLastError();
-
-std::wstring formatSystemError(const std::wstring& functionName, ErrorCode ec);
-std::wstring formatSystemError(const std::wstring& functionName, const std::wstring& errorCode, const std::wstring& errorMsg);
-
-//A low-level exception class giving (non-translated) detail information only - same conceptional level like "GetLastError()"!
-class SysError
-{
-public:
-    explicit SysError(const std::wstring& msg) : msg_(msg) {}
-    const std::wstring& toString() const { return msg_; }
-
-private:
-    std::wstring msg_;
-};
-
-#define DEFINE_NEW_SYS_ERROR(X) struct X : public SysError { X(const std::wstring& msg) : SysError(msg) {} };
-
-
-
-#define THROW_LAST_SYS_ERROR(functionName)                           \
-    do { const ErrorCode ecInternal = getLastError(); throw SysError(formatSystemError(functionName, ecInternal)); } while (false)
-
-
-
-
-
-
-//######################## implementation ########################
-inline
-ErrorCode getLastError()
-{
-    return errno; //don't use "::", errno is a macro!
-}
-
-
-std::wstring formatSystemErrorRaw(long long) = delete; //intentional overload ambiguity to catch usage errors
-
-inline
-std::wstring formatSystemErrorRaw(ErrorCode ec) //return empty string on error
-{
-    const ErrorCode currentError = getLastError(); //not necessarily == lastError
-
-    std::wstring errorMsg;
-    ZEN_ON_SCOPE_EXIT(errno = currentError);
-
-    errorMsg = utfTo<std::wstring>(::strerror(ec));
-    trim(errorMsg); //Windows messages seem to end with a blank...
-
-    return errorMsg;
-}
-
-
-std::wstring formatSystemError(const std::wstring& functionName, long long lastError) = delete; //intentional overload ambiguity to catch usage errors with HRESULT!
-
-inline
-std::wstring formatSystemError(const std::wstring& functionName, ErrorCode ec)
-{
-    return formatSystemError(functionName, replaceCpy(_("Error Code %x"), L"%x", numberTo<std::wstring>(ec)), formatSystemErrorRaw(ec));
-}
-
-
-inline
-std::wstring formatSystemError(const std::wstring& functionName, const std::wstring& errorCode, const std::wstring& errorMsg)
-{
-    std::wstring output = errorCode + L":";
-
-    const std::wstring errorMsgFmt = trimCpy(errorMsg);
-    if (!errorMsgFmt.empty())
-    {
-        output += L" ";
-        output += errorMsgFmt;
-    }
-
-    output += L" [" + functionName + L"]";
-
-    return output;
-}
-
-}
-
-#endif //SYS_ERROR_H_3284791347018951324534
+// *****************************************************************************
+// * This file is part of the FreeFileSync project. It is distributed under    *
+// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
+// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
+// *****************************************************************************
+
+#ifndef SYS_ERROR_H_3284791347018951324534
+#define SYS_ERROR_H_3284791347018951324534
+
+#include <string>
+#include "utf.h"
+#include "i18n.h"
+#include "scope_guard.h"
+
+    #include <cstring>
+    #include <cerrno>
+
+
+namespace zen
+{
+//evaluate GetLastError()/errno and assemble specific error message
+    using ErrorCode = int;
+
+ErrorCode getLastError();
+
+std::wstring formatSystemError(const std::wstring& functionName, ErrorCode ec);
+std::wstring formatSystemError(const std::wstring& functionName, const std::wstring& errorCode, const std::wstring& errorMsg);
+
+//A low-level exception class giving (non-translated) detail information only - same conceptional level like "GetLastError()"!
+class SysError
+{
+public:
+    explicit SysError(const std::wstring& msg) : msg_(msg) {}
+    const std::wstring& toString() const { return msg_; }
+
+private:
+    std::wstring msg_;
+};
+
+#define DEFINE_NEW_SYS_ERROR(X) struct X : public SysError { X(const std::wstring& msg) : SysError(msg) {} };
+
+
+
+#define THROW_LAST_SYS_ERROR(functionName)                           \
+    do { const ErrorCode ecInternal = getLastError(); throw SysError(formatSystemError(functionName, ecInternal)); } while (false)
+
+
+
+
+
+
+//######################## implementation ########################
+inline
+ErrorCode getLastError()
+{
+    return errno; //don't use "::", errno is a macro!
+}
+
+
+std::wstring formatSystemErrorRaw(long long) = delete; //intentional overload ambiguity to catch usage errors
+
+inline
+std::wstring formatSystemErrorRaw(ErrorCode ec) //return empty string on error
+{
+    const ErrorCode currentError = getLastError(); //not necessarily == lastError
+
+    std::wstring errorMsg;
+    ZEN_ON_SCOPE_EXIT(errno = currentError);
+
+    errorMsg = utfTo<std::wstring>(::strerror(ec));
+    trim(errorMsg); //Windows messages seem to end with a blank...
+
+    return errorMsg;
+}
+
+
+std::wstring formatSystemError(const std::wstring& functionName, long long lastError) = delete; //intentional overload ambiguity to catch usage errors with HRESULT!
+
+inline
+std::wstring formatSystemError(const std::wstring& functionName, ErrorCode ec)
+{
+    return formatSystemError(functionName, replaceCpy(_("Error Code %x"), L"%x", numberTo<std::wstring>(ec)), formatSystemErrorRaw(ec));
+}
+
+
+inline
+std::wstring formatSystemError(const std::wstring& functionName, const std::wstring& errorCode, const std::wstring& errorMsg)
+{
+    std::wstring output = errorCode + L":";
+
+    const std::wstring errorMsgFmt = trimCpy(errorMsg);
+    if (!errorMsgFmt.empty())
+    {
+        output += L" ";
+        output += errorMsgFmt;
+    }
+
+    output += L" [" + functionName + L"]";
+
+    return output;
+}
+
+}
+
+#endif //SYS_ERROR_H_3284791347018951324534
diff --git a/zen/thread.h b/zen/thread.h
index ae4c347e..76306a51 100755
--- a/zen/thread.h
+++ b/zen/thread.h
@@ -1,415 +1,415 @@
-// *****************************************************************************
-// * This file is part of the FreeFileSync project. It is distributed under    *
-// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
-// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
-// *****************************************************************************
-
-#ifndef THREAD_H_7896323423432235246427
-#define THREAD_H_7896323423432235246427
-
-#include <thread>
-#include <future>
-#include "scope_guard.h"
-#include "type_traits.h"
-#include "optional.h"
-
-
-namespace zen
-{
-class InterruptionStatus;
-
-class InterruptibleThread
-{
-public:
-    InterruptibleThread() {}
-    InterruptibleThread           (InterruptibleThread&& tmp) = default;
-    InterruptibleThread& operator=(InterruptibleThread&& tmp) = default;
-
-    template <class Function>
-    InterruptibleThread(Function&& f);
-
-    bool joinable () const { return stdThread_.joinable(); }
-    void interrupt();
-    void join     () { stdThread_.join(); }
-    void detach   () { stdThread_.detach(); }
-
-    template <class Rep, class Period>
-    bool tryJoinFor(const std::chrono::duration<Rep, Period>& relTime)
-    {
-        if (threadCompleted_.wait_for(relTime) == std::future_status::ready)
-        {
-            stdThread_.join(); //runs thread-local destructors => this better be fast!!!
-            return true;
-        }
-        return false;
-    }
-
-private:
-    std::thread stdThread_;
-    std::shared_ptr<InterruptionStatus> intStatus_;
-    std::future<void> threadCompleted_;
-};
-
-//context of worker thread:
-void interruptionPoint(); //throw ThreadInterruption
-
-template<class Predicate>
-void interruptibleWait(std::condition_variable& cv, std::unique_lock<std::mutex>& lock, Predicate pred); //throw ThreadInterruption
-
-template <class Rep, class Period>
-void interruptibleSleep(const std::chrono::duration<Rep, Period>& relTime); //throw ThreadInterruption
-
-
-uint64_t getThreadId(); //simple integer thread id, unlike boost::thread::id: https://svn.boost.org/trac/boost/ticket/5754
-
-//------------------------------------------------------------------------------------------
-
-/*
-std::async replacement without crappy semantics:
-    1. guaranteed to run asynchronously
-    2. does not follow C++11 [futures.async], Paragraph 5, where std::future waits for thread in destructor
-
-Example:
-        Zstring dirpath = ...
-        auto ft = zen::runAsync([=](){ return zen::dirExists(dirpath); });
-        if (ft.wait_for(std::chrono::milliseconds(200)) == std::future_status::ready && ft.get())
-            //dir exising
-*/
-template <class Function>
-auto runAsync(Function&& fun);
-
-//wait for all with a time limit: return true if *all* results are available!
-template<class InputIterator, class Duration>
-bool wait_for_all_timed(InputIterator first, InputIterator last, const Duration& wait_duration);
-
-template<typename T> inline
-bool isReady(const std::future<T>& f) { return f.wait_for(std::chrono::seconds(0)) == std::future_status::ready; }
-//------------------------------------------------------------------------------------------
-
-//wait until first job is successful or all failed: substitute until std::when_any is available
-template <class T>
-class GetFirstResult
-{
-public:
-    GetFirstResult();
-
-    template <class Fun>
-    void addJob(Fun&& f); //f must return a zen::Opt<T> containing a value if successful
-
-    template <class Duration>
-    bool timedWait(const Duration& duration) const; //true: "get()" is ready, false: time elapsed
-
-    //return first value or none if all jobs failed; blocks until result is ready!
-    Opt<T> get() const; //may be called only once!
-
-private:
-    class AsyncResult;
-    std::shared_ptr<AsyncResult> asyncResult_;
-    size_t jobsTotal_ = 0;
-};
-
-//------------------------------------------------------------------------------------------
-
-//value associated with mutex and guaranteed protected access:
-template <class T>
-class Protected
-{
-public:
-    Protected() {}
-    Protected(const T& value) : value_(value) {}
-
-    template <class Function>
-    void access(Function fun)
-    {
-        std::lock_guard<std::mutex> dummy(lockValue);
-        fun(value_);
-    }
-
-private:
-    Protected           (const Protected&) = delete;
-    Protected& operator=(const Protected&) = delete;
-
-    std::mutex lockValue;
-    T value_{};
-};
-
-
-
-
-
-
-
-
-
-//###################### implementation ######################
-
-namespace impl
-{
-template <class Function> inline
-auto runAsync(Function&& fun, TrueType /*copy-constructible*/)
-{
-    using ResultType = decltype(fun());
-
-    //note: std::packaged_task does NOT support move-only function objects!
-    std::packaged_task<ResultType()> pt(std::forward<Function>(fun));
-    auto fut = pt.get_future();
-    std::thread(std::move(pt)).detach(); //we have to explicitly detach since C++11: [thread.thread.destr] ~thread() calls std::terminate() if joinable()!!!
-    return fut;
-}
-
-
-template <class Function> inline
-auto runAsync(Function&& fun, FalseType /*copy-constructible*/)
-{
-    //support move-only function objects!
-    auto sharedFun = std::make_shared<Function>(std::forward<Function>(fun));
-    return runAsync([sharedFun] { return (*sharedFun)(); }, TrueType());
-}
-}
-
-
-template <class Function> inline
-auto runAsync(Function&& fun)
-{
-    return impl::runAsync(std::forward<Function>(fun), StaticBool<std::is_copy_constructible<Function>::value>());
-}
-
-
-template<class InputIterator, class Duration> inline
-bool wait_for_all_timed(InputIterator first, InputIterator last, const Duration& duration)
-{
-    const std::chrono::steady_clock::time_point stopTime = std::chrono::steady_clock::now() + duration;
-    for (; first != last; ++first)
-        if (first->wait_until(stopTime) != std::future_status::ready)
-            return false; //time elapsed
-    return true;
-}
-
-
-template <class T>
-class GetFirstResult<T>::AsyncResult
-{
-public:
-    //context: worker threads
-    void reportFinished(Opt<T>&& result)
-    {
-        {
-            std::lock_guard<std::mutex> dummy(lockResult);
-            ++jobsFinished;
-            if (!result_)
-                result_ = std::move(result);
-        }
-        conditionJobDone.notify_all(); //better notify all, considering bugs like: https://svn.boost.org/trac/boost/ticket/7796
-    }
-
-    //context: main thread
-    template <class Duration>
-    bool waitForResult(size_t jobsTotal, const Duration& duration)
-    {
-        std::unique_lock<std::mutex> dummy(lockResult);
-        return conditionJobDone.wait_for(dummy, duration, [&] { return this->jobDone(jobsTotal); });
-    }
-
-    Opt<T> getResult(size_t jobsTotal)
-    {
-        std::unique_lock<std::mutex> dummy(lockResult);
-        conditionJobDone.wait(dummy, [&] { return this->jobDone(jobsTotal); });
-
-        return std::move(result_);
-    }
-
-private:
-    bool jobDone(size_t jobsTotal) const { return result_ || (jobsFinished >= jobsTotal); } //call while locked!
-
-
-    std::mutex lockResult;
-    size_t jobsFinished = 0; //
-    Opt<T> result_;          //our condition is: "have result" or "jobsFinished == jobsTotal"
-    std::condition_variable conditionJobDone;
-};
-
-
-
-template <class T> inline
-GetFirstResult<T>::GetFirstResult() : asyncResult_(std::make_shared<AsyncResult>()) {}
-
-
-template <class T>
-template <class Fun> inline
-void GetFirstResult<T>::addJob(Fun&& f) //f must return a zen::Opt<T> containing a value on success
-{
-    std::thread t([asyncResult = this->asyncResult_, f = std::forward<Fun>(f)] { asyncResult->reportFinished(f()); });
-    ++jobsTotal_;
-    t.detach(); //we have to be explicit since C++11: [thread.thread.destr] ~thread() calls std::terminate() if joinable()!!!
-}
-
-
-template <class T>
-template <class Duration> inline
-bool GetFirstResult<T>::timedWait(const Duration& duration) const { return asyncResult_->waitForResult(jobsTotal_, duration); }
-
-
-template <class T> inline
-Opt<T> GetFirstResult<T>::get() const { return asyncResult_->getResult(jobsTotal_); }
-
-//------------------------------------------------------------------------------------------
-
-//thread_local with non-POD seems to cause memory leaks on VS 14 => pointer only is fine:
-    #define ZEN_THREAD_LOCAL_SPECIFIER __thread
-
-
-class ThreadInterruption {};
-
-
-class InterruptionStatus
-{
-public:
-    //context of InterruptibleThread instance:
-    void interrupt()
-    {
-        interrupted = true;
-
-        {
-            std::lock_guard<std::mutex> dummy(lockSleep); //needed! makes sure the following signal is not lost!
-            //usually we'd make "interrupted" non-atomic, but this is already given due to interruptibleWait() handling
-        }
-        conditionSleepInterruption.notify_all();
-
-        std::lock_guard<std::mutex> dummy(lockConditionPtr);
-        if (activeCondition)
-            activeCondition->notify_all(); //signal may get lost!
-        //alternative design locking the cv's mutex here could be dangerous: potential for dead lock!
-    }
-
-    //context of worker thread:
-    void checkInterruption() //throw ThreadInterruption
-    {
-        if (interrupted)
-            throw ThreadInterruption();
-    }
-
-    //context of worker thread:
-    template<class Predicate>
-    void interruptibleWait(std::condition_variable& cv, std::unique_lock<std::mutex>& lock, Predicate pred) //throw ThreadInterruption
-    {
-        setConditionVar(&cv);
-        ZEN_ON_SCOPE_EXIT(setConditionVar(nullptr));
-
-        //"interrupted" is not protected by cv's mutex => signal may get lost!!! => add artifical time out to mitigate! CPU: 0.25% vs 0% for longer time out!
-        while (!cv.wait_for(lock, std::chrono::milliseconds(1), [&] { return this->interrupted || pred(); }))
-            ;
-
-        checkInterruption(); //throw ThreadInterruption
-    }
-
-    //context of worker thread:
-    template <class Rep, class Period>
-    void interruptibleSleep(const std::chrono::duration<Rep, Period>& relTime) //throw ThreadInterruption
-    {
-        std::unique_lock<std::mutex> lock(lockSleep);
-        if (conditionSleepInterruption.wait_for(lock, relTime, [this] { return static_cast<bool>(this->interrupted); }))
-            throw ThreadInterruption();
-    }
-
-private:
-    void setConditionVar(std::condition_variable* cv)
-    {
-        std::lock_guard<std::mutex> dummy(lockConditionPtr);
-        activeCondition = cv;
-    }
-
-    std::atomic<bool> interrupted{ false }; //std:atomic is uninitialized by default!!!
-    //"The default constructor is trivial: no initialization takes place other than zero initialization of static and thread-local objects."
-
-    std::condition_variable* activeCondition = nullptr;
-    std::mutex lockConditionPtr; //serialize pointer access (only!)
-
-    std::condition_variable conditionSleepInterruption;
-    std::mutex lockSleep;
-};
-
-
-namespace impl
-{
-inline
-InterruptionStatus*& refThreadLocalInterruptionStatus()
-{
-    static ZEN_THREAD_LOCAL_SPECIFIER InterruptionStatus* threadLocalInterruptionStatus = nullptr;
-    return threadLocalInterruptionStatus;
-}
-}
-
-//context of worker thread:
-inline
-void interruptionPoint() //throw ThreadInterruption
-{
-    assert(impl::refThreadLocalInterruptionStatus());
-    if (impl::refThreadLocalInterruptionStatus())
-        impl::refThreadLocalInterruptionStatus()->checkInterruption(); //throw ThreadInterruption
-}
-
-
-//context of worker thread:
-template<class Predicate> inline
-void interruptibleWait(std::condition_variable& cv, std::unique_lock<std::mutex>& lock, Predicate pred) //throw ThreadInterruption
-{
-    assert(impl::refThreadLocalInterruptionStatus());
-    if (impl::refThreadLocalInterruptionStatus())
-        impl::refThreadLocalInterruptionStatus()->interruptibleWait(cv, lock, pred);
-    else
-        cv.wait(lock, pred);
-}
-
-//context of worker thread:
-template <class Rep, class Period> inline
-void interruptibleSleep(const std::chrono::duration<Rep, Period>& relTime) //throw ThreadInterruption
-{
-    assert(impl::refThreadLocalInterruptionStatus());
-    if (impl::refThreadLocalInterruptionStatus())
-        impl::refThreadLocalInterruptionStatus()->interruptibleSleep(relTime);
-    else
-        std::this_thread::sleep_for(relTime);
-}
-
-
-template <class Function> inline
-InterruptibleThread::InterruptibleThread(Function&& f) : intStatus_(std::make_shared<InterruptionStatus>())
-{
-    std::promise<void> pFinished;
-    threadCompleted_ = pFinished.get_future();
-
-    stdThread_ = std::thread([f = std::forward<Function>(f),
-                               intStatus = this->intStatus_,
-                               pFinished = std::move(pFinished)]() mutable
-    {
-        assert(!impl::refThreadLocalInterruptionStatus());
-        impl::refThreadLocalInterruptionStatus() = intStatus.get();
-        ZEN_ON_SCOPE_EXIT(impl::refThreadLocalInterruptionStatus() = nullptr);
-        ZEN_ON_SCOPE_EXIT(pFinished.set_value());
-
-        try
-        {
-            f(); //throw ThreadInterruption
-        }
-        catch (ThreadInterruption&) {}
-    });
-}
-
-
-inline
-void InterruptibleThread::interrupt() { intStatus_->interrupt(); }
-
-
-
-
-inline
-uint64_t getThreadId()
-{
-    //obviously "gettid()" is not available on Ubuntu/Debian/Suse => use the OpenSSL approach:
-    static_assert(sizeof(uint64_t) >= sizeof(void*), "");
-    return reinterpret_cast<uint64_t>(static_cast<void*>(&errno));
-
-}
-}
-
-#endif //THREAD_H_7896323423432235246427
+// *****************************************************************************
+// * This file is part of the FreeFileSync project. It is distributed under    *
+// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
+// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
+// *****************************************************************************
+
+#ifndef THREAD_H_7896323423432235246427
+#define THREAD_H_7896323423432235246427
+
+#include <thread>
+#include <future>
+#include "scope_guard.h"
+#include "type_traits.h"
+#include "optional.h"
+
+
+namespace zen
+{
+class InterruptionStatus;
+
+class InterruptibleThread
+{
+public:
+    InterruptibleThread() {}
+    InterruptibleThread           (InterruptibleThread&& tmp) = default;
+    InterruptibleThread& operator=(InterruptibleThread&& tmp) = default;
+
+    template <class Function>
+    InterruptibleThread(Function&& f);
+
+    bool joinable () const { return stdThread_.joinable(); }
+    void interrupt();
+    void join     () { stdThread_.join(); }
+    void detach   () { stdThread_.detach(); }
+
+    template <class Rep, class Period>
+    bool tryJoinFor(const std::chrono::duration<Rep, Period>& relTime)
+    {
+        if (threadCompleted_.wait_for(relTime) == std::future_status::ready)
+        {
+            stdThread_.join(); //runs thread-local destructors => this better be fast!!!
+            return true;
+        }
+        return false;
+    }
+
+private:
+    std::thread stdThread_;
+    std::shared_ptr<InterruptionStatus> intStatus_;
+    std::future<void> threadCompleted_;
+};
+
+//context of worker thread:
+void interruptionPoint(); //throw ThreadInterruption
+
+template<class Predicate>
+void interruptibleWait(std::condition_variable& cv, std::unique_lock<std::mutex>& lock, Predicate pred); //throw ThreadInterruption
+
+template <class Rep, class Period>
+void interruptibleSleep(const std::chrono::duration<Rep, Period>& relTime); //throw ThreadInterruption
+
+
+uint64_t getThreadId(); //simple integer thread id, unlike boost::thread::id: https://svn.boost.org/trac/boost/ticket/5754
+
+//------------------------------------------------------------------------------------------
+
+/*
+std::async replacement without crappy semantics:
+    1. guaranteed to run asynchronously
+    2. does not follow C++11 [futures.async], Paragraph 5, where std::future waits for thread in destructor
+
+Example:
+        Zstring dirpath = ...
+        auto ft = zen::runAsync([=](){ return zen::dirExists(dirpath); });
+        if (ft.wait_for(std::chrono::milliseconds(200)) == std::future_status::ready && ft.get())
+            //dir exising
+*/
+template <class Function>
+auto runAsync(Function&& fun);
+
+//wait for all with a time limit: return true if *all* results are available!
+template<class InputIterator, class Duration>
+bool wait_for_all_timed(InputIterator first, InputIterator last, const Duration& wait_duration);
+
+template<typename T> inline
+bool isReady(const std::future<T>& f) { return f.wait_for(std::chrono::seconds(0)) == std::future_status::ready; }
+//------------------------------------------------------------------------------------------
+
+//wait until first job is successful or all failed: substitute until std::when_any is available
+template <class T>
+class GetFirstResult
+{
+public:
+    GetFirstResult();
+
+    template <class Fun>
+    void addJob(Fun&& f); //f must return a zen::Opt<T> containing a value if successful
+
+    template <class Duration>
+    bool timedWait(const Duration& duration) const; //true: "get()" is ready, false: time elapsed
+
+    //return first value or none if all jobs failed; blocks until result is ready!
+    Opt<T> get() const; //may be called only once!
+
+private:
+    class AsyncResult;
+    std::shared_ptr<AsyncResult> asyncResult_;
+    size_t jobsTotal_ = 0;
+};
+
+//------------------------------------------------------------------------------------------
+
+//value associated with mutex and guaranteed protected access:
+template <class T>
+class Protected
+{
+public:
+    Protected() {}
+    Protected(const T& value) : value_(value) {}
+
+    template <class Function>
+    void access(Function fun)
+    {
+        std::lock_guard<std::mutex> dummy(lockValue);
+        fun(value_);
+    }
+
+private:
+    Protected           (const Protected&) = delete;
+    Protected& operator=(const Protected&) = delete;
+
+    std::mutex lockValue;
+    T value_{};
+};
+
+
+
+
+
+
+
+
+
+//###################### implementation ######################
+
+namespace impl
+{
+template <class Function> inline
+auto runAsync(Function&& fun, TrueType /*copy-constructible*/)
+{
+    using ResultType = decltype(fun());
+
+    //note: std::packaged_task does NOT support move-only function objects!
+    std::packaged_task<ResultType()> pt(std::forward<Function>(fun));
+    auto fut = pt.get_future();
+    std::thread(std::move(pt)).detach(); //we have to explicitly detach since C++11: [thread.thread.destr] ~thread() calls std::terminate() if joinable()!!!
+    return fut;
+}
+
+
+template <class Function> inline
+auto runAsync(Function&& fun, FalseType /*copy-constructible*/)
+{
+    //support move-only function objects!
+    auto sharedFun = std::make_shared<Function>(std::forward<Function>(fun));
+    return runAsync([sharedFun] { return (*sharedFun)(); }, TrueType());
+}
+}
+
+
+template <class Function> inline
+auto runAsync(Function&& fun)
+{
+    return impl::runAsync(std::forward<Function>(fun), StaticBool<std::is_copy_constructible<Function>::value>());
+}
+
+
+template<class InputIterator, class Duration> inline
+bool wait_for_all_timed(InputIterator first, InputIterator last, const Duration& duration)
+{
+    const std::chrono::steady_clock::time_point stopTime = std::chrono::steady_clock::now() + duration;
+    for (; first != last; ++first)
+        if (first->wait_until(stopTime) != std::future_status::ready)
+            return false; //time elapsed
+    return true;
+}
+
+
+template <class T>
+class GetFirstResult<T>::AsyncResult
+{
+public:
+    //context: worker threads
+    void reportFinished(Opt<T>&& result)
+    {
+        {
+            std::lock_guard<std::mutex> dummy(lockResult);
+            ++jobsFinished;
+            if (!result_)
+                result_ = std::move(result);
+        }
+        conditionJobDone.notify_all(); //better notify all, considering bugs like: https://svn.boost.org/trac/boost/ticket/7796
+    }
+
+    //context: main thread
+    template <class Duration>
+    bool waitForResult(size_t jobsTotal, const Duration& duration)
+    {
+        std::unique_lock<std::mutex> dummy(lockResult);
+        return conditionJobDone.wait_for(dummy, duration, [&] { return this->jobDone(jobsTotal); });
+    }
+
+    Opt<T> getResult(size_t jobsTotal)
+    {
+        std::unique_lock<std::mutex> dummy(lockResult);
+        conditionJobDone.wait(dummy, [&] { return this->jobDone(jobsTotal); });
+
+        return std::move(result_);
+    }
+
+private:
+    bool jobDone(size_t jobsTotal) const { return result_ || (jobsFinished >= jobsTotal); } //call while locked!
+
+
+    std::mutex lockResult;
+    size_t jobsFinished = 0; //
+    Opt<T> result_;          //our condition is: "have result" or "jobsFinished == jobsTotal"
+    std::condition_variable conditionJobDone;
+};
+
+
+
+template <class T> inline
+GetFirstResult<T>::GetFirstResult() : asyncResult_(std::make_shared<AsyncResult>()) {}
+
+
+template <class T>
+template <class Fun> inline
+void GetFirstResult<T>::addJob(Fun&& f) //f must return a zen::Opt<T> containing a value on success
+{
+    std::thread t([asyncResult = this->asyncResult_, f = std::forward<Fun>(f)] { asyncResult->reportFinished(f()); });
+    ++jobsTotal_;
+    t.detach(); //we have to be explicit since C++11: [thread.thread.destr] ~thread() calls std::terminate() if joinable()!!!
+}
+
+
+template <class T>
+template <class Duration> inline
+bool GetFirstResult<T>::timedWait(const Duration& duration) const { return asyncResult_->waitForResult(jobsTotal_, duration); }
+
+
+template <class T> inline
+Opt<T> GetFirstResult<T>::get() const { return asyncResult_->getResult(jobsTotal_); }
+
+//------------------------------------------------------------------------------------------
+
+//thread_local with non-POD seems to cause memory leaks on VS 14 => pointer only is fine:
+    #define ZEN_THREAD_LOCAL_SPECIFIER __thread
+
+
+class ThreadInterruption {};
+
+
+class InterruptionStatus
+{
+public:
+    //context of InterruptibleThread instance:
+    void interrupt()
+    {
+        interrupted = true;
+
+        {
+            std::lock_guard<std::mutex> dummy(lockSleep); //needed! makes sure the following signal is not lost!
+            //usually we'd make "interrupted" non-atomic, but this is already given due to interruptibleWait() handling
+        }
+        conditionSleepInterruption.notify_all();
+
+        std::lock_guard<std::mutex> dummy(lockConditionPtr);
+        if (activeCondition)
+            activeCondition->notify_all(); //signal may get lost!
+        //alternative design locking the cv's mutex here could be dangerous: potential for dead lock!
+    }
+
+    //context of worker thread:
+    void checkInterruption() //throw ThreadInterruption
+    {
+        if (interrupted)
+            throw ThreadInterruption();
+    }
+
+    //context of worker thread:
+    template<class Predicate>
+    void interruptibleWait(std::condition_variable& cv, std::unique_lock<std::mutex>& lock, Predicate pred) //throw ThreadInterruption
+    {
+        setConditionVar(&cv);
+        ZEN_ON_SCOPE_EXIT(setConditionVar(nullptr));
+
+        //"interrupted" is not protected by cv's mutex => signal may get lost!!! => add artifical time out to mitigate! CPU: 0.25% vs 0% for longer time out!
+        while (!cv.wait_for(lock, std::chrono::milliseconds(1), [&] { return this->interrupted || pred(); }))
+            ;
+
+        checkInterruption(); //throw ThreadInterruption
+    }
+
+    //context of worker thread:
+    template <class Rep, class Period>
+    void interruptibleSleep(const std::chrono::duration<Rep, Period>& relTime) //throw ThreadInterruption
+    {
+        std::unique_lock<std::mutex> lock(lockSleep);
+        if (conditionSleepInterruption.wait_for(lock, relTime, [this] { return static_cast<bool>(this->interrupted); }))
+            throw ThreadInterruption();
+    }
+
+private:
+    void setConditionVar(std::condition_variable* cv)
+    {
+        std::lock_guard<std::mutex> dummy(lockConditionPtr);
+        activeCondition = cv;
+    }
+
+    std::atomic<bool> interrupted{ false }; //std:atomic is uninitialized by default!!!
+    //"The default constructor is trivial: no initialization takes place other than zero initialization of static and thread-local objects."
+
+    std::condition_variable* activeCondition = nullptr;
+    std::mutex lockConditionPtr; //serialize pointer access (only!)
+
+    std::condition_variable conditionSleepInterruption;
+    std::mutex lockSleep;
+};
+
+
+namespace impl
+{
+inline
+InterruptionStatus*& refThreadLocalInterruptionStatus()
+{
+    static ZEN_THREAD_LOCAL_SPECIFIER InterruptionStatus* threadLocalInterruptionStatus = nullptr;
+    return threadLocalInterruptionStatus;
+}
+}
+
+//context of worker thread:
+inline
+void interruptionPoint() //throw ThreadInterruption
+{
+    assert(impl::refThreadLocalInterruptionStatus());
+    if (impl::refThreadLocalInterruptionStatus())
+        impl::refThreadLocalInterruptionStatus()->checkInterruption(); //throw ThreadInterruption
+}
+
+
+//context of worker thread:
+template<class Predicate> inline
+void interruptibleWait(std::condition_variable& cv, std::unique_lock<std::mutex>& lock, Predicate pred) //throw ThreadInterruption
+{
+    assert(impl::refThreadLocalInterruptionStatus());
+    if (impl::refThreadLocalInterruptionStatus())
+        impl::refThreadLocalInterruptionStatus()->interruptibleWait(cv, lock, pred);
+    else
+        cv.wait(lock, pred);
+}
+
+//context of worker thread:
+template <class Rep, class Period> inline
+void interruptibleSleep(const std::chrono::duration<Rep, Period>& relTime) //throw ThreadInterruption
+{
+    assert(impl::refThreadLocalInterruptionStatus());
+    if (impl::refThreadLocalInterruptionStatus())
+        impl::refThreadLocalInterruptionStatus()->interruptibleSleep(relTime);
+    else
+        std::this_thread::sleep_for(relTime);
+}
+
+
+template <class Function> inline
+InterruptibleThread::InterruptibleThread(Function&& f) : intStatus_(std::make_shared<InterruptionStatus>())
+{
+    std::promise<void> pFinished;
+    threadCompleted_ = pFinished.get_future();
+
+    stdThread_ = std::thread([f = std::forward<Function>(f),
+                               intStatus = this->intStatus_,
+                               pFinished = std::move(pFinished)]() mutable
+    {
+        assert(!impl::refThreadLocalInterruptionStatus());
+        impl::refThreadLocalInterruptionStatus() = intStatus.get();
+        ZEN_ON_SCOPE_EXIT(impl::refThreadLocalInterruptionStatus() = nullptr);
+        ZEN_ON_SCOPE_EXIT(pFinished.set_value());
+
+        try
+        {
+            f(); //throw ThreadInterruption
+        }
+        catch (ThreadInterruption&) {}
+    });
+}
+
+
+inline
+void InterruptibleThread::interrupt() { intStatus_->interrupt(); }
+
+
+
+
+inline
+uint64_t getThreadId()
+{
+    //obviously "gettid()" is not available on Ubuntu/Debian/Suse => use the OpenSSL approach:
+    static_assert(sizeof(uint64_t) >= sizeof(void*), "");
+    return reinterpret_cast<uint64_t>(static_cast<void*>(&errno));
+
+}
+}
+
+#endif //THREAD_H_7896323423432235246427
diff --git a/zen/time.h b/zen/time.h
index 1b6a3c92..ace87024 100755
--- a/zen/time.h
+++ b/zen/time.h
@@ -1,368 +1,368 @@
-// *****************************************************************************
-// * This file is part of the FreeFileSync project. It is distributed under    *
-// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
-// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
-// *****************************************************************************
-
-#ifndef TIME_H_8457092814324342453627
-#define TIME_H_8457092814324342453627
-
-#include <ctime>
-#include "string_tools.h"
-
-
-namespace zen
-{
-struct TimeComp //replaces std::tm and SYSTEMTIME
-{
-    int year   = 0; // -
-    int month  = 0; //1-12
-    int day    = 0; //1-31
-    int hour   = 0; //0-23
-    int minute = 0; //0-59
-    int second = 0; //0-60 (including leap second)
-};
-
-TimeComp getLocalTime(time_t utc = std::time(nullptr)); //convert time_t (UTC) to local time components
-time_t   localToTimeT(const TimeComp& comp);            //convert local time components to time_t (UTC), returns -1 on error
-
-TimeComp getUtcTime(time_t utc = std::time(nullptr)); //convert time_t (UTC) to UTC time components
-time_t   utcToTimeT(const TimeComp& comp);            //convert UTC time components to time_t (UTC), returns -1 on error
-
-//----------------------------------------------------------------------------------------------------------------------------------
-
-/*
-format (current) date and time; example:
-        formatTime<std::wstring>(L"%Y|%m|%d"); -> "2011|10|29"
-        formatTime<std::wstring>(FORMAT_DATE); -> "2011-10-29"
-        formatTime<std::wstring>(FORMAT_TIME); -> "17:55:34"
-*/
-template <class String, class String2>
-String formatTime(const String2& format, const TimeComp& comp = getLocalTime()); //format as specified by "std::strftime", returns empty string on failure
-
-//the "format" parameter of formatTime() is partially specialized with the following type tags:
-const struct FormatDateTag     {} FORMAT_DATE      = {}; //%x - locale dependent date representation: e.g. 08/23/01
-const struct FormatTimeTag     {} FORMAT_TIME      = {}; //%X - locale dependent time representation: e.g. 14:55:02
-const struct FormatDateTimeTag {} FORMAT_DATE_TIME = {}; //%c - locale dependent date and time:       e.g. Thu Aug 23 14:55:02 2001
-
-const struct FormatIsoDateTag     {} FORMAT_ISO_DATE      = {}; //%Y-%m-%d          - e.g. 2001-08-23
-const struct FormatIsoTimeTag     {} FORMAT_ISO_TIME      = {}; //%H:%M:%S          - e.g. 14:55:02
-const struct FormatIsoDateTimeTag {} FORMAT_ISO_DATE_TIME = {}; //%Y-%m-%d %H:%M:%S - e.g. 2001-08-23 14:55:02
-
-//----------------------------------------------------------------------------------------------------------------------------------
-
-template <class String, class String2>
-bool parseTime(const String& format, const String2& str, TimeComp& comp); //similar to ::strptime(), return true on success
-
-//----------------------------------------------------------------------------------------------------------------------------------
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-//############################ implementation ##############################
-namespace implementation
-{
-inline
-std::tm toClibTimeComponents(const TimeComp& comp)
-{
-    assert(1 <= comp.month  && comp.month  <= 12 &&
-           1 <= comp.day    && comp.day    <= 31 &&
-           0 <= comp.hour   && comp.hour   <= 23 &&
-           0 <= comp.minute && comp.minute <= 59 &&
-           0 <= comp.second && comp.second <= 61);
-
-    std::tm ctc = {};
-    ctc.tm_year  = comp.year - 1900; //years since 1900
-    ctc.tm_mon   = comp.month - 1;   //0-11
-    ctc.tm_mday  = comp.day;         //1-31
-    ctc.tm_hour  = comp.hour;        //0-23
-    ctc.tm_min   = comp.minute;      //0-59
-    ctc.tm_sec   = comp.second;      //0-60 (including leap second)
-    ctc.tm_isdst = -1;               //> 0 if DST is active, == 0 if DST is not active, < 0 if the information is not available
-    //ctc.tm_wday
-    //ctc.tm_yday
-    return ctc;
-}
-
-inline
-TimeComp toZenTimeComponents(const std::tm& ctc)
-{
-    TimeComp comp;
-    comp.year   = ctc.tm_year + 1900;
-    comp.month  = ctc.tm_mon + 1;
-    comp.day    = ctc.tm_mday;
-    comp.hour   = ctc.tm_hour;
-    comp.minute = ctc.tm_min;
-    comp.second = ctc.tm_sec;
-    return comp;
-}
-
-
-template <class T>
-struct GetFormat; //get default time formats as char* or wchar_t*
-
-template <>
-struct GetFormat<FormatDateTag> //%x - locale dependent date representation: e.g. 08/23/01
-{
-    const char*    format(char)    const { return  "%x"; }
-    const wchar_t* format(wchar_t) const { return L"%x"; }
-};
-
-template <>
-struct GetFormat<FormatTimeTag> //%X - locale dependent time representation: e.g. 14:55:02
-{
-    const char*    format(char)    const { return  "%X"; }
-    const wchar_t* format(wchar_t) const { return L"%X"; }
-};
-
-template <>
-struct GetFormat<FormatDateTimeTag> //%c - locale dependent date and time:       e.g. Thu Aug 23 14:55:02 2001
-{
-    const char*    format(char)    const { return  "%c"; }
-    const wchar_t* format(wchar_t) const { return L"%c"; }
-};
-
-template <>
-struct GetFormat<FormatIsoDateTag> //%Y-%m-%d - e.g. 2001-08-23
-{
-    const char*    format(char)    const { return  "%Y-%m-%d"; }
-    const wchar_t* format(wchar_t) const { return L"%Y-%m-%d"; }
-};
-
-template <>
-struct GetFormat<FormatIsoTimeTag> //%H:%M:%S - e.g. 14:55:02
-{
-    const char*    format(char)    const { return  "%H:%M:%S"; }
-    const wchar_t* format(wchar_t) const { return L"%H:%M:%S"; }
-};
-
-template <>
-struct GetFormat<FormatIsoDateTimeTag> //%Y-%m-%d %H:%M:%S - e.g. 2001-08-23 14:55:02
-{
-    const char*    format(char)    const { return  "%Y-%m-%d %H:%M:%S"; }
-    const wchar_t* format(wchar_t) const { return L"%Y-%m-%d %H:%M:%S"; }
-};
-
-
-//strftime() craziness on invalid input:
-//  VS 2010: CRASH unless "_invalid_parameter_handler" is set: https://msdn.microsoft.com/en-us/library/ksazx244.aspx
-//  GCC: returns 0, apparently no crash. Still, considering some clib maintainer's comments, we should expect the worst!
-inline
-size_t strftimeWrap_impl(char* buffer, size_t bufferSize, const char* format, const std::tm* timeptr)
-{
-    return std::strftime(buffer, bufferSize, format, timeptr);
-}
-
-
-inline
-size_t strftimeWrap_impl(wchar_t* buffer, size_t bufferSize, const wchar_t* format, const std::tm* timeptr)
-{
-    return std::wcsftime(buffer, bufferSize, format, timeptr);
-}
-
-/*
-inline
-bool isValid(const std::tm& t)
-{
-     -> not enough! MSCRT has different limits than the C standard which even seem to change with different versions:
-        _VALIDATE_RETURN((( timeptr->tm_sec >=0 ) && ( timeptr->tm_sec <= 59 ) ), EINVAL, FALSE)
-        _VALIDATE_RETURN(( timeptr->tm_year >= -1900 ) && ( timeptr->tm_year <= 8099 ), EINVAL, FALSE)
-    -> also std::mktime does *not* help here at all!
-
-    auto inRange = [](int value, int minVal, int maxVal) { return minVal <= value && value <= maxVal; };
-
-    //http://www.cplusplus.com/reference/clibrary/ctime/tm/
-    return inRange(t.tm_sec , 0, 61) &&
-           inRange(t.tm_min , 0, 59) &&
-           inRange(t.tm_hour, 0, 23) &&
-           inRange(t.tm_mday, 1, 31) &&
-           inRange(t.tm_mon , 0, 11) &&
-           //tm_year
-           inRange(t.tm_wday, 0, 6) &&
-           inRange(t.tm_yday, 0, 365);
-    //tm_isdst
-};
-*/
-
-template <class CharType> inline
-size_t strftimeWrap(CharType* buffer, size_t bufferSize, const CharType* format, const std::tm* timeptr)
-{
-
-    return strftimeWrap_impl(buffer, bufferSize, format, timeptr);
-}
-
-
-struct UserDefinedFormatTag {};
-struct PredefinedFormatTag  {};
-
-template <class String, class String2> inline
-String formatTime(const String2& format, const TimeComp& comp, UserDefinedFormatTag) //format as specified by "std::strftime", returns empty string on failure
-{
-    using CharType = typename GetCharType<String>::Type;
-    std::tm ctc = toClibTimeComponents(comp);
-    std::mktime(&ctc); // unfortunately std::strftime() needs all elements of "struct tm" filled, e.g. tm_wday, tm_yday
-    //note: although std::mktime() explicitly expects "local time", calculating weekday and day of year *should* be time-zone and DST independent
-
-    CharType buffer[256] = {};
-    const size_t charsWritten = strftimeWrap(buffer, 256, strBegin(format), &ctc);
-    return String(buffer, charsWritten);
-}
-
-template <class String, class FormatType> inline
-String formatTime(FormatType, const TimeComp& comp, PredefinedFormatTag)
-{
-    using CharType = typename GetCharType<String>::Type;
-    return formatTime<String>(GetFormat<FormatType>().format(CharType()), comp, UserDefinedFormatTag());
-}
-}
-
-
-inline
-TimeComp getLocalTime(time_t utc)
-{
-    std::tm comp = {};
-    if (::localtime_r(&utc, &comp) == nullptr)
-        return TimeComp();
-
-    return implementation::toZenTimeComponents(comp);
-}
-
-
-inline
-TimeComp getUtcTime(time_t utc)
-{
-    std::tm comp = {};
-    if (::gmtime_r(&utc, &comp) == nullptr)
-        return TimeComp();
-
-    return implementation::toZenTimeComponents(comp);
-}
-
-
-inline
-time_t localToTimeT(const TimeComp& comp) //returns -1 on error
-{
-    std::tm ctc = implementation::toClibTimeComponents(comp);
-    return std::mktime(&ctc);
-}
-
-
-inline
-time_t utcToTimeT(const TimeComp& comp) //returns -1 on error
-{
-    std::tm ctc = implementation::toClibTimeComponents(comp);
-    ctc.tm_isdst = 0; //"Zero (0) to indicate that standard time is in effect" => unused by _mkgmtime, but take no chances
-    return ::timegm(&ctc);
-}
-
-
-template <class String, class String2> inline
-String formatTime(const String2& format, const TimeComp& comp)
-{
-    using FormatTag = typename SelectIf<
-                      IsSameType<String2, FormatDateTag       >::value ||
-                      IsSameType<String2, FormatTimeTag       >::value ||
-                      IsSameType<String2, FormatDateTimeTag   >::value ||
-                      IsSameType<String2, FormatIsoDateTag    >::value ||
-                      IsSameType<String2, FormatIsoTimeTag    >::value ||
-                      IsSameType<String2, FormatIsoDateTimeTag>::value, implementation::PredefinedFormatTag, implementation::UserDefinedFormatTag>::Type;
-
-    return implementation::formatTime<String>(format, comp, FormatTag());
-}
-
-
-template <class String, class String2>
-bool parseTime(const String& format, const String2& str, TimeComp& comp) //return true on success
-{
-    using CharType = typename GetCharType<String>::Type;
-    static_assert(IsSameType<CharType, typename GetCharType<String2>::Type>::value, "");
-
-    const CharType*       itFmt = strBegin(format);
-    const CharType* const fmtLast = itFmt + strLength(format);
-
-    const CharType*       itStr = strBegin(str);
-    const CharType* const strLast = itStr + strLength(str);
-
-    auto extractNumber = [&](int& result, size_t digitCount) -> bool
-    {
-        if (strLast - itStr < makeSigned(digitCount))
-            return false;
-
-        if (std::any_of(itStr, itStr + digitCount, [](CharType c) { return !isDigit(c); }))
-        return false;
-
-        result = zen::stringTo<int>(StringRef<const CharType>(itStr, itStr + digitCount));
-        itStr += digitCount;
-        return true;
-    };
-
-    for (; itFmt != fmtLast; ++itFmt)
-    {
-        const CharType fmt = *itFmt;
-
-        if (fmt == '%')
-        {
-            ++itFmt;
-            if (itFmt == fmtLast)
-                return false;
-
-            switch (*itFmt)
-            {
-                case 'Y':
-                    if (!extractNumber(comp.year, 4))
-                        return false;
-                    break;
-                case 'm':
-                    if (!extractNumber(comp.month, 2))
-                        return false;
-                    break;
-                case 'd':
-                    if (!extractNumber(comp.day, 2))
-                        return false;
-                    break;
-                case 'H':
-                    if (!extractNumber(comp.hour, 2))
-                        return false;
-                    break;
-                case 'M':
-                    if (!extractNumber(comp.minute, 2))
-                        return false;
-                    break;
-                case 'S':
-                    if (!extractNumber(comp.second, 2))
-                        return false;
-                    break;
-                default:
-                    return false;
-            }
-        }
-        else if (isWhiteSpace(fmt)) //single whitespace in format => skip 0..n whitespace chars
-        {
-            while (itStr != strLast && isWhiteSpace(*itStr))
-                ++itStr;
-        }
-        else
-        {
-            if (itStr == strLast || *itStr != fmt)
-                return false;
-            ++itStr;
-        }
-    }
-
-    return itStr == strLast;
-}
-}
-
-#endif //TIME_H_8457092814324342453627
+// *****************************************************************************
+// * This file is part of the FreeFileSync project. It is distributed under    *
+// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
+// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
+// *****************************************************************************
+
+#ifndef TIME_H_8457092814324342453627
+#define TIME_H_8457092814324342453627
+
+#include <ctime>
+#include "string_tools.h"
+
+
+namespace zen
+{
+struct TimeComp //replaces std::tm and SYSTEMTIME
+{
+    int year   = 0; // -
+    int month  = 0; //1-12
+    int day    = 0; //1-31
+    int hour   = 0; //0-23
+    int minute = 0; //0-59
+    int second = 0; //0-60 (including leap second)
+};
+
+TimeComp getLocalTime(time_t utc = std::time(nullptr)); //convert time_t (UTC) to local time components
+time_t   localToTimeT(const TimeComp& comp);            //convert local time components to time_t (UTC), returns -1 on error
+
+TimeComp getUtcTime(time_t utc = std::time(nullptr)); //convert time_t (UTC) to UTC time components
+time_t   utcToTimeT(const TimeComp& comp);            //convert UTC time components to time_t (UTC), returns -1 on error
+
+//----------------------------------------------------------------------------------------------------------------------------------
+
+/*
+format (current) date and time; example:
+        formatTime<std::wstring>(L"%Y|%m|%d"); -> "2011|10|29"
+        formatTime<std::wstring>(FORMAT_DATE); -> "2011-10-29"
+        formatTime<std::wstring>(FORMAT_TIME); -> "17:55:34"
+*/
+template <class String, class String2>
+String formatTime(const String2& format, const TimeComp& comp = getLocalTime()); //format as specified by "std::strftime", returns empty string on failure
+
+//the "format" parameter of formatTime() is partially specialized with the following type tags:
+const struct FormatDateTag     {} FORMAT_DATE      = {}; //%x - locale dependent date representation: e.g. 08/23/01
+const struct FormatTimeTag     {} FORMAT_TIME      = {}; //%X - locale dependent time representation: e.g. 14:55:02
+const struct FormatDateTimeTag {} FORMAT_DATE_TIME = {}; //%c - locale dependent date and time:       e.g. Thu Aug 23 14:55:02 2001
+
+const struct FormatIsoDateTag     {} FORMAT_ISO_DATE      = {}; //%Y-%m-%d          - e.g. 2001-08-23
+const struct FormatIsoTimeTag     {} FORMAT_ISO_TIME      = {}; //%H:%M:%S          - e.g. 14:55:02
+const struct FormatIsoDateTimeTag {} FORMAT_ISO_DATE_TIME = {}; //%Y-%m-%d %H:%M:%S - e.g. 2001-08-23 14:55:02
+
+//----------------------------------------------------------------------------------------------------------------------------------
+
+template <class String, class String2>
+bool parseTime(const String& format, const String2& str, TimeComp& comp); //similar to ::strptime(), return true on success
+
+//----------------------------------------------------------------------------------------------------------------------------------
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+//############################ implementation ##############################
+namespace implementation
+{
+inline
+std::tm toClibTimeComponents(const TimeComp& comp)
+{
+    assert(1 <= comp.month  && comp.month  <= 12 &&
+           1 <= comp.day    && comp.day    <= 31 &&
+           0 <= comp.hour   && comp.hour   <= 23 &&
+           0 <= comp.minute && comp.minute <= 59 &&
+           0 <= comp.second && comp.second <= 61);
+
+    std::tm ctc = {};
+    ctc.tm_year  = comp.year - 1900; //years since 1900
+    ctc.tm_mon   = comp.month - 1;   //0-11
+    ctc.tm_mday  = comp.day;         //1-31
+    ctc.tm_hour  = comp.hour;        //0-23
+    ctc.tm_min   = comp.minute;      //0-59
+    ctc.tm_sec   = comp.second;      //0-60 (including leap second)
+    ctc.tm_isdst = -1;               //> 0 if DST is active, == 0 if DST is not active, < 0 if the information is not available
+    //ctc.tm_wday
+    //ctc.tm_yday
+    return ctc;
+}
+
+inline
+TimeComp toZenTimeComponents(const std::tm& ctc)
+{
+    TimeComp comp;
+    comp.year   = ctc.tm_year + 1900;
+    comp.month  = ctc.tm_mon + 1;
+    comp.day    = ctc.tm_mday;
+    comp.hour   = ctc.tm_hour;
+    comp.minute = ctc.tm_min;
+    comp.second = ctc.tm_sec;
+    return comp;
+}
+
+
+template <class T>
+struct GetFormat; //get default time formats as char* or wchar_t*
+
+template <>
+struct GetFormat<FormatDateTag> //%x - locale dependent date representation: e.g. 08/23/01
+{
+    const char*    format(char)    const { return  "%x"; }
+    const wchar_t* format(wchar_t) const { return L"%x"; }
+};
+
+template <>
+struct GetFormat<FormatTimeTag> //%X - locale dependent time representation: e.g. 14:55:02
+{
+    const char*    format(char)    const { return  "%X"; }
+    const wchar_t* format(wchar_t) const { return L"%X"; }
+};
+
+template <>
+struct GetFormat<FormatDateTimeTag> //%c - locale dependent date and time:       e.g. Thu Aug 23 14:55:02 2001
+{
+    const char*    format(char)    const { return  "%c"; }
+    const wchar_t* format(wchar_t) const { return L"%c"; }
+};
+
+template <>
+struct GetFormat<FormatIsoDateTag> //%Y-%m-%d - e.g. 2001-08-23
+{
+    const char*    format(char)    const { return  "%Y-%m-%d"; }
+    const wchar_t* format(wchar_t) const { return L"%Y-%m-%d"; }
+};
+
+template <>
+struct GetFormat<FormatIsoTimeTag> //%H:%M:%S - e.g. 14:55:02
+{
+    const char*    format(char)    const { return  "%H:%M:%S"; }
+    const wchar_t* format(wchar_t) const { return L"%H:%M:%S"; }
+};
+
+template <>
+struct GetFormat<FormatIsoDateTimeTag> //%Y-%m-%d %H:%M:%S - e.g. 2001-08-23 14:55:02
+{
+    const char*    format(char)    const { return  "%Y-%m-%d %H:%M:%S"; }
+    const wchar_t* format(wchar_t) const { return L"%Y-%m-%d %H:%M:%S"; }
+};
+
+
+//strftime() craziness on invalid input:
+//  VS 2010: CRASH unless "_invalid_parameter_handler" is set: https://msdn.microsoft.com/en-us/library/ksazx244.aspx
+//  GCC: returns 0, apparently no crash. Still, considering some clib maintainer's comments, we should expect the worst!
+inline
+size_t strftimeWrap_impl(char* buffer, size_t bufferSize, const char* format, const std::tm* timeptr)
+{
+    return std::strftime(buffer, bufferSize, format, timeptr);
+}
+
+
+inline
+size_t strftimeWrap_impl(wchar_t* buffer, size_t bufferSize, const wchar_t* format, const std::tm* timeptr)
+{
+    return std::wcsftime(buffer, bufferSize, format, timeptr);
+}
+
+/*
+inline
+bool isValid(const std::tm& t)
+{
+     -> not enough! MSCRT has different limits than the C standard which even seem to change with different versions:
+        _VALIDATE_RETURN((( timeptr->tm_sec >=0 ) && ( timeptr->tm_sec <= 59 ) ), EINVAL, FALSE)
+        _VALIDATE_RETURN(( timeptr->tm_year >= -1900 ) && ( timeptr->tm_year <= 8099 ), EINVAL, FALSE)
+    -> also std::mktime does *not* help here at all!
+
+    auto inRange = [](int value, int minVal, int maxVal) { return minVal <= value && value <= maxVal; };
+
+    //http://www.cplusplus.com/reference/clibrary/ctime/tm/
+    return inRange(t.tm_sec , 0, 61) &&
+           inRange(t.tm_min , 0, 59) &&
+           inRange(t.tm_hour, 0, 23) &&
+           inRange(t.tm_mday, 1, 31) &&
+           inRange(t.tm_mon , 0, 11) &&
+           //tm_year
+           inRange(t.tm_wday, 0, 6) &&
+           inRange(t.tm_yday, 0, 365);
+    //tm_isdst
+};
+*/
+
+template <class CharType> inline
+size_t strftimeWrap(CharType* buffer, size_t bufferSize, const CharType* format, const std::tm* timeptr)
+{
+
+    return strftimeWrap_impl(buffer, bufferSize, format, timeptr);
+}
+
+
+struct UserDefinedFormatTag {};
+struct PredefinedFormatTag  {};
+
+template <class String, class String2> inline
+String formatTime(const String2& format, const TimeComp& comp, UserDefinedFormatTag) //format as specified by "std::strftime", returns empty string on failure
+{
+    using CharType = typename GetCharType<String>::Type;
+    std::tm ctc = toClibTimeComponents(comp);
+    std::mktime(&ctc); // unfortunately std::strftime() needs all elements of "struct tm" filled, e.g. tm_wday, tm_yday
+    //note: although std::mktime() explicitly expects "local time", calculating weekday and day of year *should* be time-zone and DST independent
+
+    CharType buffer[256] = {};
+    const size_t charsWritten = strftimeWrap(buffer, 256, strBegin(format), &ctc);
+    return String(buffer, charsWritten);
+}
+
+template <class String, class FormatType> inline
+String formatTime(FormatType, const TimeComp& comp, PredefinedFormatTag)
+{
+    using CharType = typename GetCharType<String>::Type;
+    return formatTime<String>(GetFormat<FormatType>().format(CharType()), comp, UserDefinedFormatTag());
+}
+}
+
+
+inline
+TimeComp getLocalTime(time_t utc)
+{
+    std::tm comp = {};
+    if (::localtime_r(&utc, &comp) == nullptr)
+        return TimeComp();
+
+    return implementation::toZenTimeComponents(comp);
+}
+
+
+inline
+TimeComp getUtcTime(time_t utc)
+{
+    std::tm comp = {};
+    if (::gmtime_r(&utc, &comp) == nullptr)
+        return TimeComp();
+
+    return implementation::toZenTimeComponents(comp);
+}
+
+
+inline
+time_t localToTimeT(const TimeComp& comp) //returns -1 on error
+{
+    std::tm ctc = implementation::toClibTimeComponents(comp);
+    return std::mktime(&ctc);
+}
+
+
+inline
+time_t utcToTimeT(const TimeComp& comp) //returns -1 on error
+{
+    std::tm ctc = implementation::toClibTimeComponents(comp);
+    ctc.tm_isdst = 0; //"Zero (0) to indicate that standard time is in effect" => unused by _mkgmtime, but take no chances
+    return ::timegm(&ctc);
+}
+
+
+template <class String, class String2> inline
+String formatTime(const String2& format, const TimeComp& comp)
+{
+    using FormatTag = typename SelectIf<
+                      IsSameType<String2, FormatDateTag       >::value ||
+                      IsSameType<String2, FormatTimeTag       >::value ||
+                      IsSameType<String2, FormatDateTimeTag   >::value ||
+                      IsSameType<String2, FormatIsoDateTag    >::value ||
+                      IsSameType<String2, FormatIsoTimeTag    >::value ||
+                      IsSameType<String2, FormatIsoDateTimeTag>::value, implementation::PredefinedFormatTag, implementation::UserDefinedFormatTag>::Type;
+
+    return implementation::formatTime<String>(format, comp, FormatTag());
+}
+
+
+template <class String, class String2>
+bool parseTime(const String& format, const String2& str, TimeComp& comp) //return true on success
+{
+    using CharType = typename GetCharType<String>::Type;
+    static_assert(IsSameType<CharType, typename GetCharType<String2>::Type>::value, "");
+
+    const CharType*       itFmt = strBegin(format);
+    const CharType* const fmtLast = itFmt + strLength(format);
+
+    const CharType*       itStr = strBegin(str);
+    const CharType* const strLast = itStr + strLength(str);
+
+    auto extractNumber = [&](int& result, size_t digitCount) -> bool
+    {
+        if (strLast - itStr < makeSigned(digitCount))
+            return false;
+
+        if (std::any_of(itStr, itStr + digitCount, [](CharType c) { return !isDigit(c); }))
+        return false;
+
+        result = zen::stringTo<int>(StringRef<const CharType>(itStr, itStr + digitCount));
+        itStr += digitCount;
+        return true;
+    };
+
+    for (; itFmt != fmtLast; ++itFmt)
+    {
+        const CharType fmt = *itFmt;
+
+        if (fmt == '%')
+        {
+            ++itFmt;
+            if (itFmt == fmtLast)
+                return false;
+
+            switch (*itFmt)
+            {
+                case 'Y':
+                    if (!extractNumber(comp.year, 4))
+                        return false;
+                    break;
+                case 'm':
+                    if (!extractNumber(comp.month, 2))
+                        return false;
+                    break;
+                case 'd':
+                    if (!extractNumber(comp.day, 2))
+                        return false;
+                    break;
+                case 'H':
+                    if (!extractNumber(comp.hour, 2))
+                        return false;
+                    break;
+                case 'M':
+                    if (!extractNumber(comp.minute, 2))
+                        return false;
+                    break;
+                case 'S':
+                    if (!extractNumber(comp.second, 2))
+                        return false;
+                    break;
+                default:
+                    return false;
+            }
+        }
+        else if (isWhiteSpace(fmt)) //single whitespace in format => skip 0..n whitespace chars
+        {
+            while (itStr != strLast && isWhiteSpace(*itStr))
+                ++itStr;
+        }
+        else
+        {
+            if (itStr == strLast || *itStr != fmt)
+                return false;
+            ++itStr;
+        }
+    }
+
+    return itStr == strLast;
+}
+}
+
+#endif //TIME_H_8457092814324342453627
diff --git a/zen/type_tools.h b/zen/type_tools.h
index 082530ec..d0a62ea2 100755
--- a/zen/type_tools.h
+++ b/zen/type_tools.h
@@ -1,103 +1,103 @@
-// *****************************************************************************
-// * This file is part of the FreeFileSync project. It is distributed under    *
-// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
-// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
-// *****************************************************************************
-
-#ifndef TYPE_TOOLS_H_45237590734254545
-#define TYPE_TOOLS_H_45237590734254545
-
-#include "type_traits.h"
-
-
-namespace zen
-{
-//########## Strawman Classes ##########################
-struct NullType {}; //:= no type here
-
-//########## Type Mapping ##############################
-template <int n>
-struct Int2Type {};
-//------------------------------------------------------
-template <class T>
-struct Type2Type {};
-
-//########## Control Structures ########################
-template <bool flag, class T, class U>
-struct SelectIf : ResultType<T> {};
-
-template <class T, class U>
-struct SelectIf<false, T, U> : ResultType<U> {};
-//------------------------------------------------------
-template <class T, class U>
-struct IsSameType : FalseType {};
-
-template <class T>
-struct IsSameType<T, T> : TrueType {};
-
-//------------------------------------------------------
-template <bool, class T = void>
-struct EnableIf {};
-
-template <class T>
-struct EnableIf<true, T> : ResultType<T> {};
-//########## Type Cleanup ##############################
-template <class T>
-struct RemoveRef : ResultType<T> {};
-
-template <class T>
-struct RemoveRef<T&> : ResultType<T> {};
-
-template <class T>
-struct RemoveRef<T&&> : ResultType<T> {};
-//------------------------------------------------------
-template <class T>
-struct RemoveConst : ResultType<T> {};
-
-template <class T>
-struct RemoveConst<const T> : ResultType<T> {};
-//------------------------------------------------------
-template <class T>
-struct RemovePointer : ResultType<T> {};
-
-template <class T>
-struct RemovePointer<T*> : ResultType<T> {};
-//------------------------------------------------------
-template <class T>
-struct RemoveArray : ResultType<T> {};
-
-template <class T, int N>
-struct RemoveArray<T[N]> : ResultType<T> {};
-
-//########## Sorting ##############################
-/*
-Generate a descending binary predicate at compile time!
-
-Usage:
-    static const bool ascending = ...
-    makeSortDirection(old binary predicate, Int2Type<ascending>()) -> new binary predicate
-
-or directly;
-    makeDescending(old binary predicate) -> new binary predicate
-*/
-
-template <class Predicate>
-struct LessDescending
-{
-    LessDescending(Predicate lessThan) : lessThan_(lessThan) {}
-    template <class T> bool operator()(const T& lhs, const T& rhs) const { return lessThan_(rhs, lhs); }
-private:
-    Predicate lessThan_;
-};
-
-template <class Predicate> inline
-/**/           Predicate  makeSortDirection(Predicate pred, Int2Type<true>) { return pred; }
-
-template <class Predicate> inline
-LessDescending<Predicate> makeSortDirection(Predicate pred, Int2Type<false>) { return pred; }
-
-template <class Predicate> inline
-LessDescending<Predicate> makeDescending(Predicate pred) { return pred; }
-}
-
-#endif //TYPE_TOOLS_H_45237590734254545
+// *****************************************************************************
+// * This file is part of the FreeFileSync project. It is distributed under    *
+// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
+// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
+// *****************************************************************************
+
+#ifndef TYPE_TOOLS_H_45237590734254545
+#define TYPE_TOOLS_H_45237590734254545
+
+#include "type_traits.h"
+
+
+namespace zen
+{
+//########## Strawman Classes ##########################
+struct NullType {}; //:= no type here
+
+//########## Type Mapping ##############################
+template <int n>
+struct Int2Type {};
+//------------------------------------------------------
+template <class T>
+struct Type2Type {};
+
+//########## Control Structures ########################
+template <bool flag, class T, class U>
+struct SelectIf : ResultType<T> {};
+
+template <class T, class U>
+struct SelectIf<false, T, U> : ResultType<U> {};
+//------------------------------------------------------
+template <class T, class U>
+struct IsSameType : FalseType {};
+
+template <class T>
+struct IsSameType<T, T> : TrueType {};
+
+//------------------------------------------------------
+template <bool, class T = void>
+struct EnableIf {};
+
+template <class T>
+struct EnableIf<true, T> : ResultType<T> {};
+//########## Type Cleanup ##############################
+template <class T>
+struct RemoveRef : ResultType<T> {};
+
+template <class T>
+struct RemoveRef<T&> : ResultType<T> {};
+
+template <class T>
+struct RemoveRef<T&&> : ResultType<T> {};
+//------------------------------------------------------
+template <class T>
+struct RemoveConst : ResultType<T> {};
+
+template <class T>
+struct RemoveConst<const T> : ResultType<T> {};
+//------------------------------------------------------
+template <class T>
+struct RemovePointer : ResultType<T> {};
+
+template <class T>
+struct RemovePointer<T*> : ResultType<T> {};
+//------------------------------------------------------
+template <class T>
+struct RemoveArray : ResultType<T> {};
+
+template <class T, int N>
+struct RemoveArray<T[N]> : ResultType<T> {};
+
+//########## Sorting ##############################
+/*
+Generate a descending binary predicate at compile time!
+
+Usage:
+    static const bool ascending = ...
+    makeSortDirection(old binary predicate, Int2Type<ascending>()) -> new binary predicate
+
+or directly;
+    makeDescending(old binary predicate) -> new binary predicate
+*/
+
+template <class Predicate>
+struct LessDescending
+{
+    LessDescending(Predicate lessThan) : lessThan_(lessThan) {}
+    template <class T> bool operator()(const T& lhs, const T& rhs) const { return lessThan_(rhs, lhs); }
+private:
+    Predicate lessThan_;
+};
+
+template <class Predicate> inline
+/**/           Predicate  makeSortDirection(Predicate pred, Int2Type<true>) { return pred; }
+
+template <class Predicate> inline
+LessDescending<Predicate> makeSortDirection(Predicate pred, Int2Type<false>) { return pred; }
+
+template <class Predicate> inline
+LessDescending<Predicate> makeDescending(Predicate pred) { return pred; }
+}
+
+#endif //TYPE_TOOLS_H_45237590734254545
diff --git a/zen/type_traits.h b/zen/type_traits.h
index f4e5cebd..917b3258 100755
--- a/zen/type_traits.h
+++ b/zen/type_traits.h
@@ -1,195 +1,195 @@
-// *****************************************************************************
-// * This file is part of the FreeFileSync project. It is distributed under    *
-// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
-// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
-// *****************************************************************************
-
-#ifndef TYPE_TRAITS_H_3425628658765467
-#define TYPE_TRAITS_H_3425628658765467
-
-#include <type_traits> //all we need is std::is_class!!
-
-
-namespace zen
-{
-//################# TMP compile time return values: "inherit to return compile-time result" ##############
-template <int i>
-struct StaticInt
-{
-    enum { value = i };
-};
-
-template <bool b>
-struct StaticBool : StaticInt<b> {};
-
-using TrueType  = StaticBool<true>;
-using FalseType = StaticBool<false>;
-
-template <class EnumType, EnumType val>
-struct StaticEnum
-{
-    static const EnumType value = val;
-};
-//---------------------------------------------------------
-template <class T>
-struct ResultType
-{
-    using Type = T;
-};
-
-//Herb Sutter's signedness conversion helpers: http://herbsutter.com/2013/06/13/gotw-93-solution-auto-variables-part-2/
-template<class T> inline auto makeSigned  (T t) { return static_cast<std::make_signed_t  <T>>(t); }
-template<class T> inline auto makeUnsigned(T t) { return static_cast<std::make_unsigned_t<T>>(t); }
-
-//################# Built-in Types  ########################
-//Example: "IsSignedInt<int>::value" evaluates to "true"
-
-template <class T> struct IsUnsignedInt;
-template <class T> struct IsSignedInt;
-template <class T> struct IsFloat;
-
-template <class T> struct IsInteger;    //IsSignedInt or IsUnsignedInt
-template <class T> struct IsArithmetic; //IsInteger or IsFloat
-//remaining non-arithmetic types: bool, char, wchar_t
-
-//optional: specialize new types like:
-//template <> struct IsUnsignedInt<UInt64> : TrueType {};
-
-//################# Class Members ########################
-
-/*  Detect data or function members of a class by name: ZEN_INIT_DETECT_MEMBER + HasMember_
-    Example: 1. ZEN_INIT_DETECT_MEMBER(c_str);
-             2. HasMember_c_str<T>::value     -> use boolean
-*/
-
-/*  Detect data or function members of a class by name *and* type: ZEN_INIT_DETECT_MEMBER2 + HasMember_
-
-    Example: 1. ZEN_INIT_DETECT_MEMBER2(size, size_t (T::*)() const);
-             2. HasMember_size<T>::value     -> use as boolean
-*/
-
-/*  Detect member type of a class: ZEN_INIT_DETECT_MEMBER_TYPE + HasMemberType_
-
-    Example: 1. ZEN_INIT_DETECT_MEMBER_TYPE(value_type);
-             2. HasMemberType_value_type<T>::value     -> use as boolean
-*/
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-//################ implementation ######################
-#define ZEN_SPECIALIZE_TRAIT(X, Y) template <> struct X<Y> : TrueType {};
-
-template <class T>
-struct IsUnsignedInt : FalseType {};
-
-ZEN_SPECIALIZE_TRAIT(IsUnsignedInt, unsigned char);
-ZEN_SPECIALIZE_TRAIT(IsUnsignedInt, unsigned short int);
-ZEN_SPECIALIZE_TRAIT(IsUnsignedInt, unsigned int);
-ZEN_SPECIALIZE_TRAIT(IsUnsignedInt, unsigned long int);
-ZEN_SPECIALIZE_TRAIT(IsUnsignedInt, unsigned long long int); //new with C++11 - same type as unsigned __int64 in VS2010
-//------------------------------------------------------
-
-template <class T>
-struct IsSignedInt : FalseType {};
-
-ZEN_SPECIALIZE_TRAIT(IsSignedInt, signed char);
-ZEN_SPECIALIZE_TRAIT(IsSignedInt, short int);
-ZEN_SPECIALIZE_TRAIT(IsSignedInt, int);
-ZEN_SPECIALIZE_TRAIT(IsSignedInt, long int);
-ZEN_SPECIALIZE_TRAIT(IsSignedInt, long long int); //new with C++11 - same type as __int64 in VS2010
-//------------------------------------------------------
-
-template <class T>
-struct IsFloat : FalseType {};
-
-ZEN_SPECIALIZE_TRAIT(IsFloat, float);
-ZEN_SPECIALIZE_TRAIT(IsFloat, double);
-ZEN_SPECIALIZE_TRAIT(IsFloat, long double);
-//------------------------------------------------------
-
-#undef ZEN_SPECIALIZE_TRAIT
-
-template <class T>
-struct IsInteger : StaticBool<IsUnsignedInt<T>::value || IsSignedInt<T>::value> {};
-
-template <class T>
-struct IsArithmetic : StaticBool<IsInteger<T>::value || IsFloat<T>::value> {};
-//####################################################################
-
-#define ZEN_INIT_DETECT_MEMBER(NAME)        \
-    \
-    template<bool isClass, class T>         \
-    struct HasMemberImpl_##NAME             \
-    {                                       \
-    private:                                \
-        using Yes = char[1];                \
-        using No  = char[2];                \
-        \
-        template <typename U, U t>          \
-        class Helper {};                    \
-        struct Fallback { int NAME; };      \
-        \
-        template <class U>                  \
-        struct Helper2 : public U, public Fallback {};  /*this works only for class types!!!*/  \
-        \
-        template <class U> static  No& hasMember(Helper<int Fallback::*, &Helper2<U>::NAME>*);  \
-        template <class U> static Yes& hasMember(...);                                          \
-    public:                                                                                     \
-        enum { value = sizeof(hasMember<T>(nullptr)) == sizeof(Yes) };                          \
-    };                                                                                          \
-    \
-    template<class T>                                             \
-    struct HasMemberImpl_##NAME<false, T> : FalseType {}; \
-    \
-    template<typename T>                                          \
-    struct HasMember_##NAME : StaticBool<HasMemberImpl_##NAME<std::is_class<T>::value, T>::value> {};
-
-//####################################################################
-
-#define ZEN_INIT_DETECT_MEMBER2(NAME, TYPE)         \
-    \
-    template<typename U>                            \
-    class HasMember_##NAME                          \
-    {                                               \
-        using Yes = char[1];                        \
-        using No  = char[2];                        \
-        \
-        template <typename T, T t> class Helper {}; \
-        \
-        template <class T> static Yes& hasMember(Helper<TYPE, &T::NAME>*);  \
-        template <class T> static  No& hasMember(...);                      \
-    public:                                                                 \
-        enum { value = sizeof(hasMember<U>(nullptr)) == sizeof(Yes) };      \
-    };
-//####################################################################
-
-#define ZEN_INIT_DETECT_MEMBER_TYPE(TYPENAME)       \
-    \
-    template<typename T>                        \
-    class HasMemberType_##TYPENAME              \
-    {                                           \
-        using Yes = char[1];                    \
-        using No  = char[2];                    \
-        \
-        template <typename U> class Helper {};  \
-        \
-        template <class U> static Yes& hasMemberType(Helper<typename U::TYPENAME>*); \
-        template <class U> static  No& hasMemberType(...);                           \
-    public:                                                                          \
-        enum { value = sizeof(hasMemberType<T>(nullptr)) == sizeof(Yes) };           \
-    };
-}
-
-#endif //TYPE_TRAITS_H_3425628658765467
+// *****************************************************************************
+// * This file is part of the FreeFileSync project. It is distributed under    *
+// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
+// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
+// *****************************************************************************
+
+#ifndef TYPE_TRAITS_H_3425628658765467
+#define TYPE_TRAITS_H_3425628658765467
+
+#include <type_traits> //all we need is std::is_class!!
+
+
+namespace zen
+{
+//################# TMP compile time return values: "inherit to return compile-time result" ##############
+template <int i>
+struct StaticInt
+{
+    enum { value = i };
+};
+
+template <bool b>
+struct StaticBool : StaticInt<b> {};
+
+using TrueType  = StaticBool<true>;
+using FalseType = StaticBool<false>;
+
+template <class EnumType, EnumType val>
+struct StaticEnum
+{
+    static const EnumType value = val;
+};
+//---------------------------------------------------------
+template <class T>
+struct ResultType
+{
+    using Type = T;
+};
+
+//Herb Sutter's signedness conversion helpers: http://herbsutter.com/2013/06/13/gotw-93-solution-auto-variables-part-2/
+template<class T> inline auto makeSigned  (T t) { return static_cast<std::make_signed_t  <T>>(t); }
+template<class T> inline auto makeUnsigned(T t) { return static_cast<std::make_unsigned_t<T>>(t); }
+
+//################# Built-in Types  ########################
+//Example: "IsSignedInt<int>::value" evaluates to "true"
+
+template <class T> struct IsUnsignedInt;
+template <class T> struct IsSignedInt;
+template <class T> struct IsFloat;
+
+template <class T> struct IsInteger;    //IsSignedInt or IsUnsignedInt
+template <class T> struct IsArithmetic; //IsInteger or IsFloat
+//remaining non-arithmetic types: bool, char, wchar_t
+
+//optional: specialize new types like:
+//template <> struct IsUnsignedInt<UInt64> : TrueType {};
+
+//################# Class Members ########################
+
+/*  Detect data or function members of a class by name: ZEN_INIT_DETECT_MEMBER + HasMember_
+    Example: 1. ZEN_INIT_DETECT_MEMBER(c_str);
+             2. HasMember_c_str<T>::value     -> use boolean
+*/
+
+/*  Detect data or function members of a class by name *and* type: ZEN_INIT_DETECT_MEMBER2 + HasMember_
+
+    Example: 1. ZEN_INIT_DETECT_MEMBER2(size, size_t (T::*)() const);
+             2. HasMember_size<T>::value     -> use as boolean
+*/
+
+/*  Detect member type of a class: ZEN_INIT_DETECT_MEMBER_TYPE + HasMemberType_
+
+    Example: 1. ZEN_INIT_DETECT_MEMBER_TYPE(value_type);
+             2. HasMemberType_value_type<T>::value     -> use as boolean
+*/
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+//################ implementation ######################
+#define ZEN_SPECIALIZE_TRAIT(X, Y) template <> struct X<Y> : TrueType {};
+
+template <class T>
+struct IsUnsignedInt : FalseType {};
+
+ZEN_SPECIALIZE_TRAIT(IsUnsignedInt, unsigned char);
+ZEN_SPECIALIZE_TRAIT(IsUnsignedInt, unsigned short int);
+ZEN_SPECIALIZE_TRAIT(IsUnsignedInt, unsigned int);
+ZEN_SPECIALIZE_TRAIT(IsUnsignedInt, unsigned long int);
+ZEN_SPECIALIZE_TRAIT(IsUnsignedInt, unsigned long long int); //new with C++11 - same type as unsigned __int64 in VS2010
+//------------------------------------------------------
+
+template <class T>
+struct IsSignedInt : FalseType {};
+
+ZEN_SPECIALIZE_TRAIT(IsSignedInt, signed char);
+ZEN_SPECIALIZE_TRAIT(IsSignedInt, short int);
+ZEN_SPECIALIZE_TRAIT(IsSignedInt, int);
+ZEN_SPECIALIZE_TRAIT(IsSignedInt, long int);
+ZEN_SPECIALIZE_TRAIT(IsSignedInt, long long int); //new with C++11 - same type as __int64 in VS2010
+//------------------------------------------------------
+
+template <class T>
+struct IsFloat : FalseType {};
+
+ZEN_SPECIALIZE_TRAIT(IsFloat, float);
+ZEN_SPECIALIZE_TRAIT(IsFloat, double);
+ZEN_SPECIALIZE_TRAIT(IsFloat, long double);
+//------------------------------------------------------
+
+#undef ZEN_SPECIALIZE_TRAIT
+
+template <class T>
+struct IsInteger : StaticBool<IsUnsignedInt<T>::value || IsSignedInt<T>::value> {};
+
+template <class T>
+struct IsArithmetic : StaticBool<IsInteger<T>::value || IsFloat<T>::value> {};
+//####################################################################
+
+#define ZEN_INIT_DETECT_MEMBER(NAME)        \
+    \
+    template<bool isClass, class T>         \
+    struct HasMemberImpl_##NAME             \
+    {                                       \
+    private:                                \
+        using Yes = char[1];                \
+        using No  = char[2];                \
+        \
+        template <typename U, U t>          \
+        class Helper {};                    \
+        struct Fallback { int NAME; };      \
+        \
+        template <class U>                  \
+        struct Helper2 : public U, public Fallback {};  /*this works only for class types!!!*/  \
+        \
+        template <class U> static  No& hasMember(Helper<int Fallback::*, &Helper2<U>::NAME>*);  \
+        template <class U> static Yes& hasMember(...);                                          \
+    public:                                                                                     \
+        enum { value = sizeof(hasMember<T>(nullptr)) == sizeof(Yes) };                          \
+    };                                                                                          \
+    \
+    template<class T>                                             \
+    struct HasMemberImpl_##NAME<false, T> : FalseType {}; \
+    \
+    template<typename T>                                          \
+    struct HasMember_##NAME : StaticBool<HasMemberImpl_##NAME<std::is_class<T>::value, T>::value> {};
+
+//####################################################################
+
+#define ZEN_INIT_DETECT_MEMBER2(NAME, TYPE)         \
+    \
+    template<typename U>                            \
+    class HasMember_##NAME                          \
+    {                                               \
+        using Yes = char[1];                        \
+        using No  = char[2];                        \
+        \
+        template <typename T, T t> class Helper {}; \
+        \
+        template <class T> static Yes& hasMember(Helper<TYPE, &T::NAME>*);  \
+        template <class T> static  No& hasMember(...);                      \
+    public:                                                                 \
+        enum { value = sizeof(hasMember<U>(nullptr)) == sizeof(Yes) };      \
+    };
+//####################################################################
+
+#define ZEN_INIT_DETECT_MEMBER_TYPE(TYPENAME)       \
+    \
+    template<typename T>                        \
+    class HasMemberType_##TYPENAME              \
+    {                                           \
+        using Yes = char[1];                    \
+        using No  = char[2];                    \
+        \
+        template <typename U> class Helper {};  \
+        \
+        template <class U> static Yes& hasMemberType(Helper<typename U::TYPENAME>*); \
+        template <class U> static  No& hasMemberType(...);                           \
+    public:                                                                          \
+        enum { value = sizeof(hasMemberType<T>(nullptr)) == sizeof(Yes) };           \
+    };
+}
+
+#endif //TYPE_TRAITS_H_3425628658765467
diff --git a/zen/utf.h b/zen/utf.h
index ab8fda50..bc1e3270 100755
--- a/zen/utf.h
+++ b/zen/utf.h
@@ -1,387 +1,387 @@
-// *****************************************************************************
-// * This file is part of the FreeFileSync project. It is distributed under    *
-// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
-// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
-// *****************************************************************************
-
-#ifndef UTF_H_01832479146991573473545
-#define UTF_H_01832479146991573473545
-
-#include <cstdint>
-#include <iterator>
-#include "string_tools.h" //copyStringTo
-#include "optional.h"
-
-namespace zen
-{
-//convert all(!) char- and wchar_t-based "string-like" objects applying a UTF8 conversions (but only if necessary!)
-template <class TargetString, class SourceString>
-TargetString utfTo(const SourceString& str);
-
-const char BYTE_ORDER_MARK_UTF8[] = "\xEF\xBB\xBF";
-
-template <class UtfString>
-bool isValidUtf(const UtfString& str); //check for UTF-8 encoding errors
-
-//access unicode characters in UTF-encoded string (char- or wchar_t-based)
-template <class UtfString>
-size_t unicodeLength(const UtfString& str); //return number of code points for UTF-encoded string
-
-template <class UtfString>
-UtfString getUnicodeSubstring(const UtfString& str, size_t uniPosFirst, size_t uniPosLast);
-
-
-
-
-
-
-
-
-
-//----------------------- implementation ----------------------------------
-namespace implementation
-{
-using CodePoint = uint32_t;
-using Char16    = uint16_t;
-using Char8     = uint8_t;
-
-const CodePoint LEAD_SURROGATE      = 0xd800;
-const CodePoint TRAIL_SURROGATE     = 0xdc00; //== LEAD_SURROGATE_MAX + 1
-const CodePoint TRAIL_SURROGATE_MAX = 0xdfff;
-
-const CodePoint REPLACEMENT_CHAR    = 0xfffd;
-const CodePoint CODE_POINT_MAX      = 0x10ffff;
-
-
-template <class Function> inline
-void codePointToUtf16(CodePoint cp, Function writeOutput) //"writeOutput" is a unary function taking a Char16
-{
-    //http://en.wikipedia.org/wiki/UTF-16
-    if (cp < LEAD_SURROGATE)
-        writeOutput(static_cast<Char16>(cp));
-    else if (cp <= TRAIL_SURROGATE_MAX) //invalid code point
-        codePointToUtf16(REPLACEMENT_CHAR, writeOutput); //resolves to 1-character utf16
-    else if (cp < 0x10000)
-        writeOutput(static_cast<Char16>(cp));
-    else if (cp <= CODE_POINT_MAX)
-    {
-        cp -= 0x10000;
-        writeOutput(static_cast<Char16>( LEAD_SURROGATE + (cp >> 10)));
-        writeOutput(static_cast<Char16>(TRAIL_SURROGATE + (cp & 0x3ff)));
-    }
-    else //invalid code point
-        codePointToUtf16(REPLACEMENT_CHAR, writeOutput); //resolves to 1-character utf16
-}
-
-
-inline
-size_t getUtf16Len(Char16 ch) //ch must be first code unit! returns 0 on error!
-{
-    if (ch < LEAD_SURROGATE)
-        return 1;
-    else if (ch < TRAIL_SURROGATE)
-        return 2;
-    else if (ch <= TRAIL_SURROGATE_MAX)
-        return 0; //unexpected trail surrogate!
-    else
-        return 1;
-}
-
-
-class Utf16Decoder
-{
-public:
-    Utf16Decoder(const Char16* str, size_t len) : it_(str), last_(str + len) {}
-
-    Opt<CodePoint> getNext()
-    {
-        if (it_ == last_)
-            return NoValue();
-
-        const Char16 ch = *it_++;
-        CodePoint cp = ch;
-        switch (getUtf16Len(ch))
-        {
-            case 0: //invalid utf16 character
-                cp = REPLACEMENT_CHAR;
-                break;
-            case 1:
-                break;
-            case 2:
-                decodeTrail(cp);
-                break;
-        }
-        return cp;
-    }
-
-private:
-    void decodeTrail(CodePoint& cp)
-    {
-        if (it_ != last_) //trail surrogate expected!
-        {
-            const Char16 ch = *it_;
-            if (TRAIL_SURROGATE <= ch && ch <= TRAIL_SURROGATE_MAX) //trail surrogate expected!
-            {
-                cp = ((cp - LEAD_SURROGATE) << 10) + (ch - TRAIL_SURROGATE) + 0x10000;
-                ++it_;
-                return;
-            }
-        }
-        cp = REPLACEMENT_CHAR;
-    }
-
-    const Char16* it_;
-    const Char16* const last_;
-};
-
-//----------------------------------------------------------------------------------------------------------------
-
-template <class Function> inline
-void codePointToUtf8(CodePoint cp, Function writeOutput) //"writeOutput" is a unary function taking a Char8
-{
-    //http://en.wikipedia.org/wiki/UTF-8
-    //assert(cp < LEAD_SURROGATE || TRAIL_SURROGATE_MAX < cp); //code points [0xd800, 0xdfff] are reserved for UTF-16 and *should* not be encoded in UTF-8
-
-    if (cp < 0x80)
-        writeOutput(static_cast<Char8>(cp));
-    else if (cp < 0x800)
-    {
-        writeOutput(static_cast<Char8>((cp >> 6  ) | 0xc0));
-        writeOutput(static_cast<Char8>((cp & 0x3f) | 0x80));
-    }
-    else if (cp < 0x10000)
-    {
-        writeOutput(static_cast<Char8>( (cp >> 12       ) | 0xe0));
-        writeOutput(static_cast<Char8>(((cp >> 6) & 0x3f) | 0x80));
-        writeOutput(static_cast<Char8>( (cp       & 0x3f) | 0x80));
-    }
-    else if (cp <= CODE_POINT_MAX)
-    {
-        writeOutput(static_cast<Char8>( (cp >> 18        ) | 0xf0));
-        writeOutput(static_cast<Char8>(((cp >> 12) & 0x3f) | 0x80));
-        writeOutput(static_cast<Char8>(((cp >> 6)  & 0x3f) | 0x80));
-        writeOutput(static_cast<Char8>( (cp        & 0x3f) | 0x80));
-    }
-    else //invalid code point
-        codePointToUtf8(REPLACEMENT_CHAR, writeOutput); //resolves to 3-byte utf8
-}
-
-
-inline
-size_t getUtf8Len(Char8 ch) //ch must be first code unit! returns 0 on error!
-{
-    if (ch < 0x80)
-        return 1;
-    if (ch >> 5 == 0x6)
-        return 2;
-    if (ch >> 4 == 0xe)
-        return 3;
-    if (ch >> 3 == 0x1e)
-        return 4;
-    return 0; //innvalid begin of UTF8 encoding
-}
-
-
-class Utf8Decoder
-{
-public:
-    Utf8Decoder(const Char8* str, size_t len) : it_(str), last_(str + len) {}
-
-    Opt<CodePoint> getNext()
-    {
-        if (it_ == last_)
-            return NoValue();
-
-        const Char8 ch = *it_++;
-        CodePoint cp = ch;
-        switch (getUtf8Len(ch))
-        {
-            case 0: //invalid utf8 character
-                cp = REPLACEMENT_CHAR;
-                break;
-            case 1:
-                break;
-            case 2:
-                cp &= 0x1f;
-                decodeTrail(cp);
-                break;
-            case 3:
-                cp &= 0xf;
-                if (decodeTrail(cp))
-                    decodeTrail(cp);
-                break;
-            case 4:
-                cp &= 0x7;
-                if (decodeTrail(cp))
-                    if (decodeTrail(cp))
-                        decodeTrail(cp);
-                if (cp > CODE_POINT_MAX) cp = REPLACEMENT_CHAR;
-                break;
-        }
-        return cp;
-    }
-
-private:
-    bool decodeTrail(CodePoint& cp)
-    {
-        if (it_ != last_) //trail surrogate expected!
-        {
-            const Char8 ch = *it_;
-            if (ch >> 6 == 0x2) //trail surrogate expected!
-            {
-                cp = (cp << 6) + (ch & 0x3f);
-                ++it_;
-                return true;
-            }
-        }
-        cp = REPLACEMENT_CHAR;
-        return false;
-    }
-
-    const Char8* it_;
-    const Char8* const last_;
-};
-
-//----------------------------------------------------------------------------------------------------------------
-
-template <class Function> inline void codePointToUtf(CodePoint cp, Function writeOutput, Int2Type<1>) { codePointToUtf8 (cp, writeOutput); } //UTF8-char
-template <class Function> inline void codePointToUtf(CodePoint cp, Function writeOutput, Int2Type<2>) { codePointToUtf16(cp, writeOutput); } //Windows: UTF16-wchar_t
-template <class Function> inline void codePointToUtf(CodePoint cp, Function writeOutput, Int2Type<4>) { writeOutput(cp); } //other OS: UTF32-wchar_t
-
-template <class CharType, class Function> inline
-void codePointToUtf(CodePoint cp, Function writeOutput) //"writeOutput" is a unary function taking a CharType
-{
-    return codePointToUtf(cp, writeOutput, Int2Type<sizeof(CharType)>());
-}
-
-//----------------------------------------------------------------------------------------------------------------
-
-template <class CharType, int charSize>
-class UtfDecoderImpl;
-
-
-template <class CharType>
-class UtfDecoderImpl<CharType, 1> //UTF8-char
-{
-public:
-    UtfDecoderImpl(const CharType* str, size_t len) : decoder_(reinterpret_cast<const Char8*>(str), len) {}
-    Opt<CodePoint> getNext() { return decoder_.getNext(); }
-private:
-    Utf8Decoder decoder_;
-};
-
-
-template <class CharType>
-class UtfDecoderImpl<CharType, 2> //Windows: UTF16-wchar_t
-{
-public:
-    UtfDecoderImpl(const CharType* str, size_t len) : decoder_(reinterpret_cast<const Char16*>(str), len) {}
-    Opt<CodePoint> getNext() { return decoder_.getNext(); }
-private:
-    Utf16Decoder decoder_;
-};
-
-
-template <class CharType>
-class UtfDecoderImpl<CharType, 4> //other OS: UTF32-wchar_t
-{
-public:
-    UtfDecoderImpl(const CharType* str, size_t len) : it_(reinterpret_cast<const CodePoint*>(str)), last_(it_ + len) {}
-    Opt<CodePoint> getNext()
-    {
-        if (it_ == last_)
-            return NoValue();
-        return *it_++;
-    }
-private:
-    const CodePoint* it_;
-    const CodePoint* last_;
-};
-
-
-template <class CharType>
-using UtfDecoder = UtfDecoderImpl<CharType, sizeof(CharType)>;
-}
-
-//-------------------------------------------------------------------------------------------
-
-template <class UtfString> inline
-bool isValidUtf(const UtfString& str)
-{
-    using namespace implementation;
-
-    UtfDecoder<typename GetCharType<UtfString>::Type> decoder(strBegin(str), strLength(str));
-    while (Opt<CodePoint> cp = decoder.getNext())
-        if (*cp == REPLACEMENT_CHAR)
-            return false;
-
-    return true;
-}
-
-
-template <class UtfString> inline
-size_t unicodeLength(const UtfString& str) //return number of code points (+ correctly handle broken UTF encoding)
-{
-    size_t uniLen = 0;
-    implementation::UtfDecoder<typename GetCharType<UtfString>::Type> decoder(strBegin(str), strLength(str));
-    while (decoder.getNext())
-        ++uniLen;
-    return uniLen;
-}
-
-
-template <class UtfString> inline
-UtfString getUnicodeSubstring(const UtfString& str, size_t uniPosFirst, size_t uniPosLast) //return position of unicode char in UTF-encoded string
-{
-    assert(uniPosFirst <= uniPosLast && uniPosLast <= unicodeLength(str));
-    using namespace implementation;
-    using CharType = typename GetCharType<UtfString>::Type;
-    UtfString output;
-    if (uniPosFirst >= uniPosLast) //optimize for empty range
-        return output;
-
-    UtfDecoder<CharType> decoder(strBegin(str), strLength(str));
-    for (size_t uniPos = 0; Opt<CodePoint> cp = decoder.getNext(); ++uniPos) //[!] declaration in condition part of the for-loop
-        if (uniPosFirst <= uniPos)
-        {
-            if (uniPos >= uniPosLast)
-                break;
-            codePointToUtf<CharType>(*cp, [&](CharType c) { output += c; });
-        }
-    return output;
-}
-
-//-------------------------------------------------------------------------------------------
-
-namespace implementation
-{
-template <class TargetString, class SourceString> inline
-TargetString utfTo(const SourceString& str, FalseType)
-{
-    using CharSrc = typename GetCharType<SourceString>::Type;
-    using CharTrg = typename GetCharType<TargetString>::Type;
-    static_assert(sizeof(CharSrc) != sizeof(CharTrg), "no UTF-conversion needed");
-
-    TargetString output;
-
-    UtfDecoder<CharSrc> decoder(strBegin(str), strLength(str));
-    while (Opt<CodePoint> cp = decoder.getNext())
-        codePointToUtf<CharTrg>(*cp, [&](CharTrg c) { output += c; });
-
-    return output;
-}
-
-
-template <class TargetString, class SourceString> inline
-TargetString utfTo(const SourceString& str, TrueType) { return copyStringTo<TargetString>(str); }
-}
-
-
-template <class TargetString, class SourceString> inline
-TargetString utfTo(const SourceString& str)
-{
-    return implementation::utfTo<TargetString>(str, StaticBool<sizeof(typename GetCharType<SourceString>::Type) == sizeof(typename GetCharType<TargetString>::Type)>());
-}
-}
-
-#endif //UTF_H_01832479146991573473545
+// *****************************************************************************
+// * This file is part of the FreeFileSync project. It is distributed under    *
+// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
+// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
+// *****************************************************************************
+
+#ifndef UTF_H_01832479146991573473545
+#define UTF_H_01832479146991573473545
+
+#include <cstdint>
+#include <iterator>
+#include "string_tools.h" //copyStringTo
+#include "optional.h"
+
+namespace zen
+{
+//convert all(!) char- and wchar_t-based "string-like" objects applying a UTF8 conversions (but only if necessary!)
+template <class TargetString, class SourceString>
+TargetString utfTo(const SourceString& str);
+
+const char BYTE_ORDER_MARK_UTF8[] = "\xEF\xBB\xBF";
+
+template <class UtfString>
+bool isValidUtf(const UtfString& str); //check for UTF-8 encoding errors
+
+//access unicode characters in UTF-encoded string (char- or wchar_t-based)
+template <class UtfString>
+size_t unicodeLength(const UtfString& str); //return number of code points for UTF-encoded string
+
+template <class UtfString>
+UtfString getUnicodeSubstring(const UtfString& str, size_t uniPosFirst, size_t uniPosLast);
+
+
+
+
+
+
+
+
+
+//----------------------- implementation ----------------------------------
+namespace implementation
+{
+using CodePoint = uint32_t;
+using Char16    = uint16_t;
+using Char8     = uint8_t;
+
+const CodePoint LEAD_SURROGATE      = 0xd800;
+const CodePoint TRAIL_SURROGATE     = 0xdc00; //== LEAD_SURROGATE_MAX + 1
+const CodePoint TRAIL_SURROGATE_MAX = 0xdfff;
+
+const CodePoint REPLACEMENT_CHAR    = 0xfffd;
+const CodePoint CODE_POINT_MAX      = 0x10ffff;
+
+
+template <class Function> inline
+void codePointToUtf16(CodePoint cp, Function writeOutput) //"writeOutput" is a unary function taking a Char16
+{
+    //http://en.wikipedia.org/wiki/UTF-16
+    if (cp < LEAD_SURROGATE)
+        writeOutput(static_cast<Char16>(cp));
+    else if (cp <= TRAIL_SURROGATE_MAX) //invalid code point
+        codePointToUtf16(REPLACEMENT_CHAR, writeOutput); //resolves to 1-character utf16
+    else if (cp < 0x10000)
+        writeOutput(static_cast<Char16>(cp));
+    else if (cp <= CODE_POINT_MAX)
+    {
+        cp -= 0x10000;
+        writeOutput(static_cast<Char16>( LEAD_SURROGATE + (cp >> 10)));
+        writeOutput(static_cast<Char16>(TRAIL_SURROGATE + (cp & 0x3ff)));
+    }
+    else //invalid code point
+        codePointToUtf16(REPLACEMENT_CHAR, writeOutput); //resolves to 1-character utf16
+}
+
+
+inline
+size_t getUtf16Len(Char16 ch) //ch must be first code unit! returns 0 on error!
+{
+    if (ch < LEAD_SURROGATE)
+        return 1;
+    else if (ch < TRAIL_SURROGATE)
+        return 2;
+    else if (ch <= TRAIL_SURROGATE_MAX)
+        return 0; //unexpected trail surrogate!
+    else
+        return 1;
+}
+
+
+class Utf16Decoder
+{
+public:
+    Utf16Decoder(const Char16* str, size_t len) : it_(str), last_(str + len) {}
+
+    Opt<CodePoint> getNext()
+    {
+        if (it_ == last_)
+            return NoValue();
+
+        const Char16 ch = *it_++;
+        CodePoint cp = ch;
+        switch (getUtf16Len(ch))
+        {
+            case 0: //invalid utf16 character
+                cp = REPLACEMENT_CHAR;
+                break;
+            case 1:
+                break;
+            case 2:
+                decodeTrail(cp);
+                break;
+        }
+        return cp;
+    }
+
+private:
+    void decodeTrail(CodePoint& cp)
+    {
+        if (it_ != last_) //trail surrogate expected!
+        {
+            const Char16 ch = *it_;
+            if (TRAIL_SURROGATE <= ch && ch <= TRAIL_SURROGATE_MAX) //trail surrogate expected!
+            {
+                cp = ((cp - LEAD_SURROGATE) << 10) + (ch - TRAIL_SURROGATE) + 0x10000;
+                ++it_;
+                return;
+            }
+        }
+        cp = REPLACEMENT_CHAR;
+    }
+
+    const Char16* it_;
+    const Char16* const last_;
+};
+
+//----------------------------------------------------------------------------------------------------------------
+
+template <class Function> inline
+void codePointToUtf8(CodePoint cp, Function writeOutput) //"writeOutput" is a unary function taking a Char8
+{
+    //http://en.wikipedia.org/wiki/UTF-8
+    //assert(cp < LEAD_SURROGATE || TRAIL_SURROGATE_MAX < cp); //code points [0xd800, 0xdfff] are reserved for UTF-16 and *should* not be encoded in UTF-8
+
+    if (cp < 0x80)
+        writeOutput(static_cast<Char8>(cp));
+    else if (cp < 0x800)
+    {
+        writeOutput(static_cast<Char8>((cp >> 6  ) | 0xc0));
+        writeOutput(static_cast<Char8>((cp & 0x3f) | 0x80));
+    }
+    else if (cp < 0x10000)
+    {
+        writeOutput(static_cast<Char8>( (cp >> 12       ) | 0xe0));
+        writeOutput(static_cast<Char8>(((cp >> 6) & 0x3f) | 0x80));
+        writeOutput(static_cast<Char8>( (cp       & 0x3f) | 0x80));
+    }
+    else if (cp <= CODE_POINT_MAX)
+    {
+        writeOutput(static_cast<Char8>( (cp >> 18        ) | 0xf0));
+        writeOutput(static_cast<Char8>(((cp >> 12) & 0x3f) | 0x80));
+        writeOutput(static_cast<Char8>(((cp >> 6)  & 0x3f) | 0x80));
+        writeOutput(static_cast<Char8>( (cp        & 0x3f) | 0x80));
+    }
+    else //invalid code point
+        codePointToUtf8(REPLACEMENT_CHAR, writeOutput); //resolves to 3-byte utf8
+}
+
+
+inline
+size_t getUtf8Len(Char8 ch) //ch must be first code unit! returns 0 on error!
+{
+    if (ch < 0x80)
+        return 1;
+    if (ch >> 5 == 0x6)
+        return 2;
+    if (ch >> 4 == 0xe)
+        return 3;
+    if (ch >> 3 == 0x1e)
+        return 4;
+    return 0; //innvalid begin of UTF8 encoding
+}
+
+
+class Utf8Decoder
+{
+public:
+    Utf8Decoder(const Char8* str, size_t len) : it_(str), last_(str + len) {}
+
+    Opt<CodePoint> getNext()
+    {
+        if (it_ == last_)
+            return NoValue();
+
+        const Char8 ch = *it_++;
+        CodePoint cp = ch;
+        switch (getUtf8Len(ch))
+        {
+            case 0: //invalid utf8 character
+                cp = REPLACEMENT_CHAR;
+                break;
+            case 1:
+                break;
+            case 2:
+                cp &= 0x1f;
+                decodeTrail(cp);
+                break;
+            case 3:
+                cp &= 0xf;
+                if (decodeTrail(cp))
+                    decodeTrail(cp);
+                break;
+            case 4:
+                cp &= 0x7;
+                if (decodeTrail(cp))
+                    if (decodeTrail(cp))
+                        decodeTrail(cp);
+                if (cp > CODE_POINT_MAX) cp = REPLACEMENT_CHAR;
+                break;
+        }
+        return cp;
+    }
+
+private:
+    bool decodeTrail(CodePoint& cp)
+    {
+        if (it_ != last_) //trail surrogate expected!
+        {
+            const Char8 ch = *it_;
+            if (ch >> 6 == 0x2) //trail surrogate expected!
+            {
+                cp = (cp << 6) + (ch & 0x3f);
+                ++it_;
+                return true;
+            }
+        }
+        cp = REPLACEMENT_CHAR;
+        return false;
+    }
+
+    const Char8* it_;
+    const Char8* const last_;
+};
+
+//----------------------------------------------------------------------------------------------------------------
+
+template <class Function> inline void codePointToUtf(CodePoint cp, Function writeOutput, Int2Type<1>) { codePointToUtf8 (cp, writeOutput); } //UTF8-char
+template <class Function> inline void codePointToUtf(CodePoint cp, Function writeOutput, Int2Type<2>) { codePointToUtf16(cp, writeOutput); } //Windows: UTF16-wchar_t
+template <class Function> inline void codePointToUtf(CodePoint cp, Function writeOutput, Int2Type<4>) { writeOutput(cp); } //other OS: UTF32-wchar_t
+
+template <class CharType, class Function> inline
+void codePointToUtf(CodePoint cp, Function writeOutput) //"writeOutput" is a unary function taking a CharType
+{
+    return codePointToUtf(cp, writeOutput, Int2Type<sizeof(CharType)>());
+}
+
+//----------------------------------------------------------------------------------------------------------------
+
+template <class CharType, int charSize>
+class UtfDecoderImpl;
+
+
+template <class CharType>
+class UtfDecoderImpl<CharType, 1> //UTF8-char
+{
+public:
+    UtfDecoderImpl(const CharType* str, size_t len) : decoder_(reinterpret_cast<const Char8*>(str), len) {}
+    Opt<CodePoint> getNext() { return decoder_.getNext(); }
+private:
+    Utf8Decoder decoder_;
+};
+
+
+template <class CharType>
+class UtfDecoderImpl<CharType, 2> //Windows: UTF16-wchar_t
+{
+public:
+    UtfDecoderImpl(const CharType* str, size_t len) : decoder_(reinterpret_cast<const Char16*>(str), len) {}
+    Opt<CodePoint> getNext() { return decoder_.getNext(); }
+private:
+    Utf16Decoder decoder_;
+};
+
+
+template <class CharType>
+class UtfDecoderImpl<CharType, 4> //other OS: UTF32-wchar_t
+{
+public:
+    UtfDecoderImpl(const CharType* str, size_t len) : it_(reinterpret_cast<const CodePoint*>(str)), last_(it_ + len) {}
+    Opt<CodePoint> getNext()
+    {
+        if (it_ == last_)
+            return NoValue();
+        return *it_++;
+    }
+private:
+    const CodePoint* it_;
+    const CodePoint* last_;
+};
+
+
+template <class CharType>
+using UtfDecoder = UtfDecoderImpl<CharType, sizeof(CharType)>;
+}
+
+//-------------------------------------------------------------------------------------------
+
+template <class UtfString> inline
+bool isValidUtf(const UtfString& str)
+{
+    using namespace implementation;
+
+    UtfDecoder<typename GetCharType<UtfString>::Type> decoder(strBegin(str), strLength(str));
+    while (Opt<CodePoint> cp = decoder.getNext())
+        if (*cp == REPLACEMENT_CHAR)
+            return false;
+
+    return true;
+}
+
+
+template <class UtfString> inline
+size_t unicodeLength(const UtfString& str) //return number of code points (+ correctly handle broken UTF encoding)
+{
+    size_t uniLen = 0;
+    implementation::UtfDecoder<typename GetCharType<UtfString>::Type> decoder(strBegin(str), strLength(str));
+    while (decoder.getNext())
+        ++uniLen;
+    return uniLen;
+}
+
+
+template <class UtfString> inline
+UtfString getUnicodeSubstring(const UtfString& str, size_t uniPosFirst, size_t uniPosLast) //return position of unicode char in UTF-encoded string
+{
+    assert(uniPosFirst <= uniPosLast && uniPosLast <= unicodeLength(str));
+    using namespace implementation;
+    using CharType = typename GetCharType<UtfString>::Type;
+    UtfString output;
+    if (uniPosFirst >= uniPosLast) //optimize for empty range
+        return output;
+
+    UtfDecoder<CharType> decoder(strBegin(str), strLength(str));
+    for (size_t uniPos = 0; Opt<CodePoint> cp = decoder.getNext(); ++uniPos) //[!] declaration in condition part of the for-loop
+        if (uniPosFirst <= uniPos)
+        {
+            if (uniPos >= uniPosLast)
+                break;
+            codePointToUtf<CharType>(*cp, [&](CharType c) { output += c; });
+        }
+    return output;
+}
+
+//-------------------------------------------------------------------------------------------
+
+namespace implementation
+{
+template <class TargetString, class SourceString> inline
+TargetString utfTo(const SourceString& str, FalseType)
+{
+    using CharSrc = typename GetCharType<SourceString>::Type;
+    using CharTrg = typename GetCharType<TargetString>::Type;
+    static_assert(sizeof(CharSrc) != sizeof(CharTrg), "no UTF-conversion needed");
+
+    TargetString output;
+
+    UtfDecoder<CharSrc> decoder(strBegin(str), strLength(str));
+    while (Opt<CodePoint> cp = decoder.getNext())
+        codePointToUtf<CharTrg>(*cp, [&](CharTrg c) { output += c; });
+
+    return output;
+}
+
+
+template <class TargetString, class SourceString> inline
+TargetString utfTo(const SourceString& str, TrueType) { return copyStringTo<TargetString>(str); }
+}
+
+
+template <class TargetString, class SourceString> inline
+TargetString utfTo(const SourceString& str)
+{
+    return implementation::utfTo<TargetString>(str, StaticBool<sizeof(typename GetCharType<SourceString>::Type) == sizeof(typename GetCharType<TargetString>::Type)>());
+}
+}
+
+#endif //UTF_H_01832479146991573473545
diff --git a/zen/warn_static.h b/zen/warn_static.h
index 74dbd627..c2232f74 100755
--- a/zen/warn_static.h
+++ b/zen/warn_static.h
@@ -1,24 +1,24 @@
-// *****************************************************************************
-// * This file is part of the FreeFileSync project. It is distributed under    *
-// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
-// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
-// *****************************************************************************
-
-#ifndef WARN_STATIC_H_08724567834560832745
-#define WARN_STATIC_H_08724567834560832745
-
-/*
-Portable Compile-Time Warning
------------------------------
-Usage:
-    warn_static("my message")
-*/
-
-#define STATIC_WARNING_CONCAT_SUB(X, Y) X ## Y
-#define STATIC_WARNING_CONCAT(X, Y) STATIC_WARNING_CONCAT_SUB(X, Y)
-
-#define warn_static(TXT) \
-    typedef int STATIC_WARNING_87903124 __attribute__ ((deprecated)); \
-    enum { STATIC_WARNING_CONCAT(warn_static_dummy_value, __LINE__) = sizeof(STATIC_WARNING_87903124) };
-
-#endif //WARN_STATIC_H_08724567834560832745
+// *****************************************************************************
+// * This file is part of the FreeFileSync project. It is distributed under    *
+// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
+// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
+// *****************************************************************************
+
+#ifndef WARN_STATIC_H_08724567834560832745
+#define WARN_STATIC_H_08724567834560832745
+
+/*
+Portable Compile-Time Warning
+-----------------------------
+Usage:
+    warn_static("my message")
+*/
+
+#define STATIC_WARNING_CONCAT_SUB(X, Y) X ## Y
+#define STATIC_WARNING_CONCAT(X, Y) STATIC_WARNING_CONCAT_SUB(X, Y)
+
+#define warn_static(TXT) \
+    typedef int STATIC_WARNING_87903124 __attribute__ ((deprecated)); \
+    enum { STATIC_WARNING_CONCAT(warn_static_dummy_value, __LINE__) = sizeof(STATIC_WARNING_87903124) };
+
+#endif //WARN_STATIC_H_08724567834560832745
diff --git a/zen/xml_io.cpp b/zen/xml_io.cpp
index d3d59200..0a1c8505 100755
--- a/zen/xml_io.cpp
+++ b/zen/xml_io.cpp
@@ -1,83 +1,83 @@
-// *****************************************************************************
-// * This file is part of the FreeFileSync project. It is distributed under    *
-// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
-// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
-// *****************************************************************************
-
-#include "xml_io.h"
-#include "file_access.h"
-#include "file_io.h"
-
-using namespace zen;
-
-
-XmlDoc zen::loadXmlDocument(const Zstring& filePath) //throw FileError
-{
-    FileInput fileIn(filePath, nullptr /*notifyUnbufferedIO*/); //throw FileError, ErrorFileLocked
-    const size_t blockSize = fileIn.getBlockSize();
-    const std::string xmlPrefix = "<?xml version=";
-    bool xmlPrefixChecked = false;
-
-    std::string buffer;
-    for (;;)
-    {
-        buffer.resize(buffer.size() + blockSize);
-        const size_t bytesRead = fileIn.read(&*(buffer.end() - blockSize), blockSize); //throw FileError, (X); return "bytesToRead" bytes unless end of stream!
-        buffer.resize(buffer.size() - blockSize + bytesRead); //caveat: unsigned arithmetics
-
-        //quick test whether input is an XML: avoid loading large binary files up front!
-        if (!xmlPrefixChecked && buffer.size() >= xmlPrefix.size() + strLength(BYTE_ORDER_MARK_UTF8))
-        {
-            xmlPrefixChecked = true;
-            if (!startsWith(buffer, xmlPrefix) &&
-                !startsWith(buffer, BYTE_ORDER_MARK_UTF8 + xmlPrefix)) //allow BOM!
-                throw FileError(replaceCpy(_("File %x does not contain a valid configuration."), L"%x", fmtPath(filePath)));
-        }
-
-        if (bytesRead < blockSize) //end of file
-            break;
-    }
-
-    try
-    {
-        return parse(buffer); //throw XmlParsingError
-    }
-    catch (const XmlParsingError& e)
-    {
-        throw FileError(
-            replaceCpy(replaceCpy(replaceCpy(_("Error parsing file %x, row %y, column %z."),
-                                             L"%x", fmtPath(filePath)),
-                                  L"%y", numberTo<std::wstring>(e.row + 1)),
-                       L"%z", numberTo<std::wstring>(e.col + 1)));
-    }
-}
-
-
-void zen::saveXmlDocument(const XmlDoc& doc, const Zstring& filePath) //throw FileError
-{
-    const std::string stream = serialize(doc); //noexcept
-
-    //only update xml file if there are real changes
-    try
-    {
-        if (getFileSize(filePath) == stream.size()) //throw FileError
-            if (loadBinContainer<std::string>(filePath, nullptr /*notifyUnbufferedIO*/) == stream) //throw FileError
-                return;
-    }
-    catch (FileError&) {}
-
-    saveBinContainer(filePath, stream, nullptr /*notifyUnbufferedIO*/); //throw FileError
-}
-
-
-void zen::checkForMappingErrors(const XmlIn& xmlInput, const Zstring& filePath) //throw FileError
-{
-    if (xmlInput.errorsOccured())
-    {
-        std::wstring msg = _("The following XML elements could not be read:") + L"\n";
-        for (const std::wstring& elem : xmlInput.getErrorsAs<std::wstring>())
-            msg += L"\n" + elem;
-
-        throw FileError(replaceCpy(_("Configuration file %x is incomplete. The missing elements will be set to their default values."), L"%x", fmtPath(filePath)) + L"\n\n" + msg);
-    }
-}
+// *****************************************************************************
+// * This file is part of the FreeFileSync project. It is distributed under    *
+// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
+// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
+// *****************************************************************************
+
+#include "xml_io.h"
+#include "file_access.h"
+#include "file_io.h"
+
+using namespace zen;
+
+
+XmlDoc zen::loadXmlDocument(const Zstring& filePath) //throw FileError
+{
+    FileInput fileIn(filePath, nullptr /*notifyUnbufferedIO*/); //throw FileError, ErrorFileLocked
+    const size_t blockSize = fileIn.getBlockSize();
+    const std::string xmlPrefix = "<?xml version=";
+    bool xmlPrefixChecked = false;
+
+    std::string buffer;
+    for (;;)
+    {
+        buffer.resize(buffer.size() + blockSize);
+        const size_t bytesRead = fileIn.read(&*(buffer.end() - blockSize), blockSize); //throw FileError, (X); return "bytesToRead" bytes unless end of stream!
+        buffer.resize(buffer.size() - blockSize + bytesRead); //caveat: unsigned arithmetics
+
+        //quick test whether input is an XML: avoid loading large binary files up front!
+        if (!xmlPrefixChecked && buffer.size() >= xmlPrefix.size() + strLength(BYTE_ORDER_MARK_UTF8))
+        {
+            xmlPrefixChecked = true;
+            if (!startsWith(buffer, xmlPrefix) &&
+                !startsWith(buffer, BYTE_ORDER_MARK_UTF8 + xmlPrefix)) //allow BOM!
+                throw FileError(replaceCpy(_("File %x does not contain a valid configuration."), L"%x", fmtPath(filePath)));
+        }
+
+        if (bytesRead < blockSize) //end of file
+            break;
+    }
+
+    try
+    {
+        return parse(buffer); //throw XmlParsingError
+    }
+    catch (const XmlParsingError& e)
+    {
+        throw FileError(
+            replaceCpy(replaceCpy(replaceCpy(_("Error parsing file %x, row %y, column %z."),
+                                             L"%x", fmtPath(filePath)),
+                                  L"%y", numberTo<std::wstring>(e.row + 1)),
+                       L"%z", numberTo<std::wstring>(e.col + 1)));
+    }
+}
+
+
+void zen::saveXmlDocument(const XmlDoc& doc, const Zstring& filePath) //throw FileError
+{
+    const std::string stream = serialize(doc); //noexcept
+
+    //only update xml file if there are real changes
+    try
+    {
+        if (getFileSize(filePath) == stream.size()) //throw FileError
+            if (loadBinContainer<std::string>(filePath, nullptr /*notifyUnbufferedIO*/) == stream) //throw FileError
+                return;
+    }
+    catch (FileError&) {}
+
+    saveBinContainer(filePath, stream, nullptr /*notifyUnbufferedIO*/); //throw FileError
+}
+
+
+void zen::checkForMappingErrors(const XmlIn& xmlInput, const Zstring& filePath) //throw FileError
+{
+    if (xmlInput.errorsOccured())
+    {
+        std::wstring msg = _("The following XML elements could not be read:") + L"\n";
+        for (const std::wstring& elem : xmlInput.getErrorsAs<std::wstring>())
+            msg += L"\n" + elem;
+
+        throw FileError(replaceCpy(_("Configuration file %x is incomplete. The missing elements will be set to their default values."), L"%x", fmtPath(filePath)) + L"\n\n" + msg);
+    }
+}
diff --git a/zen/xml_io.h b/zen/xml_io.h
index ae735ae6..6c2fc720 100755
--- a/zen/xml_io.h
+++ b/zen/xml_io.h
@@ -1,26 +1,26 @@
-// *****************************************************************************
-// * This file is part of the FreeFileSync project. It is distributed under    *
-// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
-// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
-// *****************************************************************************
-
-#ifndef XML_IO_H_8914759321263879
-#define XML_IO_H_8914759321263879
-
-#include <zenxml/xml.h>
-#include "file_error.h"
-
-//combine zen::Xml and zen file i/o
-//-> loadXmlDocument vs loadStream:
-//1. better error reporting
-//2. quick exit if (potentially large) input file is not an XML
-
-namespace zen
-{
-XmlDoc loadXmlDocument(const Zstring& filePath); //throw FileError
-void checkForMappingErrors(const XmlIn& xmlInput, const Zstring& filePath); //throw FileError
-
-void saveXmlDocument(const XmlDoc& doc, const Zstring& filePath); //throw FileError
-}
-
-#endif //XML_IO_H_8914759321263879
+// *****************************************************************************
+// * This file is part of the FreeFileSync project. It is distributed under    *
+// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
+// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
+// *****************************************************************************
+
+#ifndef XML_IO_H_8914759321263879
+#define XML_IO_H_8914759321263879
+
+#include <zenxml/xml.h>
+#include "file_error.h"
+
+//combine zen::Xml and zen file i/o
+//-> loadXmlDocument vs loadStream:
+//1. better error reporting
+//2. quick exit if (potentially large) input file is not an XML
+
+namespace zen
+{
+XmlDoc loadXmlDocument(const Zstring& filePath); //throw FileError
+void checkForMappingErrors(const XmlIn& xmlInput, const Zstring& filePath); //throw FileError
+
+void saveXmlDocument(const XmlDoc& doc, const Zstring& filePath); //throw FileError
+}
+
+#endif //XML_IO_H_8914759321263879
diff --git a/zen/zstring.cpp b/zen/zstring.cpp
index a936efb5..6b41af13 100755
--- a/zen/zstring.cpp
+++ b/zen/zstring.cpp
@@ -1,151 +1,151 @@
-// *****************************************************************************
-// * This file is part of the FreeFileSync project. It is distributed under    *
-// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
-// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
-// *****************************************************************************
-
-#include "zstring.h"
-#include <stdexcept>
-#include "utf.h"
-
-
-using namespace zen;
-
-/*
-MSDN "Handling Sorting in Your Applications": https://msdn.microsoft.com/en-us/library/windows/desktop/dd318144
-
-Perf test: compare strings 10 mio times; 64 bit build
------------------------------------------------------
-    string a = "Fjk84$%kgfj$%T\\\\Gffg\\gsdgf\\fgsx----------d-"
-    string b = "fjK84$%kgfj$%T\\\\gfFg\\gsdgf\\fgSy----------dfdf"
-
-Windows (UTF16 wchar_t)
-  4 ns | wcscmp
- 67 ns | CompareStringOrdinalFunc+ + bIgnoreCase
-314 ns | LCMapString + wmemcmp
-
-OS X (UTF8 char)
-   6 ns | strcmp
-  98 ns | strcasecmp
- 120 ns | strncasecmp + std::min(sizeLhs, sizeRhs);
- 856 ns | CFStringCreateWithCString       + CFStringCompare(kCFCompareCaseInsensitive)
-1110 ns | CFStringCreateWithCStringNoCopy + CFStringCompare(kCFCompareCaseInsensitive)
-________________________
-time per call | function
-*/
-
-
-
-
-namespace
-{
-int compareNoCaseUtf8(const char* lhs, size_t lhsLen, const char* rhs, size_t rhsLen)
-{
-    //- strncasecmp implements ASCII CI-comparsion only! => signature is broken for UTF8-input; toupper() similarly doesn't support Unicode
-    //- wcsncasecmp: https://opensource.apple.com/source/Libc/Libc-763.12/string/wcsncasecmp-fbsd.c
-    // => re-implement comparison based on towlower() to avoid memory allocations
-    using namespace zen::implementation;
-
-    UtfDecoder<char> decL(lhs, lhsLen);
-    UtfDecoder<char> decR(rhs, rhsLen);
-    for (;;)
-    {
-        const Opt<CodePoint> cpL = decL.getNext();
-        const Opt<CodePoint> cpR = decR.getNext();
-        if (!cpL || !cpR)
-            return static_cast<int>(!cpR) - static_cast<int>(!cpL);
-
-        static_assert(sizeof(wchar_t) == sizeof(CodePoint), "");
-        const wchar_t charL = ::towlower(static_cast<wchar_t>(*cpL)); //ordering: towlower() converts to higher code points than towupper()
-        const wchar_t charR = ::towlower(static_cast<wchar_t>(*cpR)); //uses LC_CTYPE category of current locale
-        if (charL != charR)
-            return static_cast<unsigned int>(charL) - static_cast<unsigned int>(charR); //unsigned char-comparison is the convention!
-        //unsigned underflow is well-defined!
-    }
-}
-}
-
-
-int cmpStringNaturalLinux(const char* lhs, size_t lhsLen, const char* rhs, size_t rhsLen)
-{
-    const char* const lhsEnd = lhs + lhsLen;
-    const char* const rhsEnd = rhs + rhsLen;
-    /*
-        - compare strings after conceptually creating blocks of whitespace/numbers/text
-        - implement strict weak ordering!
-        - don't follow broken "strnatcasecmp": https://github.com/php/php-src/blob/master/ext/standard/strnatcmp.c
-                1. incorrect non-ASCII CI-comparison 2. incorrect bounds checks
-                3. incorrect trimming of *all* whitespace 4. arbitrary handling of leading 0 only at string begin
-                5. incorrect handling of whitespace following a number 6. code is a mess
-    */
-    for (;;)
-    {
-        if (lhs == lhsEnd || rhs == rhsEnd)
-            return static_cast<int>(lhs != lhsEnd) - static_cast<int>(rhs != rhsEnd); //"nothing" before "something"
-        //note: "something" never would have been condensed to "nothing" further below => can finish evaluation here
-
-        const bool wsL = isWhiteSpace(*lhs);
-        const bool wsR = isWhiteSpace(*rhs);
-        if (wsL != wsR)
-            return static_cast<int>(!wsL) - static_cast<int>(!wsR); //whitespace before non-ws!
-        if (wsL)
-        {
-            ++lhs, ++rhs;
-            while (lhs != lhsEnd && isWhiteSpace(*lhs)) ++lhs;
-            while (rhs != rhsEnd && isWhiteSpace(*rhs)) ++rhs;
-            continue;
-        }
-
-        const bool digitL = isDigit(*lhs);
-        const bool digitR = isDigit(*rhs);
-        if (digitL != digitR)
-            return static_cast<int>(!digitL) - static_cast<int>(!digitR); //number before chars!
-        if (digitL)
-        {
-            while (lhs != lhsEnd && *lhs == '0') ++lhs;
-            while (rhs != rhsEnd && *rhs == '0') ++rhs;
-
-            int rv = 0;
-            for (;; ++lhs, ++rhs)
-            {
-                const bool endL = lhs == lhsEnd || !isDigit(*lhs);
-                const bool endR = rhs == rhsEnd || !isDigit(*rhs);
-                if (endL != endR)
-                    return static_cast<int>(!endL) - static_cast<int>(!endR); //more digits means bigger number
-                if (endL)
-                    break; //same number of digits
-
-                if (rv == 0 && *lhs != *rhs)
-                    rv = *lhs - *rhs; //found first digit difference comparing from left
-            }
-            if (rv != 0)
-                return rv;
-            continue;
-        }
-
-        //compare full junks of text: consider unicode encoding!
-        const char* textBeginL = lhs++;
-        const char* textBeginR = rhs++; //current char is neither white space nor digit at this point!
-        while (lhs != lhsEnd && !isWhiteSpace(*lhs) && !isDigit(*lhs)) ++lhs;
-        while (rhs != rhsEnd && !isWhiteSpace(*rhs) && !isDigit(*rhs)) ++rhs;
-
-        const int rv = compareNoCaseUtf8(textBeginL, lhs - textBeginL, textBeginR, rhs - textBeginR);
-        if (rv != 0)
-            return rv;
-    }
-}
-
-
-namespace
-{
-}
-
-
-int CmpNaturalSort::operator()(const Zchar* lhs, size_t lhsLen, const Zchar* rhs, size_t rhsLen) const
-{
-    //auto strL = utfTo<std::string>(Zstring(lhs, lhsLen));
-    //auto strR = utfTo<std::string>(Zstring(rhs, rhsLen));
-    //return cmpStringNaturalLinux(strL.c_str(), strL.size(), strR.c_str(), strR.size());
-    return cmpStringNaturalLinux(lhs, lhsLen, rhs, rhsLen);
-
+// *****************************************************************************
+// * This file is part of the FreeFileSync project. It is distributed under    *
+// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
+// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
+// *****************************************************************************
+
+#include "zstring.h"
+#include <stdexcept>
+#include "utf.h"
+
+
+using namespace zen;
+
+/*
+MSDN "Handling Sorting in Your Applications": https://msdn.microsoft.com/en-us/library/windows/desktop/dd318144
+
+Perf test: compare strings 10 mio times; 64 bit build
+-----------------------------------------------------
+    string a = "Fjk84$%kgfj$%T\\\\Gffg\\gsdgf\\fgsx----------d-"
+    string b = "fjK84$%kgfj$%T\\\\gfFg\\gsdgf\\fgSy----------dfdf"
+
+Windows (UTF16 wchar_t)
+  4 ns | wcscmp
+ 67 ns | CompareStringOrdinalFunc+ + bIgnoreCase
+314 ns | LCMapString + wmemcmp
+
+OS X (UTF8 char)
+   6 ns | strcmp
+  98 ns | strcasecmp
+ 120 ns | strncasecmp + std::min(sizeLhs, sizeRhs);
+ 856 ns | CFStringCreateWithCString       + CFStringCompare(kCFCompareCaseInsensitive)
+1110 ns | CFStringCreateWithCStringNoCopy + CFStringCompare(kCFCompareCaseInsensitive)
+________________________
+time per call | function
+*/
+
+
+
+
+namespace
+{
+int compareNoCaseUtf8(const char* lhs, size_t lhsLen, const char* rhs, size_t rhsLen)
+{
+    //- strncasecmp implements ASCII CI-comparsion only! => signature is broken for UTF8-input; toupper() similarly doesn't support Unicode
+    //- wcsncasecmp: https://opensource.apple.com/source/Libc/Libc-763.12/string/wcsncasecmp-fbsd.c
+    // => re-implement comparison based on towlower() to avoid memory allocations
+    using namespace zen::implementation;
+
+    UtfDecoder<char> decL(lhs, lhsLen);
+    UtfDecoder<char> decR(rhs, rhsLen);
+    for (;;)
+    {
+        const Opt<CodePoint> cpL = decL.getNext();
+        const Opt<CodePoint> cpR = decR.getNext();
+        if (!cpL || !cpR)
+            return static_cast<int>(!cpR) - static_cast<int>(!cpL);
+
+        static_assert(sizeof(wchar_t) == sizeof(CodePoint), "");
+        const wchar_t charL = ::towlower(static_cast<wchar_t>(*cpL)); //ordering: towlower() converts to higher code points than towupper()
+        const wchar_t charR = ::towlower(static_cast<wchar_t>(*cpR)); //uses LC_CTYPE category of current locale
+        if (charL != charR)
+            return static_cast<unsigned int>(charL) - static_cast<unsigned int>(charR); //unsigned char-comparison is the convention!
+        //unsigned underflow is well-defined!
+    }
+}
+}
+
+
+int cmpStringNaturalLinux(const char* lhs, size_t lhsLen, const char* rhs, size_t rhsLen)
+{
+    const char* const lhsEnd = lhs + lhsLen;
+    const char* const rhsEnd = rhs + rhsLen;
+    /*
+        - compare strings after conceptually creating blocks of whitespace/numbers/text
+        - implement strict weak ordering!
+        - don't follow broken "strnatcasecmp": https://github.com/php/php-src/blob/master/ext/standard/strnatcmp.c
+                1. incorrect non-ASCII CI-comparison 2. incorrect bounds checks
+                3. incorrect trimming of *all* whitespace 4. arbitrary handling of leading 0 only at string begin
+                5. incorrect handling of whitespace following a number 6. code is a mess
+    */
+    for (;;)
+    {
+        if (lhs == lhsEnd || rhs == rhsEnd)
+            return static_cast<int>(lhs != lhsEnd) - static_cast<int>(rhs != rhsEnd); //"nothing" before "something"
+        //note: "something" never would have been condensed to "nothing" further below => can finish evaluation here
+
+        const bool wsL = isWhiteSpace(*lhs);
+        const bool wsR = isWhiteSpace(*rhs);
+        if (wsL != wsR)
+            return static_cast<int>(!wsL) - static_cast<int>(!wsR); //whitespace before non-ws!
+        if (wsL)
+        {
+            ++lhs, ++rhs;
+            while (lhs != lhsEnd && isWhiteSpace(*lhs)) ++lhs;
+            while (rhs != rhsEnd && isWhiteSpace(*rhs)) ++rhs;
+            continue;
+        }
+
+        const bool digitL = isDigit(*lhs);
+        const bool digitR = isDigit(*rhs);
+        if (digitL != digitR)
+            return static_cast<int>(!digitL) - static_cast<int>(!digitR); //number before chars!
+        if (digitL)
+        {
+            while (lhs != lhsEnd && *lhs == '0') ++lhs;
+            while (rhs != rhsEnd && *rhs == '0') ++rhs;
+
+            int rv = 0;
+            for (;; ++lhs, ++rhs)
+            {
+                const bool endL = lhs == lhsEnd || !isDigit(*lhs);
+                const bool endR = rhs == rhsEnd || !isDigit(*rhs);
+                if (endL != endR)
+                    return static_cast<int>(!endL) - static_cast<int>(!endR); //more digits means bigger number
+                if (endL)
+                    break; //same number of digits
+
+                if (rv == 0 && *lhs != *rhs)
+                    rv = *lhs - *rhs; //found first digit difference comparing from left
+            }
+            if (rv != 0)
+                return rv;
+            continue;
+        }
+
+        //compare full junks of text: consider unicode encoding!
+        const char* textBeginL = lhs++;
+        const char* textBeginR = rhs++; //current char is neither white space nor digit at this point!
+        while (lhs != lhsEnd && !isWhiteSpace(*lhs) && !isDigit(*lhs)) ++lhs;
+        while (rhs != rhsEnd && !isWhiteSpace(*rhs) && !isDigit(*rhs)) ++rhs;
+
+        const int rv = compareNoCaseUtf8(textBeginL, lhs - textBeginL, textBeginR, rhs - textBeginR);
+        if (rv != 0)
+            return rv;
+    }
+}
+
+
+namespace
+{
+}
+
+
+int CmpNaturalSort::operator()(const Zchar* lhs, size_t lhsLen, const Zchar* rhs, size_t rhsLen) const
+{
+    //auto strL = utfTo<std::string>(Zstring(lhs, lhsLen));
+    //auto strR = utfTo<std::string>(Zstring(rhs, rhsLen));
+    //return cmpStringNaturalLinux(strL.c_str(), strL.size(), strR.c_str(), strR.size());
+    return cmpStringNaturalLinux(lhs, lhsLen, rhs, rhsLen);
+
 }
 \ No newline at end of file
diff --git a/zen/zstring.h b/zen/zstring.h
index fdb71da0..273efd2f 100755
--- a/zen/zstring.h
+++ b/zen/zstring.h
@@ -1,159 +1,159 @@
-// *****************************************************************************
-// * This file is part of the FreeFileSync project. It is distributed under    *
-// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
-// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
-// *****************************************************************************
-
-#ifndef ZSTRING_H_73425873425789
-#define ZSTRING_H_73425873425789
-
-#include "string_base.h"
-
-
-    using Zchar = char;
-    #define Zstr(x) x
-    const Zchar FILE_NAME_SEPARATOR = '/';
-
-//"The reason for all the fuss above" - Loki/SmartPtr
-//a high-performance string for interfacing with native OS APIs in multithreaded contexts
-using Zstring = zen::Zbase<Zchar>;
-
-
-//Compare filepaths: Windows/OS X does NOT distinguish between upper/lower-case, while Linux DOES
-struct CmpFilePath
-{
-    int operator()(const Zchar* lhs, size_t lhsLen, const Zchar* rhs, size_t rhsLen) const;
-};
-
-struct CmpNaturalSort
-{
-    int operator()(const Zchar* lhs, size_t lhsLen, const Zchar* rhs, size_t rhsLen) const;
-};
-
-
-struct LessFilePath
-{
-    template <class S> //don't support heterogenous input! => use as container predicate only!
-    bool operator()(const S& lhs, const S& rhs) const { using namespace zen; return CmpFilePath()(strBegin(lhs), strLength(lhs), strBegin(rhs), strLength(rhs)) < 0; }
-};
-
-struct LessNaturalSort
-{
-    template <class S> //don't support heterogenous input! => use as container predicate only!
-    bool operator()(const S& lhs, const S& rhs) const { using namespace zen; return CmpNaturalSort()(strBegin(lhs), strLength(lhs), strBegin(rhs), strLength(rhs)) < 0; }
-};
-
-
-template <class S>
-S makeUpperCopy(S str);
-
-
-template <class S, class T> inline
-bool equalFilePath(const S& lhs, const T& rhs) { using namespace zen; return strEqual(lhs, rhs, CmpFilePath());  }
-
-
-inline
-Zstring appendSeparator(Zstring path) //support rvalue references!
-{
-    return zen::endsWith(path, FILE_NAME_SEPARATOR) ? path : (path += FILE_NAME_SEPARATOR); //returning a by-value parameter implicitly converts to r-value!
-}
-
-
-inline
-Zstring getFileExtension(const Zstring& filePath)
-{
-    const Zstring shortName = afterLast(filePath, FILE_NAME_SEPARATOR, zen::IF_MISSING_RETURN_ALL);
-    return afterLast(shortName, Zchar('.'), zen::IF_MISSING_RETURN_NONE);
-}
-
-
-template <class S, class T, class U>
-S ciReplaceCpy(const S& str, const T& oldTerm, const U& newTerm);
-
-
-
-
-//################################# inline implementation ########################################
-inline
-void makeUpperInPlace(wchar_t* str, size_t strLen)
-{
-    std::for_each(str, str + strLen, [](wchar_t& c) { c = std::towupper(c); }); //locale-dependent!
-}
-
-
-inline
-void makeUpperInPlace(char* str, size_t strLen)
-{
-    std::for_each(str, str + strLen, [](char& c) { c = std::toupper(static_cast<unsigned char>(c)); }); //locale-dependent!
-    //result of toupper() is an unsigned char mapped to int range: the char representation is in the last 8 bits and we need not care about signedness!
-    //this should work for UTF-8, too: all chars >= 128 are mapped upon themselves!
-}
-
-
-template <class S> inline
-S makeUpperCopy(S str)
-{
-    const size_t len = str.length(); //we assert S is a string type!
-    if (len > 0)
-        makeUpperInPlace(&*str.begin(), len);
-
-    return std::move(str); //"str" is an l-value parameter => no copy elision!
-}
-
-
-inline
-int CmpFilePath::operator()(const Zchar* lhs, size_t lhsLen, const Zchar* rhs, size_t rhsLen) const
-{
-    assert(std::find(lhs, lhs + lhsLen, 0) == lhs + lhsLen); //don't expect embedded nulls!
-    assert(std::find(rhs, rhs + rhsLen, 0) == rhs + rhsLen); //
-
-    const int rv = std::strncmp(lhs, rhs, std::min(lhsLen, rhsLen));
-    if (rv != 0)
-        return rv;
-    return static_cast<int>(lhsLen) - static_cast<int>(rhsLen);
-}
-
-
-template <class S, class T, class U> inline
-S ciReplaceCpy(const S& str, const T& oldTerm, const U& newTerm)
-{
-    using namespace zen;
-    static_assert(IsSameType<typename GetCharType<S>::Type, typename GetCharType<T>::Type>::value, "");
-    static_assert(IsSameType<typename GetCharType<T>::Type, typename GetCharType<U>::Type>::value, "");
-    const size_t oldLen = strLength(oldTerm);
-    if (oldLen == 0)
-        return str;
-
-    const S strU = makeUpperCopy(str); //S required to be a string class
-    const S oldU = makeUpperCopy<S>(oldTerm); //[!] T not required to be a string class
-    assert(strLength(strU) == strLength(str    ));
-    assert(strLength(oldU) == strLength(oldTerm));
-
-    const auto* const newBegin = strBegin(newTerm);
-    const auto* const newEnd   = newBegin + strLength(newTerm);
-
-    S output;
-
-    for (size_t pos = 0;;)
-    {
-        const auto itFound = std::search(strU.begin() + pos, strU.end(),
-                                         oldU.begin(), oldU.end());
-        if (itFound == strU.end() && pos == 0)
-            return str; //optimize "oldTerm not found": return ref-counted copy
-
-        impl::stringAppend(output, str.begin() + pos, str.begin() + (itFound - strU.begin()));
-        if (itFound == strU.end())
-            return output;
-
-        impl::stringAppend(output, newBegin, newEnd);
-        pos = (itFound - strU.begin()) + oldLen;
-    }
-}
-
-    int cmpStringNaturalLinux(const char* lhs, size_t lhsLen, const char* rhs, size_t rhsLen);
-
-//---------------------------------------------------------------------------
-//ZEN macro consistency checks:
-
-
-#endif //ZSTRING_H_73425873425789
+// *****************************************************************************
+// * This file is part of the FreeFileSync project. It is distributed under    *
+// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0           *
+// * Copyright (C) Zenju (zenju AT freefilesync DOT org) - All Rights Reserved *
+// *****************************************************************************
+
+#ifndef ZSTRING_H_73425873425789
+#define ZSTRING_H_73425873425789
+
+#include "string_base.h"
+
+
+    using Zchar = char;
+    #define Zstr(x) x
+    const Zchar FILE_NAME_SEPARATOR = '/';
+
+//"The reason for all the fuss above" - Loki/SmartPtr
+//a high-performance string for interfacing with native OS APIs in multithreaded contexts
+using Zstring = zen::Zbase<Zchar>;
+
+
+//Compare filepaths: Windows/OS X does NOT distinguish between upper/lower-case, while Linux DOES
+struct CmpFilePath
+{
+    int operator()(const Zchar* lhs, size_t lhsLen, const Zchar* rhs, size_t rhsLen) const;
+};
+
+struct CmpNaturalSort
+{
+    int operator()(const Zchar* lhs, size_t lhsLen, const Zchar* rhs, size_t rhsLen) const;
+};
+
+
+struct LessFilePath
+{
+    template <class S> //don't support heterogenous input! => use as container predicate only!
+    bool operator()(const S& lhs, const S& rhs) const { using namespace zen; return CmpFilePath()(strBegin(lhs), strLength(lhs), strBegin(rhs), strLength(rhs)) < 0; }
+};
+
+struct LessNaturalSort
+{
+    template <class S> //don't support heterogenous input! => use as container predicate only!
+    bool operator()(const S& lhs, const S& rhs) const { using namespace zen; return CmpNaturalSort()(strBegin(lhs), strLength(lhs), strBegin(rhs), strLength(rhs)) < 0; }
+};
+
+
+template <class S>
+S makeUpperCopy(S str);
+
+
+template <class S, class T> inline
+bool equalFilePath(const S& lhs, const T& rhs) { using namespace zen; return strEqual(lhs, rhs, CmpFilePath());  }
+
+
+inline
+Zstring appendSeparator(Zstring path) //support rvalue references!
+{
+    return zen::endsWith(path, FILE_NAME_SEPARATOR) ? path : (path += FILE_NAME_SEPARATOR); //returning a by-value parameter implicitly converts to r-value!
+}
+
+
+inline
+Zstring getFileExtension(const Zstring& filePath)
+{
+    const Zstring shortName = afterLast(filePath, FILE_NAME_SEPARATOR, zen::IF_MISSING_RETURN_ALL);
+    return afterLast(shortName, Zchar('.'), zen::IF_MISSING_RETURN_NONE);
+}
+
+
+template <class S, class T, class U>
+S ciReplaceCpy(const S& str, const T& oldTerm, const U& newTerm);
+
+
+
+
+//################################# inline implementation ########################################
+inline
+void makeUpperInPlace(wchar_t* str, size_t strLen)
+{
+    std::for_each(str, str + strLen, [](wchar_t& c) { c = std::towupper(c); }); //locale-dependent!
+}
+
+
+inline
+void makeUpperInPlace(char* str, size_t strLen)
+{
+    std::for_each(str, str + strLen, [](char& c) { c = std::toupper(static_cast<unsigned char>(c)); }); //locale-dependent!
+    //result of toupper() is an unsigned char mapped to int range: the char representation is in the last 8 bits and we need not care about signedness!
+    //this should work for UTF-8, too: all chars >= 128 are mapped upon themselves!
+}
+
+
+template <class S> inline
+S makeUpperCopy(S str)
+{
+    const size_t len = str.length(); //we assert S is a string type!
+    if (len > 0)
+        makeUpperInPlace(&*str.begin(), len);
+
+    return std::move(str); //"str" is an l-value parameter => no copy elision!
+}
+
+
+inline
+int CmpFilePath::operator()(const Zchar* lhs, size_t lhsLen, const Zchar* rhs, size_t rhsLen) const
+{
+    assert(std::find(lhs, lhs + lhsLen, 0) == lhs + lhsLen); //don't expect embedded nulls!
+    assert(std::find(rhs, rhs + rhsLen, 0) == rhs + rhsLen); //
+
+    const int rv = std::strncmp(lhs, rhs, std::min(lhsLen, rhsLen));
+    if (rv != 0)
+        return rv;
+    return static_cast<int>(lhsLen) - static_cast<int>(rhsLen);
+}
+
+
+template <class S, class T, class U> inline
+S ciReplaceCpy(const S& str, const T& oldTerm, const U& newTerm)
+{
+    using namespace zen;
+    static_assert(IsSameType<typename GetCharType<S>::Type, typename GetCharType<T>::Type>::value, "");
+    static_assert(IsSameType<typename GetCharType<T>::Type, typename GetCharType<U>::Type>::value, "");
+    const size_t oldLen = strLength(oldTerm);
+    if (oldLen == 0)
+        return str;
+
+    const S strU = makeUpperCopy(str); //S required to be a string class
+    const S oldU = makeUpperCopy<S>(oldTerm); //[!] T not required to be a string class
+    assert(strLength(strU) == strLength(str    ));
+    assert(strLength(oldU) == strLength(oldTerm));
+
+    const auto* const newBegin = strBegin(newTerm);
+    const auto* const newEnd   = newBegin + strLength(newTerm);
+
+    S output;
+
+    for (size_t pos = 0;;)
+    {
+        const auto itFound = std::search(strU.begin() + pos, strU.end(),
+                                         oldU.begin(), oldU.end());
+        if (itFound == strU.end() && pos == 0)
+            return str; //optimize "oldTerm not found": return ref-counted copy
+
+        impl::stringAppend(output, str.begin() + pos, str.begin() + (itFound - strU.begin()));
+        if (itFound == strU.end())
+            return output;
+
+        impl::stringAppend(output, newBegin, newEnd);
+        pos = (itFound - strU.begin()) + oldLen;
+    }
+}
+
+    int cmpStringNaturalLinux(const char* lhs, size_t lhsLen, const char* rhs, size_t rhsLen);
+
+//---------------------------------------------------------------------------
+//ZEN macro consistency checks:
+
+
+#endif //ZSTRING_H_73425873425789