From 6b2e75a53414da0b98f9501b0610fb4b21549f39 Mon Sep 17 00:00:00 2001
From: Benedikt Reinartz <filmor@gmail.com>
Date: Fri, 11 Dec 2020 07:51:27 +0100
Subject: [PATCH] Replace custom platform handling by RuntimeInformation

---
 src/embed_tests/TestRuntime.cs         | 19 -----
 src/runtime/platform/LibraryLoader.cs  | 29 +++++---
 src/runtime/platform/NativeCodePage.cs | 99 +++++---------------------
 src/runtime/runtime.cs                 |  7 +-
 4 files changed, 37 insertions(+), 117 deletions(-)

diff --git a/src/embed_tests/TestRuntime.cs b/src/embed_tests/TestRuntime.cs
index 38878205c..cde5dd6fa 100644
--- a/src/embed_tests/TestRuntime.cs
+++ b/src/embed_tests/TestRuntime.cs
@@ -18,25 +18,6 @@ public void SetUp()
             }
         }
 
-        /// <summary>
-        /// Test the cache of the information from the platform module.
-        ///
-        /// Test fails on platforms we haven't implemented yet.
-        /// </summary>
-        [Test]
-        public static void PlatformCache()
-        {
-            Runtime.Runtime.Initialize();
-
-            Assert.That(NativeCodePageHelper.Machine, Is.Not.EqualTo(MachineType.Other));
-            Assert.That(!string.IsNullOrEmpty(NativeCodePageHelper.MachineName));
-
-            Assert.That(NativeCodePageHelper.OperatingSystem, Is.Not.EqualTo(OperatingSystemType.Other));
-            Assert.That(!string.IsNullOrEmpty(NativeCodePageHelper.OperatingSystemName));
-
-            Runtime.Runtime.Shutdown();
-        }
-
         [Test]
         public static void Py_IsInitializedValue()
         {
diff --git a/src/runtime/platform/LibraryLoader.cs b/src/runtime/platform/LibraryLoader.cs
index a6d88cd19..193dff274 100644
--- a/src/runtime/platform/LibraryLoader.cs
+++ b/src/runtime/platform/LibraryLoader.cs
@@ -15,18 +15,27 @@ interface ILibraryLoader
 
     static class LibraryLoader
     {
-        public static ILibraryLoader Get(OperatingSystemType os)
+        static ILibraryLoader _instance = null;
+
+        public static ILibraryLoader Instance
         {
-            switch (os)
+            get
             {
-                case OperatingSystemType.Windows:
-                    return new WindowsLoader();
-                case OperatingSystemType.Darwin:
-                    return new DarwinLoader();
-                case OperatingSystemType.Linux:
-                    return new LinuxLoader();
-                default:
-                    throw new PlatformNotSupportedException($"This operating system ({os}) is not supported");
+                if (_instance == null)
+                {
+                    if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+                        _instance = new WindowsLoader();
+                    else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
+                        _instance = new LinuxLoader();
+                    else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
+                        _instance = new DarwinLoader();
+                    else
+                        throw new PlatformNotSupportedException(
+                            "This operating system is not supported"
+                        );
+                }
+
+                return _instance;
             }
         }
     }
diff --git a/src/runtime/platform/NativeCodePage.cs b/src/runtime/platform/NativeCodePage.cs
index ab2ee3bcf..b6fe89425 100644
--- a/src/runtime/platform/NativeCodePage.cs
+++ b/src/runtime/platform/NativeCodePage.cs
@@ -6,28 +6,6 @@ namespace Python.Runtime.Platform
 {
     class NativeCodePageHelper
     {
-        /// <summary>
-        /// Gets the operating system as reported by python's platform.system().
-        /// </summary>
-        public static OperatingSystemType OperatingSystem { get; private set; }
-
-        /// <summary>
-        /// Gets the operating system as reported by python's platform.system().
-        /// </summary>
-        [Obsolete]
-        public static string OperatingSystemName => PythonEngine.Platform;
-
-        /// <summary>
-        /// Gets the machine architecture as reported by python's platform.machine().
-        /// </summary>
-        public static MachineType Machine { get; private set; }/* set in Initialize using python's platform.machine */
-
-        /// <summary>
-        /// Gets the machine architecture as reported by python's platform.machine().
-        /// </summary>
-        [Obsolete]
-        public static string MachineName { get; private set; }
-
         /// <summary>
         /// Initialized by InitializeNativeCodePage.
         ///
@@ -45,33 +23,6 @@ class NativeCodePageHelper
         internal static IntPtr NativeCodePage = IntPtr.Zero;
 
 
-        static readonly Dictionary<string, OperatingSystemType> OperatingSystemTypeMapping = new Dictionary<string, OperatingSystemType>()
-        {
-            { "Windows", OperatingSystemType.Windows },
-            { "Darwin", OperatingSystemType.Darwin },
-            { "Linux", OperatingSystemType.Linux },
-        };
-
-        /// <summary>
-        /// Map lower-case version of the python machine name to the processor
-        /// type. There are aliases, e.g. x86_64 and amd64 are two names for
-        /// the same thing. Make sure to lower-case the search string, because
-        /// capitalization can differ.
-        /// </summary>
-        static readonly Dictionary<string, MachineType> MachineTypeMapping = new Dictionary<string, MachineType>()
-        {
-            ["i386"] = MachineType.i386,
-            ["i686"] = MachineType.i386,
-            ["x86"] = MachineType.i386,
-            ["x86_64"] = MachineType.x86_64,
-            ["amd64"] = MachineType.x86_64,
-            ["x64"] = MachineType.x86_64,
-            ["em64t"] = MachineType.x86_64,
-            ["armv7l"] = MachineType.armv7l,
-            ["armv8"] = MachineType.armv8,
-            ["aarch64"] = MachineType.aarch64,
-        };
-
         /// <summary>
         /// Structure to describe native code.
         ///
@@ -108,11 +59,11 @@ public static NativeCode Active
             {
                 get
                 {
-                    switch (Machine)
+                    switch (RuntimeInformation.ProcessArchitecture)
                     {
-                        case MachineType.i386:
+                        case Architecture.X86:
                             return I386;
-                        case MachineType.x86_64:
+                        case Architecture.X64:
                             return X86_64;
                         default:
                             return null;
@@ -205,14 +156,14 @@ int MAP_ANONYMOUS
             {
                 get
                 {
-                    switch (OperatingSystem)
+                    if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
                     {
-                        case OperatingSystemType.Darwin:
-                            return 0x1000;
-                        case OperatingSystemType.Linux:
-                            return 0x20;
-                        default:
-                            throw new NotImplementedException($"mmap is not supported on {OperatingSystemName}");
+                        return 0x20;
+                    }
+                    else
+                    {
+                        // OSX, FreeBSD
+                        return 0x1000;
                     }
                 }
             }
@@ -236,32 +187,16 @@ public void SetReadExec(IntPtr mappedMemory, int numBytes)
             }
         }
 
-        /// <summary>
-        /// Initializes the data about platforms.
-        ///
-        /// This must be the last step when initializing the runtime:
-        /// GetManagedString needs to have the cached values for types.
-        /// But it must run before initializing anything outside the runtime
-        /// because those rely on the platform data.
-        /// </summary>
-        public static void InitializePlatformData()
-        {
-            MachineName = SystemInfo.GetArchitecture();
-            Machine = SystemInfo.GetMachineType();
-            OperatingSystem = SystemInfo.GetSystemType();
-        }
-
         internal static IMemoryMapper CreateMemoryMapper()
         {
-            switch (OperatingSystem)
+            if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+            {
+                return new WindowsMemoryMapper();
+            }
+            else
             {
-                case OperatingSystemType.Darwin:
-                case OperatingSystemType.Linux:
-                    return new UnixMemoryMapper();
-                case OperatingSystemType.Windows:
-                    return new WindowsMemoryMapper();
-                default:
-                    throw new NotImplementedException($"No support for {OperatingSystemName}");
+                // Linux, OSX, FreeBSD
+                return new UnixMemoryMapper();
             }
         }
 
diff --git a/src/runtime/runtime.cs b/src/runtime/runtime.cs
index 43c63f346..d9301acdc 100644
--- a/src/runtime/runtime.cs
+++ b/src/runtime/runtime.cs
@@ -158,11 +158,6 @@ internal static void Initialize(bool initSigs = false, ShutdownMode mode = Shutd
             ClassDerivedObject.Reset();
             TypeManager.Initialize();
 
-            // Initialize data about the platform we're running on. We need
-            // this for the type manager and potentially other details. Must
-            // happen after caching the python types, above.
-            NativeCodePageHelper.InitializePlatformData();
-
             // Initialize modules that depend on the runtime class.
             AssemblyManager.Initialize();
             if (mode == ShutdownMode.Reload && RuntimeData.HasStashData())
@@ -2153,7 +2148,7 @@ internal static void Py_CLEAR(ref IntPtr ob)
 
         internal static void SetNoSiteFlag()
         {
-            var loader = LibraryLoader.Get(NativeCodePageHelper.OperatingSystem);
+            var loader = LibraryLoader.Instance;
             IntPtr dllLocal = IntPtr.Zero;
             if (_PythonDll != "__Internal")
             {

<!DOCTYPE html PUBLIC '-//W3C//DTD XHTML 1.0 Transitional//EN' 'http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd'>
<html xmlns='http://www.w3.org/1999/xhtml'>
<head>
<title>pFad - Phonifier reborn</title>
<meta http-equiv='Content-Type' content='text/html; charset=utf-8' />
</head>
<body>
<h1>Pfad - The Proxy pFad of &#169; 2024 Garber Painting. All rights reserved.</h1>


<!-- Disclaimer -->
<p>Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.</p>
<br>
<p>Alternative Proxies:</p><p><a href="http://rainy.clevelandohioweatherforecast.com/php-proxy/index.php?q=https://patch-diff.githubusercontent.com/raw/pythonnet/pythonnet/pull/1314.patch" target="_blank">Alternative Proxy</a></p><p><a href="http://rainy.clevelandohioweatherforecast.com/pFad/index.php?u=https://patch-diff.githubusercontent.com/raw/pythonnet/pythonnet/pull/1314.patch" target="_blank">pFad Proxy</a></p><p><a href="http://rainy.clevelandohioweatherforecast.com/pFad/v3index.php?u=https://patch-diff.githubusercontent.com/raw/pythonnet/pythonnet/pull/1314.patch" target="_blank">pFad v3 Proxy</a></p><p><a href="http://rainy.clevelandohioweatherforecast.com/pFad/v4index.php?u=https://patch-diff.githubusercontent.com/raw/pythonnet/pythonnet/pull/1314.patch" target="_blank">pFad v4 Proxy</a></p></body>
</html>