From 4b0d30fbc4769422617966fa7e27c025867a6828 Mon Sep 17 00:00:00 2001
From: GriffinR <griffin.g.richards@gmail.com>
Date: Wed, 28 Aug 2024 14:42:39 -0400
Subject: [PATCH 1/6] Initial enum support

---
 include/core/parseutil.h |   9 +--
 src/core/parseutil.cpp   | 139 ++++++++++++++++++++++++---------------
 2 files changed, 90 insertions(+), 58 deletions(-)

diff --git a/include/core/parseutil.h b/include/core/parseutil.h
index 9e00087e8..271d1247b 100644
--- a/include/core/parseutil.h
+++ b/include/core/parseutil.h
@@ -54,9 +54,9 @@ class ParseUtil
     QString readCIncbin(const QString &text, const QString &label);
     QMap<QString, QString> readCIncbinMulti(const QString &filepath);
     QStringList readCIncbinArray(const QString &filename, const QString &label);
-    QMap<QString, int> readCDefinesByPrefix(const QString &filename, QStringList prefixes);
+    QMap<QString, int> readCDefinesByPrefix(const QString &filename, QStringList searchText);
     QMap<QString, int> readCDefinesByName(const QString &filename, QStringList names);
-    QStringList readCDefineNames(const QString&, const QStringList&);
+    QStringList readCDefineNames(const QString&, QStringList searchText);
     QMap<QString, QHash<QString, QString>> readCStructs(const QString &, const QString & = "", const QHash<int, QString> = { });
     QList<QStringList> getLabelMacros(const QList<QStringList>&, const QString&);
     QStringList getLabelValues(const QList<QStringList>&, const QString&);
@@ -97,8 +97,9 @@ class ParseUtil
     void recordErrors(const QStringList &errors);
     void logRecordedErrors();
     QString createErrorMessage(const QString &message, const QString &expression);
-    QString readCDefinesFile(const QString &filename);
-    QMap<QString, int> readCDefines(const QString &filename, const QStringList &searchText, bool fullMatch);
+    QMap<QString, QString> readCDefineExpressions(const QString &filename);
+    QMap<QString,QString> filterCDefineExpressions(const QMap<QString,QString> &allExpressions, QStringList searchText, bool fullMatch);
+    QMap<QString, int> evaluateCDefines(const QString &filename, const QStringList &searchText, bool fullMatch);
 
     static const QRegularExpression re_incScriptLabel;
     static const QRegularExpression re_globalIncScriptLabel;
diff --git a/src/core/parseutil.cpp b/src/core/parseutil.cpp
index c5d096355..f1d702195 100644
--- a/src/core/parseutil.cpp
+++ b/src/core/parseutil.cpp
@@ -15,6 +15,22 @@ const QRegularExpression ParseUtil::re_poryScriptLabel("\\b(script)(\\((global|l
 const QRegularExpression ParseUtil::re_globalPoryScriptLabel("\\b(script)(\\((global)\\))?\\s*\\b(?<label>[\\w_][\\w\\d_]*)");
 const QRegularExpression ParseUtil::re_poryRawSection("\\b(raw)\\s*`(?<raw_script>[^`]*)");
 
+static const QMap<QString, int> defaultDefineValues = {
+    {"FALSE", 0},
+    {"TRUE", 1},
+    {"SCHAR_MIN", SCHAR_MIN},
+    {"SCHAR_MAX", SCHAR_MAX},
+    {"CHAR_MIN", CHAR_MIN},
+    {"CHAR_MAX", CHAR_MAX},
+    {"UCHAR_MAX", UCHAR_MAX},
+    {"SHRT_MIN", SHRT_MIN},
+    {"SHRT_MAX", SHRT_MAX},
+    {"USHRT_MAX", USHRT_MAX},
+    {"INT_MIN", INT_MIN},
+    {"INT_MAX", INT_MAX},
+    {"UINT_MAX", UINT_MAX},
+};
+
 using OrderedJson = poryjson::Json;
 
 ParseUtil::ParseUtil() { }
@@ -353,12 +369,14 @@ QStringList ParseUtil::readCIncbinArray(const QString &filename, const QString &
     return paths;
 }
 
-QString ParseUtil::readCDefinesFile(const QString &filename)
+// Open the file and return all the names and expressions defined by #define or enum
+QMap<QString,QString> ParseUtil::readCDefineExpressions(const QString &filename)
 {
+    QMap<QString, QString> expressions;
     this->file = filename;
 
     if (this->file.isEmpty()) {
-        return QString();
+        return expressions;
     }
 
     QString filepath = this->root + "/" + this->file;
@@ -366,50 +384,82 @@ QString ParseUtil::readCDefinesFile(const QString &filename)
 
     if (this->text.isNull()) {
         logError(QString("Failed to read C defines file: '%1'").arg(filepath));
-        return QString();
+        return expressions;
     }
 
     static const QRegularExpression re_extraChars("(//.*)|(\\/+\\*+[^*]*\\*+\\/+)");
     this->text.replace(re_extraChars, "");
     static const QRegularExpression re_extraSpaces("(\\\\\\s+)");
     this->text.replace(re_extraSpaces, "");
-    return this->text;
-}
 
-// Read all the define names and their expressions in the specified file, then evaluate the ones matching the search text (and any they depend on).
-// If 'fullMatch' is true, 'searchText' is a list of exact define names to evaluate and return.
-// If 'fullMatch' is false, 'searchText' is a list of prefixes or regexes for define names to evaluate and return.
-QMap<QString, int> ParseUtil::readCDefines(const QString &filename, const QStringList &searchText, bool fullMatch)
-{
-    QMap<QString, int> filteredValues;
+    if (this->text.isEmpty())
+        return expressions;
 
-    this->text = this->readCDefinesFile(filename);
-    if (this->text.isEmpty()) {
-        return filteredValues;
-    }
+    // Capture either the name and value of a #define, or everything between the braces of 'enum { }'
+    static const QRegularExpression re("#define\\s+(?<defineName>\\w+)[\\s\\n][^\\S\\n]*(?<defineValue>.+)?"
+                                       "|\\benum\\b[^{]*{(?<enumBody>[^}]*)}");
 
-    // Extract all the define names and expressions
-    QMap<QString, QString> allExpressions;
-    QMap<QString, QString> filteredExpressions;
-    static const QRegularExpression re("#define\\s+(?<defineName>\\w+)[^\\S\\n]+(?<defineValue>.+)");
     QRegularExpressionMatchIterator iter = re.globalMatch(this->text);
     while (iter.hasNext()) {
         QRegularExpressionMatch match = iter.next();
-        const QString name = match.captured("defineName");
-        const QString expression = match.captured("defineValue");
-        // If name matches the search text record it for evaluation.
+        const QString enumBody = match.captured("enumBody");
+        if (!enumBody.isNull()) {
+            // Encountered an enum, extract the elements of the enum and give each an appropriate expression
+            int baseNum = 0;
+            QString baseExpression = "0";
+            static const QRegularExpression re_enumElement("\\b(?<name>\\w+)\\b\\s*=?\\s*(?<expression>.+)?[,\\$]"); // TODO: Ignores terminal element lacking comma
+            QRegularExpressionMatchIterator elementIter = re_enumElement.globalMatch(enumBody);
+            while (elementIter.hasNext()) {
+                QRegularExpressionMatch elementMatch = elementIter.next();
+                QString expression = elementMatch.captured("expression");
+                if (expression.isEmpty()) {
+                    // enum values may use tokens that we don't know how to evaluate yet.
+                    // For now we define each element to be 1 + the previous element's expression.
+                    expression = QString("((%1)+%2)").arg(baseExpression).arg(baseNum++);
+                } else {
+                    // This element was explicitly assigned an expression with '=', reset the bases for any subsequent elements.
+                    baseExpression = expression;
+                    baseNum = 1;
+                }
+                expressions.insert(elementMatch.captured("name"), expression);
+            }
+        } else {
+            // Encountered a #define
+            expressions.insert(match.captured("defineName"), match.captured("defineValue"));
+        }
+    }
+
+    return expressions;
+}
+
+// Given a map of define names->expressions, returns a map of define names->expressions where all the names match searchText.
+// If 'fullMatch' is true, 'searchText' is a list of exact define names to match.
+// If 'fullMatch' is false, 'searchText' is a list of prefixes or regexes of define names to match.
+QMap<QString,QString> ParseUtil::filterCDefineExpressions(const QMap<QString,QString> &allExpressions, QStringList searchText, bool fullMatch) {
+    QMap<QString,QString> filteredExpressions;
+    searchText.removeDuplicates();
+    for (auto i = allExpressions.cbegin(), end = allExpressions.cend(); i != end; i++) {
+        const QString name = i.key();
         for (auto s : searchText) {
             if ((fullMatch && name == s) || (!fullMatch && (name.startsWith(s) || QRegularExpression(s).match(name).hasMatch()))) {
-                filteredExpressions.insert(name, expression);
+                filteredExpressions.insert(name, i.value());
                 break;
             }
         }
-        allExpressions.insert(name, expression);
     }
+    return filteredExpressions;
+}
+
+// Read all the define names and their expressions in the specified file, then evaluate the ones matching the search text (and any they depend on).
+QMap<QString, int> ParseUtil::evaluateCDefines(const QString &filename, const QStringList &searchText, bool fullMatch) {
+    QMap<QString, int> filteredValues;
+    QMap<QString, int> allValues = defaultDefineValues;
+
+    QMap<QString, QString> allExpressions = this->readCDefineExpressions(filename);
+    if (allExpressions.isEmpty())
+        return filteredValues;
 
-    QMap<QString, int> allValues;
-    allValues.insert("FALSE", 0);
-    allValues.insert("TRUE", 1);
+    QMap<QString, QString> filteredExpressions = this->filterCDefineExpressions(allExpressions, searchText, fullMatch);
 
     // Evaluate defines
     this->errorMap.clear();
@@ -425,39 +475,20 @@ QMap<QString, int> ParseUtil::readCDefines(const QString &filename, const QStrin
 }
 
 // Find and evaluate an unknown list of defines with a known name prefix.
-QMap<QString, int> ParseUtil::readCDefinesByPrefix(const QString &filename, QStringList prefixes) {
-    prefixes.removeDuplicates();
-    return this->readCDefines(filename, prefixes, false);
+QMap<QString, int> ParseUtil::readCDefinesByPrefix(const QString &filename, QStringList searchText) {
+    return this->evaluateCDefines(filename, searchText, false);
 }
 
 // Find and evaluate a specific set of defines with known names.
 QMap<QString, int> ParseUtil::readCDefinesByName(const QString &filename, QStringList names) {
-    names.removeDuplicates();
-    return this->readCDefines(filename, names, true);
+    return this->evaluateCDefines(filename, names, true);
 }
 
-// Similar to readCDefines, but for cases where we only need to show a list of define names.
-// We can skip reading/evaluating any expressions (and by extension skip reporting any errors from this process).
-QStringList ParseUtil::readCDefineNames(const QString &filename, const QStringList &prefixes) {
-    QStringList filteredNames;
-
-    this->text = this->readCDefinesFile(filename);
-    if (this->text.isEmpty()) {
-        return filteredNames;
-    }
-
-    static const QRegularExpression re("#define\\s+(?<defineName>\\w+)[^\\S\\n]+");
-    QRegularExpressionMatchIterator iter = re.globalMatch(this->text);
-    while (iter.hasNext()) {
-        QRegularExpressionMatch match = iter.next();
-        QString name = match.captured("defineName");
-        for (QString prefix : prefixes) {
-            if (name.startsWith(prefix) || QRegularExpression(prefix).match(name).hasMatch()) {
-                filteredNames.append(name);
-            }
-        }
-    }
-    return filteredNames;
+// Similar to readCDefinesByPrefix, but for cases where we only need to show a list of define names.
+// We can skip evaluating any expressions (and by extension skip reporting any errors from this process).
+QStringList ParseUtil::readCDefineNames(const QString &filename, QStringList searchText) {
+    // TODO: These will now be alphabetical. Is that ok?
+    return this->filterCDefineExpressions(this->readCDefineExpressions(filename), searchText, false).keys();
 }
 
 QStringList ParseUtil::readCArray(const QString &filename, const QString &label) {

From 869d0c7dec151eaf5b2c6f5afa204c844bd3ddc2 Mon Sep 17 00:00:00 2001
From: GriffinR <griffin.g.richards@gmail.com>
Date: Wed, 28 Aug 2024 15:38:41 -0400
Subject: [PATCH 2/6] Restore display order for unevaluated defines

---
 include/core/parseutil.h | 17 +++++---
 src/core/parseutil.cpp   | 90 ++++++++++++++++++----------------------
 2 files changed, 51 insertions(+), 56 deletions(-)

diff --git a/include/core/parseutil.h b/include/core/parseutil.h
index 271d1247b..001668216 100644
--- a/include/core/parseutil.h
+++ b/include/core/parseutil.h
@@ -54,9 +54,9 @@ class ParseUtil
     QString readCIncbin(const QString &text, const QString &label);
     QMap<QString, QString> readCIncbinMulti(const QString &filepath);
     QStringList readCIncbinArray(const QString &filename, const QString &label);
-    QMap<QString, int> readCDefinesByPrefix(const QString &filename, QStringList searchText);
-    QMap<QString, int> readCDefinesByName(const QString &filename, QStringList names);
-    QStringList readCDefineNames(const QString&, QStringList searchText);
+    QMap<QString, int> readCDefinesByPrefix(const QString &filename, const QStringList &searchText);
+    QMap<QString, int> readCDefinesByName(const QString &filename, const QStringList &names);
+    QStringList readCDefineNames(const QString&, const QStringList &searchText);
     QMap<QString, QHash<QString, QString>> readCStructs(const QString &, const QString & = "", const QHash<int, QString> = { });
     QList<QStringList> getLabelMacros(const QList<QStringList>&, const QString&);
     QStringList getLabelValues(const QList<QStringList>&, const QString&);
@@ -97,9 +97,14 @@ class ParseUtil
     void recordErrors(const QStringList &errors);
     void logRecordedErrors();
     QString createErrorMessage(const QString &message, const QString &expression);
-    QMap<QString, QString> readCDefineExpressions(const QString &filename);
-    QMap<QString,QString> filterCDefineExpressions(const QMap<QString,QString> &allExpressions, QStringList searchText, bool fullMatch);
-    QMap<QString, int> evaluateCDefines(const QString &filename, const QStringList &searchText, bool fullMatch);
+
+    struct ParsedDefines {
+        QMap<QString,QString> expressions; // Map of all define names->expressions encountered
+        QStringList filteredNames; // Define names matching the search text in the order they were encountered in the file
+    };
+    ParsedDefines readCDefines(const QString &filename, const QStringList &filterList, bool fullMatch);
+    QMap<QString, int> evaluateCDefines(const QString &filename, const QStringList &filterList, bool fullMatch);
+    bool defineNameMatchesFilter(const QString &name, const QStringList &filterList, bool fullMatch);
 
     static const QRegularExpression re_incScriptLabel;
     static const QRegularExpression re_globalIncScriptLabel;
diff --git a/src/core/parseutil.cpp b/src/core/parseutil.cpp
index f1d702195..4043ea17f 100644
--- a/src/core/parseutil.cpp
+++ b/src/core/parseutil.cpp
@@ -15,7 +15,7 @@ const QRegularExpression ParseUtil::re_poryScriptLabel("\\b(script)(\\((global|l
 const QRegularExpression ParseUtil::re_globalPoryScriptLabel("\\b(script)(\\((global)\\))?\\s*\\b(?<label>[\\w_][\\w\\d_]*)");
 const QRegularExpression ParseUtil::re_poryRawSection("\\b(raw)\\s*`(?<raw_script>[^`]*)");
 
-static const QMap<QString, int> defaultDefineValues = {
+static const QMap<QString, int> globalDefineValues = {
     {"FALSE", 0},
     {"TRUE", 1},
     {"SCHAR_MIN", SCHAR_MIN},
@@ -369,14 +369,23 @@ QStringList ParseUtil::readCIncbinArray(const QString &filename, const QString &
     return paths;
 }
 
-// Open the file and return all the names and expressions defined by #define or enum
-QMap<QString,QString> ParseUtil::readCDefineExpressions(const QString &filename)
-{
-    QMap<QString, QString> expressions;
+bool ParseUtil::defineNameMatchesFilter(const QString &name, const QStringList &filterList, bool fullMatch) {
+    for (auto filter : filterList) {
+        if (fullMatch) {
+            if (name == filter) return true;
+        } else {
+            if (name.startsWith(filter) || QRegularExpression(filter).match(name).hasMatch()) return true;
+        }
+    }
+    return false;
+}
+
+ParseUtil::ParsedDefines ParseUtil::readCDefines(const QString &filename, const QStringList &filterList, bool fullMatch) {
+    ParsedDefines result;
     this->file = filename;
 
     if (this->file.isEmpty()) {
-        return expressions;
+        return result;
     }
 
     QString filepath = this->root + "/" + this->file;
@@ -384,7 +393,7 @@ QMap<QString,QString> ParseUtil::readCDefineExpressions(const QString &filename)
 
     if (this->text.isNull()) {
         logError(QString("Failed to read C defines file: '%1'").arg(filepath));
-        return expressions;
+        return result;
     }
 
     static const QRegularExpression re_extraChars("(//.*)|(\\/+\\*+[^*]*\\*+\\/+)");
@@ -393,7 +402,7 @@ QMap<QString,QString> ParseUtil::readCDefineExpressions(const QString &filename)
     this->text.replace(re_extraSpaces, "");
 
     if (this->text.isEmpty())
-        return expressions;
+        return result;
 
     // Capture either the name and value of a #define, or everything between the braces of 'enum { }'
     static const QRegularExpression re("#define\\s+(?<defineName>\\w+)[\\s\\n][^\\S\\n]*(?<defineValue>.+)?"
@@ -411,6 +420,7 @@ QMap<QString,QString> ParseUtil::readCDefineExpressions(const QString &filename)
             QRegularExpressionMatchIterator elementIter = re_enumElement.globalMatch(enumBody);
             while (elementIter.hasNext()) {
                 QRegularExpressionMatch elementMatch = elementIter.next();
+                const QString name = elementMatch.captured("name");
                 QString expression = elementMatch.captured("expression");
                 if (expression.isEmpty()) {
                     // enum values may use tokens that we don't know how to evaluate yet.
@@ -421,74 +431,54 @@ QMap<QString,QString> ParseUtil::readCDefineExpressions(const QString &filename)
                     baseExpression = expression;
                     baseNum = 1;
                 }
-                expressions.insert(elementMatch.captured("name"), expression);
+                result.expressions.insert(name, expression);
+                if (defineNameMatchesFilter(name, filterList, fullMatch))
+                    result.filteredNames.append(name);
             }
         } else {
             // Encountered a #define
-            expressions.insert(match.captured("defineName"), match.captured("defineValue"));
-        }
-    }
-
-    return expressions;
-}
-
-// Given a map of define names->expressions, returns a map of define names->expressions where all the names match searchText.
-// If 'fullMatch' is true, 'searchText' is a list of exact define names to match.
-// If 'fullMatch' is false, 'searchText' is a list of prefixes or regexes of define names to match.
-QMap<QString,QString> ParseUtil::filterCDefineExpressions(const QMap<QString,QString> &allExpressions, QStringList searchText, bool fullMatch) {
-    QMap<QString,QString> filteredExpressions;
-    searchText.removeDuplicates();
-    for (auto i = allExpressions.cbegin(), end = allExpressions.cend(); i != end; i++) {
-        const QString name = i.key();
-        for (auto s : searchText) {
-            if ((fullMatch && name == s) || (!fullMatch && (name.startsWith(s) || QRegularExpression(s).match(name).hasMatch()))) {
-                filteredExpressions.insert(name, i.value());
-                break;
-            }
+            const QString name = match.captured("defineName");
+            result.expressions.insert(name, match.captured("defineValue"));
+            if (defineNameMatchesFilter(name, filterList, fullMatch))
+                result.filteredNames.append(name);
         }
     }
-    return filteredExpressions;
+    return result;
 }
 
 // Read all the define names and their expressions in the specified file, then evaluate the ones matching the search text (and any they depend on).
-QMap<QString, int> ParseUtil::evaluateCDefines(const QString &filename, const QStringList &searchText, bool fullMatch) {
-    QMap<QString, int> filteredValues;
-    QMap<QString, int> allValues = defaultDefineValues;
-
-    QMap<QString, QString> allExpressions = this->readCDefineExpressions(filename);
-    if (allExpressions.isEmpty())
-        return filteredValues;
-
-    QMap<QString, QString> filteredExpressions = this->filterCDefineExpressions(allExpressions, searchText, fullMatch);
+QMap<QString, int> ParseUtil::evaluateCDefines(const QString &filename, const QStringList &filterList, bool fullMatch) {
+    ParsedDefines defines = readCDefines(filename, filterList, fullMatch);
 
     // Evaluate defines
+    QMap<QString, int> filteredValues;
+    QMap<QString, int> allValues = globalDefineValues;
     this->errorMap.clear();
-    while (!filteredExpressions.isEmpty()) {
-        const QString name = filteredExpressions.firstKey();
-        const QString expression = filteredExpressions.take(name);
+    while (!defines.filteredNames.isEmpty()) {
+        const QString name = defines.filteredNames.takeFirst();
+        const QString expression = defines.expressions.take(name);
         if (expression == " ") continue;
         this->curDefine = name;
-        filteredValues.insert(name, evaluateDefine(name, expression, &allValues, &allExpressions));
+        filteredValues.insert(name, evaluateDefine(name, expression, &allValues, &defines.expressions));
         logRecordedErrors(); // Only log errors for defines that Porymap is looking for
     }
     return filteredValues;
 }
 
 // Find and evaluate an unknown list of defines with a known name prefix.
-QMap<QString, int> ParseUtil::readCDefinesByPrefix(const QString &filename, QStringList searchText) {
-    return this->evaluateCDefines(filename, searchText, false);
+QMap<QString, int> ParseUtil::readCDefinesByPrefix(const QString &filename, const QStringList &filterList) {
+    return evaluateCDefines(filename, filterList, false);
 }
 
 // Find and evaluate a specific set of defines with known names.
-QMap<QString, int> ParseUtil::readCDefinesByName(const QString &filename, QStringList names) {
-    return this->evaluateCDefines(filename, names, true);
+QMap<QString, int> ParseUtil::readCDefinesByName(const QString &filename, const QStringList &names) {
+    return evaluateCDefines(filename, names, true);
 }
 
 // Similar to readCDefinesByPrefix, but for cases where we only need to show a list of define names.
 // We can skip evaluating any expressions (and by extension skip reporting any errors from this process).
-QStringList ParseUtil::readCDefineNames(const QString &filename, QStringList searchText) {
-    // TODO: These will now be alphabetical. Is that ok?
-    return this->filterCDefineExpressions(this->readCDefineExpressions(filename), searchText, false).keys();
+QStringList ParseUtil::readCDefineNames(const QString &filename, const QStringList &filterList) {
+    return readCDefines(filename, filterList, false).filteredNames;
 }
 
 QStringList ParseUtil::readCArray(const QString &filename, const QString &label) {

From b1ad6d83f474a918f66921f8969d57f4e4029943 Mon Sep 17 00:00:00 2001
From: GriffinR <griffin.g.richards@gmail.com>
Date: Wed, 28 Aug 2024 16:06:28 -0400
Subject: [PATCH 3/6] Replace 'prefix' names where we were actually using regex

---
 include/core/parseutil.h | 10 +++---
 src/core/parseutil.cpp   | 41 ++++++++++++-----------
 src/project.cpp          | 72 ++++++++++++++++++++--------------------
 3 files changed, 62 insertions(+), 61 deletions(-)

diff --git a/include/core/parseutil.h b/include/core/parseutil.h
index 001668216..a69ed2f46 100644
--- a/include/core/parseutil.h
+++ b/include/core/parseutil.h
@@ -54,9 +54,9 @@ class ParseUtil
     QString readCIncbin(const QString &text, const QString &label);
     QMap<QString, QString> readCIncbinMulti(const QString &filepath);
     QStringList readCIncbinArray(const QString &filename, const QString &label);
-    QMap<QString, int> readCDefinesByPrefix(const QString &filename, const QStringList &searchText);
+    QMap<QString, int> readCDefinesByRegex(const QString &filename, const QStringList &regexList);
     QMap<QString, int> readCDefinesByName(const QString &filename, const QStringList &names);
-    QStringList readCDefineNames(const QString&, const QStringList &searchText);
+    QStringList readCDefineNames(const QString &filename, const QStringList &regexList);
     QMap<QString, QHash<QString, QString>> readCStructs(const QString &, const QString & = "", const QHash<int, QString> = { });
     QList<QStringList> getLabelMacros(const QList<QStringList>&, const QString&);
     QStringList getLabelValues(const QList<QStringList>&, const QString&);
@@ -102,9 +102,9 @@ class ParseUtil
         QMap<QString,QString> expressions; // Map of all define names->expressions encountered
         QStringList filteredNames; // Define names matching the search text in the order they were encountered in the file
     };
-    ParsedDefines readCDefines(const QString &filename, const QStringList &filterList, bool fullMatch);
-    QMap<QString, int> evaluateCDefines(const QString &filename, const QStringList &filterList, bool fullMatch);
-    bool defineNameMatchesFilter(const QString &name, const QStringList &filterList, bool fullMatch);
+    ParsedDefines readCDefines(const QString &filename, const QStringList &filterList, bool useRegex);
+    QMap<QString, int> evaluateCDefines(const QString &filename, const QStringList &filterList, bool useRegex);
+    bool defineNameMatchesFilter(const QString &name, const QStringList &filterList, bool useRegex);
 
     static const QRegularExpression re_incScriptLabel;
     static const QRegularExpression re_globalIncScriptLabel;
diff --git a/src/core/parseutil.cpp b/src/core/parseutil.cpp
index 4043ea17f..c9b022756 100644
--- a/src/core/parseutil.cpp
+++ b/src/core/parseutil.cpp
@@ -369,18 +369,18 @@ QStringList ParseUtil::readCIncbinArray(const QString &filename, const QString &
     return paths;
 }
 
-bool ParseUtil::defineNameMatchesFilter(const QString &name, const QStringList &filterList, bool fullMatch) {
+bool ParseUtil::defineNameMatchesFilter(const QString &name, const QStringList &filterList, bool useRegex) {
     for (auto filter : filterList) {
-        if (fullMatch) {
-            if (name == filter) return true;
-        } else {
-            if (name.startsWith(filter) || QRegularExpression(filter).match(name).hasMatch()) return true;
-        }
+        if (useRegex) {
+            // TODO: These QRegularExpression should probably be constructed beforehand,
+            // otherwise we recreate them for every define we check.
+            if (QRegularExpression(filter).match(name).hasMatch()) return true;
+        } else if (name == filter) return true;
     }
     return false;
 }
 
-ParseUtil::ParsedDefines ParseUtil::readCDefines(const QString &filename, const QStringList &filterList, bool fullMatch) {
+ParseUtil::ParsedDefines ParseUtil::readCDefines(const QString &filename, const QStringList &filterList, bool useRegex) {
     ParsedDefines result;
     this->file = filename;
 
@@ -432,14 +432,14 @@ ParseUtil::ParsedDefines ParseUtil::readCDefines(const QString &filename, const
                     baseNum = 1;
                 }
                 result.expressions.insert(name, expression);
-                if (defineNameMatchesFilter(name, filterList, fullMatch))
+                if (defineNameMatchesFilter(name, filterList, useRegex))
                     result.filteredNames.append(name);
             }
         } else {
             // Encountered a #define
             const QString name = match.captured("defineName");
             result.expressions.insert(name, match.captured("defineValue"));
-            if (defineNameMatchesFilter(name, filterList, fullMatch))
+            if (defineNameMatchesFilter(name, filterList, useRegex))
                 result.filteredNames.append(name);
         }
     }
@@ -447,8 +447,8 @@ ParseUtil::ParsedDefines ParseUtil::readCDefines(const QString &filename, const
 }
 
 // Read all the define names and their expressions in the specified file, then evaluate the ones matching the search text (and any they depend on).
-QMap<QString, int> ParseUtil::evaluateCDefines(const QString &filename, const QStringList &filterList, bool fullMatch) {
-    ParsedDefines defines = readCDefines(filename, filterList, fullMatch);
+QMap<QString, int> ParseUtil::evaluateCDefines(const QString &filename, const QStringList &filterList, bool useRegex) {
+    ParsedDefines defines = readCDefines(filename, filterList, useRegex);
 
     // Evaluate defines
     QMap<QString, int> filteredValues;
@@ -465,20 +465,21 @@ QMap<QString, int> ParseUtil::evaluateCDefines(const QString &filename, const QS
     return filteredValues;
 }
 
-// Find and evaluate an unknown list of defines with a known name prefix.
-QMap<QString, int> ParseUtil::readCDefinesByPrefix(const QString &filename, const QStringList &filterList) {
-    return evaluateCDefines(filename, filterList, false);
-}
-
 // Find and evaluate a specific set of defines with known names.
 QMap<QString, int> ParseUtil::readCDefinesByName(const QString &filename, const QStringList &names) {
-    return evaluateCDefines(filename, names, true);
+    return evaluateCDefines(filename, names, false);
+}
+
+// Find and evaluate an unknown list of defines with a known name pattern.
+QMap<QString, int> ParseUtil::readCDefinesByRegex(const QString &filename, const QStringList &regexList) {
+    return evaluateCDefines(filename, regexList, true);
 }
 
-// Similar to readCDefinesByPrefix, but for cases where we only need to show a list of define names.
+// Find an unknown list of defines with a known name pattern.
+// Similar to readCDefinesByRegex, but for cases where we only need to show a list of define names.
 // We can skip evaluating any expressions (and by extension skip reporting any errors from this process).
-QStringList ParseUtil::readCDefineNames(const QString &filename, const QStringList &filterList) {
-    return readCDefines(filename, filterList, false).filteredNames;
+QStringList ParseUtil::readCDefineNames(const QString &filename, const QStringList &regexList) {
+    return readCDefines(filename, regexList, true).filteredNames;
 }
 
 QStringList ParseUtil::readCArray(const QString &filename, const QString &label) {
diff --git a/src/project.cpp b/src/project.cpp
index 10ace3961..8c1dbba5f 100644
--- a/src/project.cpp
+++ b/src/project.cpp
@@ -1557,8 +1557,8 @@ bool Project::readTilesetMetatileLabels() {
     QString metatileLabelsFilename = projectConfig.getFilePath(ProjectFilePath::constants_metatile_labels);
     fileWatcher.addPath(root + "/" + metatileLabelsFilename);
 
-    const QStringList prefixes = {QString("\\b%1").arg(projectConfig.getIdentifier(ProjectIdentifier::define_metatile_label_prefix))};
-    QMap<QString, int> defines = parser.readCDefinesByPrefix(metatileLabelsFilename, prefixes);
+    const QStringList regexList = {QString("\\b%1").arg(projectConfig.getIdentifier(ProjectIdentifier::define_metatile_label_prefix))};
+    QMap<QString, int> defines = parser.readCDefinesByRegex(metatileLabelsFilename, regexList);
 
     for (QString label : defines.keys()) {
         uint32_t metatileId = static_cast<uint32_t>(defines[label]);
@@ -2114,10 +2114,10 @@ bool Project::readRegionMapSections() {
     this->mapSectionNameToValue.clear();
     this->mapSectionValueToName.clear();
 
-    const QStringList prefixes = {QString("\\b%1").arg(projectConfig.getIdentifier(ProjectIdentifier::define_map_section_prefix))};
+    const QStringList regexList = {QString("\\b%1").arg(projectConfig.getIdentifier(ProjectIdentifier::define_map_section_prefix))};
     QString filename = projectConfig.getFilePath(ProjectFilePath::constants_region_map_sections);
     fileWatcher.addPath(root + "/" + filename);
-    this->mapSectionNameToValue = parser.readCDefinesByPrefix(filename, prefixes);
+    this->mapSectionNameToValue = parser.readCDefinesByRegex(filename, regexList);
     if (this->mapSectionNameToValue.isEmpty()) {
         logError(QString("Failed to read region map sections from %1.").arg(filename));
         return false;
@@ -2132,13 +2132,13 @@ bool Project::readRegionMapSections() {
 // Read the constants to preserve any "unused" heal locations when writing the file later
 bool Project::readHealLocationConstants() {
     this->healLocationNameToValue.clear();
-    const QStringList prefixes = {
+    const QStringList regexList = {
         QString("\\b%1").arg(projectConfig.getIdentifier(ProjectIdentifier::define_heal_locations_prefix)),
         QString("\\b%1").arg(projectConfig.getIdentifier(ProjectIdentifier::define_spawn_prefix))
     };
     QString constantsFilename = projectConfig.getFilePath(ProjectFilePath::constants_heal_locations);
     fileWatcher.addPath(root + "/" + constantsFilename);
-    this->healLocationNameToValue = parser.readCDefinesByPrefix(constantsFilename, prefixes);
+    this->healLocationNameToValue = parser.readCDefinesByRegex(constantsFilename, regexList);
     // No need to check if empty, not finding any heal location constants is ok
     return true;
 }
@@ -2237,40 +2237,40 @@ bool Project::readHealLocations() {
 }
 
 bool Project::readItemNames() {
-    const QStringList prefixes = {projectConfig.getIdentifier(ProjectIdentifier::regex_items)};  
+    const QStringList regexList = {projectConfig.getIdentifier(ProjectIdentifier::regex_items)};
     const QString filename = projectConfig.getFilePath(ProjectFilePath::constants_items);
     fileWatcher.addPath(root + "/" + filename);
-    itemNames = parser.readCDefineNames(filename, prefixes);
+    itemNames = parser.readCDefineNames(filename, regexList);
     if (itemNames.isEmpty())
         logWarn(QString("Failed to read item constants from %1").arg(filename));
     return true;
 }
 
 bool Project::readFlagNames() {
-    const QStringList prefixes = {projectConfig.getIdentifier(ProjectIdentifier::regex_flags)};
+    const QStringList regexList = {projectConfig.getIdentifier(ProjectIdentifier::regex_flags)};
     const QString filename = projectConfig.getFilePath(ProjectFilePath::constants_flags);
     fileWatcher.addPath(root + "/" + filename);
-    flagNames = parser.readCDefineNames(filename, prefixes);
+    flagNames = parser.readCDefineNames(filename, regexList);
     if (flagNames.isEmpty())
         logWarn(QString("Failed to read flag constants from %1").arg(filename));
     return true;
 }
 
 bool Project::readVarNames() {
-    const QStringList prefixes = {projectConfig.getIdentifier(ProjectIdentifier::regex_vars)};
+    const QStringList regexList = {projectConfig.getIdentifier(ProjectIdentifier::regex_vars)};
     const QString filename = projectConfig.getFilePath(ProjectFilePath::constants_vars);
     fileWatcher.addPath(root + "/" + filename);
-    varNames = parser.readCDefineNames(filename, prefixes);
+    varNames = parser.readCDefineNames(filename, regexList);
     if (varNames.isEmpty())
         logWarn(QString("Failed to read var constants from %1").arg(filename));
     return true;
 }
 
 bool Project::readMovementTypes() {
-    const QStringList prefixes = {projectConfig.getIdentifier(ProjectIdentifier::regex_movement_types)};
+    const QStringList regexList = {projectConfig.getIdentifier(ProjectIdentifier::regex_movement_types)};
     const QString filename = projectConfig.getFilePath(ProjectFilePath::constants_obj_event_movement);
     fileWatcher.addPath(root + "/" + filename);
-    movementTypes = parser.readCDefineNames(filename, prefixes);
+    movementTypes = parser.readCDefineNames(filename, regexList);
     if (movementTypes.isEmpty())
         logWarn(QString("Failed to read movement type constants from %1").arg(filename));
     return true;
@@ -2286,30 +2286,30 @@ bool Project::readInitialFacingDirections() {
 }
 
 bool Project::readMapTypes() {
-    const QStringList prefixes = {projectConfig.getIdentifier(ProjectIdentifier::regex_map_types)};
+    const QStringList regexList = {projectConfig.getIdentifier(ProjectIdentifier::regex_map_types)};
     const QString filename = projectConfig.getFilePath(ProjectFilePath::constants_map_types);
     fileWatcher.addPath(root + "/" + filename);
-    mapTypes = parser.readCDefineNames(filename, prefixes);
+    mapTypes = parser.readCDefineNames(filename, regexList);
     if (mapTypes.isEmpty())
         logWarn(QString("Failed to read map type constants from %1").arg(filename));
     return true;
 }
 
 bool Project::readMapBattleScenes() {
-    const QStringList prefixes = {projectConfig.getIdentifier(ProjectIdentifier::regex_battle_scenes)};
+    const QStringList regexList = {projectConfig.getIdentifier(ProjectIdentifier::regex_battle_scenes)};
     const QString filename = projectConfig.getFilePath(ProjectFilePath::constants_map_types);
     fileWatcher.addPath(root + "/" + filename);
-    mapBattleScenes = parser.readCDefineNames(filename, prefixes);
+    mapBattleScenes = parser.readCDefineNames(filename, regexList);
     if (mapBattleScenes.isEmpty())
         logWarn(QString("Failed to read map battle scene constants from %1").arg(filename));
     return true;
 }
 
 bool Project::readWeatherNames() {
-    const QStringList prefixes = {projectConfig.getIdentifier(ProjectIdentifier::regex_weather)};
+    const QStringList regexList = {projectConfig.getIdentifier(ProjectIdentifier::regex_weather)};
     const QString filename = projectConfig.getFilePath(ProjectFilePath::constants_weather);
     fileWatcher.addPath(root + "/" + filename);
-    weatherNames = parser.readCDefineNames(filename, prefixes);
+    weatherNames = parser.readCDefineNames(filename, regexList);
     if (weatherNames.isEmpty())
         logWarn(QString("Failed to read weather constants from %1").arg(filename));
     return true;
@@ -2319,10 +2319,10 @@ bool Project::readCoordEventWeatherNames() {
     if (!projectConfig.eventWeatherTriggerEnabled)
         return true;
 
-    const QStringList prefixes = {projectConfig.getIdentifier(ProjectIdentifier::regex_coord_event_weather)};
+    const QStringList regexList = {projectConfig.getIdentifier(ProjectIdentifier::regex_coord_event_weather)};
     const QString filename = projectConfig.getFilePath(ProjectFilePath::constants_weather);
     fileWatcher.addPath(root + "/" + filename);
-    coordEventWeatherNames = parser.readCDefineNames(filename, prefixes);
+    coordEventWeatherNames = parser.readCDefineNames(filename, regexList);
     if (coordEventWeatherNames.isEmpty())
         logWarn(QString("Failed to read coord event weather constants from %1").arg(filename));
     return true;
@@ -2332,30 +2332,30 @@ bool Project::readSecretBaseIds() {
     if (!projectConfig.eventSecretBaseEnabled)
         return true;
 
-    const QStringList prefixes = {projectConfig.getIdentifier(ProjectIdentifier::regex_secret_bases)};
+    const QStringList regexList = {projectConfig.getIdentifier(ProjectIdentifier::regex_secret_bases)};
     const QString filename = projectConfig.getFilePath(ProjectFilePath::constants_secret_bases);
     fileWatcher.addPath(root + "/" + filename);
-    secretBaseIds = parser.readCDefineNames(filename, prefixes);
+    secretBaseIds = parser.readCDefineNames(filename, regexList);
     if (secretBaseIds.isEmpty())
         logWarn(QString("Failed to read secret base id constants from '%1'").arg(filename));
     return true;
 }
 
 bool Project::readBgEventFacingDirections() {
-    const QStringList prefixes = {projectConfig.getIdentifier(ProjectIdentifier::regex_sign_facing_directions)};
+    const QStringList regexList = {projectConfig.getIdentifier(ProjectIdentifier::regex_sign_facing_directions)};
     const QString filename = projectConfig.getFilePath(ProjectFilePath::constants_event_bg);
     fileWatcher.addPath(root + "/" + filename);
-    bgEventFacingDirections = parser.readCDefineNames(filename, prefixes);
+    bgEventFacingDirections = parser.readCDefineNames(filename, regexList);
     if (bgEventFacingDirections.isEmpty())
         logWarn(QString("Failed to read bg event facing direction constants from %1").arg(filename));
     return true;
 }
 
 bool Project::readTrainerTypes() {
-    const QStringList prefixes = {projectConfig.getIdentifier(ProjectIdentifier::regex_trainer_types)};
+    const QStringList regexList = {projectConfig.getIdentifier(ProjectIdentifier::regex_trainer_types)};
     const QString filename = projectConfig.getFilePath(ProjectFilePath::constants_trainer_types);
     fileWatcher.addPath(root + "/" + filename);
-    trainerTypes = parser.readCDefineNames(filename, prefixes);
+    trainerTypes = parser.readCDefineNames(filename, regexList);
     if (trainerTypes.isEmpty())
         logWarn(QString("Failed to read trainer type constants from %1").arg(filename));
     return true;
@@ -2365,10 +2365,10 @@ bool Project::readMetatileBehaviors() {
     this->metatileBehaviorMap.clear();
     this->metatileBehaviorMapInverse.clear();
 
-    const QStringList prefixes = {projectConfig.getIdentifier(ProjectIdentifier::regex_behaviors)};
+    const QStringList regexList = {projectConfig.getIdentifier(ProjectIdentifier::regex_behaviors)};
     QString filename = projectConfig.getFilePath(ProjectFilePath::constants_metatile_behaviors);
     fileWatcher.addPath(root + "/" + filename);
-    QMap<QString, int> defines = parser.readCDefinesByPrefix(filename, prefixes);
+    QMap<QString, int> defines = parser.readCDefinesByRegex(filename, regexList);
     if (defines.isEmpty()) {
         // Not having any metatile behavior names is ok (their values will be displayed instead).
         // If the user's metatiles can have nonzero values then warn them, as they likely want names.
@@ -2387,10 +2387,10 @@ bool Project::readMetatileBehaviors() {
 }
 
 bool Project::readSongNames() {
-    const QStringList prefixes = {projectConfig.getIdentifier(ProjectIdentifier::regex_music)};
+    const QStringList regexList = {projectConfig.getIdentifier(ProjectIdentifier::regex_music)};
     const QString filename = projectConfig.getFilePath(ProjectFilePath::constants_songs);
     fileWatcher.addPath(root + "/" + filename);
-    this->songNames = parser.readCDefineNames(filename, prefixes);
+    this->songNames = parser.readCDefineNames(filename, regexList);
     if (this->songNames.isEmpty())
         logWarn(QString("Failed to read song names from %1.").arg(filename));
 
@@ -2402,10 +2402,10 @@ bool Project::readSongNames() {
 }
 
 bool Project::readObjEventGfxConstants() {
-    const QStringList prefixes = {projectConfig.getIdentifier(ProjectIdentifier::regex_obj_event_gfx)};
+    const QStringList regexList = {projectConfig.getIdentifier(ProjectIdentifier::regex_obj_event_gfx)};
     QString filename = projectConfig.getFilePath(ProjectFilePath::constants_obj_events);
     fileWatcher.addPath(root + "/" + filename);
-    this->gfxDefines = parser.readCDefinesByPrefix(filename, prefixes);
+    this->gfxDefines = parser.readCDefinesByRegex(filename, regexList);
     if (this->gfxDefines.isEmpty())
         logWarn(QString("Failed to read object event graphics constants from %1.").arg(filename));
     return true;
@@ -2611,10 +2611,10 @@ bool Project::readSpeciesIconPaths() {
     const QMap<QString, QString> iconIncbins = parser.readCIncbinMulti(incfilename);
 
     // Read species constants. If this fails we can get them from the icon table (but we shouldn't rely on it).
-    const QStringList prefixes = {projectConfig.getIdentifier(ProjectIdentifier::regex_species)};
+    const QStringList regexList = {projectConfig.getIdentifier(ProjectIdentifier::regex_species)};
     const QString constantsFilename = projectConfig.getFilePath(ProjectFilePath::constants_species);
     fileWatcher.addPath(root + "/" + constantsFilename);
-    QStringList speciesNames = parser.readCDefineNames(constantsFilename, prefixes);
+    QStringList speciesNames = parser.readCDefineNames(constantsFilename, regexList);
     if (speciesNames.isEmpty())
         speciesNames = monIconNames.keys();
 

From 5c9a1d41409dcf80e9bf082eebd75675da5f816b Mon Sep 17 00:00:00 2001
From: GriffinR <griffin.g.richards@gmail.com>
Date: Wed, 28 Aug 2024 16:13:10 -0400
Subject: [PATCH 4/6] Fix enum comma parsing

---
 include/core/parseutil.h | 4 ++--
 src/core/parseutil.cpp   | 7 ++++++-
 2 files changed, 8 insertions(+), 3 deletions(-)

diff --git a/include/core/parseutil.h b/include/core/parseutil.h
index a69ed2f46..bc167a303 100644
--- a/include/core/parseutil.h
+++ b/include/core/parseutil.h
@@ -99,8 +99,8 @@ class ParseUtil
     QString createErrorMessage(const QString &message, const QString &expression);
 
     struct ParsedDefines {
-        QMap<QString,QString> expressions; // Map of all define names->expressions encountered
-        QStringList filteredNames; // Define names matching the search text in the order they were encountered in the file
+        QMap<QString,QString> expressions; // Map of all define names encountered to their expressions
+        QStringList filteredNames; // List of define names that matched the search text, in the order that they were encountered
     };
     ParsedDefines readCDefines(const QString &filename, const QStringList &filterList, bool useRegex);
     QMap<QString, int> evaluateCDefines(const QString &filename, const QStringList &filterList, bool useRegex);
diff --git a/src/core/parseutil.cpp b/src/core/parseutil.cpp
index c9b022756..5448229cb 100644
--- a/src/core/parseutil.cpp
+++ b/src/core/parseutil.cpp
@@ -416,7 +416,11 @@ ParseUtil::ParsedDefines ParseUtil::readCDefines(const QString &filename, const
             // Encountered an enum, extract the elements of the enum and give each an appropriate expression
             int baseNum = 0;
             QString baseExpression = "0";
-            static const QRegularExpression re_enumElement("\\b(?<name>\\w+)\\b\\s*=?\\s*(?<expression>.+)?[,\\$]"); // TODO: Ignores terminal element lacking comma
+
+            // Note: We lazily consider an enum's expression to be any characters after the assignment up until the first comma or EOL.
+            // This would be a problem for e.g. NAME = MACRO(a, b), but we're currently unable to parse function-like macros anyway.
+            // If this changes then the regex below needs to be updated.
+            static const QRegularExpression re_enumElement("\\b(?<name>\\w+)\\b\\s*=?\\s*(?<expression>[^,]*)");
             QRegularExpressionMatchIterator elementIter = re_enumElement.globalMatch(enumBody);
             while (elementIter.hasNext()) {
                 QRegularExpressionMatch elementMatch = elementIter.next();
@@ -462,6 +466,7 @@ QMap<QString, int> ParseUtil::evaluateCDefines(const QString &filename, const QS
         filteredValues.insert(name, evaluateDefine(name, expression, &allValues, &defines.expressions));
         logRecordedErrors(); // Only log errors for defines that Porymap is looking for
     }
+
     return filteredValues;
 }
 

From c9022a90895c5611aa7ec171c07f769c44dd5d32 Mon Sep 17 00:00:00 2001
From: GriffinR <griffin.g.richards@gmail.com>
Date: Thu, 29 Aug 2024 00:05:27 -0400
Subject: [PATCH 5/6] Fix freeze on mismatched parentheses

---
 src/core/parseutil.cpp | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/core/parseutil.cpp b/src/core/parseutil.cpp
index 5448229cb..04cdbcc7f 100644
--- a/src/core/parseutil.cpp
+++ b/src/core/parseutil.cpp
@@ -241,10 +241,11 @@ QList<Token> ParseUtil::generatePostfix(const QList<Token> &tokens) {
     }
 
     while (!operatorStack.isEmpty()) {
-        if (operatorStack.top().value == "(" || operatorStack.top().value == ")") {
+        Token token = operatorStack.pop();
+        if (token.value == "(" || token.value == ")") {
             recordError("Mismatched parentheses detected in expression!");
         } else {
-            output.append(operatorStack.pop());
+            output.append(token);
         }
     }
 

From 7c207a1558bea84048060935f582ed373417147d Mon Sep 17 00:00:00 2001
From: GriffinR <griffin.g.richards@gmail.com>
Date: Thu, 29 Aug 2024 00:05:41 -0400
Subject: [PATCH 6/6] Update changelog

---
 CHANGELOG.md | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 86009d499..1d7d9f025 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -11,6 +11,7 @@ The **"Breaking Changes"** listed below are changes that have been made in the d
 - Redesigned the Connections tab, adding a number of new features including the option to open or display diving maps and a list UI for easier edit access.
 - Add a `Close Project` option
 - An alert will be displayed when attempting to open a seemingly invalid project.
+- Add support for defining project values with `enum` where `#define` was expected.
 
 ### Changed
 - Edits to map connections now have Undo/Redo and can be viewed in exported timelapses.
@@ -38,6 +39,7 @@ The **"Breaking Changes"** listed below are changes that have been made in the d
 - Fix map connections rendering incorrectly if their dimensions were smaller than the border draw distance.
 - Fix the map list filter retaining text between project open/close.
 - Fix the map list mishandling value gaps when sorting by Area.
+- Fix a freeze on startup if project values are defined with mismatched parentheses.
 
 ## [5.4.1] - 2024-03-21
 ### Fixed