UnityCsReference/Runtime/Export/Scripting/ClassLibraryInitializer.cs at master · drawcode/UnityCsReference · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
// Unity C# reference source
// Copyright (c) Unity Technologies. For terms of use, see
// https://unity3d.com/legal/licenses/Unity_Reference_Only_License

using Microsoft.Win32.SafeHandles;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.InteropServices;
using UnityEngine.Bindings;
using UnityEngine.Scripting;

namespace UnityEngine
{
    internal static class ClassLibraryInitializer
    {
        [RequiredByNativeCode]
        static void Init()
        {
            UnityLogWriter.Init();
        }

        // If the AssemblyResolve call fails to load the assembly, this could lead
        // to infinite recursion.  Mono projects against this, but CoreCLR does not,
        // So this causes infinite recursion on CoreCLR.
        // This logic should be handled by the AssemblyLoadContext in the CoreCLR host
        [RequiredByNativeCode(Optional = true)]
        static void InitAssemblyRedirections()
        {
        }
    }

    [StructLayout(LayoutKind.Sequential)]
    [NativeHeader("Runtime/Mono/AssemblyFullName.h")]
    [RequiredByNativeCode(GenerateProxy = true)]
    struct AssemblyVersion
    {
        public ushort major;
        public ushort minor;
        public ushort build;
        public ushort revision;

        public AssemblyVersion(ushort major, ushort minor, ushort build, ushort revision)
        {
            this.major = major;
            this.minor = minor;
            this.build = build;
            this.revision = revision;
        }

        public static bool operator ==(AssemblyVersion lhs, AssemblyVersion rhs)
        {
            return lhs.major == rhs.major
                && lhs.minor == rhs.minor
                && lhs.build == rhs.build
                && lhs.revision == rhs.revision;
        }

        public static bool operator !=(AssemblyVersion lhs, AssemblyVersion rhs)
        {
            return !(lhs == rhs);
        }

        public static bool operator <(AssemblyVersion lhs, AssemblyVersion rhs)
        {
            if (lhs.major != rhs.major)
                return lhs.major < rhs.major;
            if (lhs.minor != rhs.minor)
                return lhs.minor < rhs.minor;
            if (lhs.build != rhs.build)
                return lhs.build < rhs.build;
            if (lhs.revision != rhs.revision)
                return lhs.revision < rhs.revision;
            return false;
        }

        public static bool operator >(AssemblyVersion lhs, AssemblyVersion rhs)
        {
            if (lhs.major != rhs.major)
                return lhs.major > rhs.major;
            if (lhs.minor != rhs.minor)
                return lhs.minor > rhs.minor;
            if (lhs.build != rhs.build)
                return lhs.build > rhs.build;
            if (lhs.revision != rhs.revision)
                return lhs.revision > rhs.revision;
            return false;
        }

        public override string ToString()
        {
            return $"{major}.{minor}.{build}.{revision}";
        }

        public override bool Equals(object other)
        {
            return other is AssemblyVersion otherVersion
                && major == otherVersion.major
                && minor == otherVersion.minor
                && build == otherVersion.build
                && revision == otherVersion.revision;
        }

        public override int GetHashCode()
        {
            return HashCode.Combine(major, minor, build, revision);
        }
    }

    [StructLayout(LayoutKind.Sequential)]
    [NativeHeader("Runtime/Mono/AssemblyFullName.h")]
    [RequiredByNativeCode(GenerateProxy = true)]
    struct AssemblyFullName
    {
        [NativeName("name")]
        public string Name;
        [NativeName("version")]
        public AssemblyVersion Version;
        [NativeName("publicKeyToken")]
        public string PublicKeyToken;
        [NativeName("culture")]
        public string Culture;

        public override bool Equals(object other)
        {
            return other is AssemblyFullName otherVersion
                && Name == otherVersion.Name
                && Version == otherVersion.Version
                && PublicKeyToken == otherVersion.PublicKeyToken
                && Culture == otherVersion.Culture;
        }

        public override int GetHashCode()
        {
            return HashCode.Combine(Name, Version, PublicKeyToken, Culture);
        }

        public override string ToString()
        {
            return $"{Name}, Version={Version}, Culture={(string.IsNullOrEmpty(Culture) ? "neutral" : Culture)}, PublicKeyToken={PublicKeyToken}";
        }
    }
}