private ITIAssemblyIdentityRule ParseAssemblyIdentityInternal(bool insideTypeParameter = false)
{
/* *
* Annoying truth of AssemblyQualifiedNames, commas are legal,
* as are [, ], = and so on.
* The rules for ] being escaped changes though.
* */
var quotedInfo = ParseCaptureOrSubset(insideTypeParameter ? LookAhead_AssemblyIdentity_Nested : LookAhead_AssemblyIdentity_TopLevel);
string assemblyName = null;
if (quotedInfo.Item3)
{
assemblyName = quotedInfo.Item1;
}
else
{
assemblyName = ParseCapture(insideTypeParameter ? TokenTransitions.Captures.NestedQualifiedAssemblyIdentifier : TokenTransitions.Captures.QualifiedAssemblyIdentifier);
ParseSubset(TokenTransitions.CommonSymbols.QuoteChar);
}
ParseSubset(TokenTransitions.CommonSymbols.Comma);
SkipWhitespace();
ParseSubset(TokenTransitions.AssemblyTerminals.Version);
SkipWhitespace();
ParseSubset(TokenTransitions.CommonSymbols.Equals);
SkipWhitespace();
var version = ParseVersion();
ParseSubset(TokenTransitions.CommonSymbols.Comma);
SkipWhitespace();
ParseSubset(TokenTransitions.AssemblyTerminals.Culture);
SkipWhitespace();
ParseSubset(TokenTransitions.CommonSymbols.Equals);
SkipWhitespace();
var cultureIdParse = ParseCapture(TokenTransitions.Captures.CultureIdentifier);
var cultureId = CultureIdentifiers.GetIdentifierByName(cultureIdParse == "neutral" ? string.Empty : cultureIdParse);
ParseSubset(TokenTransitions.CommonSymbols.Comma);
SkipWhitespace();
ParseSubset(TokenTransitions.AssemblyTerminals.KeyToken);
SkipWhitespace();
ParseSubset(TokenTransitions.CommonSymbols.Equals);
var publicKeyTokenParse = ParseCaptureOrSubset(LookAhead_AssemblyIdentity_KeyToken);
if (publicKeyTokenParse.Item3)
{
return(new TIAssemblyIdentityRule(assemblyName, version, cultureId, ParsePublicKeyBytes(publicKeyTokenParse.Item1)));
}
else
{
return(new TIAssemblyIdentityRule(assemblyName, version, cultureId, null));
}
}
public AssemblyInformation(Assembly assembly)
{
AttributeCollection attrC = new AttributeCollection(assembly.GetCustomAttributes(false).Cast <Attribute>().ToArray());
if (attrC[typeof(AssemblyTitleAttribute)] != null)
{
this.title = ((AssemblyTitleAttribute)attrC[typeof(AssemblyTitleAttribute)]).Title;
}
if (attrC[typeof(AssemblyCompanyAttribute)] != null)
{
this.company = ((AssemblyCompanyAttribute)attrC[typeof(AssemblyCompanyAttribute)]).Company;
}
if (attrC[typeof(AssemblyDescriptionAttribute)] != null)
{
this.description = ((AssemblyDescriptionAttribute)attrC[typeof(AssemblyDescriptionAttribute)]).Description;
}
if (attrC[typeof(AssemblyCopyrightAttribute)] != null)
{
this.copyright = ((AssemblyCopyrightAttribute)attrC[typeof(AssemblyCopyrightAttribute)]).Copyright;
}
if (attrC[typeof(AssemblyProductAttribute)] != null)
{
this.product = ((AssemblyProductAttribute)attrC[typeof(AssemblyProductAttribute)]).Product;
}
if (attrC[typeof(AssemblyTrademarkAttribute)] != null)
{
this.trademark = ((AssemblyTrademarkAttribute)attrC[typeof(AssemblyTrademarkAttribute)]).Trademark;
}
if (attrC[typeof(AssemblyFileVersionAttribute)] != null)
{
this.fileVersion = new Version(((AssemblyFileVersionAttribute)attrC[typeof(AssemblyFileVersionAttribute)]).Version);
}
this.assemblyVersion = assembly.GetName().Version;
this.culture = CultureIdentifiers.GetIdentifierById(assembly.GetName().CultureInfo.LCID);
/*
* if (attrC[typeof(NeutralResourcesLanguageAttribute)] != null)
* this.culture = CultureIdentifier.defaultCultureIDByCultureName[((NeutralResourcesLanguageAttribute)attrC[typeof(NeutralResourcesLanguageAttribute)]).CultureName];
* //*/
this.path = assembly.Location;
this.strongName = attrC[typeof(AssemblyKeyFileAttribute)] != null;
this.loadedFromGac = assembly.GlobalAssemblyCache;
this.assemblyName = assembly.GetName().Name;
}
private static void ValidateAssemblyTable(IAssembly hostAssembly, ICliMetadataRoot metadataRoot, CompilerErrorCollection resultErrorCollection)
{
if (metadataRoot == null)
{
throw new ArgumentNullException("metadataRoot");
}
if (metadataRoot.TableStream == null)
{
throw new ArgumentException("Table stream does not exist in the metadata provided.", "metadataRoot");
}
var assemblyTable = metadataRoot.TableStream.AssemblyTable;
if (assemblyTable != null)
{
if (assemblyTable.Count > 1)
{
/* *
* The assembly table shall contain zero or one row only.
* */
resultErrorCollection.ModelError(CliWarningsAndErrors.CliMetadata2001, hostAssembly, assemblyTable);
}
var firstAssembly = assemblyTable[1];
switch (firstAssembly.HashAlgorithmId)
{
case AssemblyHashAlgorithm.None:
case AssemblyHashAlgorithm.MD5_Reserved:
case AssemblyHashAlgorithm.SHA1:
case AssemblyHashAlgorithm.SHA256:
case AssemblyHashAlgorithm.SHA384:
case AssemblyHashAlgorithm.SHA512:
break;
default:
/* *
* HashAlgId shall be one of the specified values.
* */
resultErrorCollection.ModelError(CliWarningsAndErrors.CliMetadata2002, hostAssembly, firstAssembly);
break;
}
var remainingFlags = (firstAssembly.Flags & ~CliMetadataAssemblyFlags.ValidMask);
if ((int)remainingFlags != 0)
{
/* *
* Flags shall have only those values set that are specified.
* */
resultErrorCollection.ModelError(CliWarningsAndErrors.CliMetadata2004, hostAssembly, firstAssembly);
}
if (firstAssembly.NameIndex == 0 || firstAssembly.Name == string.Empty)
{
/* *
* Name shall index a non-empty string in the String Heap.
* */
resultErrorCollection.ModelError(CliWarningsAndErrors.CliMetadata2006, hostAssembly, firstAssembly);
}
if (firstAssembly.CultureIndex != 0)
{
/* *
* The sets of identifiers used vary slightly, transcode it from the metadata set
* to the standard culture identifier set.
* */
var transcodedCulture = ValidCultureIdentifiers.TranscodeToCultureIdentifier(firstAssembly.Culture);
try
{
CultureIdentifiers.GetIdentifierByName(transcodedCulture);
}
catch (ArgumentOutOfRangeException)
{
/* *
* The specified culture was invalid.
* */
resultErrorCollection.ModelError(CliWarningsAndErrors.CliMetadata2009, hostAssembly, firstAssembly, new string[] { firstAssembly.Culture });
}
}
}
}
