switch from Invariant culture to Ordinal culture for Registry States and Environment Variables

tomysshadow · tomysshadow · commit d090c9b0ea7d · 2023-01-09T18:14:48.000-07:00
diff --git a/FlashpointSecurePlayer/CustomSecurityManager.cs b/FlashpointSecurePlayer/CustomSecurityManager.cs
@@ -153,7 +153,7 @@ int InternetInterfaces.IInternetSecurityManager.ProcessUrlAction([MarshalAs(Unma
                     string extension = Path.GetExtension(flashpointURI.LocalPath);
 
                     if (extension != null) {
-                        if (extension.Equals(FLASH_EXTENSION, StringComparison.InvariantCultureIgnoreCase)) {
+                        if (extension.Equals(FLASH_EXTENSION, StringComparison.OrdinalIgnoreCase)) {
                             if (dwAction == URLACTION_ACTIVEX_TREATASUNTRUSTED) {
                                 pPolicy = URLPOLICY_ALLOW;
                                 return S_OK;
diff --git a/FlashpointSecurePlayer/EnvironmentVariables.cs b/FlashpointSecurePlayer/EnvironmentVariables.cs
@@ -43,7 +43,7 @@ private string GetValue(EnvironmentVariablesElement environmentVariablesElement)
             string comparableName = GetComparableName(environmentVariablesElement.Name);
 
             if (comparableName != null) {
-                if (comparableName.Equals(__COMPAT_LAYER, StringComparison.InvariantCultureIgnoreCase)) {
+                if (comparableName.Equals(__COMPAT_LAYER, StringComparison.OrdinalIgnoreCase)) {
                     throw new InvalidEnvironmentVariablesException("Find and replace with the \"" + __COMPAT_LAYER + "\" Environment Variable is not supported.");
                 }
             }
@@ -138,7 +138,7 @@ private string GetValue(EnvironmentVariablesElement environmentVariablesElement)
                         comparableName = GetComparableName(environmentVariablesElement.Name);
 
                         if (comparableName != null) {
-                            if (UnmodifiableComparableNames.Contains(comparableName, StringComparer.InvariantCultureIgnoreCase)) {
+                            if (UnmodifiableComparableNames.Contains(comparableName, StringComparer.OrdinalIgnoreCase)) {
                                 throw new InvalidEnvironmentVariablesException("The \"" + environmentVariablesElement.Name + "\" Environment Variable cannot be modified while creating the Active Environment Variables Element.");
                             }
                         }
@@ -172,7 +172,7 @@ private string GetValue(EnvironmentVariablesElement environmentVariablesElement)
                         comparableName = GetComparableName(environmentVariablesElement.Name);
 
                         if (comparableName != null) {
-                            if (UnmodifiableComparableNames.Contains(comparableName, StringComparer.InvariantCultureIgnoreCase)) {
+                            if (UnmodifiableComparableNames.Contains(comparableName, StringComparer.OrdinalIgnoreCase)) {
                                 throw new InvalidEnvironmentVariablesException("The \"" + environmentVariablesElement.Name + "\" Environment Variable cannot be modified at this time.");
                             }
                         }
@@ -189,7 +189,7 @@ private string GetValue(EnvironmentVariablesElement environmentVariablesElement)
 
                         // now throw up a restart in Web Browser Mode for Compatibility Settings
                         if (comparableName != null) {
-                            if (comparableName.Equals(__COMPAT_LAYER, StringComparison.InvariantCultureIgnoreCase)
+                            if (comparableName.Equals(__COMPAT_LAYER, StringComparison.OrdinalIgnoreCase)
                                 && modeElement.Name == ModeElement.NAME.WEB_BROWSER) {
                                 values = new List<string>();
 
@@ -206,7 +206,7 @@ private string GetValue(EnvironmentVariablesElement environmentVariablesElement)
                                 // we have to restart in this case in server mode
                                 // because the compatibility layers only take effect
                                 // on process start
-                                if (values.Except(compatibilityLayerValues, StringComparer.InvariantCultureIgnoreCase).Any()) {
+                                if (values.Except(compatibilityLayerValues, StringComparer.OrdinalIgnoreCase).Any()) {
                                     throw new CompatibilityLayersException("The Compatibility Layers (" + value + ") require a restart to be set.");
                                 }
                             }
@@ -308,7 +308,7 @@ public void Deactivate(MODIFICATIONS_REVERT_METHOD modificationsRevertMethod = M
                             comparableName = GetComparableName(activeEnvironmentVariablesElement.Name);
 
                             if (comparableName != null) {
-                                if (UnmodifiableComparableNames.Contains(comparableName, StringComparer.InvariantCultureIgnoreCase)) {
+                                if (UnmodifiableComparableNames.Contains(comparableName, StringComparer.OrdinalIgnoreCase)) {
                                     throw new InvalidEnvironmentVariablesException("The \"" + activeEnvironmentVariablesElement.Name + "\" Environment Variable cannot be modified at this time.");
                                 }
                             }
@@ -331,8 +331,8 @@ public void Deactivate(MODIFICATIONS_REVERT_METHOD modificationsRevertMethod = M
                             } else {
                                 // don't reset Compatibility Settings if we're restarting for Web Browser Mode
                                 if (comparableName != null) {
-                                    if (comparableName.Equals(__COMPAT_LAYER, StringComparison.InvariantCultureIgnoreCase)
-                                        || values.Except(compatibilityLayerValues, StringComparer.InvariantCultureIgnoreCase).Any()
+                                    if (comparableName.Equals(__COMPAT_LAYER, StringComparison.OrdinalIgnoreCase)
+                                        || values.Except(compatibilityLayerValues, StringComparer.OrdinalIgnoreCase).Any()
                                         || modeElement.Name != ModeElement.NAME.WEB_BROWSER) {
                                         try {
                                             Environment.SetEnvironmentVariable(activeEnvironmentVariablesElement.Name, activeEnvironmentVariablesElement.Value, EnvironmentVariableTarget.Process);
diff --git a/FlashpointSecurePlayer/FlashpointSecurePlayerGUI.cs b/FlashpointSecurePlayer/FlashpointSecurePlayerGUI.cs
@@ -121,7 +121,7 @@ private void ShowNoGameSelected() {
             }
 
             if (parentProcessFileName == null
-                || !parentProcessFileName.Equals(FLASHPOINT_LAUNCHER_PARENT_PROCESS_FILE_NAME, StringComparison.InvariantCultureIgnoreCase)) {
+                || !parentProcessFileName.Equals(FLASHPOINT_LAUNCHER_PARENT_PROCESS_FILE_NAME, StringComparison.OrdinalIgnoreCase)) {
                 text += " " + Properties.Resources.UseFlashpointLauncher;
                 Process[] processesByName;
 
@@ -247,7 +247,7 @@ private void AskLaunchWithOldCPUSimulator() {
             }
 
             if (parentProcessFileName != null) {
-                if (parentProcessFileName.Equals(OLD_CPU_SIMULATOR_PARENT_PROCESS_FILE_NAME, StringComparison.InvariantCultureIgnoreCase)) {
+                if (parentProcessFileName.Equals(OLD_CPU_SIMULATOR_PARENT_PROCESS_FILE_NAME, StringComparison.OrdinalIgnoreCase)) {
                     return;
                 }
             }
@@ -1325,7 +1325,7 @@ await ImportActiveX(delegate (string text) {
                         try {
                             // ignore host if going through localhost (no proxy)
                             if (requestUri != null) {
-                                if (!requestUri.Host.Equals("localhost", StringComparison.InvariantCultureIgnoreCase)) {
+                                if (!requestUri.Host.Equals("localhost", StringComparison.OrdinalIgnoreCase)) {
                                     htdocsFilePath.Append("\\");
                                     htdocsFilePath.Append(requestUri.Host);
                                 }
diff --git a/FlashpointSecurePlayer/OldCPUSimulator.cs b/FlashpointSecurePlayer/OldCPUSimulator.cs
@@ -41,7 +41,7 @@ public bool TestRunningWithOldCPUSimulator() {
             }
 
             if (parentProcessFileName != null) {
-                if (parentProcessFileName.Equals(OLD_CPU_SIMULATOR_PARENT_PROCESS_FILE_NAME, StringComparison.InvariantCultureIgnoreCase)) {
+                if (parentProcessFileName.Equals(OLD_CPU_SIMULATOR_PARENT_PROCESS_FILE_NAME, StringComparison.OrdinalIgnoreCase)) {
                     return true;
                 }
             }
diff --git a/FlashpointSecurePlayer/RegistryStates.cs b/FlashpointSecurePlayer/RegistryStates.cs
@@ -215,10 +215,10 @@ private string GetUserKeyValueName(string keyValueName, string activeCurrentUser
 
             string keyValueNameCurrentUser = "HKEY_USERS\\" + (String.IsNullOrEmpty(activeCurrentUser) ? WindowsIdentity.GetCurrent().User.Value : activeCurrentUser) + "\\";
 
-            if (keyValueName.StartsWith(HKEY_CURRENT_USER, StringComparison.InvariantCultureIgnoreCase)) {
+            if (keyValueName.StartsWith(HKEY_CURRENT_USER, StringComparison.OrdinalIgnoreCase)) {
                 // make this explicit in case this is a shared computer
                 keyValueName = keyValueNameCurrentUser + keyValueName.Substring(HKEY_CURRENT_USER.Length);
-            } else if (keyValueName.StartsWith(HKEY_LOCAL_MACHINE, StringComparison.InvariantCultureIgnoreCase)) {
+            } else if (keyValueName.StartsWith(HKEY_LOCAL_MACHINE, StringComparison.OrdinalIgnoreCase)) {
                 if (!activeAdministrator || !TestLaunchedAsAdministratorUser()) {
                     // if activeAdministrator is false, we use HKEY_USERS anyway
                     // because the registry state was created as a non-admin
@@ -241,24 +241,24 @@ private string GetKeyValueNameFromKernelRegistryString(string kernelRegistryStri
             string keyValueName = String.Empty;
             kernelRegistryString = AddTrailingSlash(kernelRegistryString);
 
-            if (kernelRegistryString.StartsWith(REGISTRY_MACHINE, StringComparison.InvariantCultureIgnoreCase)) {
+            if (kernelRegistryString.StartsWith(REGISTRY_MACHINE, StringComparison.OrdinalIgnoreCase)) {
                 keyValueName = "HKEY_LOCAL_MACHINE\\" + kernelRegistryString.Substring(REGISTRY_MACHINE.Length);
             } else {
                 const string REGISTRY_USER = "\\REGISTRY\\USER\\";
 
-                if (kernelRegistryString.StartsWith(REGISTRY_USER, StringComparison.InvariantCultureIgnoreCase)) {
+                if (kernelRegistryString.StartsWith(REGISTRY_USER, StringComparison.OrdinalIgnoreCase)) {
                     const string HKEY_USERS = "HKEY_USERS\\";
 
                     keyValueName = HKEY_USERS + kernelRegistryString.Substring(REGISTRY_USER.Length);
                     string currentUser = WindowsIdentity.GetCurrent().User.Value;
                     string keyValueNameCurrentUser = HKEY_USERS + currentUser + "_CLASSES\\";
 
-                    if (keyValueName.StartsWith(keyValueNameCurrentUser, StringComparison.InvariantCultureIgnoreCase)) {
+                    if (keyValueName.StartsWith(keyValueNameCurrentUser, StringComparison.OrdinalIgnoreCase)) {
                         keyValueName = "HKEY_CURRENT_USER\\SOFTWARE\\CLASSES\\" + keyValueName.Substring(keyValueNameCurrentUser.Length);
                     } else {
                         keyValueNameCurrentUser = HKEY_USERS + currentUser + "\\";
 
-                        if (keyValueName.StartsWith(keyValueNameCurrentUser, StringComparison.InvariantCultureIgnoreCase)) {
+                        if (keyValueName.StartsWith(keyValueNameCurrentUser, StringComparison.OrdinalIgnoreCase)) {
                             keyValueName = "HKEY_CURRENT_USER\\" + keyValueName.Substring(keyValueNameCurrentUser.Length);
                         }
                     }
@@ -278,19 +278,19 @@ private RegistryKey OpenBaseKeyInRegistryView(string keyName, RegistryView regis
 
             RegistryHive? registryHive = null;
 
-            if (keyName.StartsWith("HKEY_CURRENT_USER\\", StringComparison.InvariantCultureIgnoreCase)) {
+            if (keyName.StartsWith("HKEY_CURRENT_USER\\", StringComparison.OrdinalIgnoreCase)) {
                 registryHive = RegistryHive.CurrentUser;
-            } else if (keyName.StartsWith("HKEY_LOCAL_MACHINE\\", StringComparison.InvariantCultureIgnoreCase)) {
+            } else if (keyName.StartsWith("HKEY_LOCAL_MACHINE\\", StringComparison.OrdinalIgnoreCase)) {
                 registryHive = RegistryHive.LocalMachine;
-            } else if (keyName.StartsWith("HKEY_CLASSES_ROOT\\", StringComparison.InvariantCultureIgnoreCase)) {
+            } else if (keyName.StartsWith("HKEY_CLASSES_ROOT\\", StringComparison.OrdinalIgnoreCase)) {
                 registryHive = RegistryHive.ClassesRoot;
-            } else if (keyName.StartsWith("HKEY_USERS\\", StringComparison.InvariantCultureIgnoreCase)) {
+            } else if (keyName.StartsWith("HKEY_USERS\\", StringComparison.OrdinalIgnoreCase)) {
                 registryHive = RegistryHive.Users;
-            } else if (keyName.StartsWith("HKEY_PERFORMANCE_DATA\\", StringComparison.InvariantCultureIgnoreCase)) {
+            } else if (keyName.StartsWith("HKEY_PERFORMANCE_DATA\\", StringComparison.OrdinalIgnoreCase)) {
                 registryHive = RegistryHive.PerformanceData;
-            } else if (keyName.StartsWith("HKEY_CURRENT_CONFIG\\", StringComparison.InvariantCultureIgnoreCase)) {
+            } else if (keyName.StartsWith("HKEY_CURRENT_CONFIG\\", StringComparison.OrdinalIgnoreCase)) {
                 registryHive = RegistryHive.CurrentConfig;
-            } else if (keyName.StartsWith("HKEY_DYN_DATA\\", StringComparison.InvariantCultureIgnoreCase)) {
+            } else if (keyName.StartsWith("HKEY_DYN_DATA\\", StringComparison.OrdinalIgnoreCase)) {
                 registryHive = RegistryHive.DynData;
             }
             
@@ -601,7 +601,7 @@ private string GetRedirectedKeyValueName(string keyValueName, BINARY_TYPE binary
                 bool removeWOW64Subkey = false;
 
                 for (int i = 0;i < wow64KeyList.Count;i++) {
-                    if (wow64KeyName.StartsWith(wow64KeyList[i].Name + "\\", StringComparison.InvariantCultureIgnoreCase)) {
+                    if (wow64KeyName.StartsWith(wow64KeyList[i].Name + "\\", StringComparison.OrdinalIgnoreCase)) {
                         effect = wow64KeyList[i].Effect;
                         effectExceptionValueNames = wow64KeyList[i].EffectExceptionValueNames;
 
@@ -1323,7 +1323,7 @@ private void GotValue(RegistryTraceData registryTraceData) {
                 && (registryTraceData.ProcessID == Process.GetCurrentProcess().Id
                 || registryTraceData.ProcessID == -1)) {
                 if (ImportPaused) {
-                    if (registryTraceData.ValueName.Equals(IMPORT_RESUME, StringComparison.InvariantCultureIgnoreCase)) {
+                    if (registryTraceData.ValueName.Equals(IMPORT_RESUME, StringComparison.OrdinalIgnoreCase)) {
                         ImportPaused = false;
                         // hold here until after the control has installed
                         // that way we can recieve registry messages as they come in
@@ -1332,7 +1332,7 @@ private void GotValue(RegistryTraceData registryTraceData) {
                         resumeEventWaitHandle.WaitOne();
                     }
                 } else {
-                    if (registryTraceData.ValueName.Equals(IMPORT_PAUSE, StringComparison.InvariantCultureIgnoreCase)) {
+                    if (registryTraceData.ValueName.Equals(IMPORT_PAUSE, StringComparison.OrdinalIgnoreCase)) {
                         ImportPaused = true;
                     }
                 }
diff --git a/FlashpointSecurePlayer/Shared.cs b/FlashpointSecurePlayer/Shared.cs
@@ -2159,7 +2159,7 @@ private static Configuration GetEXEConfiguration(bool create, string name) {
 
             // caching...
             if (!String.IsNullOrEmpty(name)) {
-                if (name.Equals(EXEConfigurationName, StringComparison.InvariantCultureIgnoreCase)) {
+                if (name.Equals(EXEConfigurationName, StringComparison.OrdinalIgnoreCase)) {
                     return EXEConfiguration;
                 }
             }
@@ -2246,7 +2246,7 @@ public static FlashpointSecurePlayerSection GetFlashpointSecurePlayerSection(boo
                 string name = GetValidEXEConfigurationName(exeConfigurationName);
 
                 if (!String.IsNullOrEmpty(name) && Shared.flashpointSecurePlayerSection != null) {
-                    if (name.Equals(EXEConfigurationName, StringComparison.InvariantCultureIgnoreCase)) {
+                    if (name.Equals(EXEConfigurationName, StringComparison.OrdinalIgnoreCase)) {
                         return Shared.flashpointSecurePlayerSection;
                     }
                 }
@@ -2664,8 +2664,10 @@ public static string AddLeadingSlash(string path) {
                 return path;
             }
 
-            if (path.Length > 0 && path.Substring(0, 1) != "\\") {
-                path = "\\" + path;
+            const string SLASH = "\\";
+
+            if (!path.StartsWith(SLASH, StringComparison.Ordinal)) {
+                path = path.Insert(0, SLASH);
             }
             return path;
         }
@@ -2676,12 +2678,13 @@ public static string RemoveLeadingSlash(string path) {
                 return path;
             }
 
-            const int INDEX = 1;
+            const string SLASH = "\\";
 
-            while (path.Length > 0 && path.Substring(0, INDEX) == "\\") {
-                path = path.Substring(INDEX);
+            while (path.StartsWith(SLASH, StringComparison.Ordinal)) {
+                path = path.Substring(SLASH.Length);
             }
             return path;
+            //return path.TrimStart('\\');
         }
         */
 
@@ -2691,8 +2694,10 @@ public static string AddTrailingSlash(string path) {
                 return path;
             }
 
-            if (path.Length > 0 && path.Substring(path.Length - 1) != "\\") {
-                path = path + "\\";
+            const string SLASH = "\\";
+
+            if (!path.EndsWith(SLASH, StringComparison.Ordinal)) {
+                path = path.Insert(path.Length, SLASH);
             }
             return path;
         }
@@ -2703,12 +2708,13 @@ public static string RemoveTrailingSlash(string path) {
                 return path;
             }
 
-            int index = path.Length - 1;
+            const string SLASH = "\\";
 
-            while (path.Length > 0 && path.Substring(index) == "\\") {
-                path = path.Substring(0, index);
+            while (path.EndsWith(SLASH, StringComparison.Ordinal)) {
+                path = path.Remove(path.Length - SLASH.Length);
             }
             return path;
+            //return path.TrimEnd('\\');
         }
 
         public static object LengthenValue(object value, string path) {
@@ -2737,7 +2743,7 @@ public static object LengthenValue(object value, string path) {
             }
 
             // if the value is a short value...
-            if (!valueString.StartsWith(shortPathName, StringComparison.InvariantCultureIgnoreCase)) {
+            if (!valueString.StartsWith(shortPathName, StringComparison.OrdinalIgnoreCase)) {
                 return value;
             }
 
@@ -2775,13 +2781,13 @@ public static object ReplaceStartupPathEnvironmentVariable(object lengthenedValu
 
             longStartupPathName = RemoveTrailingSlash(longStartupPathName);
 
-            if (lengthenedValueString.Equals(longStartupPathName, StringComparison.InvariantCultureIgnoreCase)) {
+            if (lengthenedValueString.Equals(longStartupPathName, StringComparison.OrdinalIgnoreCase)) {
                 return "%" + FP_STARTUP_PATH + "%";
             }
 
             longStartupPathName = AddTrailingSlash(longStartupPathName);
 
-            if (lengthenedValueString.StartsWith(longStartupPathName, StringComparison.InvariantCultureIgnoreCase)) {
+            if (lengthenedValueString.StartsWith(longStartupPathName, StringComparison.OrdinalIgnoreCase)) {
                 return "%" + FP_STARTUP_PATH + "%\\" + lengthenedValueString.Substring(longStartupPathName.Length);
             }
             return lengthenedValue;

Original file line number	Diff line number	Diff line change
`@@ -43,7 +43,7 @@ private string GetValue(EnvironmentVariablesElement environmentVariablesElement)`
`43`	`43`	`string comparableName = GetComparableName(environmentVariablesElement.Name);`
`44`	`44`
`45`	`45`	`if (comparableName != null) {`
`46`		`- if (comparableName.Equals(__COMPAT_LAYER, StringComparison.InvariantCultureIgnoreCase)) {`
	`46`	`+ if (comparableName.Equals(__COMPAT_LAYER, StringComparison.OrdinalIgnoreCase)) {`
`47`	`47`	`throw new InvalidEnvironmentVariablesException("Find and replace with the \"" + __COMPAT_LAYER + "\" Environment Variable is not supported.");`
`48`	`48`	`}`
`49`	`49`	`}`
`@@ -138,7 +138,7 @@ private string GetValue(EnvironmentVariablesElement environmentVariablesElement)`
`138`	`138`	`comparableName = GetComparableName(environmentVariablesElement.Name);`
`139`	`139`
`140`	`140`	`if (comparableName != null) {`
`141`		`- if (UnmodifiableComparableNames.Contains(comparableName, StringComparer.InvariantCultureIgnoreCase)) {`
	`141`	`+ if (UnmodifiableComparableNames.Contains(comparableName, StringComparer.OrdinalIgnoreCase)) {`
`142`	`142`	`throw new InvalidEnvironmentVariablesException("The \"" + environmentVariablesElement.Name + "\" Environment Variable cannot be modified while creating the Active Environment Variables Element.");`
`143`	`143`	`}`
`144`	`144`	`}`
`@@ -172,7 +172,7 @@ private string GetValue(EnvironmentVariablesElement environmentVariablesElement)`
`172`	`172`	`comparableName = GetComparableName(environmentVariablesElement.Name);`
`173`	`173`
`174`	`174`	`if (comparableName != null) {`
`175`		`- if (UnmodifiableComparableNames.Contains(comparableName, StringComparer.InvariantCultureIgnoreCase)) {`
	`175`	`+ if (UnmodifiableComparableNames.Contains(comparableName, StringComparer.OrdinalIgnoreCase)) {`
`176`	`176`	`throw new InvalidEnvironmentVariablesException("The \"" + environmentVariablesElement.Name + "\" Environment Variable cannot be modified at this time.");`
`177`	`177`	`}`
`178`	`178`	`}`
`@@ -189,7 +189,7 @@ private string GetValue(EnvironmentVariablesElement environmentVariablesElement)`
`189`	`189`
`190`	`190`	`// now throw up a restart in Web Browser Mode for Compatibility Settings`
`191`	`191`	`if (comparableName != null) {`
`192`		`- if (comparableName.Equals(__COMPAT_LAYER, StringComparison.InvariantCultureIgnoreCase)`
	`192`	`+ if (comparableName.Equals(__COMPAT_LAYER, StringComparison.OrdinalIgnoreCase)`
`193`	`193`	`&& modeElement.Name == ModeElement.NAME.WEB_BROWSER) {`
`194`	`194`	`values = new List<string>();`
`195`	`195`
`@@ -206,7 +206,7 @@ private string GetValue(EnvironmentVariablesElement environmentVariablesElement)`
`206`	`206`	`// we have to restart in this case in server mode`
`207`	`207`	`// because the compatibility layers only take effect`
`208`	`208`	`// on process start`
`209`		`- if (values.Except(compatibilityLayerValues, StringComparer.InvariantCultureIgnoreCase).Any()) {`
	`209`	`+ if (values.Except(compatibilityLayerValues, StringComparer.OrdinalIgnoreCase).Any()) {`
`210`	`210`	`throw new CompatibilityLayersException("The Compatibility Layers (" + value + ") require a restart to be set.");`
`211`	`211`	`}`
`212`	`212`	`}`
`@@ -308,7 +308,7 @@ public void Deactivate(MODIFICATIONS_REVERT_METHOD modificationsRevertMethod = M`
`308`	`308`	`comparableName = GetComparableName(activeEnvironmentVariablesElement.Name);`
`309`	`309`
`310`	`310`	`if (comparableName != null) {`
`311`		`- if (UnmodifiableComparableNames.Contains(comparableName, StringComparer.InvariantCultureIgnoreCase)) {`
	`311`	`+ if (UnmodifiableComparableNames.Contains(comparableName, StringComparer.OrdinalIgnoreCase)) {`
`312`	`312`	`throw new InvalidEnvironmentVariablesException("The \"" + activeEnvironmentVariablesElement.Name + "\" Environment Variable cannot be modified at this time.");`
`313`	`313`	`}`
`314`	`314`	`}`
`@@ -331,8 +331,8 @@ public void Deactivate(MODIFICATIONS_REVERT_METHOD modificationsRevertMethod = M`
`331`	`331`	`} else {`
`332`	`332`	`// don't reset Compatibility Settings if we're restarting for Web Browser Mode`
`333`	`333`	`if (comparableName != null) {`
`334`		`- if (comparableName.Equals(__COMPAT_LAYER, StringComparison.InvariantCultureIgnoreCase)`
`335`		`- \|\| values.Except(compatibilityLayerValues, StringComparer.InvariantCultureIgnoreCase).Any()`
	`334`	`+ if (comparableName.Equals(__COMPAT_LAYER, StringComparison.OrdinalIgnoreCase)`
	`335`	`+ \|\| values.Except(compatibilityLayerValues, StringComparer.OrdinalIgnoreCase).Any()`
`336`	`336`	`\|\| modeElement.Name != ModeElement.NAME.WEB_BROWSER) {`
`337`	`337`	`try {`
`338`	`338`	`Environment.SetEnvironmentVariable(activeEnvironmentVariablesElement.Name, activeEnvironmentVariablesElement.Value, EnvironmentVariableTarget.Process);`
Original file line number	Diff line number	Diff line change
`@@ -121,7 +121,7 @@ private void ShowNoGameSelected() {`
`121`	`121`	`}`
`122`	`122`
`123`	`123`	`if (parentProcessFileName == null`
`124`		`- \|\| !parentProcessFileName.Equals(FLASHPOINT_LAUNCHER_PARENT_PROCESS_FILE_NAME, StringComparison.InvariantCultureIgnoreCase)) {`
	`124`	`+ \|\| !parentProcessFileName.Equals(FLASHPOINT_LAUNCHER_PARENT_PROCESS_FILE_NAME, StringComparison.OrdinalIgnoreCase)) {`
`125`	`125`	`text += " " + Properties.Resources.UseFlashpointLauncher;`
`126`	`126`	`Process[] processesByName;`
`127`	`127`
`@@ -247,7 +247,7 @@ private void AskLaunchWithOldCPUSimulator() {`
`247`	`247`	`}`
`248`	`248`
`249`	`249`	`if (parentProcessFileName != null) {`
`250`		`- if (parentProcessFileName.Equals(OLD_CPU_SIMULATOR_PARENT_PROCESS_FILE_NAME, StringComparison.InvariantCultureIgnoreCase)) {`
	`250`	`+ if (parentProcessFileName.Equals(OLD_CPU_SIMULATOR_PARENT_PROCESS_FILE_NAME, StringComparison.OrdinalIgnoreCase)) {`
`251`	`251`	`return;`
`252`	`252`	`}`
`253`	`253`	`}`
`@@ -1325,7 +1325,7 @@ await ImportActiveX(delegate (string text) {`
`1325`	`1325`	`try {`
`1326`	`1326`	`// ignore host if going through localhost (no proxy)`
`1327`	`1327`	`if (requestUri != null) {`
`1328`		`- if (!requestUri.Host.Equals("localhost", StringComparison.InvariantCultureIgnoreCase)) {`
	`1328`	`+ if (!requestUri.Host.Equals("localhost", StringComparison.OrdinalIgnoreCase)) {`
`1329`	`1329`	`htdocsFilePath.Append("\\");`
`1330`	`1330`	`htdocsFilePath.Append(requestUri.Host);`
`1331`	`1331`	`}`
Original file line number	Diff line number	Diff line change
`@@ -41,7 +41,7 @@ public bool TestRunningWithOldCPUSimulator() {`
`41`	`41`	`}`
`42`	`42`
`43`	`43`	`if (parentProcessFileName != null) {`
`44`		`- if (parentProcessFileName.Equals(OLD_CPU_SIMULATOR_PARENT_PROCESS_FILE_NAME, StringComparison.InvariantCultureIgnoreCase)) {`
	`44`	`+ if (parentProcessFileName.Equals(OLD_CPU_SIMULATOR_PARENT_PROCESS_FILE_NAME, StringComparison.OrdinalIgnoreCase)) {`
`45`	`45`	`return true;`
`46`	`46`	`}`
`47`	`47`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2159,7 +2159,7 @@ private static Configuration GetEXEConfiguration(bool create, string name) {`
`2159`	`2159`
`2160`	`2160`	`// caching...`
`2161`	`2161`	`if (!String.IsNullOrEmpty(name)) {`
`2162`		`- if (name.Equals(EXEConfigurationName, StringComparison.InvariantCultureIgnoreCase)) {`
	`2162`	`+ if (name.Equals(EXEConfigurationName, StringComparison.OrdinalIgnoreCase)) {`
`2163`	`2163`	`return EXEConfiguration;`
`2164`	`2164`	`}`
`2165`	`2165`	`}`
`@@ -2246,7 +2246,7 @@ public static FlashpointSecurePlayerSection GetFlashpointSecurePlayerSection(boo`
`2246`	`2246`	`string name = GetValidEXEConfigurationName(exeConfigurationName);`
`2247`	`2247`
`2248`	`2248`	`if (!String.IsNullOrEmpty(name) && Shared.flashpointSecurePlayerSection != null) {`
`2249`		`- if (name.Equals(EXEConfigurationName, StringComparison.InvariantCultureIgnoreCase)) {`
	`2249`	`+ if (name.Equals(EXEConfigurationName, StringComparison.OrdinalIgnoreCase)) {`
`2250`	`2250`	`return Shared.flashpointSecurePlayerSection;`
`2251`	`2251`	`}`
`2252`	`2252`	`}`
`@@ -2664,8 +2664,10 @@ public static string AddLeadingSlash(string path) {`
`2664`	`2664`	`return path;`
`2665`	`2665`	`}`
`2666`	`2666`
`2667`		`- if (path.Length > 0 && path.Substring(0, 1) != "\\") {`
`2668`		`- path = "\\" + path;`
	`2667`	`+ const string SLASH = "\\";`
	`2668`	`+`
	`2669`	`+ if (!path.StartsWith(SLASH, StringComparison.Ordinal)) {`
	`2670`	`+ path = path.Insert(0, SLASH);`
`2669`	`2671`	`}`
`2670`	`2672`	`return path;`
`2671`	`2673`	`}`
`@@ -2676,12 +2678,13 @@ public static string RemoveLeadingSlash(string path) {`
`2676`	`2678`	`return path;`
`2677`	`2679`	`}`
`2678`	`2680`
`2679`		`- const int INDEX = 1;`
	`2681`	`+ const string SLASH = "\\";`
`2680`	`2682`
`2681`		`- while (path.Length > 0 && path.Substring(0, INDEX) == "\\") {`
`2682`		`- path = path.Substring(INDEX);`
	`2683`	`+ while (path.StartsWith(SLASH, StringComparison.Ordinal)) {`
	`2684`	`+ path = path.Substring(SLASH.Length);`
`2683`	`2685`	`}`
`2684`	`2686`	`return path;`
	`2687`	`+ //return path.TrimStart('\\');`
`2685`	`2688`	`}`
`2686`	`2689`	`*/`
`2687`	`2690`
`@@ -2691,8 +2694,10 @@ public static string AddTrailingSlash(string path) {`
`2691`	`2694`	`return path;`
`2692`	`2695`	`}`
`2693`	`2696`
`2694`		`- if (path.Length > 0 && path.Substring(path.Length - 1) != "\\") {`
`2695`		`- path = path + "\\";`
	`2697`	`+ const string SLASH = "\\";`
	`2698`	`+`
	`2699`	`+ if (!path.EndsWith(SLASH, StringComparison.Ordinal)) {`
	`2700`	`+ path = path.Insert(path.Length, SLASH);`
`2696`	`2701`	`}`
`2697`	`2702`	`return path;`
`2698`	`2703`	`}`
`@@ -2703,12 +2708,13 @@ public static string RemoveTrailingSlash(string path) {`
`2703`	`2708`	`return path;`
`2704`	`2709`	`}`
`2705`	`2710`
`2706`		`- int index = path.Length - 1;`
	`2711`	`+ const string SLASH = "\\";`
`2707`	`2712`
`2708`		`- while (path.Length > 0 && path.Substring(index) == "\\") {`
`2709`		`- path = path.Substring(0, index);`
	`2713`	`+ while (path.EndsWith(SLASH, StringComparison.Ordinal)) {`
	`2714`	`+ path = path.Remove(path.Length - SLASH.Length);`
`2710`	`2715`	`}`
`2711`	`2716`	`return path;`
	`2717`	`+ //return path.TrimEnd('\\');`
`2712`	`2718`	`}`
`2713`	`2719`
`2714`	`2720`	`public static object LengthenValue(object value, string path) {`
`@@ -2737,7 +2743,7 @@ public static object LengthenValue(object value, string path) {`
`2737`	`2743`	`}`
`2738`	`2744`
`2739`	`2745`	`// if the value is a short value...`
`2740`		`- if (!valueString.StartsWith(shortPathName, StringComparison.InvariantCultureIgnoreCase)) {`
	`2746`	`+ if (!valueString.StartsWith(shortPathName, StringComparison.OrdinalIgnoreCase)) {`
`2741`	`2747`	`return value;`
`2742`	`2748`	`}`
`2743`	`2749`
`@@ -2775,13 +2781,13 @@ public static object ReplaceStartupPathEnvironmentVariable(object lengthenedValu`
`2775`	`2781`
`2776`	`2782`	`longStartupPathName = RemoveTrailingSlash(longStartupPathName);`
`2777`	`2783`
`2778`		`- if (lengthenedValueString.Equals(longStartupPathName, StringComparison.InvariantCultureIgnoreCase)) {`
	`2784`	`+ if (lengthenedValueString.Equals(longStartupPathName, StringComparison.OrdinalIgnoreCase)) {`
`2779`	`2785`	`return "%" + FP_STARTUP_PATH + "%";`
`2780`	`2786`	`}`
`2781`	`2787`
`2782`	`2788`	`longStartupPathName = AddTrailingSlash(longStartupPathName);`
`2783`	`2789`
`2784`		`- if (lengthenedValueString.StartsWith(longStartupPathName, StringComparison.InvariantCultureIgnoreCase)) {`
	`2790`	`+ if (lengthenedValueString.StartsWith(longStartupPathName, StringComparison.OrdinalIgnoreCase)) {`
`2785`	`2791`	`return "%" + FP_STARTUP_PATH + "%\\" + lengthenedValueString.Substring(longStartupPathName.Length);`
`2786`	`2792`	`}`
`2787`	`2793`	`return lengthenedValue;`