Update for Qt 5.12.9qt-5.12.9

Signed-off-by: Michael Schuster <michael@schuster.ms>

3 files changed, 13 insertions, 589 deletions

diff --git a/README.md b/README.md
index cb86635ba..9bd1d4154 100644
--- a/README.md
+++ b/README.md
@@ -2,6 +2,13 @@
 
 This allows you to easily build the desktop client for 64-bit and 32-bit Windows.
 
+## Update: 2020-07-22
+
+Upgrade / new default version:
+- Qt 5.12.9
+
+The previous patch of the Qt 5.12.8 include file is not required anymore :)
+
 ## Update: 2020-07-16
 
 Added new option to build the Updater (disabled by default):
@@ -39,7 +46,9 @@ Upgrades / new default versions:
 - Visual Studio 2019 (and 2017) support
 - can build Desktop client series 2.6 and 2.7 (QML)
 
-Note: You need to patch an include file of Qt 5.12.8 for use with MSVC, see section: Install list
+Note: You need to patch an include file of Qt 5.12.8 for use with MSVC, see: https://github.com/nextcloud/client-building/blob/e7b04ac00f0cfd7f9b3b4a3651ce0adc5ca07c29/README.md#install-list
+
+Patched file: https://raw.githubusercontent.com/nextcloud/client-building/e7b04ac00f0cfd7f9b3b4a3651ce0adc5ca07c29/Windows/Qt-5.12.8-QtCore-Patch/qlinkedlist.h
 
 Also note that the Qt Maintenance tool now requires you to register an Qt Account (free).
 
@@ -110,21 +119,13 @@ Optional:
 - [ ] Git bash (it comes with Git):
       https://git-scm.com/download/win
 
-- [ ] Qt 5.12.8 (select in the wizard: MSVC 2017 64-bit AND 32-bit and all the "Qt ..." options, not required: Debug Info Files):
+- [ ] Qt 5.12.9 (select in the wizard: MSVC 2017 64-bit AND 32-bit and all the "Qt ..." options, not required: Debug Info Files):
       http://download.qt.io/official_releases/online_installers/qt-unified-windows-x86-online.exe
 
       Install to: C:\Qt
 
   Note: MSVC 2017 is binary compatible with VS 2019, so don't be confused ;-)
 
-  You need to patch an include file of Qt 5.12.8 for use with MSVC: https://github.com/nextcloud/client-building/raw/master/Windows/Qt-5.12.8-QtCore-Patch/qlinkedlist.h
-
-      After installing Qt 5.12.8 put qlinkedlist.h in the following two folders:
-      - C:\Qt\5.12.8\msvc2017\include\QtCore
-      - C:\Qt\5.12.8\msvc2017_64\include\QtCore
-
-  It was modified to solve this bug: https://bugreports.qt.io/browse/QTBUG-81727
-
 - [ ] CMake 3.14.x (choose the ZIP version, extract and rename to: C:\Nextcloud\tools\cmake):
       https://cmake.org/download/
 
@@ -141,7 +142,7 @@ Optional:
       - 64-bit: C:\OpenSSL\Win64
       - 32-bit: C:\OpenSSL\Win32
 
-    Note: Qt 5.12.8 also includes the option to install OpenSSL 1.1.1 libraries from the Maintenance tool wizard.
+    Note: Qt 5.12.9 also includes the option to install OpenSSL 1.1.1 libraries from the Maintenance tool wizard.
           You may also use these libraries instead of the ones above but then you have to modify the paths in defaults.inc.bat
           and be sure to check for updates on a regular basis!
 
diff --git a/Windows/Qt-5.12.8-QtCore-Patch/qlinkedlist.h b/Windows/Qt-5.12.8-QtCore-Patch/qlinkedlist.h
deleted file mode 100644
index b75767a3a..000000000
--- a/Windows/Qt-5.12.8-QtCore-Patch/qlinkedlist.h
+++ /dev/null
@@ -1,577 +0,0 @@
-/****************************************************************************

-**

-** Copyright (C) 2016 The Qt Company Ltd.

-** Contact: https://www.qt.io/licensing/

-**

-** This file is part of the QtCore module of the Qt Toolkit.

-**

-** $QT_BEGIN_LICENSE:LGPL$

-** Commercial License Usage

-** Licensees holding valid commercial Qt licenses may use this file in

-** accordance with the commercial license agreement provided with the

-** Software or, alternatively, in accordance with the terms contained in

-** a written agreement between you and The Qt Company. For licensing terms

-** and conditions see https://www.qt.io/terms-conditions. For further

-** information use the contact form at https://www.qt.io/contact-us.

-**

-** GNU Lesser General Public License Usage

-** Alternatively, this file may be used under the terms of the GNU Lesser

-** General Public License version 3 as published by the Free Software

-** Foundation and appearing in the file LICENSE.LGPL3 included in the

-** packaging of this file. Please review the following information to

-** ensure the GNU Lesser General Public License version 3 requirements

-** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.

-**

-** GNU General Public License Usage

-** Alternatively, this file may be used under the terms of the GNU

-** General Public License version 2.0 or (at your option) the GNU General

-** Public license version 3 or any later version approved by the KDE Free

-** Qt Foundation. The licenses are as published by the Free Software

-** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3

-** included in the packaging of this file. Please review the following

-** information to ensure the GNU General Public License requirements will

-** be met: https://www.gnu.org/licenses/gpl-2.0.html and

-** https://www.gnu.org/licenses/gpl-3.0.html.

-**

-** $QT_END_LICENSE$

-**

-****************************************************************************/

-

-#ifndef QLINKEDLIST_H

-#define QLINKEDLIST_H

-

-#include <QtCore/qiterator.h>

-#include <QtCore/qrefcount.h>

-

-#include <iterator>

-#include <list>

-

-#include <algorithm>

-

-#if defined(Q_COMPILER_INITIALIZER_LISTS)

-# include <initializer_list>

-#endif

-

-QT_BEGIN_NAMESPACE

-

-

-/*

- MODIFIED to solve this bug: https://bugreports.qt.io/browse/QTBUG-81727

-

- https://codereview.qt-project.org/c/qt/qtbase/+/301313/2/src/corelib/tools/qlinkedlist.h#65

-

- Qt 5.12.8 with VS2019 - https://github.com/nextcloud/client-building/

-*/

-struct QLinkedListData

-{

-    QLinkedListData *n, *p;

-    QtPrivate::RefCount ref;

-    int size;

-    uint sharable : 1;

-

-    Q_CORE_EXPORT static const QLinkedListData shared_null;

-};

-

-template <typename T>

-struct QLinkedListNode

-{

-    inline QLinkedListNode(const T &arg): t(arg) { }

-    QLinkedListNode *n, *p;

-    T t;

-};

-

-template <class T>

-class QLinkedList

-{

-    typedef QLinkedListNode<T> Node;

-    union { QLinkedListData *d; QLinkedListNode<T> *e; };

-

-public:

-    inline QLinkedList() Q_DECL_NOTHROW : d(const_cast<QLinkedListData *>(&QLinkedListData::shared_null)) { }

-    inline QLinkedList(const QLinkedList<T> &l) : d(l.d) { d->ref.ref(); if (!d->sharable) detach(); }

-#if defined(Q_COMPILER_INITIALIZER_LISTS)

-    inline QLinkedList(std::initializer_list<T> list)

-        : d(const_cast<QLinkedListData *>(&QLinkedListData::shared_null))

-    {

-        std::copy(list.begin(), list.end(), std::back_inserter(*this));

-    }

-#endif

-    ~QLinkedList();

-    QLinkedList<T> &operator=(const QLinkedList<T> &);

-#ifdef Q_COMPILER_RVALUE_REFS

-    QLinkedList(QLinkedList<T> &&other) Q_DECL_NOTHROW

-        : d(other.d) { other.d = const_cast<QLinkedListData *>(&QLinkedListData::shared_null); }

-    QLinkedList<T> &operator=(QLinkedList<T> &&other) Q_DECL_NOTHROW

-    { QLinkedList moved(std::move(other)); swap(moved); return *this; }

-#endif

-    inline void swap(QLinkedList<T> &other) Q_DECL_NOTHROW { qSwap(d, other.d); }

-    bool operator==(const QLinkedList<T> &l) const;

-    inline bool operator!=(const QLinkedList<T> &l) const { return !(*this == l); }

-

-    inline int size() const { return d->size; }

-    inline void detach()

-    { if (d->ref.isShared()) detach_helper2(this->e); }

-    inline bool isDetached() const { return !d->ref.isShared(); }

-#if !defined(QT_NO_UNSHARABLE_CONTAINERS)

-    inline void setSharable(bool sharable) { if (!sharable) detach(); if (d != &QLinkedListData::shared_null) d->sharable = sharable; }

-#endif

-    inline bool isSharedWith(const QLinkedList<T> &other) const { return d == other.d; }

-

-    inline bool isEmpty() const { return d->size == 0; }

-

-    void clear();

-

-    void append(const T &);

-    void prepend(const T &);

-    T takeFirst();

-    T takeLast();

-    int removeAll(const T &t);

-    bool removeOne(const T &t);

-    bool contains(const T &t) const;

-    int count(const T &t) const;

-

-    class const_iterator;

-

-    class iterator

-    {

-    public:

-        typedef std::bidirectional_iterator_tag  iterator_category;

-        typedef qptrdiff difference_type;

-        typedef T value_type;

-        typedef T *pointer;

-        typedef T &reference;

-        Node *i;

-        inline iterator() : i(nullptr) {}

-        inline iterator(Node *n) : i(n) {}

-#if QT_VERSION < QT_VERSION_CHECK(6,0,0)

-        iterator(const iterator &other) Q_DECL_NOTHROW : i(other.i) {}

-        iterator &operator=(const iterator &other) Q_DECL_NOTHROW { i = other.i; return *this; }

-        iterator(iterator &&other) Q_DECL_NOTHROW : i(other.i) {}

-        iterator &operator=(iterator &&other) Q_DECL_NOTHROW { return *this = other; }

-#endif

-        inline T &operator*() const { return i->t; }

-        inline T *operator->() const { return &i->t; }

-        inline bool operator==(const iterator &o) const { return i == o.i; }

-        inline bool operator!=(const iterator &o) const { return i != o.i; }

-        inline bool operator==(const const_iterator &o) const

-            { return i == o.i; }

-        inline bool operator!=(const const_iterator &o) const

-            { return i != o.i; }

-        inline iterator &operator++() { i = i->n; return *this; }

-        inline iterator operator++(int) { Node *n = i; i = i->n; return n; }

-        inline iterator &operator--() { i = i->p; return *this; }

-        inline iterator operator--(int) { Node *n = i; i = i->p; return n; }

-        inline iterator operator+(int j) const

-        { Node *n = i; if (j > 0) while (j--) n = n->n; else while (j++) n = n->p; return n; }

-        inline iterator operator-(int j) const { return operator+(-j); }

-        inline iterator &operator+=(int j) { return *this = *this + j; }

-        inline iterator &operator-=(int j) { return *this = *this - j; }

-        friend inline iterator operator+(int j, iterator k) { return k + j; }

-    };

-    friend class iterator;

-

-    class const_iterator

-    {

-    public:

-        typedef std::bidirectional_iterator_tag  iterator_category;

-        typedef qptrdiff difference_type;

-        typedef T value_type;

-        typedef const T *pointer;

-        typedef const T &reference;

-        Node *i;

-        inline const_iterator() : i(nullptr) {}

-        inline const_iterator(Node *n) : i(n) {}

-        inline const_iterator(iterator ci) : i(ci.i){}

-#if QT_VERSION < QT_VERSION_CHECK(6,0,0)

-        const_iterator(const const_iterator &other) Q_DECL_NOTHROW : i(other.i) {}

-        const_iterator &operator=(const const_iterator &other) Q_DECL_NOTHROW { i = other.i; return *this; }

-        const_iterator(const_iterator &&other) Q_DECL_NOTHROW : i(other.i) {}

-        const_iterator &operator=(const_iterator &&other) Q_DECL_NOTHROW { return *this = other; }

-#endif

-        inline const T &operator*() const { return i->t; }

-        inline const T *operator->() const { return &i->t; }

-        inline bool operator==(const const_iterator &o) const { return i == o.i; }

-        inline bool operator!=(const const_iterator &o) const { return i != o.i; }

-        inline const_iterator &operator++() { i = i->n; return *this; }

-        inline const_iterator operator++(int) { Node *n = i; i = i->n; return n; }

-        inline const_iterator &operator--() { i = i->p; return *this; }

-        inline const_iterator operator--(int) { Node *n = i; i = i->p; return n; }

-        inline const_iterator operator+(int j) const

-        { Node *n = i; if (j > 0) while (j--) n = n->n; else while (j++) n = n->p; return n; }

-        inline const_iterator operator-(int j) const { return operator+(-j); }

-        inline const_iterator &operator+=(int j) { return *this = *this + j; }

-        inline const_iterator &operator-=(int j) { return *this = *this - j; }

-        friend inline const_iterator operator+(int j, const_iterator k) { return k + j; }

-    };

-    friend class const_iterator;

-

-    // stl style

-    typedef std::reverse_iterator<iterator> reverse_iterator;

-    typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

-

-    inline iterator begin() { detach(); return e->n; }

-    inline const_iterator begin() const Q_DECL_NOTHROW { return e->n; }

-    inline const_iterator cbegin() const Q_DECL_NOTHROW { return e->n; }

-    inline const_iterator constBegin() const Q_DECL_NOTHROW { return e->n; }

-    inline iterator end() { detach(); return e; }

-    inline const_iterator end() const Q_DECL_NOTHROW { return e; }

-    inline const_iterator cend() const Q_DECL_NOTHROW { return e; }

-    inline const_iterator constEnd() const Q_DECL_NOTHROW { return e; }

-

-    reverse_iterator rbegin() { return reverse_iterator(end()); }

-    reverse_iterator rend() { return reverse_iterator(begin()); }

-    const_reverse_iterator rbegin() const Q_DECL_NOTHROW { return const_reverse_iterator(end()); }

-    const_reverse_iterator rend() const Q_DECL_NOTHROW { return const_reverse_iterator(begin()); }

-    const_reverse_iterator crbegin() const Q_DECL_NOTHROW { return const_reverse_iterator(end()); }

-    const_reverse_iterator crend() const Q_DECL_NOTHROW { return const_reverse_iterator(begin()); }

-

-    iterator insert(iterator before, const T &t);

-    iterator erase(iterator pos);

-    iterator erase(iterator first, iterator last);

-

-    // more Qt

-    typedef iterator Iterator;

-    typedef const_iterator ConstIterator;

-    inline int count() const { return d->size; }

-    inline T& first() { Q_ASSERT(!isEmpty()); return *begin(); }

-    inline const T& first() const { Q_ASSERT(!isEmpty()); return *begin(); }

-    T& last() { Q_ASSERT(!isEmpty()); return *(--end()); }

-    const T& last() const { Q_ASSERT(!isEmpty()); return *(--end()); }

-    inline void removeFirst() { Q_ASSERT(!isEmpty()); erase(begin()); }

-    inline void removeLast() { Q_ASSERT(!isEmpty()); erase(--end()); }

-    inline bool startsWith(const T &t) const { return !isEmpty() && first() == t; }

-    inline bool endsWith(const T &t) const { return !isEmpty() && last() == t; }

-

-    // stl compatibility

-    inline void push_back(const T &t) { append(t); }

-    inline void push_front(const T &t) { prepend(t); }

-    inline T& front() { return first(); }

-    inline const T& front() const { return first(); }

-    inline T& back() { return last(); }

-    inline const T& back() const { return last(); }

-    inline void pop_front() { removeFirst(); }

-    inline void pop_back() { removeLast(); }

-    inline bool empty() const { return isEmpty(); }

-    typedef int size_type;

-    typedef T value_type;

-    typedef value_type *pointer;

-    typedef const value_type *const_pointer;

-    typedef value_type &reference;

-    typedef const value_type &const_reference;

-    typedef qptrdiff difference_type;

-

-    static inline QLinkedList<T> fromStdList(const std::list<T> &list)

-    { QLinkedList<T> tmp; std::copy(list.begin(), list.end(), std::back_inserter(tmp)); return tmp; }

-    inline std::list<T> toStdList() const

-    { std::list<T> tmp; std::copy(constBegin(), constEnd(), std::back_inserter(tmp)); return tmp; }

-

-    // comfort

-    QLinkedList<T> &operator+=(const QLinkedList<T> &l);

-    QLinkedList<T> operator+(const QLinkedList<T> &l) const;

-    inline QLinkedList<T> &operator+=(const T &t) { append(t); return *this; }

-    inline QLinkedList<T> &operator<< (const T &t) { append(t); return *this; }

-    inline QLinkedList<T> &operator<<(const QLinkedList<T> &l) { *this += l; return *this; }

-

-private:

-    void detach_helper();

-    iterator detach_helper2(iterator);

-    void freeData(QLinkedListData*);

-};

-

-template <typename T>

-inline QLinkedList<T>::~QLinkedList()

-{

-    if (!d->ref.deref())

-        freeData(d);

-}

-

-template <typename T>

-void QLinkedList<T>::detach_helper()

-{

-    detach_helper2(this->e);

-}

-

-template <typename T>

-typename QLinkedList<T>::iterator QLinkedList<T>::detach_helper2(iterator orgite)

-{

-    // detach and convert orgite to an iterator in the detached instance

-    bool isEndIterator = (orgite.i == this->e);

-    union { QLinkedListData *d; Node *e; } x;

-    x.d = new QLinkedListData;

-    x.d->ref.initializeOwned();

-    x.d->size = d->size;

-    x.d->sharable = true;

-    Node *original = e->n;

-    Node *copy = x.e;

-    Node *org = orgite.i;

-

-    while (original != org) {

-        QT_TRY {

-            copy->n = new Node(original->t);

-            copy->n->p = copy;

-            original = original->n;

-            copy = copy->n;

-        } QT_CATCH(...) {

-            copy->n = x.e;

-            Q_ASSERT(!x.d->ref.deref()); // Don't trigger assert in free

-            freeData(x.d);

-            QT_RETHROW;

-        }

-    }

-    iterator r(copy);

-    while (original != e) {

-        QT_TRY {

-            copy->n = new Node(original->t);

-            copy->n->p = copy;

-            original = original->n;

-            copy = copy->n;

-        } QT_CATCH(...) {

-            copy->n = x.e;

-            Q_ASSERT(!x.d->ref.deref()); // Don't trigger assert in free

-            freeData(x.d);

-            QT_RETHROW;

-        }

-    }

-    copy->n = x.e;

-    x.e->p = copy;

-    if (!d->ref.deref())

-        freeData(d);

-    d = x.d;

-    if (!isEndIterator)

-        ++r; // since we stored the element right before the original node.

-    return r;

-}

-

-template <typename T>

-void QLinkedList<T>::freeData(QLinkedListData *x)

-{

-    Node *y = reinterpret_cast<Node*>(x);

-    Node *i = y->n;

-    Q_ASSERT(x->ref.atomic.load() == 0);

-    while (i != y) {

-        Node *n = i;

-        i = i->n;

-        delete n;

-    }

-    delete x;

-}

-

-template <typename T>

-void QLinkedList<T>::clear()

-{

-    *this = QLinkedList<T>();

-}

-

-template <typename T>

-QLinkedList<T> &QLinkedList<T>::operator=(const QLinkedList<T> &l)

-{

-    if (d != l.d) {

-        QLinkedListData *o = l.d;

-        o->ref.ref();

-        if (!d->ref.deref())

-            freeData(d);

-        d = o;

-        if (!d->sharable)

-            detach_helper();

-    }

-    return *this;

-}

-

-template <typename T>

-bool QLinkedList<T>::operator== (const QLinkedList<T> &l) const

-{

-    if (d->size != l.d->size)

-        return false;

-    if (e == l.e)

-        return true;

-    Node *i = e->n;

-    Node *il = l.e->n;

-    while (i != e) {

-        if (! (i->t == il->t))

-            return false;

-        i = i->n;

-        il = il->n;

-    }

-    return true;

-}

-

-template <typename T>

-void QLinkedList<T>::append(const T &t)

-{

-    detach();

-    Node *i = new Node(t);

-    i->n = e;

-    i->p = e->p;

-    i->p->n = i;

-    e->p = i;

-    d->size++;

-}

-

-template <typename T>

-void QLinkedList<T>::prepend(const T &t)

-{

-    detach();

-    Node *i = new Node(t);

-    i->n = e->n;

-    i->p = e;

-    i->n->p = i;

-    e->n = i;

-    d->size++;

-}

-

-template <typename T>

-int QLinkedList<T>::removeAll(const T &_t)

-{

-    detach();

-    const T t = _t;

-    Node *i = e->n;

-    int c = 0;

-    while (i != e) {

-        if (i->t == t) {

-            Node *n = i;

-            i->n->p = i->p;

-            i->p->n = i->n;

-            i = i->n;

-            delete n;

-            c++;

-        } else {

-            i = i->n;

-        }

-    }

-    d->size-=c;

-    return c;

-}

-

-template <typename T>

-bool QLinkedList<T>::removeOne(const T &_t)

-{

-    detach();

-    iterator it = std::find(begin(), end(), _t);

-    if (it != end()) {

-        erase(it);

-        return true;

-    }

-    return false;

-}

-

-template <typename T>

-inline T QLinkedList<T>::takeFirst()

-{

-    T t = std::move(first());

-    removeFirst();

-    return t;

-}

-

-template <typename T>

-inline T QLinkedList<T>::takeLast()

-{

-    T t = std::move(last());

-    removeLast();

-    return t;

-}

-

-template <typename T>

-bool QLinkedList<T>::contains(const T &t) const

-{

-    Node *i = e;

-    while ((i = i->n) != e)

-        if (i->t == t)

-            return true;

-    return false;

-}

-

-template <typename T>

-int QLinkedList<T>::count(const T &t) const

-{

-    Node *i = e;

-    int c = 0;

-    while ((i = i->n) != e)

-        if (i->t == t)

-            c++;

-    return c;

-}

-

-

-template <typename T>

-typename QLinkedList<T>::iterator QLinkedList<T>::insert(iterator before, const T &t)

-{

-    if (d->ref.isShared())

-        before = detach_helper2(before);

-

-    Node *i = before.i;

-    Node *m = new Node(t);

-    m->n = i;

-    m->p = i->p;

-    m->p->n = m;

-    i->p = m;

-    d->size++;

-    return m;

-}

-

-template <typename T>

-typename QLinkedList<T>::iterator QLinkedList<T>::erase(typename QLinkedList<T>::iterator afirst,

-                                                         typename QLinkedList<T>::iterator alast)

-{

-    while (afirst != alast)

-        erase(afirst++);

-    return alast;

-}

-

-

-template <typename T>

-typename QLinkedList<T>::iterator QLinkedList<T>::erase(iterator pos)

-{

-    if (d->ref.isShared())

-        pos = detach_helper2(pos);

-

-    Node *i = pos.i;

-    if (i != e) {

-        Node *n = i;

-        i->n->p = i->p;

-        i->p->n = i->n;

-        i = i->n;

-        delete n;

-        d->size--;

-    }

-    return i;

-}

-

-template <typename T>

-QLinkedList<T> &QLinkedList<T>::operator+=(const QLinkedList<T> &l)

-{

-    detach();

-    int n = l.d->size;

-    d->size += n;

-    Node *original = l.e->n;

-    while (n--) {

-        QT_TRY {

-            Node *copy = new Node(original->t);

-            original = original->n;

-            copy->n = e;

-            copy->p = e->p;

-            copy->p->n = copy;

-            e->p = copy;

-        } QT_CATCH(...) {

-            // restore the original list

-            while (n++<d->size)

-                removeLast();

-            QT_RETHROW;

-        }

-    }

-    return *this;

-}

-

-template <typename T>

-QLinkedList<T> QLinkedList<T>::operator+(const QLinkedList<T> &l) const

-{

-    QLinkedList<T> n = *this;

-    n += l;

-    return n;

-}

-

-Q_DECLARE_SEQUENTIAL_ITERATOR(LinkedList)

-Q_DECLARE_MUTABLE_SEQUENTIAL_ITERATOR(LinkedList)

-

-QT_END_NAMESPACE

-

-#endif // QLINKEDLIST_H

diff --git a/defaults.inc.bat b/defaults.inc.bat
index c2af73b99..efe1f2f93 100644
--- a/defaults.inc.bat
+++ b/defaults.inc.bat
@@ -32,7 +32,7 @@ rem Comma separated list of build targets (default: Win64, Win32)
 if "%BUILD_TARGETS%" == ""                  set BUILD_TARGETS=Win64,Win32
 
 if "%PROJECT_PATH%" == ""                   set PROJECT_PATH=c:/Nextcloud/client-building
-if "%QT_PATH%" == ""                        set QT_PATH=c:/Qt/5.12.8
+if "%QT_PATH%" == ""                        set QT_PATH=c:/Qt/5.12.9
 
                                             set PATH=c:/Nextcloud/tools/cmake/bin;c:/Nextcloud/tools;C:/Program Files (x86)/NSIS;%PATH%