// Application headers.
 #include "FilterListHelper.h"
-#include "structs/OverrideStruct.h"
+#include "structs/FilterOptionsOverrideStruct.h"
 
 // KDE Framework headers.
 #include <KLocalizedString>
     requestStructPointer->urlStringWithSeparators.replace(QLatin1Char('='), QLatin1Char('^'));
     requestStructPointer->urlStringWithSeparators.replace(QLatin1Char('&'), QLatin1Char('^'));
 
-    // Add a `^` to the end of the string it it doesn't already contain one.
+    // Add a `^` to the end of the string if it doesn't already contain one.
     if (!requestStructPointer->urlStringWithSeparators.endsWith(QLatin1Char('^')))
         requestStructPointer->urlStringWithSeparators.append(QLatin1Char('^'));
 
     // Check the main allow list.
     while (continueChecking && (mainAllowListEntry != mainAllowListEnd))
     {
-        // Get the entry struct.
-        EntryStruct *entryStructPointer = *mainAllowListEntry;
+        // Get the filter list entry struct.
+        FilterListEntryStruct *filterListEntryStructPointer = *mainAllowListEntry;
 
         // Check the applied entry against the request URL.
         continueChecking = checkAppliedEntry(urlRequestInfo, requestStructPointer, filterListStructPointer->title, MAIN_ALLOWLIST, requestStructPointer->urlString,
-                                             RequestUrlType::Url, entryStructPointer);
+                                             RequestUrlType::Url, filterListEntryStructPointer);
 
         // Check the applied entry against the request URL with separators.
         if (continueChecking)
             continueChecking = checkAppliedEntry(urlRequestInfo, requestStructPointer, filterListStructPointer->title, MAIN_ALLOWLIST, requestStructPointer->urlStringWithSeparators,
-                                                 RequestUrlType::UrlWithSeparators, entryStructPointer);
+                                                 RequestUrlType::UrlWithSeparators, filterListEntryStructPointer);
 
         // Increment the main allow list entry.
         ++mainAllowListEntry;
         // Check the initial domain white list.
         while (continueChecking && (initialDomainAllowListEntry != initialDomainAllowListEnd))
         {
-            // Get the entry struct.
-            EntryStruct *entryStructPointer = *initialDomainAllowListEntry;
+            // Get the filter list entry struct.
+            FilterListEntryStruct *filterListEntryStructPointer = *initialDomainAllowListEntry;
 
             // Check the applied entry against the truncated URL.
             continueChecking = checkAppliedEntry(urlRequestInfo, requestStructPointer, filterListStructPointer->title, INITIAL_DOMAIN_ALLOWLIST, requestStructPointer->truncatedUrlString,
-                                                 RequestUrlType::TruncatedUrl, entryStructPointer);
+                                                 RequestUrlType::TruncatedUrl, filterListEntryStructPointer);
 
             //Check the applied entry against the truncated URL with separators.
             if (continueChecking)
                 continueChecking = checkAppliedEntry(urlRequestInfo, requestStructPointer, filterListStructPointer->title, INITIAL_DOMAIN_ALLOWLIST,
-                                                     requestStructPointer->truncatedUrlStringWithSeparators, RequestUrlType::TruncatedUrlWithSeparators, entryStructPointer);
+                                                     requestStructPointer->truncatedUrlStringWithSeparators, RequestUrlType::TruncatedUrlWithSeparators, filterListEntryStructPointer);
 
             // Increment the initial domain allow list entry.
             ++initialDomainAllowListEntry;
         // Check the main block list.
         while (continueChecking && (mainBlockListEntry != mainBlockListEnd))
         {
-            // Get the entry struct.
-            EntryStruct *entryStructPointer = *mainBlockListEntry;
+            // Get the filter list entry struct.
+            FilterListEntryStruct *filterListEntryStructPointer = *mainBlockListEntry;
 
             // Check the applied entry against the request URL.
             continueChecking = checkAppliedEntry(urlRequestInfo, requestStructPointer, filterListStructPointer->title, MAIN_BLOCKLIST, requestStructPointer->urlString,
-                                                 RequestUrlType::Url, entryStructPointer);
+                                                 RequestUrlType::Url, filterListEntryStructPointer);
 
             // Check the applied entry against the request URL with separators.
             if (continueChecking)
                 continueChecking = checkAppliedEntry(urlRequestInfo, requestStructPointer, filterListStructPointer->title, MAIN_BLOCKLIST, requestStructPointer->urlStringWithSeparators,
-                                                 RequestUrlType::UrlWithSeparators, entryStructPointer);
+                                                 RequestUrlType::UrlWithSeparators, filterListEntryStructPointer);
 
             // Increment the main block list entry.
             ++mainBlockListEntry;
         while (continueChecking && (initialDomainBlockListEntry != initialDomainBlockListEnd))
         {
             // Get the entry struct.
-            EntryStruct *entryStructPointer = *initialDomainBlockListEntry;
+            FilterListEntryStruct *filterListEntryStructPointer = *initialDomainBlockListEntry;
 
             // Check the applied entry against the truncated URL.
             continueChecking = checkAppliedEntry(urlRequestInfo, requestStructPointer, filterListStructPointer->title, INITIAL_DOMAIN_BLOCKLIST, requestStructPointer->truncatedUrlString,
-                                                 RequestUrlType::TruncatedUrl, entryStructPointer);
+                                                 RequestUrlType::TruncatedUrl, filterListEntryStructPointer);
 
             // Check the applied entry against the truncated URL with separators.
             if (continueChecking)
                 continueChecking = checkAppliedEntry(urlRequestInfo, requestStructPointer, filterListStructPointer->title, INITIAL_DOMAIN_BLOCKLIST,
-                                                     requestStructPointer->truncatedUrlStringWithSeparators, RequestUrlType::TruncatedUrlWithSeparators, entryStructPointer);
+                                                     requestStructPointer->truncatedUrlStringWithSeparators, RequestUrlType::TruncatedUrlWithSeparators, filterListEntryStructPointer);
 
             // Increment the initial domain block list entry.
             ++initialDomainBlockListEntry;
         while (continueChecking && (regularExpressionBlockListEntry != regularExpressionBlockListEnd))
         {
             // Get the entry struct.
-            EntryStruct *entryStructPointer = *regularExpressionBlockListEntry;
+            FilterListEntryStruct *filterListEntryStructPointer = *regularExpressionBlockListEntry;
 
             // Check the applied entries.
-            continueChecking = checkRegularExpression(urlRequestInfo, requestStructPointer, filterListStructPointer->title, REGULAR_EXPRESSION_BLOCKLIST, entryStructPointer);
+            continueChecking = checkRegularExpression(urlRequestInfo, requestStructPointer, filterListStructPointer->title, REGULAR_EXPRESSION_BLOCKLIST, filterListEntryStructPointer);
 
             // Increment the regular expression block list entry.
             ++regularExpressionBlockListEntry;
 }
 
 bool FilterListHelper::checkAppliedEntry(QWebEngineUrlRequestInfo &urlRequestInfo, RequestStruct *requestStructPointer, const QString &filterListTitle, const int sublistInt, QString urlString,
-                                         const RequestUrlType requestUrlType, EntryStruct *entryStructPointer) const
+                                         const RequestUrlType requestUrlType, FilterListEntryStruct *filterListEntryStructPointer) const
 {
     // Check the entries according to the number.
-    if (entryStructPointer->singleAppliedEntry)  // There is a single entry.
+    if (filterListEntryStructPointer->singleAppliedEntry)  // There is a single entry.
     {
         // Process initial and final matches.
-        if (entryStructPointer->initialMatch && entryStructPointer->finalMatch)  // This is both an initial and final match.
+        if (filterListEntryStructPointer->initialMatch && filterListEntryStructPointer->finalMatch)  // This is both an initial and final match.
         {
             // Check the URL against the applied entry.
-            if (urlString == entryStructPointer->appliedEntryList[0])
+            if (urlString == filterListEntryStructPointer->appliedEntryList[0])
             {
                 // Set the matched URL type.
                 requestStructPointer->matchedUrlType = requestUrlType;
 
                 // Check the domain status.
-                return checkDomain(urlRequestInfo, requestStructPointer, filterListTitle, sublistInt, entryStructPointer);
+                return checkDomain(urlRequestInfo, requestStructPointer, filterListTitle, sublistInt, filterListEntryStructPointer);
             }
         }
-        else if (entryStructPointer->initialMatch)  // This is an initial match.
+        else if (filterListEntryStructPointer->initialMatch)  // This is an initial match.
         {
             // Check the URL against the applied entry.
-            if (urlString.startsWith(entryStructPointer->appliedEntryList[0]))
+            if (urlString.startsWith(filterListEntryStructPointer->appliedEntryList[0]))
             {
                 // Set the matched URL type.
                 requestStructPointer->matchedUrlType = requestUrlType;
 
                 // Check the domain status.
-                return checkDomain(urlRequestInfo, requestStructPointer, filterListTitle, sublistInt, entryStructPointer);
+                return checkDomain(urlRequestInfo, requestStructPointer, filterListTitle, sublistInt, filterListEntryStructPointer);
             }
         }
-        else if (entryStructPointer->finalMatch)  // This is a final match.
+        else if (filterListEntryStructPointer->finalMatch)  // This is a final match.
         {
             // Check the URL against the applied entry.
-            if (urlString.endsWith(entryStructPointer->appliedEntryList[0]))
+            if (urlString.endsWith(filterListEntryStructPointer->appliedEntryList[0]))
             {
                 // Set the matched URL type.
                 requestStructPointer->matchedUrlType = requestUrlType;
 
                 // Check the domain status.
-                return checkDomain(urlRequestInfo, requestStructPointer, filterListTitle, sublistInt, entryStructPointer);
+                return checkDomain(urlRequestInfo, requestStructPointer, filterListTitle, sublistInt, filterListEntryStructPointer);
             }
         }
         else  // There is no initial or final matching.
         {
             // Check if the URL string contains the applied entry.
-            if (urlString.contains(entryStructPointer->appliedEntryList[0]))
+            if (urlString.contains(filterListEntryStructPointer->appliedEntryList[0]))
             {
                 // Set the matched URL type.
                 requestStructPointer->matchedUrlType = requestUrlType;
 
                 // Check the domain status.
-                return checkDomain(urlRequestInfo, requestStructPointer, filterListTitle, sublistInt, entryStructPointer);
+                return checkDomain(urlRequestInfo, requestStructPointer, filterListTitle, sublistInt, filterListEntryStructPointer);
             }
         }
     }
     else  // There are multiple entries.
     {
         // Process initial and final matches.
-        if (entryStructPointer->initialMatch && entryStructPointer->finalMatch)  // This is both an initial and final match.
+        if (filterListEntryStructPointer->initialMatch && filterListEntryStructPointer->finalMatch)  // This is both an initial and final match.
         {
             // Check the URL.
-            if (urlString.startsWith(entryStructPointer->appliedEntryList[0]))
+            if (urlString.startsWith(filterListEntryStructPointer->appliedEntryList[0]))
             {
                 // Get the number of characters to remove from the front of the URL string.
-                int charactersToRemove = entryStructPointer->appliedEntryList[0].size();
+                int charactersToRemove = filterListEntryStructPointer->appliedEntryList[0].size();
 
                 // Remove the entry from the front of the URL string copies.
                 urlString.remove(0, charactersToRemove);
 
                 // Get the entry locations.
-                int penultimateEntryNumber = (entryStructPointer->sizeOfAppliedEntryList - 1);
+                int penultimateEntryNumber = (filterListEntryStructPointer->sizeOfAppliedEntryList - 1);
                 int ultimateEntryIndex = penultimateEntryNumber;
 
                 // Create a URL matches flag.
                 for (int i = 1; i < penultimateEntryNumber; ++i)
                 {
                     // Get the applied entry index, which will be `-1` if it doesn't exist.
-                    int appliedEntryIndex = urlString.indexOf(entryStructPointer->appliedEntryList[i]);
+                    int appliedEntryIndex = urlString.indexOf(filterListEntryStructPointer->appliedEntryList[i]);
 
                     // Check if the entry was found.
                     if (appliedEntryIndex >= 0)  // The entry is contained in the URL string.
                     {
                         // Get the number of characters to remove from the front of the URL strings.
-                        int charactersToRemove = appliedEntryIndex + entryStructPointer->appliedEntryList[i].size();
+                        int charactersToRemove = appliedEntryIndex + filterListEntryStructPointer->appliedEntryList[i].size();
 
                         // Remove the entry from the front of the URL string copies.
                         urlString.remove(0, charactersToRemove);
                 // Check the final entry if the URL still matches.
                 if (urlMatches)
                 {
-                    if (urlString.endsWith(entryStructPointer->appliedEntryList[ultimateEntryIndex]))  // The URL string ends with the last applied entry.
+                    if (urlString.endsWith(filterListEntryStructPointer->appliedEntryList[ultimateEntryIndex]))  // The URL string ends with the last applied entry.
                     {
                         // Set the matched URL type.
                         requestStructPointer->matchedUrlType = requestUrlType;
 
                         // Check the domain status.
-                        return checkDomain(urlRequestInfo, requestStructPointer, filterListTitle, sublistInt, entryStructPointer);
+                        return checkDomain(urlRequestInfo, requestStructPointer, filterListTitle, sublistInt, filterListEntryStructPointer);
                     }
                 }
             }
         }
-        else if (entryStructPointer->initialMatch)  // This is an initial match.
+        else if (filterListEntryStructPointer->initialMatch)  // This is an initial match.
         {
             // Check the URL.
-            if (urlString.startsWith(entryStructPointer->appliedEntryList[0]))
+            if (urlString.startsWith(filterListEntryStructPointer->appliedEntryList[0]))
             {
                 // Get the number of characters to remove from the front of the URL strings.
-                int charactersToRemove = entryStructPointer->appliedEntryList[0].size();
+                int charactersToRemove = filterListEntryStructPointer->appliedEntryList[0].size();
 
                 // Remove the entry from the front of the URL string copies.
                 urlString.remove(0, charactersToRemove);
                 // Create a URL matches flag.
                 bool urlMatches = true;
 
-                for (int i = 1; i < entryStructPointer->sizeOfAppliedEntryList; ++i)
+                for (int i = 1; i < filterListEntryStructPointer->sizeOfAppliedEntryList; ++i)
                 {
                     // Get the applied entry index, which will be `-1` if it doesn't exist.
-                    int appliedEntryIndex = urlString.indexOf(entryStructPointer->appliedEntryList[i]);
+                    int appliedEntryIndex = urlString.indexOf(filterListEntryStructPointer->appliedEntryList[i]);
 
                     // Check if the entry was found.
                     if (appliedEntryIndex >= 0)  // The entry is contained in the URL string.
                     {
                         // Get the number of characters to remove from the front of the URL strings.
-                        int charactersToRemove = appliedEntryIndex + entryStructPointer->appliedEntryList[i].size();
+                        int charactersToRemove = appliedEntryIndex + filterListEntryStructPointer->appliedEntryList[i].size();
 
                         // Remove the entry from the front of the URL string copies.
                         urlString.remove(0, charactersToRemove);
                     requestStructPointer->matchedUrlType = requestUrlType;
 
                     // Check the domain status.
-                    return checkDomain(urlRequestInfo, requestStructPointer, filterListTitle, sublistInt, entryStructPointer);
+                    return checkDomain(urlRequestInfo, requestStructPointer, filterListTitle, sublistInt, filterListEntryStructPointer);
                 }
             }
         }
-        else if (entryStructPointer->finalMatch)  // This is a final match.
+        else if (filterListEntryStructPointer->finalMatch)  // This is a final match.
         {
             // Get the entry locations.
-            int penultimateEntryNumber = (entryStructPointer->sizeOfAppliedEntryList - 1);
+            int penultimateEntryNumber = (filterListEntryStructPointer->sizeOfAppliedEntryList - 1);
             int ultimateEntryIndex = penultimateEntryNumber;
 
             // Create a URL matches flag.
             for (int i = 0; i < penultimateEntryNumber; ++i)
             {
                 // Get the applied entry index, which will be `-1` if it doesn't exist.
-                int appliedEntryIndex = urlString.indexOf(entryStructPointer->appliedEntryList[i]);
+                int appliedEntryIndex = urlString.indexOf(filterListEntryStructPointer->appliedEntryList[i]);
 
                 // Check if the entry was found.
                 if (appliedEntryIndex >= 0)  // The entry is contained in the URL string.
                 {
                     // Get the number of characters to remove from the front of the URL strings.
-                    int charactersToRemove = appliedEntryIndex + entryStructPointer->appliedEntryList[i].size();
+                    int charactersToRemove = appliedEntryIndex + filterListEntryStructPointer->appliedEntryList[i].size();
 
                     // Remove the entry from the front of the URL string copies.
                     urlString.remove(0, charactersToRemove);
             // Check the final entry if the URL still matches.
             if (urlMatches)
             {
-                if (urlString.endsWith(entryStructPointer->appliedEntryList[ultimateEntryIndex]))  // The URL string ends with the last applied entry.
+                if (urlString.endsWith(filterListEntryStructPointer->appliedEntryList[ultimateEntryIndex]))  // The URL string ends with the last applied entry.
                 {
                     // Set the matched URL type.
                     requestStructPointer->matchedUrlType = requestUrlType;
 
                     // Check the domain status.
-                    return checkDomain(urlRequestInfo, requestStructPointer, filterListTitle, sublistInt, entryStructPointer);
+                    return checkDomain(urlRequestInfo, requestStructPointer, filterListTitle, sublistInt, filterListEntryStructPointer);
                 }
             }
         }
             // Create a URL matches flag.
             bool urlMatches = true;
 
-            for (int i = 0; i < entryStructPointer->sizeOfAppliedEntryList; ++i)
+            for (int i = 0; i < filterListEntryStructPointer->sizeOfAppliedEntryList; ++i)
             {
                 // Get the applied entry index, which will be `-1` if it doesn't exist.
-                int appliedEntryIndex = urlString.indexOf(entryStructPointer->appliedEntryList[i]);
+                int appliedEntryIndex = urlString.indexOf(filterListEntryStructPointer->appliedEntryList[i]);
 
                 // Check if the entry was found.
                 if (appliedEntryIndex >= 0)  // The entry is contained in the URL string.
                 {
                     // Get the number of characters to remove from the front of the URL strings.
-                    int charactersToRemove = appliedEntryIndex + entryStructPointer->appliedEntryList[i].size();
+                    int charactersToRemove = appliedEntryIndex + filterListEntryStructPointer->appliedEntryList[i].size();
 
                     // Remove the entry from the front of the URL string copies.
                     urlString.remove(0, charactersToRemove);
                 requestStructPointer->matchedUrlType = requestUrlType;
 
                 // Check the domain status.
-                return checkDomain(urlRequestInfo, requestStructPointer, filterListTitle, sublistInt, entryStructPointer);
+                return checkDomain(urlRequestInfo, requestStructPointer, filterListTitle, sublistInt, filterListEntryStructPointer);
             }
         }
     }
 }
 
 bool FilterListHelper::checkRegularExpression(QWebEngineUrlRequestInfo &urlRequestInfo, RequestStruct *requestStructPointer, const QString &filterListTitle, const int sublistInt,
-                                              EntryStruct *entryStructPointer) const
+                                              FilterListEntryStruct *filterListEntryStructPointer) const
 {
     // Create an applied entry regular expression.
-    QRegularExpression appliedEntryRegularExpression(entryStructPointer->appliedEntryList[0]);
+    QRegularExpression appliedEntryRegularExpression(filterListEntryStructPointer->appliedEntryList[0]);
 
     // Check if the regular expression matches the applied entry.
     if (requestStructPointer->urlString.contains(appliedEntryRegularExpression))
     {
         // Check the domain status.
-        return checkDomain(urlRequestInfo, requestStructPointer, filterListTitle, sublistInt, entryStructPointer);
+        return checkDomain(urlRequestInfo, requestStructPointer, filterListTitle, sublistInt, filterListEntryStructPointer);
     }
 
     // If the regular expression doesn't match, return `true` to continue processing the URL request.
 }
 
 bool FilterListHelper::checkDomain(QWebEngineUrlRequestInfo &urlRequestInfo, RequestStruct *requestStructPointer, const QString &filterListTitle, const int sublistInt,
-                                   EntryStruct *entryStructPointer) const
+                                   FilterListEntryStruct *filterListEntryStructPointer) const
 {
     // Check domain status.
-    if (entryStructPointer->domain == FilterOptionDisposition::Null)  // Ignore domain status.
+    if (filterListEntryStructPointer->domain == FilterOptionDisposition::Null)  // Ignore domain status.
     {
         // Check the third-party status.
-        return checkThirdParty(urlRequestInfo, requestStructPointer, filterListTitle, sublistInt, entryStructPointer);
+        return checkThirdParty(urlRequestInfo, requestStructPointer, filterListTitle, sublistInt, filterListEntryStructPointer);
     }
-    else if (entryStructPointer->domain == FilterOptionDisposition::Apply)  // Block requests from listed domains.
+    else if (filterListEntryStructPointer->domain == FilterOptionDisposition::Apply)  // Block requests from listed domains.
     {
         // Check each domain.
-        for (QString blockedDomain : entryStructPointer->domainList)
+        for (QString blockedDomain : filterListEntryStructPointer->domainList)
         {
             // Check if the request came from a blocked domain.
             if (requestStructPointer->firstPartyHost.endsWith(blockedDomain))
             {
                 // Check the third-party status.
-                return checkThirdParty(urlRequestInfo, requestStructPointer, filterListTitle, sublistInt, entryStructPointer);
+                return checkThirdParty(urlRequestInfo, requestStructPointer, filterListTitle, sublistInt, filterListEntryStructPointer);
             }
         }
     }
-    else if (entryStructPointer->domain == FilterOptionDisposition::Override)  // Block domains that are not overridden.
+    else if (filterListEntryStructPointer->domain == FilterOptionDisposition::Override)  // Block domains that are not overridden.
     {
         // Create a block domain flag.
         bool blockDomain = true;
 
         // Check each overridden domain.
-        for (QString overriddenDomain : entryStructPointer->domainList)
+        for (QString overriddenDomain : filterListEntryStructPointer->domainList)
         {
             // Check if the request came from an overridden domain.
             if (requestStructPointer->firstPartyHost.endsWith(overriddenDomain))
         if (blockDomain)
         {
             // Check the third-party status.
-            return checkThirdParty(urlRequestInfo, requestStructPointer, filterListTitle, sublistInt, entryStructPointer);
+            return checkThirdParty(urlRequestInfo, requestStructPointer, filterListTitle, sublistInt, filterListEntryStructPointer);
         }
     }
 
 }
 
 bool FilterListHelper::checkThirdParty(QWebEngineUrlRequestInfo &urlRequestInfo, RequestStruct *requestStructPointer, const QString &filterListTitle, const int sublistInt,
-                                       EntryStruct *entryStructPointer) const
+                                       FilterListEntryStruct *filterListEntryStructPointer) const
 {
     // Check third-party status.
-    if (entryStructPointer->thirdParty == FilterOptionDisposition::Null)  // Ignore third-party status.
+    if (filterListEntryStructPointer->thirdParty == FilterOptionDisposition::Null)  // Ignore third-party status.
     {
         // Check if request options are applied.
-        if (entryStructPointer->hasRequestOptions)  // Request options are applied.
+        if (filterListEntryStructPointer->hasRequestOptions)  // Request options are applied.
         {
             // Check the request options.
-            return checkRequestOptions(urlRequestInfo, requestStructPointer, filterListTitle, sublistInt, entryStructPointer);
+            return checkRequestOptions(urlRequestInfo, requestStructPointer, filterListTitle, sublistInt, filterListEntryStructPointer);
         }
         else  // Request options are not applied.
         {
             // Process the request.
-            return processRequest(urlRequestInfo, requestStructPointer, filterListTitle, sublistInt, entryStructPointer);
+            return processRequest(urlRequestInfo, requestStructPointer, filterListTitle, sublistInt, filterListEntryStructPointer);
         }
     }
-    else if ((entryStructPointer->thirdParty == FilterOptionDisposition::Apply) && requestStructPointer->isThirdPartyRequest)  // Block third-party request.
+    else if ((filterListEntryStructPointer->thirdParty == FilterOptionDisposition::Apply) && requestStructPointer->isThirdPartyRequest)  // Block third-party request.
     {
         // Check if request options are applied.
-        if (entryStructPointer->hasRequestOptions)  // Request options are applied.
+        if (filterListEntryStructPointer->hasRequestOptions)  // Request options are applied.
         {
             // Check the request options.
-            return checkRequestOptions(urlRequestInfo, requestStructPointer, filterListTitle, sublistInt, entryStructPointer);
+            return checkRequestOptions(urlRequestInfo, requestStructPointer, filterListTitle, sublistInt, filterListEntryStructPointer);
         }
         else  // Request options are not applied.
         {
             // Process the request.
-            return processRequest(urlRequestInfo, requestStructPointer, filterListTitle, sublistInt, entryStructPointer);
+            return processRequest(urlRequestInfo, requestStructPointer, filterListTitle, sublistInt, filterListEntryStructPointer);
         }
     }
-    else if ((entryStructPointer->thirdParty == FilterOptionDisposition::Override) && !requestStructPointer->isThirdPartyRequest)  // Block first-party requests.
+    else if ((filterListEntryStructPointer->thirdParty == FilterOptionDisposition::Override) && !requestStructPointer->isThirdPartyRequest)  // Block first-party requests.
     {
         // Check if request options are applied.
-        if (entryStructPointer->hasRequestOptions)  // Request options are applied.
+        if (filterListEntryStructPointer->hasRequestOptions)  // Request options are applied.
         {
             // Check the request options.
-            return checkRequestOptions(urlRequestInfo, requestStructPointer, filterListTitle, sublistInt, entryStructPointer);
+            return checkRequestOptions(urlRequestInfo, requestStructPointer, filterListTitle, sublistInt, filterListEntryStructPointer);
         }
         else  // Request options are not applied.
         {
             // Process the request.
-            return processRequest(urlRequestInfo, requestStructPointer, filterListTitle, sublistInt, entryStructPointer);
+            return processRequest(urlRequestInfo, requestStructPointer, filterListTitle, sublistInt, filterListEntryStructPointer);
         }
     }
 
 }
 
 bool FilterListHelper::checkRequestOptions(QWebEngineUrlRequestInfo &urlRequestInfo, RequestStruct *requestStructPointer, const QString &filterListTitle, const int sublistInt,
-                                           EntryStruct *entryStructPointer) const
+                                           FilterListEntryStruct *filterListEntryStructPointer) const
 {
     // Process font requests.
-    if ((entryStructPointer->font == FilterOptionDisposition::Apply) && (requestStructPointer->resourceTypeInt == QWebEngineUrlRequestInfo::ResourceTypeFontResource))
-        return processRequest(urlRequestInfo, requestStructPointer, filterListTitle, sublistInt, entryStructPointer);
+    if ((filterListEntryStructPointer->font == FilterOptionDisposition::Apply) && (requestStructPointer->resourceTypeInt == QWebEngineUrlRequestInfo::ResourceTypeFontResource))
+        return processRequest(urlRequestInfo, requestStructPointer, filterListTitle, sublistInt, filterListEntryStructPointer);
 
     // Process image requests.
-    if ((entryStructPointer->image == FilterOptionDisposition::Apply) && (requestStructPointer->resourceTypeInt == QWebEngineUrlRequestInfo::ResourceTypeImage))
-        return processRequest(urlRequestInfo, requestStructPointer, filterListTitle, sublistInt, entryStructPointer);
+    if ((filterListEntryStructPointer->image == FilterOptionDisposition::Apply) && (requestStructPointer->resourceTypeInt == QWebEngineUrlRequestInfo::ResourceTypeImage))
+        return processRequest(urlRequestInfo, requestStructPointer, filterListTitle, sublistInt, filterListEntryStructPointer);
 
     // Process main frame requests.
-    if ((entryStructPointer->mainFrame == FilterOptionDisposition::Apply) && ((requestStructPointer->resourceTypeInt == QWebEngineUrlRequestInfo::ResourceTypeMainFrame) ||
+    if ((filterListEntryStructPointer->mainFrame == FilterOptionDisposition::Apply) && ((requestStructPointer->resourceTypeInt == QWebEngineUrlRequestInfo::ResourceTypeMainFrame) ||
                                                                               (requestStructPointer->resourceTypeInt == QWebEngineUrlRequestInfo::ResourceTypeNavigationPreloadMainFrame)))
-        return processRequest(urlRequestInfo, requestStructPointer, filterListTitle, sublistInt, entryStructPointer);
+        return processRequest(urlRequestInfo, requestStructPointer, filterListTitle, sublistInt, filterListEntryStructPointer);
 
     // Process media requests.
-    if ((entryStructPointer->media == FilterOptionDisposition::Apply) && (requestStructPointer->resourceTypeInt == QWebEngineUrlRequestInfo::ResourceTypeMedia))
-        return processRequest(urlRequestInfo, requestStructPointer, filterListTitle, sublistInt, entryStructPointer);
+    if ((filterListEntryStructPointer->media == FilterOptionDisposition::Apply) && (requestStructPointer->resourceTypeInt == QWebEngineUrlRequestInfo::ResourceTypeMedia))
+        return processRequest(urlRequestInfo, requestStructPointer, filterListTitle, sublistInt, filterListEntryStructPointer);
 
     // Process object requests.
-    if ((entryStructPointer->object == FilterOptionDisposition::Apply) && (requestStructPointer->resourceTypeInt == QWebEngineUrlRequestInfo::ResourceTypeObject))
-        return processRequest(urlRequestInfo, requestStructPointer, filterListTitle, sublistInt, entryStructPointer);
+    if ((filterListEntryStructPointer->object == FilterOptionDisposition::Apply) && (requestStructPointer->resourceTypeInt == QWebEngineUrlRequestInfo::ResourceTypeObject))
+        return processRequest(urlRequestInfo, requestStructPointer, filterListTitle, sublistInt, filterListEntryStructPointer);
 
     // Process other requests.
-    if ((entryStructPointer->other == FilterOptionDisposition::Apply) && ((requestStructPointer->resourceTypeInt == QWebEngineUrlRequestInfo::ResourceTypeSubResource) ||
+    if ((filterListEntryStructPointer->other == FilterOptionDisposition::Apply) && ((requestStructPointer->resourceTypeInt == QWebEngineUrlRequestInfo::ResourceTypeSubResource) ||
                                                                           (requestStructPointer->resourceTypeInt == QWebEngineUrlRequestInfo::ResourceTypeWorker) ||
                                                                           (requestStructPointer->resourceTypeInt == QWebEngineUrlRequestInfo::ResourceTypeSharedWorker) ||
                                                                           (requestStructPointer->resourceTypeInt == QWebEngineUrlRequestInfo::ResourceTypePrefetch) ||
                                                                           (requestStructPointer->resourceTypeInt == QWebEngineUrlRequestInfo::ResourceTypeCspReport) ||
                                                                           (requestStructPointer->resourceTypeInt == QWebEngineUrlRequestInfo::ResourceTypePluginResource) ||
                                                                           (requestStructPointer->resourceTypeInt == QWebEngineUrlRequestInfo::ResourceTypeUnknown)))
-        return processRequest(urlRequestInfo, requestStructPointer, filterListTitle, sublistInt, entryStructPointer);
+        return processRequest(urlRequestInfo, requestStructPointer, filterListTitle, sublistInt, filterListEntryStructPointer);
 
     // Process ping requests
-    if ((entryStructPointer->ping == FilterOptionDisposition::Apply) && (requestStructPointer->resourceTypeInt == QWebEngineUrlRequestInfo::ResourceTypePing))
-        return processRequest(urlRequestInfo, requestStructPointer, filterListTitle, sublistInt, entryStructPointer);
+    if ((filterListEntryStructPointer->ping == FilterOptionDisposition::Apply) && (requestStructPointer->resourceTypeInt == QWebEngineUrlRequestInfo::ResourceTypePing))
+        return processRequest(urlRequestInfo, requestStructPointer, filterListTitle, sublistInt, filterListEntryStructPointer);
 
     // Process script requests.
-    if ((entryStructPointer->script == FilterOptionDisposition::Apply) && (requestStructPointer->resourceTypeInt == QWebEngineUrlRequestInfo::ResourceTypeScript))
-        return processRequest(urlRequestInfo, requestStructPointer, filterListTitle, sublistInt, entryStructPointer);
+    if ((filterListEntryStructPointer->script == FilterOptionDisposition::Apply) && (requestStructPointer->resourceTypeInt == QWebEngineUrlRequestInfo::ResourceTypeScript))
+        return processRequest(urlRequestInfo, requestStructPointer, filterListTitle, sublistInt, filterListEntryStructPointer);
 
     // Process style sheet requests.
-    if ((entryStructPointer->styleSheet == FilterOptionDisposition::Apply) && (requestStructPointer->resourceTypeInt == QWebEngineUrlRequestInfo::ResourceTypeStylesheet))
-        return processRequest(urlRequestInfo, requestStructPointer, filterListTitle, sublistInt, entryStructPointer);
+    if ((filterListEntryStructPointer->styleSheet == FilterOptionDisposition::Apply) && (requestStructPointer->resourceTypeInt == QWebEngineUrlRequestInfo::ResourceTypeStylesheet))
+        return processRequest(urlRequestInfo, requestStructPointer, filterListTitle, sublistInt, filterListEntryStructPointer);
 
     // Process sub resource requests.
-    if ((entryStructPointer->subFrame == FilterOptionDisposition::Apply) && ((requestStructPointer->resourceTypeInt == QWebEngineUrlRequestInfo::ResourceTypeSubFrame) ||
+    if ((filterListEntryStructPointer->subFrame == FilterOptionDisposition::Apply) && ((requestStructPointer->resourceTypeInt == QWebEngineUrlRequestInfo::ResourceTypeSubFrame) ||
                                                                              (requestStructPointer->resourceTypeInt == QWebEngineUrlRequestInfo::ResourceTypeNavigationPreloadSubFrame)))
-        return processRequest(urlRequestInfo, requestStructPointer, filterListTitle, sublistInt, entryStructPointer);
+        return processRequest(urlRequestInfo, requestStructPointer, filterListTitle, sublistInt, filterListEntryStructPointer);
 
     // Process web socket requests.
-    if ((entryStructPointer->webSocket == FilterOptionDisposition::Apply) && (requestStructPointer->resourceTypeInt == QWebEngineUrlRequestInfo::ResourceTypeWebSocket))
-        return processRequest(urlRequestInfo, requestStructPointer, filterListTitle, sublistInt, entryStructPointer);
+    if ((filterListEntryStructPointer->webSocket == FilterOptionDisposition::Apply) && (requestStructPointer->resourceTypeInt == QWebEngineUrlRequestInfo::ResourceTypeWebSocket))
+        return processRequest(urlRequestInfo, requestStructPointer, filterListTitle, sublistInt, filterListEntryStructPointer);
 
     // Process XML HTTP requests.
-    if ((entryStructPointer->xmlHttpRequest == FilterOptionDisposition::Apply) && (requestStructPointer->resourceTypeInt == QWebEngineUrlRequestInfo::ResourceTypeXhr))
-        return processRequest(urlRequestInfo, requestStructPointer, filterListTitle, sublistInt, entryStructPointer);
+    if ((filterListEntryStructPointer->xmlHttpRequest == FilterOptionDisposition::Apply) && (requestStructPointer->resourceTypeInt == QWebEngineUrlRequestInfo::ResourceTypeXhr))
+        return processRequest(urlRequestInfo, requestStructPointer, filterListTitle, sublistInt, filterListEntryStructPointer);
 
     // The request options specified don't match this request.  Return `true` to continue processing the URL request.
     return true;
 }
 
 bool FilterListHelper::processRequest(QWebEngineUrlRequestInfo &urlRequestInfo, RequestStruct *requestStructPointer, const QString &filterListTitle, const int sublistInt,
-                                    EntryStruct *entryStructPointer) const
+                                    FilterListEntryStruct *filterListEntryStructPointer) const
 {
     // Set the request disposition.
     if (sublistInt <= 2)
     // Populate the request struct.
     requestStructPointer->filterListTitle = filterListTitle;
     requestStructPointer->sublistInt = sublistInt;
-    requestStructPointer->entryStruct = *entryStructPointer;
+    requestStructPointer->filterListEntryStruct = *filterListEntryStructPointer;
 
     // Block the request if specified.
     if (requestStructPointer->dispositionInt == BLOCKED)
     // Populate the filter list file name.
     filterListStructPointer->filePath = filterListFileName;
 
-    // Create a filter list string.
-    QString filterListString;
+    // Create the temporary filter list entry string.
+    QString filterListEntryString;
 
-    // Process each line of the filter list.
-    while (filterListTextStream.readLineInto(&filterListString)) {
-        // Create an entry struct.
-        EntryStruct *entryStructPointer = new EntryStruct;
+    // Parse each line of the filter list.
+    while (filterListTextStream.readLineInto(&filterListEntryString)) {
+        // Create a filter list entry struct.
+        FilterListEntryStruct *filterListEntryStructPointer = new FilterListEntryStruct;
 
         // Store the original entry.
-        entryStructPointer->originalEntry = filterListString;
+        filterListEntryStructPointer->originalEntryString = filterListEntryString;
 
-        // Process the entry.
-        if (filterListString.isEmpty())  // Ignore empty lines.
+        // Parse the entry.
+        if (filterListEntryString.isEmpty())  // Ignore empty lines.
         {
             // Do nothing.
 
             // Log the dropping of the line.
-            //qDebug().noquote().nospace() << filterListString << " NOT added from " << filterListFileName << " (empty line).";
+            //qDebug().noquote().nospace() << filterListEntryString << "  NOT added from  " << filterListFileName << "  (empty line).";
         }
-        else if (filterListString.startsWith(QLatin1Char('[')))  // The line starts with `[`, which is the file format.
+        else if (filterListEntryString.startsWith(QLatin1Char('[')))  // The line starts with `[`, which is the file format.
         {
             // Do nothing.
 
             // Log the dropping of the line.
-            //qDebug().noquote().nospace() << filterListString << " NOT added from " << filterListFileName << " (file format).";
+            //qDebug().noquote().nospace() << filterListEntryString << "  NOT added from  " << filterListFileName << "  (file format).";
         }
-        else if (filterListString.contains(QLatin1String("##")) ||
-                 filterListString.contains(QLatin1String("#?#")) ||
-                 filterListString.contains(QLatin1String("#@#")) ||
-                 filterListString.contains(QLatin1String("#$#")))  // The line contains unimplemented content filtering.
+        else if (filterListEntryString.contains(QLatin1String("##")) ||
+                 filterListEntryString.contains(QLatin1String("#?#")) ||
+                 filterListEntryString.contains(QLatin1String("#@#")) ||
+                 filterListEntryString.contains(QLatin1String("#$#")))  // The line contains unimplemented content filtering.
         {
             // Do nothing.
 
             // Log the dropping of the line.
-            //qDebug().noquote().nospace() << filterListString << " NOT added from " << filterListFileName << " (content filtering).";
+            //qDebug().noquote().nospace() << filterListEntryString << "  NOT added from  " << filterListFileName << "  (content filtering).";
         }
-        else if (filterListString.startsWith(QLatin1Char('!')))  // The line starts with `!`, which are comments.
+        else if (filterListEntryString.startsWith(QLatin1Char('!')))  // The line starts with `!`, which are comments.
         {
-            if (filterListString.startsWith(QLatin1String("! Title: ")))  // The line contains the title.
+            if (filterListEntryString.startsWith(QLatin1String("! Title: ")))  // The line contains the title.
             {
                 // Add the title to the filter list struct.
-                filterListStructPointer->title = filterListString.remove(0, 9);
+                filterListStructPointer->title = filterListEntryString.remove(0, 9);
 
                 // Log the addition of the filter list title.
-                //qDebug().noquote().nospace() << "Filter list title:  " << filterListString << " added from " << filterListFileName;
+                //qDebug().noquote().nospace() << "Filter list title:  " << filterListEntryString << "  ADDED from  " << filterListFileName << ".";
             }
-            else if (filterListString.startsWith(QLatin1String("! Version: ")))  // The line contains the version.
+            else if (filterListEntryString.startsWith(QLatin1String("! Version: ")))  // The line contains the version.
             {
                 // Add the version to the filter list struct.
-                filterListStructPointer->version = filterListString.remove(0, 11);
+                filterListStructPointer->version = filterListEntryString.remove(0, 11);
 
                 // Log the addition of the filter list version.
-                //qDebug().noquote().nospace() << "Filter list version:  " << filterListString << " added from " << filterListFileName;
+                //qDebug().noquote().nospace() << "Filter list version:  " << filterListEntryString << "  ADDED from  " << filterListFileName << ".";
             }
+            else  // The comment is not important
+            {
+                // Else do nothing.
 
-            // Else do nothing.
-
-            // Log the dropping of the line.
-            //qDebug().noquote().nospace() << originalFilterListString << " NOT added from " << filterListFileName;
+                // Log the dropping of the line.
+                //qDebug().noquote().nospace() << filterListEntryString << "  NOT added from  " << filterListFileName << "  (comment).";
+            }
         }
-        else  // Process the filter options.
+        else  // Process the entry.
         {
             // Get the index of the last dollar sign.
-            int indexOfLastDollarSign = filterListString.lastIndexOf(QLatin1Char('$'));
+            int indexOfLastDollarSign = filterListEntryString.lastIndexOf(QLatin1Char('$'));
 
             // Process the filter options if they exist.
             if (indexOfLastDollarSign > -1)
             {
-                // Get the filter options.
-                entryStructPointer->originalFilterOptions = filterListString.section(QLatin1Char('$'), -1);
+                // Store the original filter options.
+                filterListEntryStructPointer->originalFilterOptionsString = filterListEntryString.section(QLatin1Char('$'), -1);
 
                 // Store the entry without the filter options as the filter list string.
-                filterListString.truncate(indexOfLastDollarSign);
+                filterListEntryString.truncate(indexOfLastDollarSign);
 
                 // Split the filter options.
-                QStringList originalFilterOptionsList = entryStructPointer->originalFilterOptions.split(QLatin1Char(','));
-
-                // Create an applied filter options list.
-                QStringList appliedFilterOptionsList;
+                QStringList originalFilterOptionsList = filterListEntryStructPointer->originalFilterOptionsString.split(QLatin1Char(','));
 
                 // Populate the applied filter options list.
-                for (QString filterOption : originalFilterOptionsList)
+                for (QString filterOptionString : originalFilterOptionsList)
                 {
                     // Only add filter options that are handled by Privacy Browser.  <https://help.adblockplus.org/hc/en-us/articles/360062733293-How-to-write-filters>
                     // `csp` specifies a Content Security Policy, which isn't handled by Privacy Browser.
                     // `generichide` isn't implemented by Privacy Browser.
                     // `match-case` isn't currently implemented by Privacy Browser, but it could be if that became important.
                     // `xhr` is probably a misspelling of `xmlhttprequest`.
-                    if (!(filterOption.startsWith(QLatin1String("csp=")) ||
-                          filterOption.startsWith(QLatin1String("method=")) ||
-                          filterOption.startsWith(QLatin1String("redirect=")) ||
-                          filterOption.startsWith(QLatin1String("rewrite=")) ||
-                          (filterOption == (QLatin1String("1p"))) ||
-                          (filterOption == (QLatin1String("elemhide"))) ||
-                          (filterOption == (QLatin1String("genericblock"))) ||
-                          (filterOption == (QLatin1String("generichide"))) ||
-                          (filterOption == (QLatin1String("match-case"))) ||
-                          (filterOption == (QLatin1String("xhr")))))
-                        appliedFilterOptionsList.append(filterOption);
+                    if (!(filterOptionString.startsWith(QLatin1String("csp=")) ||
+                          filterOptionString.startsWith(QLatin1String("method=")) ||
+                          filterOptionString.startsWith(QLatin1String("redirect=")) ||
+                          filterOptionString.startsWith(QLatin1String("rewrite=")) ||
+                          (filterOptionString == (QLatin1String("1p"))) ||
+                          (filterOptionString == (QLatin1String("elemhide"))) ||
+                          (filterOptionString == (QLatin1String("genericblock"))) ||
+                          (filterOptionString == (QLatin1String("generichide"))) ||
+                          (filterOptionString == (QLatin1String("match-case"))) ||
+                          (filterOptionString == (QLatin1String("xhr")))))
+                        // Add the filter option to the applied filter options list.
+                        filterListEntryStructPointer->appliedFilterOptionsList.append(filterOptionString);
                 }
 
-                // Store the applied filter options list.
-                entryStructPointer->appliedFilterOptionsList = appliedFilterOptionsList;
-
                 // Initialize an override struct.
-                OverrideStruct overrideStruct;
+                FilterOptionsOverrideStruct filterOptionsOverrideStruct;
 
                 // Populate the filter options entries.
-                for (QString filterOption : appliedFilterOptionsList)
+                for (QString filterOptionString : filterListEntryStructPointer->appliedFilterOptionsList)
                 {
                     // Parse the filter options.
-                    if (filterOption.startsWith(QLatin1String("domain=")))  // Domain.
+                    if (filterOptionString.startsWith(QLatin1String("domain=")))  // Domain.
                     {
                         // Remove `domain=` from the filter option.
-                        filterOption.remove(0, 7);
-
-                        // Store the domain list.
-                        entryStructPointer->domainList = filterOption.split(QLatin1Char('|'));
+                        filterOptionString.remove(0, 7);
 
-                        // Set the disposition.
-                        if (entryStructPointer->domainList[0].startsWith(QLatin1Char('~')))  // Override domains.
+                        // Set the disposition according to the domain type.
+                        if (filterOptionString.contains(QLatin1Char('~')))  // Override domains.
                         {
-                            // Populate the domain filter disposition.
-                            entryStructPointer->domain = FilterOptionDisposition::Override;
+                            // Remove the tilde from the beginning of each domain.
+                            filterOptionString.remove(QLatin1Char('~'));
 
-                            // Remove the initial `~` from each domain.
-                            entryStructPointer->domainList.replaceInStrings(QLatin1String("~"), QLatin1String(""));
+                            // Populate the domain filter disposition.
+                            filterListEntryStructPointer->domain = FilterOptionDisposition::Override;
                         }
                         else  // Standard domains.
                         {
                             // Populate the domain filter disposition.
-                            entryStructPointer->domain = FilterOptionDisposition::Apply;
+                            filterListEntryStructPointer->domain = FilterOptionDisposition::Apply;
                         }
+
+                        // Store the domain list.
+                        filterListEntryStructPointer->domainList = filterOptionString.split(QLatin1Char('|'));
                     }
-                    else if (filterOption == QLatin1String("third-party"))  // Third-party.
+                    else if (filterOptionString == QLatin1String("third-party"))  // Third-party.
                     {
                         // Populate the third-party filter disposition.
-                        entryStructPointer->thirdParty = FilterOptionDisposition::Apply;
+                        filterListEntryStructPointer->thirdParty = FilterOptionDisposition::Apply;
                     }
-                    else if (filterOption == QLatin1String("~third-party"))  // Third-party override.
+                    else if (filterOptionString == QLatin1String("~third-party"))  // Third-party override.
                     {
                         // Populate the third-party filter disposition.
-                        entryStructPointer->thirdParty = FilterOptionDisposition::Override;
+                        filterListEntryStructPointer->thirdParty = FilterOptionDisposition::Override;
                     }
-                    else if ((filterOption == QLatin1String("document")) || (filterOption == QLatin1String("popup")))  // Document (and popup).
+                    else if ((filterOptionString == QLatin1String("document")) || (filterOptionString == QLatin1String("popup")))  // Document (and popup).
                     {
                         // Populate the main frame disposition.
-                        entryStructPointer->mainFrame = FilterOptionDisposition::Apply;
+                        filterListEntryStructPointer->mainFrame = FilterOptionDisposition::Apply;
 
                         // Set the has request options flag.
-                        entryStructPointer->hasRequestOptions = true;
+                        filterListEntryStructPointer->hasRequestOptions = true;
                     }
-                    else if (filterOption == QLatin1String("font"))  // Font.
+                    else if (filterOptionString == QLatin1String("font"))  // Font.
                     {
                         // Populate the font disposition.
-                        entryStructPointer->font = FilterOptionDisposition::Apply;
+                        filterListEntryStructPointer->font = FilterOptionDisposition::Apply;
 
                         // Set the has request options flag.
-                        entryStructPointer->hasRequestOptions = true;
+                        filterListEntryStructPointer->hasRequestOptions = true;
                     }
-                    else if (filterOption == QLatin1String("image"))  // Image.
+                    else if (filterOptionString == QLatin1String("image"))  // Image.
                     {
                         // Populate the image disposition.
-                        entryStructPointer->image = FilterOptionDisposition::Apply;
+                        filterListEntryStructPointer->image = FilterOptionDisposition::Apply;
 
                         // Set the has request options flag.
-                        entryStructPointer->hasRequestOptions = true;
+                        filterListEntryStructPointer->hasRequestOptions = true;
                     }
-                    else if (filterOption == QLatin1String("media"))  // Media.
+                    else if (filterOptionString == QLatin1String("media"))  // Media.
                     {
                         // Populate the media disposition.
-                        entryStructPointer->media = FilterOptionDisposition::Apply;
+                        filterListEntryStructPointer->media = FilterOptionDisposition::Apply;
 
                         // Set the has request options flag.
-                        entryStructPointer->hasRequestOptions = true;
+                        filterListEntryStructPointer->hasRequestOptions = true;
                     }
-                    else if (filterOption == QLatin1String("object"))  // Object.
+                    else if (filterOptionString == QLatin1String("object"))  // Object.
                     {
                         // Populate the object disposition.
-                        entryStructPointer->object = FilterOptionDisposition::Apply;
+                        filterListEntryStructPointer->object = FilterOptionDisposition::Apply;
 
                         // Set the has request options flag.
-                        entryStructPointer->hasRequestOptions = true;
+                        filterListEntryStructPointer->hasRequestOptions = true;
                     }
-                    else if ((filterOption == QLatin1String("other")) || (filterOption == QLatin1String("webrtc")))  // Other.
+                    else if ((filterOptionString == QLatin1String("other")) || (filterOptionString == QLatin1String("webrtc")))  // Other.
                     {
                         // Populate the other disposition.
-                        entryStructPointer->other = FilterOptionDisposition::Apply;
+                        filterListEntryStructPointer->other = FilterOptionDisposition::Apply;
 
                         // Set the has request options flag.
-                        entryStructPointer->hasRequestOptions = true;
+                        filterListEntryStructPointer->hasRequestOptions = true;
                     }
-                    else if (filterOption == QLatin1String("ping"))  // Ping.
+                    else if (filterOptionString == QLatin1String("ping"))  // Ping.
                     {
                         // Populate the ping disposition.
-                        entryStructPointer->ping = FilterOptionDisposition::Apply;
+                        filterListEntryStructPointer->ping = FilterOptionDisposition::Apply;
 
                         // Set the has request options flag.
-                        entryStructPointer->hasRequestOptions = true;
+                        filterListEntryStructPointer->hasRequestOptions = true;
                     }
-                    else if (filterOption == QLatin1String("script"))  // Script.
+                    else if (filterOptionString == QLatin1String("script"))  // Script.
                     {
                         // Populate the script disposition.
-                        entryStructPointer->script = FilterOptionDisposition::Apply;
+                        filterListEntryStructPointer->script = FilterOptionDisposition::Apply;
 
                         // Set the has request options flag.
-                        entryStructPointer->hasRequestOptions = true;
+                        filterListEntryStructPointer->hasRequestOptions = true;
                     }
-                    else if (filterOption == QLatin1String("stylesheet"))  // Style sheet.
+                    else if (filterOptionString == QLatin1String("stylesheet"))  // Style sheet.
                     {
                         // Populate the script disposition.
-                        entryStructPointer->styleSheet = FilterOptionDisposition::Apply;
+                        filterListEntryStructPointer->styleSheet = FilterOptionDisposition::Apply;
 
                         // Set the has request options flag.
-                        entryStructPointer->hasRequestOptions = true;
+                        filterListEntryStructPointer->hasRequestOptions = true;
                     }
-                    else if (filterOption == QLatin1String("subdocument"))  // Sub document.
+                    else if (filterOptionString == QLatin1String("subdocument"))  // Sub document.
                     {
                         // Populate the sub resource disposition.
-                        entryStructPointer->subFrame = FilterOptionDisposition::Apply;
+                        filterListEntryStructPointer->subFrame = FilterOptionDisposition::Apply;
 
                         // Set the has request options flag.
-                        entryStructPointer->hasRequestOptions = true;
+                        filterListEntryStructPointer->hasRequestOptions = true;
                     }
-                    else if (filterOption == QLatin1String("websocket"))  // Web socket.
+                    else if (filterOptionString == QLatin1String("websocket"))  // Web socket.
                     {
                         // Populate the web socket disposition.
-                        entryStructPointer->webSocket = FilterOptionDisposition::Apply;
+                        filterListEntryStructPointer->webSocket = FilterOptionDisposition::Apply;
 
                         // Set the has request options flag.
-                        entryStructPointer->hasRequestOptions = true;
+                        filterListEntryStructPointer->hasRequestOptions = true;
                     }
-                    else if (filterOption == QLatin1String("xmlhttprequest"))  // XML HTTP request.
+                    else if (filterOptionString == QLatin1String("xmlhttprequest"))  // XML HTTP request.
                     {
                         //Populate the XML HTTP request disposition.
-                        entryStructPointer->xmlHttpRequest = FilterOptionDisposition::Apply;
+                        filterListEntryStructPointer->xmlHttpRequest = FilterOptionDisposition::Apply;
 
                         // Set the has request options flag.
-                        entryStructPointer->hasRequestOptions = true;
+                        filterListEntryStructPointer->hasRequestOptions = true;
                     }
-                    else if (filterOption == QLatin1String("~document"))  // Document override.
+                    else if (filterOptionString == QLatin1String("~document"))  // Document override.
                     {
                         // Populate the override struct.
-                        overrideStruct.hasOverride = true;
-                        overrideStruct.mainFrame = true;
+                        filterOptionsOverrideStruct.hasOverride = true;
+                        filterOptionsOverrideStruct.mainFrame = true;
                     }
-                    else if (filterOption == QLatin1String("~font"))  // Font override.
+                    else if (filterOptionString == QLatin1String("~font"))  // Font override.
                     {
                         // Populate the override struct.
-                        overrideStruct.hasOverride = true;
-                        overrideStruct.font = true;
+                        filterOptionsOverrideStruct.hasOverride = true;
+                        filterOptionsOverrideStruct.font = true;
                     }
-                    else if (filterOption == QLatin1String("~image"))  // Image override.
+                    else if (filterOptionString == QLatin1String("~image"))  // Image override.
                     {
                         // Populate the override struct.
-                        overrideStruct.hasOverride = true;
-                        overrideStruct.image = true;
+                        filterOptionsOverrideStruct.hasOverride = true;
+                        filterOptionsOverrideStruct.image = true;
                     }
-                    else if (filterOption == QLatin1String("~media"))  // Media override.
+                    else if (filterOptionString == QLatin1String("~media"))  // Media override.
                     {
                         // Populate the override struct.
-                        overrideStruct.hasOverride = true;
-                        overrideStruct.media = true;
+                        filterOptionsOverrideStruct.hasOverride = true;
+                        filterOptionsOverrideStruct.media = true;
                     }
-                    else if (filterOption == QLatin1String("~object"))  // Object override.
+                    else if (filterOptionString == QLatin1String("~object"))  // Object override.
                     {
                         // Populate the override struct.
-                        overrideStruct.hasOverride = true;
-                        overrideStruct.object = true;
+                        filterOptionsOverrideStruct.hasOverride = true;
+                        filterOptionsOverrideStruct.object = true;
                     }
-                    else if ((filterOption == QLatin1String("~other")) || (filterOption == QLatin1String("~webrtc")))  // Other override.
+                    else if ((filterOptionString == QLatin1String("~other")) || (filterOptionString == QLatin1String("~webrtc")))  // Other override.
                     {
                         // Populate the override struct.
-                        overrideStruct.hasOverride = true;
-                        overrideStruct.other = true;
+                        filterOptionsOverrideStruct.hasOverride = true;
+                        filterOptionsOverrideStruct.other = true;
                     }
-                    else if (filterOption == QLatin1String("~ping"))  // Ping override.
+                    else if (filterOptionString == QLatin1String("~ping"))  // Ping override.
                     {
                         // Populate the override struct.
-                        overrideStruct.hasOverride = true;
-                        overrideStruct.ping = true;
+                        filterOptionsOverrideStruct.hasOverride = true;
+                        filterOptionsOverrideStruct.ping = true;
                     }
-                    else if (filterOption == QLatin1String("~script"))  // Script override.
+                    else if (filterOptionString == QLatin1String("~script"))  // Script override.
                     {
                         // Populate the override struct.
-                        overrideStruct.hasOverride = true;
-                        overrideStruct.script = true;
+                        filterOptionsOverrideStruct.hasOverride = true;
+                        filterOptionsOverrideStruct.script = true;
                     }
-                    else if (filterOption == QLatin1String("~stylesheet"))  // Style sheet override.
+                    else if (filterOptionString == QLatin1String("~stylesheet"))  // Style sheet override.
                     {
                         // Populate the override struct.
-                        overrideStruct.hasOverride = true;
-                        overrideStruct.styleSheet = true;
+                        filterOptionsOverrideStruct.hasOverride = true;
+                        filterOptionsOverrideStruct.styleSheet = true;
                     }
-                    else if (filterOption == QLatin1String("~subdocument"))  // Sub document override.
+                    else if (filterOptionString == QLatin1String("~subdocument"))  // Sub document override.
                     {
                         // Populate the override struct.
-                        overrideStruct.hasOverride = true;
-                        overrideStruct.subFrame = true;
+                        filterOptionsOverrideStruct.hasOverride = true;
+                        filterOptionsOverrideStruct.subFrame = true;
                     }
-                    else if (filterOption == QLatin1String("~websocket"))  // Web socket override.
+                    else if (filterOptionString == QLatin1String("~websocket"))  // Web socket override.
                     {
                         // Populate the override struct.
-                        overrideStruct.hasOverride = true;
-                        overrideStruct.webSocket = true;
+                        filterOptionsOverrideStruct.hasOverride = true;
+                        filterOptionsOverrideStruct.webSocket = true;
                     }
-                    else if (filterOption == QLatin1String("~xmlhttprequest"))  // XML HTTP request override.
+                    else if (filterOptionString == QLatin1String("~xmlhttprequest"))  // XML HTTP request override.
                     {
                         // Populate the override struct.
-                        overrideStruct.hasOverride = true;
-                        overrideStruct.xmlHttpRequest = true;
+                        filterOptionsOverrideStruct.hasOverride = true;
+                        filterOptionsOverrideStruct.xmlHttpRequest = true;
                     }
                 }
 
                 // Apply the overrides.
-                if (overrideStruct.hasOverride)
+                if (filterOptionsOverrideStruct.hasOverride)
                 {
                     // Set the has request options flag.
-                    entryStructPointer->hasRequestOptions = true;
+                    filterListEntryStructPointer->hasRequestOptions = true;
 
                     // Font.
-                    if (overrideStruct.font)
-                        entryStructPointer->font = FilterOptionDisposition::Override;
+                    if (filterOptionsOverrideStruct.font)
+                        filterListEntryStructPointer->font = FilterOptionDisposition::Override;
                     else
-                        entryStructPointer->font = FilterOptionDisposition::Apply;
+                        filterListEntryStructPointer->font = FilterOptionDisposition::Apply;
 
                     // Image.
-                    if (overrideStruct.image)
-                        entryStructPointer->image = FilterOptionDisposition::Override;
+                    if (filterOptionsOverrideStruct.image)
+                        filterListEntryStructPointer->image = FilterOptionDisposition::Override;
                     else
-                        entryStructPointer->image = FilterOptionDisposition::Apply;
+                        filterListEntryStructPointer->image = FilterOptionDisposition::Apply;
 
                     // Main Frame (document).
-                    if (overrideStruct.mainFrame)
-                        entryStructPointer->mainFrame = FilterOptionDisposition::Override;
+                    if (filterOptionsOverrideStruct.mainFrame)
+                        filterListEntryStructPointer->mainFrame = FilterOptionDisposition::Override;
                     else
-                        entryStructPointer->mainFrame = FilterOptionDisposition::Apply;
+                        filterListEntryStructPointer->mainFrame = FilterOptionDisposition::Apply;
 
                     // Media.
-                    if (overrideStruct.media)
-                        entryStructPointer->media = FilterOptionDisposition::Override;
+                    if (filterOptionsOverrideStruct.media)
+                        filterListEntryStructPointer->media = FilterOptionDisposition::Override;
                     else
-                        entryStructPointer->media = FilterOptionDisposition::Apply;
+                        filterListEntryStructPointer->media = FilterOptionDisposition::Apply;
 
                     // Object.
-                    if (overrideStruct.object)
-                        entryStructPointer->object = FilterOptionDisposition::Override;
+                    if (filterOptionsOverrideStruct.object)
+                        filterListEntryStructPointer->object = FilterOptionDisposition::Override;
                     else
-                        entryStructPointer->object = FilterOptionDisposition::Apply;
+                        filterListEntryStructPointer->object = FilterOptionDisposition::Apply;
 
                     // Other.
-                    if (overrideStruct.other)
-                        entryStructPointer->other = FilterOptionDisposition::Override;
+                    if (filterOptionsOverrideStruct.other)
+                        filterListEntryStructPointer->other = FilterOptionDisposition::Override;
                     else
-                        entryStructPointer->other = FilterOptionDisposition::Apply;
+                        filterListEntryStructPointer->other = FilterOptionDisposition::Apply;
 
                     // Ping.
-                    if (overrideStruct.ping)
-                        entryStructPointer->ping = FilterOptionDisposition::Override;
+                    if (filterOptionsOverrideStruct.ping)
+                        filterListEntryStructPointer->ping = FilterOptionDisposition::Override;
                     else
-                        entryStructPointer->ping = FilterOptionDisposition::Apply;
+                        filterListEntryStructPointer->ping = FilterOptionDisposition::Apply;
 
                     //  Script.
-                    if (overrideStruct.script)
-                        entryStructPointer->script = FilterOptionDisposition::Override;
+                    if (filterOptionsOverrideStruct.script)
+                        filterListEntryStructPointer->script = FilterOptionDisposition::Override;
                     else
-                        entryStructPointer->script = FilterOptionDisposition::Apply;
+                        filterListEntryStructPointer->script = FilterOptionDisposition::Apply;
 
                     // Style Sheet.
-                    if (overrideStruct.styleSheet)
-                        entryStructPointer->styleSheet = FilterOptionDisposition::Override;
+                    if (filterOptionsOverrideStruct.styleSheet)
+                        filterListEntryStructPointer->styleSheet = FilterOptionDisposition::Override;
                     else
-                        entryStructPointer->styleSheet = FilterOptionDisposition::Apply;
+                        filterListEntryStructPointer->styleSheet = FilterOptionDisposition::Apply;
 
                     // Sub Resource.
-                    if (overrideStruct.subFrame)
-                        entryStructPointer->subFrame = FilterOptionDisposition::Override;
+                    if (filterOptionsOverrideStruct.subFrame)
+                        filterListEntryStructPointer->subFrame = FilterOptionDisposition::Override;
                     else
-                        entryStructPointer->subFrame = FilterOptionDisposition::Apply;
+                        filterListEntryStructPointer->subFrame = FilterOptionDisposition::Apply;
 
                     // Web Socket.
-                    if (overrideStruct.webSocket)
-                        entryStructPointer->webSocket = FilterOptionDisposition::Override;
+                    if (filterOptionsOverrideStruct.webSocket)
+                        filterListEntryStructPointer->webSocket = FilterOptionDisposition::Override;
                     else
-                        entryStructPointer->webSocket = FilterOptionDisposition::Apply;
+                        filterListEntryStructPointer->webSocket = FilterOptionDisposition::Apply;
 
                     // XML HTTP Request.
-                    if (overrideStruct.xmlHttpRequest)
-                        entryStructPointer->xmlHttpRequest = FilterOptionDisposition::Override;
+                    if (filterOptionsOverrideStruct.xmlHttpRequest)
+                        filterListEntryStructPointer->xmlHttpRequest = FilterOptionDisposition::Override;
                     else
-                        entryStructPointer->xmlHttpRequest = FilterOptionDisposition::Apply;
+                        filterListEntryStructPointer->xmlHttpRequest = FilterOptionDisposition::Apply;
                 }
             }  // Finish processing filter options.
 
-
-
-            if ((entryStructPointer->originalFilterOptions == QLatin1String("1p")) ||
-                (entryStructPointer->originalFilterOptions == QLatin1String("elemhide")) ||
-                (entryStructPointer->originalFilterOptions == QLatin1String("genericblock")) ||
-                (entryStructPointer->originalFilterOptions == QLatin1String("generichide")) ||
-                (entryStructPointer->originalFilterOptions == QLatin1String("match-case")) ||
-                (entryStructPointer->originalFilterOptions == QLatin1String("xhr")))  // There is a single filter option that Privacy Browser cannot process.
+            // Process the base entry.
+            if ((filterListEntryStructPointer->originalFilterOptionsString.length() > 0) &&
+                !filterListEntryStructPointer->hasRequestOptions &&
+                (filterListEntryStructPointer->domain == FilterOptionDisposition::Null) &&
+                (filterListEntryStructPointer->thirdParty == FilterOptionDisposition::Null))
+                // There were filter options, but they have all been removed because they don't apply to Privacy Browser.
             {
-                // Ignore entries that contain a single, unsupported filter option.  See <https://redmine.stoutner.com/issues/1217>.
-                // `1p` is not an official filter option.
-                // `elemhide` isn't implemented by Privacy Browser.
-                // `genericblock` isn't implemented by Privacy Browser.
-                // `generichide` isn't implemented by Privacy Browser.
-                // `match-case` isn't currently implemented by Privacy Browser, but it could be if that became important.
-                // `xhr` is probably a misspelling of `xmlhttprequest`.
+                // Ignore these entries as they will have unintended consequences.
 
                 // Log the dropping of the entry.
-                //qDebug().noquote().nospace() << "Unsupported filter option:  " << entryStructPointer->originalEntry << " NOT added from " << filterListFileName << ".";
+                //qDebug().noquote().nospace() << "Unsupported filter options:  " << filterListEntryStructPointer->originalEntryString << "  NOT added from  " << filterListFileName << ".";
             }
-            else if (filterListString.isEmpty() && !entryStructPointer->hasRequestOptions)  // There are no applied entries and no request options.
+            else if (filterListEntryString.isEmpty() && !filterListEntryStructPointer->hasRequestOptions)  // There are no applied entries and no request options.
             {
                 // Ignore these entries as they will block all requests generally or for a specified domain.  Typically these are left over after removing `csp=` filter options.
 
                 // Log the dropping of the entry.
-                //qDebug().noquote().nospace() << entryStructPointer->originalEntry << " NOT added from " << filterListFileName << ".";
+                //qDebug().noquote().nospace() << "Nothing left is applied:  " << filterListEntryStructPointer->originalEntryString << "  NOT added from  " << filterListFileName << ".";
             }
-            else if (filterListString.startsWith(QLatin1String("@@")))  // Process an allow list entry.
+            else if (filterListEntryString.startsWith(QLatin1String("@@")))  // Process an allow list entry.
             {
                 // Remove the initial `@@`.
-                filterListString.remove(0, 2);
+                filterListEntryString.remove(0, 2);
 
-                if (filterListString.startsWith(QLatin1String("||")))  // Process an initial domain allow list entry.
+                if (filterListEntryString.startsWith(QLatin1String("||")))  // Process an initial domain allow list entry.
                 {
                     // Remove the initial `||`.
-                    filterListString.remove(0, 2);
+                    filterListEntryString.remove(0, 2);
 
                     // Set the initial match flag.
-                    entryStructPointer->initialMatch = true;
+                    filterListEntryStructPointer->initialMatch = true;
 
                     // Prepare the filter list string.
-                    prepareFilterListString(filterListString, entryStructPointer);
+                    prepareFilterListString(filterListEntryString, filterListEntryStructPointer);
 
                     // Add the entry struct to the initial domain allow list.
-                    filterListStructPointer->initialDomainAllowListPointer->push_front(entryStructPointer);
+                    filterListStructPointer->initialDomainAllowListPointer->push_front(filterListEntryStructPointer);
 
                     // Log the addition to the filter list.
-                    //qDebug().noquote().nospace() << entryStructPointer->originalEntry << " added to Initial Domain Allow List from " << filterListFileName << ".";
+                    //qDebug().noquote().nospace() << filterListEntryStructPointer->originalEntry << " added to Initial Domain Allow List from " << filterListFileName << ".";
                 }
-                else if (filterListString.contains(QLatin1String("\\")))  // Process a regular expression allow list entry.
+                else if (filterListEntryString.contains(QLatin1String("\\")))  // Process a regular expression allow list entry.
                 {
                     // Add the regular expression to the applied entry list.
-                    entryStructPointer->appliedEntryList.append(filterListString);
+                    filterListEntryStructPointer->appliedEntryList.append(filterListEntryString);
 
                     // Add the entry struct to the regular expression allow list.
-                    filterListStructPointer->regularExpressionAllowListPointer->push_front(entryStructPointer);
+                    filterListStructPointer->regularExpressionAllowListPointer->push_front(filterListEntryStructPointer);
+
+                    // Log the addition to the filter list.
+                    //qDebug().noquote().nospace() << filterListEntryStructPointer->originalEntry << " added to Regular Expression Allow List from " << filterListFileName << ".";
                 }
                 else  // Process a main allow list entry.
                 {
                     // Prepare the filter list string.
-                    prepareFilterListString(filterListString, entryStructPointer);
+                    prepareFilterListString(filterListEntryString, filterListEntryStructPointer);
 
                     // Add the entry struct to the main allow list.
-                    filterListStructPointer->mainAllowListPointer->push_front(entryStructPointer);
+                    filterListStructPointer->mainAllowListPointer->push_front(filterListEntryStructPointer);
 
                     // Log the addition to the filter list.
-                    //qDebug().noquote().nospace() << entryStructPointer->originalEntry << " added to Main Allow List from " << filterListFileName << ".";
+                    //qDebug().noquote().nospace() << filterListEntryStructPointer->originalEntry << " added to Main Allow List from " << filterListFileName << ".";
                 }
             }
-            else if (filterListString.startsWith(QLatin1String("||")))  // Process an initial domain block list entry.
+            else if (filterListEntryString.startsWith(QLatin1String("||")))  // Process an initial domain block list entry.
             {
                 // Remove the initial `||`.
-                filterListString.remove(0, 2);
+                filterListEntryString.remove(0, 2);
 
                 // Set the initial match flag.
-                entryStructPointer->initialMatch = true;
+                filterListEntryStructPointer->initialMatch = true;
 
                 // Prepare the filter list string.
-                prepareFilterListString(filterListString, entryStructPointer);
+                prepareFilterListString(filterListEntryString, filterListEntryStructPointer);
 
                 // Add the entry struct to the initial domain block list.
-                filterListStructPointer->initialDomainBlockListPointer->push_front(entryStructPointer);
+                filterListStructPointer->initialDomainBlockListPointer->push_front(filterListEntryStructPointer);
 
                 // Log the addition to the filter list.
-                //qDebug().noquote().nospace() << entryStructPointer->originalEntry << " added to Initial Domain Block List from " << filterListFileName << ".";
+                //qDebug().noquote().nospace() << filterListEntryStructPointer->originalEntryString << " added to Initial Domain Block List from " << filterListFileName << ".";
             }
-            else if (filterListString.contains(QLatin1String("\\")))  // Process a regular expression block list entry.
+            else if (filterListEntryString.contains(QLatin1String("\\")))  // Process a regular expression block list entry.
             {
                 // Add the regular expression to the applied entry list.
-                entryStructPointer->appliedEntryList.append(filterListString);
+                filterListEntryStructPointer->appliedEntryList.append(filterListEntryString);
 
                 // Add the entry struct to the regular expression block list.
-                filterListStructPointer->regularExpressionBlockListPointer->push_front(entryStructPointer);
+                filterListStructPointer->regularExpressionBlockListPointer->push_front(filterListEntryStructPointer);
+
+                // Log the addition to the filter list.
+                //qDebug().noquote().nospace() << filterListEntryStructPointer->originalEntryString << " added to Regular Expression Block List from " << filterListFileName << ".";
             }
             else  // Process a main block list entry.
             {
                 // Prepare the filter list string.
-                prepareFilterListString(filterListString, entryStructPointer);
+                prepareFilterListString(filterListEntryString, filterListEntryStructPointer);
 
                 // Add the entry struct to the main block list.
-                filterListStructPointer->mainBlockListPointer->push_front(entryStructPointer);
+                filterListStructPointer->mainBlockListPointer->push_front(filterListEntryStructPointer);
 
                 // Log the addition to the filter list.
-                //qDebug().noquote().nospace() << entryStructPointer->originalEntry << " added to Main Block List from " << filterListFileName << ".";
+                //qDebug().noquote().nospace() << filterListEntryStructPointer->originalEntry << " added to Main Block List from " << filterListFileName << ".";
             }
         }
     }
     // Close the filter list file.
     filterListFile.close();
 
-    // Return the filter list pair.
+    // Return the filter list struct pointer.
     return filterListStructPointer;
 }
 
-void FilterListHelper::prepareFilterListString(QString &filterListString, EntryStruct *entryStructPointer) const
+void FilterListHelper::prepareFilterListString(QString &filterListEntryString, FilterListEntryStruct *filterListEntryStructPointer) const
 {
     // Check if this is an initial match.
-    if (filterListString.startsWith(QLatin1Char('|')))
+    if (filterListEntryString.startsWith(QLatin1Char('|')))
     {
         // Strip the initial `|`.
-        filterListString.remove(0, 1);
+        filterListEntryString.remove(0, 1);
 
         // Set the initial match flag.
-        entryStructPointer->initialMatch = true;
+        filterListEntryStructPointer->initialMatch = true;
     }
 
     // Check if this is a final match.
-    if (filterListString.endsWith(QLatin1Char('|')))
+    if (filterListEntryString.endsWith(QLatin1Char('|')))
     {
         // Strip the final `|`.
-        filterListString.chop(1);
+        filterListEntryString.chop(1);
 
         // Set the final match flag.
-        entryStructPointer->finalMatch = true;
+        filterListEntryStructPointer->finalMatch = true;
     }
 
     // Remove the initial asterisk if it exists.
-    if (filterListString.startsWith(QLatin1Char('*')))
-        filterListString.remove(0, 1);
+    if (filterListEntryString.startsWith(QLatin1Char('*')))
+        filterListEntryString.remove(0, 1);
 
     // Remove the final asterisk if it exists.
-    if (filterListString.endsWith(QLatin1Char('*')))
-        filterListString.chop(1);
+    if (filterListEntryString.endsWith(QLatin1Char('*')))
+        filterListEntryString.chop(1);
 
-    // Split the filter list string and set it as the applied entry list.
-    entryStructPointer->appliedEntryList = filterListString.split(QLatin1Char('*'));
+    // Split the filter list entry string and set it as the applied entry list.
+    filterListEntryStructPointer->appliedEntryList = filterListEntryString.split(QLatin1Char('*'));
 
     // Store the size of the applied entry list.
-    entryStructPointer->sizeOfAppliedEntryList = entryStructPointer->appliedEntryList.size();
+    filterListEntryStructPointer->sizeOfAppliedEntryList = filterListEntryStructPointer->appliedEntryList.size();
 
     // Determine if this is a single applied entry (including an empty entry).
-    entryStructPointer->singleAppliedEntry = (entryStructPointer->sizeOfAppliedEntryList == 1);
+    filterListEntryStructPointer->singleAppliedEntry = (filterListEntryStructPointer->sizeOfAppliedEntryList == 1);
 }