public AssemblyReferenceHandle GetAssemblyRef(AssemblyName name)
{
if (!_assemblyRefNameHandles.TryGetValue(name.FullName, out var handle))
{
StringHandle assemblyName = _metadataBuilder.GetOrAddString(name.Name);
StringHandle cultureName = (name.CultureName != null) ? _metadataBuilder.GetOrAddString(name.CultureName) : default(StringHandle);
BlobHandle publicTokenBlob = name.GetPublicKeyToken() != null?_metadataBuilder.GetOrAddBlob(name.GetPublicKeyToken()) : default(BlobHandle);
AssemblyFlags flags = default(AssemblyFlags);
if (name.Flags.HasFlag(AssemblyNameFlags.Retargetable))
{
flags |= AssemblyFlags.Retargetable;
}
if (name.ContentType == AssemblyContentType.WindowsRuntime)
{
flags |= AssemblyFlags.WindowsRuntime;
}
Version version = name.Version;
if (version == null)
{
version = new Version(0, 0);
}
handle = _metadataBuilder.AddAssemblyReference(assemblyName, version, cultureName, publicTokenBlob, flags, default(BlobHandle));
_assemblyRefNameHandles[name.FullName] = handle;
}
return(handle);
}
public AssemblyReferenceHandle GetAssemblyRef(IAssemblyDesc assemblyDesc)
{
if (_assemblyRefs.TryGetValue(assemblyDesc, out var handle))
{
return(handle);
}
AssemblyName name = assemblyDesc.GetName();
StringHandle assemblyName = _metadataBuilder.GetOrAddString(name.Name);
StringHandle cultureName = (name.CultureName != null) ? _metadataBuilder.GetOrAddString(name.CultureName) : default(StringHandle);
BlobHandle publicTokenBlob = name.GetPublicKeyToken() != null?_metadataBuilder.GetOrAddBlob(name.GetPublicKeyToken()) : default(BlobHandle);
AssemblyFlags flags = default(AssemblyFlags);
if (name.Flags.HasFlag(AssemblyNameFlags.Retargetable))
{
flags |= AssemblyFlags.Retargetable;
}
if (name.ContentType == AssemblyContentType.WindowsRuntime)
{
flags |= AssemblyFlags.WindowsRuntime;
}
var referenceHandle = _metadataBuilder.AddAssemblyReference(assemblyName, name.Version, cultureName, publicTokenBlob, flags, default(BlobHandle));
_assemblyRefs.Add(assemblyDesc, referenceHandle);
return(referenceHandle);
}
public TargetAssembly(string name,
SupportedLanguage language,
AssemblyFlags flags,
TargetAssemblyType type,
string pathPrefix,
string[] additionalPrefixes,
Func <string, int> pathFilter,
Func <ScriptAssemblySettings, string[], bool> compatFunc,
ScriptCompilerOptions compilerOptions) : this()
{
Language = language;
Filename = name;
Flags = flags;
PathPrefix = pathPrefix;
AdditionalPrefixes = additionalPrefixes;
PathFilter = pathFilter;
IsCompatibleFunc = compatFunc;
Type = type;
CompilerOptions = compilerOptions;
ExplicitPrecompiledReferences = new List <string>();
VersionDefines = new List <VersionDefine>();
if (PathPrefix != null)
{
MaxPathLength = PathPrefix.Length;
}
if (AdditionalPrefixes != null)
{
MaxPathLength = UnityEngine.Mathf.Max(MaxPathLength, AdditionalPrefixes.Max(am => am.Length));
}
}
public static AssemblyIdentity TryGetAssemblyIdentity(string filePath)
{
try
{
using var stream = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite | FileShare.Delete);
using var peReader = new PEReader(stream);
var metadataReader = peReader.GetMetadataReader();
AssemblyDefinition assemblyDefinition = metadataReader.GetAssemblyDefinition();
string name = metadataReader.GetString(assemblyDefinition.Name);
Version version = assemblyDefinition.Version;
StringHandle cultureHandle = assemblyDefinition.Culture;
string cultureName = (!cultureHandle.IsNil) ? metadataReader.GetString(cultureHandle) : null;
AssemblyFlags flags = assemblyDefinition.Flags;
bool hasPublicKey = (flags & AssemblyFlags.PublicKey) != 0;
BlobHandle publicKeyHandle = assemblyDefinition.PublicKey;
ImmutableArray <byte> publicKeyOrToken = !publicKeyHandle.IsNil
? metadataReader.GetBlobBytes(publicKeyHandle).AsImmutableOrNull()
: default;
return(new AssemblyIdentity(name, version, cultureName, publicKeyOrToken, hasPublicKey));
}
catch { }
return(null);
}
private static RuntimeAssemblyName CreateRuntimeAssemblyNameFromMetadata(
MetadataReader reader,
ConstantStringValueHandle name,
ushort majorVersion,
ushort minorVersion,
ushort buildNumber,
ushort revisionNumber,
ConstantStringValueHandle culture,
IEnumerable <byte> publicKeyOrToken,
AssemblyFlags assemblyFlags)
{
AssemblyNameFlags assemblyNameFlags = AssemblyNameFlags.None;
if (0 != (assemblyFlags & AssemblyFlags.PublicKey))
{
assemblyNameFlags |= AssemblyNameFlags.PublicKey;
}
if (0 != (assemblyFlags & AssemblyFlags.Retargetable))
{
assemblyNameFlags |= AssemblyNameFlags.Retargetable;
}
int contentType = ((int)assemblyFlags) & 0x00000E00;
assemblyNameFlags |= (AssemblyNameFlags)contentType;
return(new RuntimeAssemblyName(
name.GetString(reader),
new Version(majorVersion, minorVersion, buildNumber, revisionNumber),
culture.GetStringOrNull(reader),
assemblyNameFlags,
publicKeyOrToken.ToArray()
));
}
private static RuntimeAssemblyName CreateRuntimeAssemblyNameFromMetadata(
MetadataReader reader,
StringHandle name,
Version version,
StringHandle culture,
BlobHandle publicKeyOrToken,
AssemblyFlags assemblyFlags)
{
AssemblyNameFlags assemblyNameFlags = AssemblyNameFlags.None;
if (0 != (assemblyFlags & AssemblyFlags.PublicKey))
{
assemblyNameFlags |= AssemblyNameFlags.PublicKey;
}
if (0 != (assemblyFlags & AssemblyFlags.Retargetable))
{
assemblyNameFlags |= AssemblyNameFlags.Retargetable;
}
int contentType = ((int)assemblyFlags) & 0x00000E00;
assemblyNameFlags |= (AssemblyNameFlags)contentType;
return(new RuntimeAssemblyName(
name.GetString(reader),
version,
culture.GetString(reader),
assemblyNameFlags,
reader.GetBlobContent(publicKeyOrToken).ToArray()
));
}
public static void Assembly_reference_with_flag(AssemblyFlags flag)
{
var builder = BuildAssembly();
var baseType = typeof(AttributeTargets);
var baseTypeAssemblyName = baseType.Assembly.GetName();
var assemblyReferenceHandle = builder.AddAssemblyReference(
builder.GetOrAddString(baseTypeAssemblyName.Name),
baseTypeAssemblyName.Version,
builder.GetOrAddString(baseTypeAssemblyName.CultureName),
builder.GetOrAddBlob((baseTypeAssemblyName.Flags & AssemblyNameFlags.PublicKey) != 0 ? baseTypeAssemblyName.GetPublicKey() : baseTypeAssemblyName.GetPublicKeyToken()),
(AssemblyFlags)baseTypeAssemblyName.Flags | flag,
hashValue: default);
var typeReferenceHandle = builder.AddTypeReference(
assemblyReferenceHandle,
builder.GetOrAddString(baseType.Namespace),
builder.GetOrAddString(baseType.Name));
var fieldTypeBlob = new BlobBuilder();
var fieldTypeEncoder = new BlobEncoder(fieldTypeBlob).FieldSignature();
fieldTypeEncoder.Type(typeReferenceHandle, isValueType: false);
var fieldHandle = builder.AddFieldDefinition(
FieldAttributes.Public | FieldAttributes.Static | FieldAttributes.Literal,
builder.GetOrAddString("TestField"),
builder.GetOrAddBlob(fieldTypeBlob));
builder.AddConstant(fieldHandle, null);
builder.AddTypeDefinition(
TypeAttributes.Public,
@namespace: default,
private static RuntimeAssemblyName CreateRuntimeAssemblyNameFromMetadata(
MetadataReader reader,
ConstantStringValueHandle name,
ushort majorVersion,
ushort minorVersion,
ushort buildNumber,
ushort revisionNumber,
ConstantStringValueHandle culture,
IEnumerable<byte> publicKeyOrToken,
AssemblyFlags assemblyFlags)
{
AssemblyNameFlags assemblyNameFlags = AssemblyNameFlags.None;
if (0 != (assemblyFlags & AssemblyFlags.PublicKey))
assemblyNameFlags |= AssemblyNameFlags.PublicKey;
if (0 != (assemblyFlags & AssemblyFlags.Retargetable))
assemblyNameFlags |= AssemblyNameFlags.Retargetable;
int contentType = ((int)assemblyFlags) & 0x00000E00;
assemblyNameFlags |= (AssemblyNameFlags)contentType;
ArrayBuilder<byte> keyOrTokenArrayBuilder = new ArrayBuilder<byte>();
foreach (byte b in publicKeyOrToken)
keyOrTokenArrayBuilder.Add(b);
return new RuntimeAssemblyName(
name.GetString(reader),
new Version(majorVersion, minorVersion, buildNumber, revisionNumber),
culture.GetStringOrNull(reader),
assemblyNameFlags,
keyOrTokenArrayBuilder.ToArray()
);
}
internal static Assembly[] GetAssemblies(EditorCompilation editorCompilation)
{
ScriptAssembly[] allEditorScriptAssemblies = editorCompilation.GetAllEditorScriptAssemblies();
Assembly[] array = new Assembly[allEditorScriptAssemblies.Length];
Dictionary <ScriptAssembly, Assembly> scriptAssemblyToAssembly = new Dictionary <ScriptAssembly, Assembly>();
for (int i = 0; i < allEditorScriptAssemblies.Length; i++)
{
scriptAssemblyToAssembly.Add(allEditorScriptAssemblies[i], array[i]);
}
for (int j = 0; j < allEditorScriptAssemblies.Length; j++)
{
ScriptAssembly scriptAssembly = allEditorScriptAssemblies[j];
string assemblyNameWithoutExtension = AssetPath.GetAssemblyNameWithoutExtension(scriptAssembly.Filename);
string fullPath = scriptAssembly.FullPath;
string[] files = scriptAssembly.Files;
string[] defines = scriptAssembly.Defines;
string[] references = scriptAssembly.References;
Assembly[] assemblyReferences = (from a in scriptAssembly.ScriptAssemblyReferences
select scriptAssemblyToAssembly[a]).ToArray <Assembly>();
AssemblyFlags assemblyFlags = AssemblyFlags.None;
if ((scriptAssembly.Flags & UnityEditor.Scripting.ScriptCompilation.AssemblyFlags.EditorOnly) == UnityEditor.Scripting.ScriptCompilation.AssemblyFlags.EditorOnly)
{
assemblyFlags |= AssemblyFlags.EditorAssembly;
}
array[j] = new Assembly(assemblyNameWithoutExtension, fullPath, files, defines, assemblyReferences, references, assemblyFlags);
}
return(array);
}
private AssemblyNameFlags GetAssemblyNameFlags(AssemblyFlags flags)
{
AssemblyNameFlags assemblyNameFlags = AssemblyNameFlags.None;
if ((flags & AssemblyFlags.PublicKey) != 0)
{
assemblyNameFlags |= AssemblyNameFlags.PublicKey;
}
if ((flags & AssemblyFlags.Retargetable) != 0)
{
assemblyNameFlags |= AssemblyNameFlags.Retargetable;
}
if ((flags & AssemblyFlags.EnableJitCompileTracking) != 0)
{
assemblyNameFlags |= AssemblyNameFlags.EnableJITcompileTracking;
}
if ((flags & AssemblyFlags.DisableJitCompileOptimizer) != 0)
{
assemblyNameFlags |= AssemblyNameFlags.EnableJITcompileOptimizer;
}
return(assemblyNameFlags);
}
public ReaderMetadataAssemblyReference(string name, Version version, string cultureName, byte[] publicKeyOrToken, AssemblyFlags flags)
{
Name = name;
Version = version;
CultureName = cultureName;
this.publicKeyOrToken = publicKeyOrToken;
this.flags = flags;
}
} // Read
public static uint Read(this NativeReader reader, uint offset, out AssemblyFlags value)
{
uint ivalue;
offset = reader.DecodeUnsigned(offset, out ivalue);
value = (AssemblyFlags)ivalue;
return(offset);
} // Read
public TargetAssembly(string name, SupportedLanguage language, AssemblyFlags flags, EditorBuildRules.TargetAssemblyType type, Func <string, int> pathFilter) : this()
{
this.Language = language;
this.Filename = name;
this.Flags = flags;
this.PathFilter = pathFilter;
this.Type = type;
}
public void Read(ClrModuleReader reader)
{
this.HashAlgId = (AssemblyHashAlgorithm)reader.Binary.ReadUInt32();
this.Version = reader.ReadVersion();
this.Flags = (AssemblyFlags)reader.Binary.ReadUInt32();
this.PublicKey = reader.ReadBlob();
this.Name = reader.ReadString();
this.Culture = reader.ReadString();
}
public TargetAssembly(string name, SupportedLanguage language, AssemblyFlags flags, EditorBuildRules.TargetAssemblyType type, Func <string, int> pathFilter, Func <BuildTarget, EditorScriptCompilationOptions, bool> compatFunc) : this()
{
this.Language = language;
this.Filename = name;
this.Flags = flags;
this.PathFilter = pathFilter;
this.IsCompatibleFunc = compatFunc;
this.Type = type;
}
public void Read(ClrModuleReader reader)
{
this.Version = reader.ReadVersion();
this.Flags = (AssemblyFlags)reader.Binary.ReadUInt32();
this.PublicKeyOrToken = reader.ReadBlob();
this.Name = reader.ReadString();
this.Culture = reader.ReadString();
this.HashValue = reader.ReadBlob();
}
public void Read(ClrModuleReader reader)
{
this.HashAlgId = (AssemblyHashAlgorithm)reader.Binary.ReadUInt32();
this.Version = reader.ReadVersion();
this.Flags = (AssemblyFlags)reader.Binary.ReadUInt32();
this.PublicKey = reader.ReadBlob();
this.Name = reader.ReadString();
this.Culture = reader.ReadString();
}
public void Read(ClrModuleReader reader)
{
this.Version = reader.ReadVersion();
this.Flags = (AssemblyFlags)reader.Binary.ReadUInt32();
this.PublicKeyOrToken = reader.ReadBlob();
this.Name = reader.ReadString();
this.Culture = reader.ReadString();
this.HashValue = reader.ReadBlob();
}
public Cache(MutableModule module, string assemblyName, AssemblyFlags assemblyFlags, byte[] publicKeyArray, Version version, AssemblyHashAlgorithm hashAlgorithm, Func <ModuleDesc, int> moduleToIndex)
{
_module = module;
_assemblyName = assemblyName;
_assemblyFlags = assemblyFlags;
_publicKeyArray = publicKeyArray;
_version = version;
_hashAlgorithm = hashAlgorithm;
_moduleToIndex = moduleToIndex;
ResetEmitter();
}
public static AssemblyNameFlags ConvertAssemblyFlagsToAssemblyNameFlags(AssemblyFlags assemblyFlags)
{
AssemblyNameFlags assemblyNameFlags = AssemblyNameFlags.None;
if ((assemblyFlags & AssemblyFlags.Retargetable) != 0)
{
assemblyNameFlags |= AssemblyNameFlags.Retargetable;
}
return(assemblyNameFlags);
}
public AssemblyName GetAssemblyName()
{
AssemblyFlags flags = Flags;
// compat: assembly names from metadata definitions should set the bit for the full key.
if (!PublicKey.IsNil)
{
flags |= AssemblyFlags.PublicKey;
}
return(_reader.GetAssemblyName(Name, Version, Culture, PublicKey, HashAlgorithm, flags));
}
private static AssemblyIdentity TryGetAssemblyIdentity(string filePath)
{
try
{
if (!File.Exists(filePath))
{
return(null);
}
using (var stream = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read | FileShare.Delete))
using (var peReader = new PEReader(stream))
{
var metadataReader = peReader.GetMetadataReader();
AssemblyDefinition assemblyDefinition = metadataReader.GetAssemblyDefinition();
string name = metadataReader.GetString(assemblyDefinition.Name);
if (!MetadataHelpers.IsValidMetadataIdentifier(name))
{
return(null);
}
Version version = assemblyDefinition.Version;
StringHandle cultureHandle = assemblyDefinition.Culture;
string cultureName = (!cultureHandle.IsNil) ? metadataReader.GetString(cultureHandle) : null;
if (cultureName != null && !MetadataHelpers.IsValidMetadataIdentifier(cultureName))
{
return(null);
}
AssemblyFlags flags = assemblyDefinition.Flags;
bool hasPublicKey = (flags & AssemblyFlags.PublicKey) != 0;
BlobHandle publicKeyHandle = assemblyDefinition.PublicKey;
ImmutableArray <byte> publicKeyOrToken = !publicKeyHandle.IsNil
? metadataReader.GetBlobBytes(publicKeyHandle).AsImmutableOrNull()
: default(ImmutableArray <byte>);
if (hasPublicKey)
{
if (!MetadataHelpers.IsValidPublicKey(publicKeyOrToken))
{
return(null);
}
}
return(new AssemblyIdentity(name, version, cultureName, publicKeyOrToken, hasPublicKey));
}
}
catch { }
return(null);
}
private void LoadData(CLIFile pFile)
{
HashAlgId = (AssemblyHashAlgorithm)pFile.ReadUInt32();
MajorVersion = pFile.ReadUInt16();
MinorVersion = pFile.ReadUInt16();
BuildNumber = pFile.ReadUInt16();
RevisionNumber = pFile.ReadUInt16();
Flags = (AssemblyFlags)pFile.ReadUInt32();
PublicKey = pFile.ReadBlobHeap(pFile.ReadHeapIndex(HeapOffsetSizes.Blob32Bit));
Name = pFile.ReadStringHeap(pFile.ReadHeapIndex(HeapOffsetSizes.Strings32Bit));
Culture = pFile.ReadStringHeap(pFile.ReadHeapIndex(HeapOffsetSizes.Strings32Bit));
}
public ManagedBinaryEmitterForInternalUse(AssemblyName assemblyName,
TypeSystemContext typeSystemContext,
AssemblyFlags assemblyFlags,
byte[] publicKeyArray,
AssemblyHashAlgorithm hashAlgorithm,
Func <ModuleDesc, int> moduleToIndex,
MutableModule mutableModule)
: base(assemblyName, typeSystemContext, assemblyFlags, publicKeyArray, hashAlgorithm)
{
_moduleToIndex = moduleToIndex;
_mutableModule = mutableModule;
}
private static AssemblyIdentity ReadAssemblyIdentity(MetadataReader metadataReader)
{
var assemblyDefinition = metadataReader.GetAssemblyDefinition();
string name = metadataReader.GetString(assemblyDefinition.Name);
Version version = assemblyDefinition.Version;
string cultureName = metadataReader.GetString(assemblyDefinition.Culture);
ImmutableArray <byte> publicKeyOrToken = metadataReader.GetBlobContent(assemblyDefinition.PublicKey);
AssemblyFlags flags = assemblyDefinition.Flags;
bool hasPublicKey = (flags & AssemblyFlags.PublicKey) != 0;
return(new AssemblyIdentity(name, version, cultureName, publicKeyOrToken, hasPublicKey: hasPublicKey));
}
public string Assemble(string code, AssemblyFlags flags)
{
try
{
_spasm.Options = (uint)flags;
_spasm.Assemble(code);
return(_spasm.StdOut.ReadAll());
}
catch (COMException)
{
return(string.Empty);
}
}
public string Assemble(AssemblyFlags flags)
{
try
{
_spasm.Options = (uint)flags;
_spasm.Assemble();
return(_spasm.StdOut.ReadAll());
}
catch (COMException)
{
return("Error assembling.");
}
}
private static RuntimeAssemblyName CreateRuntimeAssemblyNameFromMetadata(
MetadataReader reader,
StringHandle name,
Version version,
StringHandle culture,
BlobHandle publicKeyOrToken,
AssemblyFlags assemblyFlags)
{
AssemblyNameFlags assemblyNameFlags = AssemblyNameFlags.None;
if (0 != (assemblyFlags & AssemblyFlags.PublicKey))
{
assemblyNameFlags |= AssemblyNameFlags.PublicKey;
}
if (0 != (assemblyFlags & AssemblyFlags.Retargetable))
{
assemblyNameFlags |= AssemblyNameFlags.Retargetable;
}
int contentType = ((int)assemblyFlags) & 0x00000E00;
assemblyNameFlags |= (AssemblyNameFlags)contentType;
byte[] publicKeyOrTokenByteArray;
if (!publicKeyOrToken.IsNil)
{
ImmutableArray <byte> publicKeyOrTokenBlob = reader.GetBlobContent(publicKeyOrToken);
publicKeyOrTokenByteArray = new byte[publicKeyOrTokenBlob.Length];
publicKeyOrTokenBlob.CopyTo(publicKeyOrTokenByteArray);
}
else
{
publicKeyOrTokenByteArray = Array.Empty <byte>();
}
string cultureName = culture.GetString(reader);
if (!String.IsNullOrEmpty(cultureName))
{
// Canonicalize spelling and force a CultureNotFoundException if not a valid culture
CultureInfo cultureInfo = CultureInfo.GetCultureInfo(cultureName);
cultureName = cultureInfo.Name;
}
return(new RuntimeAssemblyName(
name.GetString(reader),
version,
cultureName,
assemblyNameFlags,
publicKeyOrTokenByteArray
));
}
/// <summary>
/// Creates a new instance of <see cref="AssemblyBuilder"/>.
/// </summary>
/// <param name="name">The name of the assembly.</param>
/// <param name="version">The assembly version. If this is null, the version 0.0.0.0
/// is used.</param>
/// <param name="culture">The assembly culture, or null if there is no culture associated
/// with the assembly.</param>
/// <param name="flags">A set of bit flags from <see cref="AssemblyFlags"/>.</param>
/// <param name="hashAlgorithm">The hash algorithm for the assembly. This is ignored for now,
/// as emitting multi-file assemblies is not supported.</param>
/// <param name="publicKey">The public key for the assembly, null if there is no public key.</param>
/// <param name="mainModuleName">The name of the manifest module, null to use the assembly
/// name.</param>
/// <param name="moduleVersionId">A GUID that uniquely identifies the current version of
/// the main module. If not specified, a random value is used.</param>
public AssemblyBuilder(
string name,
Version?version = null,
string?culture = null,
AssemblyFlags flags = 0,
AssemblyHashAlgorithm hashAlgorithm = AssemblyHashAlgorithm.None,
byte[]?publicKey = null,
string?mainModuleName = null,
Guid moduleVersionId = default
)
{
if (name == null || name.Length == 0)
{
throw new ArgumentException("Assembly name must not be null or empty.", nameof(name));
}
version ??= new Version(0, 0, 0, 0);
var metadataBuilder = new MetadataBuilder();
m_metadataContext = new MetadataContext(metadataBuilder);
StringHandle nameHandle = m_metadataContext.getStringHandle(name);
StringHandle cultureHandle = m_metadataContext.getStringHandle(culture);
BlobHandle publicKeyHandle = m_metadataContext.getBlobHandle(publicKey);
metadataBuilder.AddAssembly(nameHandle, version, cultureHandle, publicKeyHandle, flags, hashAlgorithm);
StringHandle moduleNameHandle = (mainModuleName != null && mainModuleName.Length != 0)
? metadataBuilder.GetOrAddString(mainModuleName)
: nameHandle;
if (moduleVersionId.Equals(default(Guid)))
{
moduleVersionId = Guid.NewGuid();
}
GuidHandle mvid = metadataBuilder.GetOrAddGuid(moduleVersionId);
metadataBuilder.AddModule(0, moduleNameHandle, mvid, MetadataTokens.GuidHandle(0), MetadataTokens.GuidHandle(0));
// <Module> should be the first row in TypeDef
metadataBuilder.AddTypeDefinition(
attributes: TypeAttributes.Class,
@namespace: m_metadataContext.getStringHandle(null),
name: m_metadataContext.getStringHandle("<Module>"),
baseType: MetadataTokens.TypeDefinitionHandle(0),
fieldList: MetadataTokens.FieldDefinitionHandle(1),
methodList: MetadataTokens.MethodDefinitionHandle(1)
);
}
/// <summary>
/// Initializes a new instance of the <see cref="AssemblyRow"/> struct.
/// </summary>
/// <param name="hashAlgId">The hash alg id.</param>
/// <param name="majorVersion">The major version.</param>
/// <param name="minorVersion">The minor version.</param>
/// <param name="buildNumber">The build number.</param>
/// <param name="revision">The revision.</param>
/// <param name="flags">The flags.</param>
/// <param name="publicKeyIdx">The public key idx.</param>
/// <param name="nameIdx">The name idx.</param>
/// <param name="cultureIdx">The culture idx.</param>
public AssemblyRow(AssemblyHashAlgorithm hashAlgId,
ushort majorVersion, ushort minorVersion, ushort buildNumber, ushort revision,
AssemblyFlags flags, TokenTypes publicKeyIdx, TokenTypes nameIdx, TokenTypes cultureIdx)
{
_hashAlgId = hashAlgId;
_majorVersion = majorVersion;
_minorVersion = minorVersion;
_buildNumber = buildNumber;
_revision = revision;
_flags = flags;
_publicKeyIdx = publicKeyIdx;
_nameIdx = nameIdx;
_cultureIdx = cultureIdx;
}
/// <summary>
/// Initializes a new instance of the <see cref="AssemblyRefRow"/> struct.
/// </summary>
/// <param name="majorVersion">The major version.</param>
/// <param name="minorVersion">The minor version.</param>
/// <param name="buildNumber">The build number.</param>
/// <param name="revisionNumber">The revision number.</param>
/// <param name="flags">The flags.</param>
/// <param name="publicKeyOrTokenIdx">The public key or token idx.</param>
/// <param name="nameIdx">The name idx.</param>
/// <param name="cultureIdx">The culture idx.</param>
/// <param name="hashValueIdx">The hash value idx.</param>
public AssemblyRefRow(ushort majorVersion, ushort minorVersion, ushort buildNumber, ushort revisionNumber,
AssemblyFlags flags, TokenTypes publicKeyOrTokenIdx, TokenTypes nameIdx,
TokenTypes cultureIdx, TokenTypes hashValueIdx)
{
_majorVersion = majorVersion;
_minorVersion = minorVersion;
_buildNumber = buildNumber;
_revision = revisionNumber;
_flags = flags;
_publicKeyOrTokenIdx = publicKeyOrTokenIdx;
_nameIdx = nameIdx;
_cultureIdx = cultureIdx;
_hashValueIdx = hashValueIdx;
}
public void AssembleFileTest()
{
AssemblerService target = new AssemblerService(); // TODO: Initialize to an appropriate value
FilePath inputPath = null; // TODO: Initialize to an appropriate value
FilePath outputPath = null; // TODO: Initialize to an appropriate value
IList <IDefine> defines = null; // TODO: Initialize to an appropriate value
AssemblyFlags flags = new AssemblyFlags(); // TODO: Initialize to an appropriate value
Action <string> callback = null; // TODO: Initialize to an appropriate value
bool expected = false; // TODO: Initialize to an appropriate value
bool actual;
actual = target.AssembleFile(inputPath, outputPath, defines, flags, callback);
Assert.AreEqual(expected, actual);
Assert.Inconclusive("Verify the correctness of this test method.");
}
public static PrecompiledAssembly CreateUserCompiledAssembly(string path)
{
AssemblyFlags assemblyFlags = AssemblyFlags.None;
string text = path.ToLower();
if (text.Contains("/editor/") || text.Contains("\\editor\\"))
{
assemblyFlags |= AssemblyFlags.EditorOnly;
}
return(new PrecompiledAssembly
{
Path = path,
Flags = assemblyFlags
});
}
public MutableModule(TypeSystemContext context,
string assemblyName,
AssemblyFlags assemblyFlags,
byte[] publicKeyArray,
Version version,
AssemblyHashAlgorithm hashAlgorithm,
Func <ModuleDesc, int> moduleToIndex,
ReadyToRunCompilationModuleGroupBase compilationGroup) : base(context, null)
{
_compilationGroup = compilationGroup;
_cache = new Cache(this, assemblyName, assemblyFlags, publicKeyArray, version, hashAlgorithm, moduleToIndex);
TryGetHandle = _cache.CreateCacheFunc <TypeSystemEntity>(GetHandleForTypeSystemEntity);
TryGetStringHandle = _cache.CreateCacheFunc <string>(GetUserStringHandle);
TryGetAssemblyRefHandle = _cache.CreateCacheFunc <AssemblyName>(GetAssemblyRefHandle);
}
internal AssemblyRefRow(
ushort majorVersion,
ushort minorVersion,
ushort buildNumber,
ushort revisionNumber,
AssemblyFlags flags,
uint publicKeyOrToken,
uint name,
uint culture,
uint hashValue)
{
this.MajorVersion = majorVersion;
this.MinorVersion = minorVersion;
this.BuildNumber = buildNumber;
this.RevisionNumber = revisionNumber;
this.Flags = flags;
this.PublicKeyOrToken = publicKeyOrToken;
this.Name = name;
this.Culture = culture;
this.HashValue = hashValue;
}
internal AssemblyRow(
uint hashAlgId,
ushort majorVersion,
ushort minorVersion,
ushort buildNumber,
ushort revisionNumber,
AssemblyFlags flags,
uint publicKey,
uint name,
uint culture)
{
this.HashAlgId = hashAlgId;
this.MajorVersion = majorVersion;
this.MinorVersion = minorVersion;
this.BuildNumber = buildNumber;
this.RevisionNumber = revisionNumber;
this.Flags = flags;
this.PublicKey = publicKey;
this.Name = name;
this.Culture = culture;
}
private static RuntimeAssemblyName CreateRuntimeAssemblyNameFromMetadata(
MetadataReader reader,
StringHandle name,
Version version,
StringHandle culture,
BlobHandle publicKeyOrToken,
AssemblyFlags assemblyFlags)
{
AssemblyNameFlags assemblyNameFlags = AssemblyNameFlags.None;
if (0 != (assemblyFlags & AssemblyFlags.PublicKey))
assemblyNameFlags |= AssemblyNameFlags.PublicKey;
if (0 != (assemblyFlags & AssemblyFlags.Retargetable))
assemblyNameFlags |= AssemblyNameFlags.Retargetable;
int contentType = ((int)assemblyFlags) & 0x00000E00;
assemblyNameFlags |= (AssemblyNameFlags)contentType;
return new RuntimeAssemblyName(
name.GetString(reader),
version,
culture.GetString(reader),
assemblyNameFlags,
reader.GetBlobContent(publicKeyOrToken).ToArray()
);
}
public AssemblyRow CreateAssemblyRow(AssemblyHashAlgorithm _hashAlgId, ushort _majorVersion, ushort _minorVersion, ushort _buildNumber, ushort _revisionNumber, AssemblyFlags _flags, uint _publicKey, uint _name, uint _culture)
{
AssemblyRow row = new AssemblyRow ();
row.HashAlgId = _hashAlgId;
row.MajorVersion = _majorVersion;
row.MinorVersion = _minorVersion;
row.BuildNumber = _buildNumber;
row.RevisionNumber = _revisionNumber;
row.Flags = _flags;
row.PublicKey = _publicKey;
row.Name = _name;
row.Culture = _culture;
return row;
}
public AssemblyReferenceHandle AddAssemblyReference(
StringHandle name,
Version version,
StringHandle culture,
BlobHandle publicKeyOrToken,
AssemblyFlags flags,
BlobHandle hashValue)
{
_assemblyRefTable.Add(new AssemblyRefTableRow
{
Name = name,
Version = version,
Culture = culture,
PublicKeyToken = publicKeyOrToken,
Flags = (uint)flags,
HashValue = hashValue
});
return MetadataTokens.AssemblyReferenceHandle(_assemblyRefTable.Count);
}
public void AddAssembly(
StringHandle name,
Version version,
StringHandle culture,
BlobHandle publicKey,
AssemblyFlags flags,
AssemblyHashAlgorithm hashAlgorithm)
{
_assemblyTable.Add(new AssemblyRow
{
Flags = (ushort)flags,
HashAlgorithm = (uint)hashAlgorithm,
Version = version,
AssemblyKey = publicKey,
AssemblyName = name,
AssemblyCulture = culture
});
}
/// <summary>
/// Initializes a new instance of the <see cref="AssemblyRefRow"/> struct.
/// </summary>
/// <param name="majorVersion">The major version.</param>
/// <param name="minorVersion">The minor version.</param>
/// <param name="buildNumber">The build number.</param>
/// <param name="revisionNumber">The revision number.</param>
/// <param name="flags">The flags.</param>
/// <param name="publicKeyOrTokenIdx">The public key or token idx.</param>
/// <param name="nameIdx">The name idx.</param>
/// <param name="cultureIdx">The culture idx.</param>
/// <param name="hashValueIdx">The hash value idx.</param>
public AssemblyRefRow(ushort majorVersion, ushort minorVersion, ushort buildNumber, ushort revisionNumber,
AssemblyFlags flags, TokenTypes publicKeyOrTokenIdx, TokenTypes nameIdx,
TokenTypes cultureIdx, TokenTypes hashValueIdx)
{
_majorVersion = majorVersion;
_minorVersion = minorVersion;
_buildNumber = buildNumber;
_revision = revisionNumber;
_flags = flags;
_publicKeyOrTokenIdx = publicKeyOrTokenIdx;
_nameIdx = nameIdx;
_cultureIdx = cultureIdx;
_hashValueIdx = hashValueIdx;
}
} // Read
public static uint Read(this NativeReader reader, uint offset, out AssemblyFlags value)
{
uint ivalue;
offset = reader.DecodeUnsigned(offset, out ivalue);
value = (AssemblyFlags)ivalue;
return offset;
} // Read
/// <exception cref="BadImageFormatException">An exception from metadata reader.</exception>
private static AssemblyIdentity CreateAssemblyIdentityOrThrow(
this MetadataReader reader,
Version version,
AssemblyFlags flags,
BlobHandle publicKey,
StringHandle name,
StringHandle culture,
bool isReference)
{
string nameStr = reader.GetString(name);
if (!MetadataHelpers.IsValidMetadataIdentifier(nameStr))
{
throw new BadImageFormatException(string.Format(CodeAnalysisResources.InvalidAssemblyName, nameStr));
}
string cultureName = culture.IsNil ? null : reader.GetString(culture);
if (cultureName != null && !MetadataHelpers.IsValidMetadataIdentifier(cultureName))
{
throw new BadImageFormatException(string.Format(CodeAnalysisResources.InvalidCultureName, cultureName));
}
ImmutableArray<byte> publicKeyOrToken = reader.GetBlobContent(publicKey);
bool hasPublicKey;
if (isReference)
{
hasPublicKey = (flags & AssemblyFlags.PublicKey) != 0;
if (hasPublicKey)
{
if (!MetadataHelpers.IsValidPublicKey(publicKeyOrToken))
{
throw new BadImageFormatException(CodeAnalysisResources.InvalidPublicKey);
}
}
else
{
if (!publicKeyOrToken.IsEmpty &&
publicKeyOrToken.Length != AssemblyIdentity.PublicKeyTokenSize)
{
throw new BadImageFormatException(CodeAnalysisResources.InvalidPublicKeyToken);
}
}
}
else
{
// Assembly definitions never contain a public key token, they only can have a full key or nothing,
// so the flag AssemblyFlags.PublicKey does not make sense for them and is ignored.
// See Ecma-335, Partition II Metadata, 22.2 "Assembly : 0x20".
// This also corresponds to the behavior of the native C# compiler and sn.exe tool.
hasPublicKey = !publicKeyOrToken.IsEmpty;
if (hasPublicKey && !MetadataHelpers.IsValidPublicKey(publicKeyOrToken))
{
throw new BadImageFormatException(CodeAnalysisResources.InvalidPublicKey);
}
}
if (publicKeyOrToken.IsEmpty)
{
publicKeyOrToken = default(ImmutableArray<byte>);
}
return new AssemblyIdentity(
name: nameStr,
version: version,
cultureName: cultureName,
publicKeyOrToken: publicKeyOrToken,
hasPublicKey: hasPublicKey,
isRetargetable: (flags & AssemblyFlags.Retargetable) != 0,
contentType: (AssemblyContentType)((int)(flags & AssemblyFlags.ContentTypeMask) >> 9),
noThrow: true);
}
public void AddAssemblyReference(
StringIdx name,
Version version,
StringIdx culture,
BlobIdx publicKeyOrToken,
AssemblyFlags flags,
BlobIdx hashValue)
{
_assemblyRefTable.Add(new AssemblyRefTableRow
{
Name = name,
Version = version,
Culture = culture,
PublicKeyToken = publicKeyOrToken,
Flags = (uint)flags,
HashValue = hashValue
});
}
/// <summary>
/// Initializes a new instance of the <see cref="AssemblyRow"/> struct.
/// </summary>
/// <param name="hashAlgId">The hash alg id.</param>
/// <param name="majorVersion">The major version.</param>
/// <param name="minorVersion">The minor version.</param>
/// <param name="buildNumber">The build number.</param>
/// <param name="revision">The revision.</param>
/// <param name="flags">The flags.</param>
/// <param name="publicKeyIdx">The public key idx.</param>
/// <param name="nameIdx">The name idx.</param>
/// <param name="cultureIdx">The culture idx.</param>
public AssemblyRow(AssemblyHashAlgorithm hashAlgId,
ushort majorVersion, ushort minorVersion, ushort buildNumber, ushort revision,
AssemblyFlags flags, TokenTypes publicKeyIdx, TokenTypes nameIdx, TokenTypes cultureIdx)
{
_hashAlgId = hashAlgId;
_majorVersion = majorVersion;
_minorVersion = minorVersion;
_buildNumber = buildNumber;
_revision = revision;
_flags = flags;
_publicKeyIdx = publicKeyIdx;
_nameIdx = nameIdx;
_cultureIdx = cultureIdx;
}
public AssemblyRefRow CreateAssemblyRefRow(ushort _majorVersion, ushort _minorVersion, ushort _buildNumber, ushort _revisionNumber, AssemblyFlags _flags, uint _publicKeyOrToken, uint _name, uint _culture, uint _hashValue)
{
AssemblyRefRow row = new AssemblyRefRow ();
row.MajorVersion = _majorVersion;
row.MinorVersion = _minorVersion;
row.BuildNumber = _buildNumber;
row.RevisionNumber = _revisionNumber;
row.Flags = _flags;
row.PublicKeyOrToken = _publicKeyOrToken;
row.Name = _name;
row.Culture = _culture;
row.HashValue = _hashValue;
return row;
}
/// <summary>
/// Fills the row from the array of bytes.
/// </summary>
unsafe public void FromRawData(byte [] buff, int offs)
{
if (buff == null) throw new Exception("buff == null");
if (offs + Size > buff.Length) throw new Exception("bounds");
this.MajorVersion = LEBitConverter.ToInt16(buff, offs);
offs += sizeof (short);
this.MinorVersion = LEBitConverter.ToInt16(buff, offs);
offs += sizeof (short);
this.BuildNumber = LEBitConverter.ToInt16(buff, offs);
offs += sizeof (short);
this.RevisionNumber = LEBitConverter.ToInt16(buff, offs);
offs += sizeof (short);
this.Flags = (AssemblyFlags) LEBitConverter.ToUInt32(buff, offs);
offs += sizeof (uint);
this.PublicKeyOrToken = LEBitConverter.ToInt32(buff, offs);
offs += 4;
this.Name = LEBitConverter.ToInt32(buff, offs);
offs += 4;
this.Culture = LEBitConverter.ToInt32(buff, offs);
offs += 4;
this.HashValue = LEBitConverter.ToInt32(buff, offs);
}
} // Write
public static void Write(this NativeWriter writer, AssemblyFlags value)
{
writer.WriteUnsigned((uint)value);
} // Write
