// Look for %(Identity).{dll|exe|..}
// if specific_version==true
// resolve if assembly names match
// else
// resolve the valid assembly
public ResolvedReference FindInDirectory(ITaskItem reference, string directory, string [] file_extensions, bool specific_version)
{
string filename = reference.ItemSpec;
int comma_pos = filename.IndexOf(',');
if (comma_pos >= 0)
{
filename = filename.Substring(0, comma_pos);
}
// Try as a filename
string path = Path.GetFullPath(Path.Combine(directory, filename));
AssemblyName aname = specific_version ? new AssemblyName(reference.ItemSpec) : null;
ResolvedReference resolved_ref = ResolveReferenceForPath(path, reference, aname, null, SearchPath.Directory, specific_version);
if (resolved_ref != null)
{
return(resolved_ref);
}
// try path + Include + {.dll|.exe|..}
foreach (string extn in file_extensions)
{
resolved_ref = ResolveReferenceForPath(path + extn, reference, aname, null, SearchPath.Directory, specific_version);
if (resolved_ref != null)
{
return(resolved_ref);
}
}
return(null);
}
public ResolvedReference ResolvePkgConfigReference(ITaskItem reference, bool specific_version)
{
PackageAssemblyInfo pkg = null;
if (specific_version)
{
pkg = PcCache.GetAssemblyLocation(reference.ItemSpec);
}
else
{
// if not specific version, then just match simple name
string name = reference.ItemSpec;
if (name.IndexOf(',') > 0)
{
name = name.Substring(0, name.IndexOf(','));
}
pkg = PcCache.ResolveAssemblyName(name).FirstOrDefault();
}
if (pkg == null)
{
LogSearchMessage("Considered {0}, but could not find in any pkg-config files.",
reference.ItemSpec);
return(null);
}
ResolvedReference rr = GetResolvedReference(reference, pkg.File, new AssemblyName(pkg.FullName),
false, SearchPath.PkgConfig);
rr.FoundInSearchPathAsString = String.Format("{{PkgConfig}} provided by package named {0}",
pkg.ParentPackage.Name);
return(rr);
}
//FIXME: Consider CandidateAssemblyFiles also here
void ResolveAssemblyFiles()
{
if (assemblyFiles == null)
{
return;
}
foreach (ITaskItem item in assemblyFiles)
{
assembly_resolver.ResetSearchLogger();
if (!File.Exists(item.ItemSpec))
{
LogWithPrecedingNewLine(MessageImportance.Low,
"Primary Reference from AssemblyFiles {0}, file not found. Ignoring",
item.ItemSpec);
continue;
}
LogWithPrecedingNewLine(MessageImportance.Low, "Primary Reference from AssemblyFiles {0}", item.ItemSpec);
string copy_local;
AssemblyName aname;
if (!assembly_resolver.TryGetAssemblyNameFromFile(item.ItemSpec, out aname))
{
Log.LogWarning("Reference '{0}' not resolved", item.ItemSpec);
assembly_resolver.LogSearchLoggerMessages(MessageImportance.Normal);
continue;
}
if (Environment.GetEnvironmentVariable("XBUILD_LOG_REFERENCE_RESOLVER") != null)
{
assembly_resolver.LogSearchLoggerMessages(MessageImportance.Low);
}
ResolvedReference rr = assembly_resolver.GetResolvedReference(item, item.ItemSpec, aname, true,
SearchPath.RawFileName);
copy_local = rr.CopyLocal.ToString();
if (!TryAddNewReference(tempResolvedFiles, rr))
{
// already resolved
continue;
}
SetCopyLocal(rr.TaskItem, copy_local);
FindAndAddRelatedFiles(item.ItemSpec, copy_local);
FindAndAddSatellites(item.ItemSpec, copy_local);
if (FindDependencies && !IsFromGacOrTargetFramework(rr) &&
rr.FoundInSearchPath != SearchPath.PkgConfig)
{
primaryReferences.Add(new PrimaryReference(item, copy_local));
}
}
}
bool IncludeDependencies(ResolvedReference rr, string aname)
{
if (rr == null)
{
return(false);
}
if (aname.Equals("System.Runtime, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a"))
{
return(true);
}
return(!IsFromGacOrTargetFramework(rr) && rr.FoundInSearchPath != SearchPath.PkgConfig);
}
// returns true is it was new
bool TryAddNewReference(List <ITaskItem> file_list, ResolvedReference key_ref)
{
ResolvedReference found_ref;
if (!TryGetResolvedReferenceByAssemblyName(key_ref.AssemblyName, key_ref.IsPrimary, out found_ref))
{
assemblyNameToResolvedRef [key_ref.AssemblyName.Name] = key_ref;
file_list.Add(key_ref.TaskItem);
return(true);
}
return(false);
}
void ResolveAssemblies()
{
if (assemblies == null || assemblies.Length == 0)
{
return;
}
foreach (ITaskItem item in assemblies)
{
if (!String.IsNullOrEmpty(item.GetMetadata("SubType")))
{
Log.LogWarning("Reference '{0}' has non-empty SubType. Ignoring.", item.ItemSpec);
continue;
}
LogWithPrecedingNewLine(MessageImportance.Low, "Primary Reference {0}", item.ItemSpec);
ResolvedReference resolved_ref = ResolveReference(item, searchPaths, true);
if (resolved_ref == null)
{
resolved_ref = ResolveWithAlternateName(item, allowedAssemblyExtensions ?? default_assembly_extensions);
}
if (resolved_ref == null)
{
Log.LogWarning("Reference '{0}' not resolved", item.ItemSpec);
assembly_resolver.LogSearchLoggerMessages(MessageImportance.Normal);
}
else
{
Log.LogMessage(MessageImportance.Low,
"\tReference {0} resolved to {1}. CopyLocal = {2}",
item.ItemSpec, resolved_ref.TaskItem,
resolved_ref.TaskItem.GetMetadata("CopyLocal"));
Log.LogMessage(MessageImportance.Low,
"\tReference found at search path {0}",
resolved_ref.FoundInSearchPathAsString);
assembly_resolver.LogSearchLoggerMessages(MessageImportance.Low);
if (TryAddNewReference(tempResolvedFiles, resolved_ref) &&
!IsFromGacOrTargetFramework(resolved_ref) &&
resolved_ref.FoundInSearchPath != SearchPath.PkgConfig)
{
primaryReferences.Add(new PrimaryReference(
resolved_ref.TaskItem,
resolved_ref.TaskItem.GetMetadata("CopyLocal")));
}
}
}
}
public ResolvedReference ResolveHintPathReference(ITaskItem reference, bool specific_version)
{
AssemblyName name = new AssemblyName(reference.ItemSpec);
ResolvedReference resolved = null;
string hintpath = reference.GetMetadata("HintPath");
if (String.IsNullOrEmpty(hintpath))
{
LogSearchMessage("HintPath attribute not found");
return(null);
}
if (!File.Exists(hintpath))
{
log.LogMessage(MessageImportance.Low, "HintPath {0} does not exist.", hintpath);
LogSearchMessage("Considered {0}, but it does not exist.", hintpath);
return(null);
}
AssemblyName found = GetAssemblyNameFromFile(hintpath);
if (found == null)
{
log.LogMessage(MessageImportance.Low, "File at HintPath {0}, is either an invalid assembly or the file does not exist.", hintpath);
return(null);
}
if (AssemblyNamesCompatible(name, found, specific_version))
{
resolved = GetResolvedReference(reference, hintpath, found, true, SearchPath.HintPath);
}
else
{
LogSearchMessage("Considered {0}, but assembly name '{1}' did not match the " +
"expected '{2}' (SpecificVersion={3})", hintpath, found, name, specific_version);
log.LogMessage(MessageImportance.Low, "Assembly names are not compatible.");
}
return(resolved);
}
// Tries to resolve assemblies referenced by @item
// Skips gac references
// @item : filename
void ResolveAssemblyFileDependencies(ITaskItem item, string parent_copy_local)
{
Queue <string> dependencies = new Queue <string> ();
dependencies.Enqueue(item.ItemSpec);
while (dependencies.Count > 0)
{
string filename = Path.GetFullPath(dependencies.Dequeue());
Assembly asm = Assembly.ReflectionOnlyLoadFrom(filename);
if (alreadyScannedAssemblyNames.ContainsKey(asm.FullName))
{
continue;
}
// set the 1st search path to this ref's base path
// Will be used for resolving the dependencies
dependency_search_paths [0] = Path.GetDirectoryName(filename);
foreach (AssemblyName aname in asm.GetReferencedAssemblies())
{
if (alreadyScannedAssemblyNames.ContainsKey(aname.FullName))
{
continue;
}
ResolvedReference resolved_ref = ResolveDependencyByAssemblyName(
aname, asm.FullName, parent_copy_local);
if (resolved_ref != null && !IsFromGacOrTargetFramework(resolved_ref) &&
resolved_ref.FoundInSearchPath != SearchPath.PkgConfig)
{
tempResolvedDepFiles[resolved_ref.AssemblyName.FullName] = resolved_ref.TaskItem;
dependencies.Enqueue(resolved_ref.TaskItem.ItemSpec);
}
}
alreadyScannedAssemblyNames.Add(asm.FullName, String.Empty);
}
}
bool IsFromGacOrTargetFramework(ResolvedReference rr)
{
return(rr.FoundInSearchPath == SearchPath.Gac ||
rr.FoundInSearchPath == SearchPath.TargetFrameworkDirectory);
}
bool TryGetResolvedReferenceByAssemblyName(AssemblyName key_aname, bool is_primary, out ResolvedReference found_ref)
{
found_ref = null;
// Match by just name
if (!assemblyNameToResolvedRef.TryGetValue(key_aname.Name, out found_ref))
{
// not there
return(false);
}
// match for full name
if (AssemblyResolver.AssemblyNamesCompatible(key_aname, found_ref.AssemblyName, true, false))
{
// exact match, so its already there, dont add anything
return(true);
}
// we have a name match, but version mismatch!
assembly_resolver.LogSearchMessage("A conflict was detected between '{0}' and '{1}'",
key_aname.FullName, found_ref.AssemblyName.FullName);
if (is_primary == found_ref.IsPrimary)
{
assembly_resolver.LogSearchMessage("Unable to choose between the two. " +
"Choosing '{0}' arbitrarily.", found_ref.AssemblyName.FullName);
return(true);
}
// since all dependencies are processed after
// all primary refererences, the one in the cache
// has to be a primary
// Prefer a primary reference over a dependency
assembly_resolver.LogSearchMessage("Choosing '{0}' as it is a primary reference.",
found_ref.AssemblyName.FullName);
// If we can successfully use the primary reference, don't log a warning. It's too
// verbose.
//LogConflictWarning (found_ref.AssemblyName.FullName, key_aname.FullName);
return(true);
}
// Use @search_paths to resolve the reference
ResolvedReference ResolveReference(ITaskItem item, IEnumerable <string> search_paths, bool set_copy_local)
{
ResolvedReference resolved = null;
bool specific_version;
assembly_resolver.ResetSearchLogger();
if (!TryGetSpecificVersionValue(item, out specific_version))
{
return(null);
}
foreach (string spath in search_paths)
{
assembly_resolver.LogSearchMessage("For searchpath {0}", spath);
if (String.Compare(spath, "{HintPathFromItem}") == 0)
{
resolved = assembly_resolver.ResolveHintPathReference(item, specific_version);
}
else if (String.Compare(spath, "{TargetFrameworkDirectory}") == 0)
{
if (targetFrameworkDirectories == null)
{
continue;
}
foreach (string fpath in targetFrameworkDirectories)
{
resolved = assembly_resolver.FindInTargetFramework(item,
fpath, specific_version);
if (resolved != null)
{
break;
}
}
}
else if (String.Compare(spath, "{GAC}") == 0)
{
resolved = assembly_resolver.ResolveGacReference(item, specific_version);
}
else if (String.Compare(spath, "{RawFileName}") == 0)
{
//FIXME: identify assembly names, as extract the name, and try with that?
AssemblyName aname;
if (assembly_resolver.TryGetAssemblyNameFromFile(item.ItemSpec, out aname))
{
resolved = assembly_resolver.GetResolvedReference(item, item.ItemSpec, aname, true,
SearchPath.RawFileName);
}
}
else if (String.Compare(spath, "{CandidateAssemblyFiles}") == 0)
{
assembly_resolver.LogSearchMessage(
"Warning: {{CandidateAssemblyFiles}} not supported currently");
}
else if (String.Compare(spath, "{PkgConfig}") == 0)
{
resolved = assembly_resolver.ResolvePkgConfigReference(item, specific_version);
}
else
{
resolved = assembly_resolver.FindInDirectory(
item, spath,
allowedAssemblyExtensions ?? default_assembly_extensions,
specific_version);
}
if (resolved != null)
{
break;
}
}
if (resolved != null && set_copy_local)
{
SetCopyLocal(resolved.TaskItem, resolved.CopyLocal.ToString());
}
return(resolved);
}
bool IsFromGacOrTargetFramework (ResolvedReference rr)
{
return rr.FoundInSearchPath == SearchPath.Gac ||
rr.FoundInSearchPath == SearchPath.TargetFrameworkDirectory;
}
bool TryGetResolvedReferenceByAssemblyName (AssemblyName key_aname, bool is_primary, out ResolvedReference found_ref)
{
found_ref = null;
// Match by just name
if (!assemblyNameToResolvedRef.TryGetValue (key_aname.Name, out found_ref))
// not there
return false;
// match for full name
if (AssemblyResolver.AssemblyNamesCompatible (key_aname, found_ref.AssemblyName, true, false))
// exact match, so its already there, dont add anything
return true;
// we have a name match, but version mismatch!
assembly_resolver.LogSearchMessage ("A conflict was detected between '{0}' and '{1}'",
key_aname.FullName, found_ref.AssemblyName.FullName);
if (is_primary == found_ref.IsPrimary) {
assembly_resolver.LogSearchMessage ("Unable to choose between the two. " +
"Choosing '{0}' arbitrarily.", found_ref.AssemblyName.FullName);
return true;
}
// since all dependencies are processed after
// all primary refererences, the one in the cache
// has to be a primary
// Prefer a primary reference over a dependency
assembly_resolver.LogSearchMessage ("Choosing '{0}' as it is a primary reference.",
found_ref.AssemblyName.FullName);
LogConflictWarning (found_ref.AssemblyName.FullName, key_aname.FullName);
return true;
}
// returns true is it was new
bool TryAddNewReference (List<ITaskItem> file_list, ResolvedReference key_ref)
{
ResolvedReference found_ref;
if (!TryGetResolvedReferenceByAssemblyName (key_ref.AssemblyName, key_ref.IsPrimary, out found_ref)) {
assemblyNameToResolvedRef [key_ref.AssemblyName.Name] = key_ref;
file_list.Add (key_ref.TaskItem);
return true;
}
return false;
}
bool IncludeDependencies (ResolvedReference rr, string aname)
{
if (rr == null)
return false;
if (aname.Equals ("System.Runtime, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a"))
return true;
return !IsFromGacOrTargetFramework (rr) && rr.FoundInSearchPath != SearchPath.PkgConfig;
}
// Use @search_paths to resolve the reference
ResolvedReference ResolveReference(ITaskItem item, IEnumerable <string> search_paths, bool set_copy_local)
{
ResolvedReference resolved = null;
bool specific_version;
assembly_resolver.ResetSearchLogger();
if (!TryGetSpecificVersionValue(item, out specific_version))
{
return(null);
}
var spath_index = 0;
foreach (string spath in search_paths)
{
assembly_resolver.LogSearchMessage("For searchpath {0}", spath);
// The first value of search_paths can be the parent assembly directory.
// In that case the value would be treated as a directory.
// This code checks if we should treat the value as a TargetFramework assembly.
// Doing so avoids CopyLocal beeing set to true.
if (spath_index++ == 0 && targetFrameworkDirectories != null)
{
foreach (string fpath in targetFrameworkDirectories)
{
if (String.Compare(
Path.GetFullPath(spath).TrimEnd(Path.DirectorySeparatorChar),
Path.GetFullPath(fpath).TrimEnd(Path.DirectorySeparatorChar),
StringComparison.InvariantCulture) != 0)
{
continue;
}
resolved = assembly_resolver.FindInTargetFramework(item,
fpath, specific_version);
break;
}
if (resolved != null)
{
break;
}
}
if (String.Compare(spath, "{HintPathFromItem}") == 0)
{
resolved = assembly_resolver.ResolveHintPathReference(item, specific_version);
}
else if (String.Compare(spath, "{TargetFrameworkDirectory}") == 0)
{
if (targetFrameworkDirectories == null)
{
continue;
}
foreach (string fpath in targetFrameworkDirectories)
{
resolved = assembly_resolver.FindInTargetFramework(item,
fpath, specific_version);
if (resolved != null)
{
break;
}
}
}
else if (String.Compare(spath, "{GAC}") == 0)
{
resolved = assembly_resolver.ResolveGacReference(item, specific_version);
}
else if (String.Compare(spath, "{RawFileName}") == 0)
{
//FIXME: identify assembly names, as extract the name, and try with that?
AssemblyName aname;
if (assembly_resolver.TryGetAssemblyNameFromFile(item.ItemSpec, out aname))
{
resolved = assembly_resolver.GetResolvedReference(item, item.ItemSpec, aname, true,
SearchPath.RawFileName);
}
}
else if (String.Compare(spath, "{CandidateAssemblyFiles}") == 0)
{
assembly_resolver.LogSearchMessage(
"Warning: {{CandidateAssemblyFiles}} not supported currently");
}
else if (String.Compare(spath, "{PkgConfig}") == 0)
{
resolved = assembly_resolver.ResolvePkgConfigReference(item, specific_version);
}
else
{
resolved = assembly_resolver.FindInDirectory(
item, spath,
allowedAssemblyExtensions ?? default_assembly_extensions,
specific_version);
}
if (resolved != null)
{
break;
}
}
if (resolved != null && set_copy_local)
{
SetCopyLocal(resolved.TaskItem, resolved.CopyLocal.ToString());
}
return(resolved);
}