public Il2CppOutputProgram(string name) : base(name)
{
AddLibIl2CppAsLibraryFor(this);
Libraries.Add(BoehmGCProgram);
Sources.Add(Distribution.Path.Combine("external").Combine("xxHash/xxhash.c"));
this.DynamicLinkerSettingsForMsvc()
.Add(l => l.WithSubSystemType(SubSystemType.Console).WithEntryPoint("wWinMainCRTStartup"));
Libraries.Add(c => c.ToolChain.Platform is WindowsPlatform, new SystemLibrary("kernel32.lib"));
Defines.Add(c => c.Platform is WebGLPlatform, "IL2CPP_DISABLE_GC=1");
this.DynamicLinkerSettingsForMsvc().Add(l => l
.WithSubSystemType(SubSystemType.Console)
.WithEntryPoint("wWinMainCRTStartup")
);
Defines.Add(c => c.ToolChain.DynamicLibraryFormat == null, "FORCE_PINVOKE_INTERNAL=1");
this.DynamicLinkerSettingsForEmscripten().Add(c =>
c.WithShellFile(BuildProgram.BeeRoot.Combine("shell.html")));
Libraries.Add(c => c.Platform is WebGLPlatform, new PreJsLibrary(BuildProgram.BeeRoot.Combine("tiny_runtime.js")));
Defines.Add(ManagedDebuggingIsEnabled, "IL2CPP_MONO_DEBUGGER=1");
Defines.Add(ManagedDebuggingIsEnabled, "IL2CPP_DEBUGGER_PORT=56000");
CompilerSettings().Add(ManagedDebuggingIsEnabled, c => c.WithExceptions(true));
CompilerSettings().Add(ManagedDebuggingIsEnabled, c => c.WithRTTI(true));
MsvcNativeProgramExtensions.CompilerSettingsForMsvc(this).Add(c => c.WithWarningPolicies(new [] { new WarningAndPolicy("4102", WarningPolicy.Silent) }));
CompilerSettings().Add(s => s.WithCppLanguageVersion(CppLanguageVersion.Cpp11));
}
private void AddLibrary_OnClick(object sender, RoutedEventArgs e)
{
var button = sender as Button;
if (button == null)
{
return;
}
var imageLibrary = button.DataContext as Type;
if (imageLibrary == null)
{
return;
}
var newLibrary = imageLibrary.GetMethod("CreateLibrary").Invoke(null, null) as ImageLibrary;
if (newLibrary == null)
{
return;
}
Libraries.Add(newLibrary);
Browser.SetLibrary(newLibrary);
}
private void LibraryTreeList_OnMouseDoubleClick(object sender, MouseButtonEventArgs e)
{
var value = LibraryTreeList.SelectedItem as ImageLibrary;
if (value != null)
{
Process.Start(value.SourceUrl);
}
else
{
var newValue = LibraryTreeList.SelectedItem as ImageData;
if (newValue == null)
{
return;
}
ImageLibrary subLibrary = Browser.CurrentLibrary.CreateSubLibrary(newValue);
if (subLibrary == null)
{
return;
}
Libraries.Add(subLibrary);
Browser.SetLibrary(subLibrary);
}
}
public void Scanning(InputFile input)
{
var currentLibrary = input.Libraries.FirstOrDefault(x => input.Libraries.Max(x => x.StepID) == x.StepID);
currentLibrary.ProcessType = ProcessType.SCANNED;
LibrariesStep.Add(currentLibrary);
input.Libraries.Remove(currentLibrary);
Libraries.Add(new Library()
{
ID = 0
});
for (int i = currentLibrary.SignupProcess; i < input.DaysForScanning; i++)
{
generateNextLibrary(input);
foreach (var item in LibrariesStep)
{
if (item.ProcessType == ProcessType.SCANNED)
{
scannBooks(item);
}
}
UpdateLibrary(i);
}
}
private void generateNextLibrary(InputFile input)
{
var daysSpent = LibrariesStep.Sum(x => x.SignupProcess);
var daysLast = input.DaysForScanning - daysSpent;
foreach (var library in input.Libraries)
{
library.UpdateStepId(daysLast);
}
if (input.Libraries.Count == 0)
{
return;
}
var currentLibrary = input.Libraries.FirstOrDefault(x => input.Libraries.Max(z => z.StepID) == x.StepID);
currentLibrary.ProcessType = ProcessType.SIGNUP;
LibrariesStep.Add(currentLibrary);
Libraries.Add(new Library()
{
ID = Libraries.Max(x => x.ID) + 1
});
input.Libraries.Remove(currentLibrary);
}
private static void Register(IEmulatorServiceProvider serviceProvider)
{
// Register external apis
var apis = Assembly
.Load("BizHawk.Client.ApiHawk")
.GetTypes()
.Where(t => typeof(IExternalApi).IsAssignableFrom(t))
.Where(t => t.IsSealed)
.Where(t => ServiceInjector.IsAvailable(serviceProvider, t))
.ToList();
apis.AddRange(
Assembly
.GetAssembly(typeof(ApiContainer))
.GetTypes()
.Where(t => typeof(IExternalApi).IsAssignableFrom(t))
.Where(t => t.IsSealed)
.Where(t => ServiceInjector.IsAvailable(serviceProvider, t)));
foreach (var api in apis)
{
var instance = (IExternalApi)Activator.CreateInstance(api);
ServiceInjector.UpdateServices(serviceProvider, instance);
Libraries.Add(api, instance);
}
container = new ApiContainer(Libraries);
GlobalWin.ApiProvider = new BasicApiProvider(container);
}
private void Libraries_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
{
if (e.Action == NotifyCollectionChangedAction.Add)
{
foreach (SteamLibrary addition in e.NewItems)
{
var newLib = (addition is SteamArchive)
? new SteamArchiveViewModel(addition as SteamArchive)
: new SteamLibraryViewModel(addition);
newLib.UpdateFilter(LocalListFilter);
Libraries.Add(newLib);
}
}
if (e.Action == NotifyCollectionChangedAction.Remove)
{
foreach (SteamLibrary removal in e.OldItems)
{
SteamLibraryViewModel itemToRemove = null;
foreach (var lib in Libraries)
{
if (lib.Model == removal)
{
itemToRemove = lib;
break;
}
}
if (itemToRemove != null)
{
Libraries.Remove(itemToRemove);
}
}
}
}
public void SetupConditionalSourcesAndLibrariesForConfig(DotsRuntimeCSharpProgramConfiguration config, DotNetAssembly setupGame)
{
NPath[] il2cppGeneratedFiles = SetupInvocation(setupGame);
//todo: stop comparing identifier.
Sources.Add(npc => ((DotsRuntimeNativeProgramConfiguration)npc).CSharpConfig == config, il2cppGeneratedFiles);
Libraries.Add(npc => ((DotsRuntimeNativeProgramConfiguration)npc).CSharpConfig == config, setupGame.RecursiveRuntimeDependenciesIncludingSelf.SelectMany(r => r.Deployables.OfType <StaticLibrary>()));
}
public EmuLuaLibrary(IEmulatorServiceProvider serviceProvider)
: this()
{
LuaWait = new AutoResetEvent(false);
Docs.Clear();
// Register lua libraries
var libs = Assembly
.Load("BizHawk.Client.Common")
.GetTypes()
.Where(t => typeof(LuaLibraryBase).IsAssignableFrom(t))
.Where(t => t.IsSealed)
.Where(t => ServiceInjector.IsAvailable(serviceProvider, t))
.ToList();
libs.AddRange(
Assembly
.GetAssembly(typeof(EmuLuaLibrary))
.GetTypes()
.Where(t => typeof(LuaLibraryBase).IsAssignableFrom(t))
.Where(t => t.IsSealed)
.Where(t => ServiceInjector.IsAvailable(serviceProvider, t)));
foreach (var lib in libs)
{
bool addLibrary = true;
var attributes = lib.GetCustomAttributes(typeof(LuaLibraryAttributes), false);
if (attributes.Any())
{
addLibrary = VersionInfo.DeveloperBuild || (attributes.First() as LuaLibraryAttributes).Released;
}
if (addLibrary)
{
var instance = (LuaLibraryBase)Activator.CreateInstance(lib, _lua);
instance.LuaRegister(lib, Docs);
instance.LogOutputCallback = ConsoleLuaLibrary.LogOutput;
ServiceInjector.UpdateServices(serviceProvider, instance);
Libraries.Add(lib, instance);
}
}
_lua.RegisterFunction("print", this, GetType().GetMethod("Print"));
EmulatorLuaLibrary.FrameAdvanceCallback = Frameadvance;
EmulatorLuaLibrary.YieldCallback = EmuYield;
// Add LuaCanvas to Docs
Type luaCanvas = typeof(LuaCanvas);
var methods = luaCanvas
.GetMethods()
.Where(m => m.GetCustomAttributes(typeof(LuaMethodAttributes), false).Any());
foreach (var method in methods)
{
Docs.Add(new LibraryFunction(nameof(LuaCanvas), luaCanvas.Description(), method));
}
}
public async Task Init()
{
var libs = await Load();
foreach (var lib in libs)
{
Libraries.Add(lib);
}
}
public void AddAll(IEnumerable <StorageFolder> folders)
{
var folderLibraries = folders.Select(f => new StoreFolderLocalLibrary(f));
foreach (var lib in folderLibraries)
{
Libraries.Add(lib);
}
Reset();
}
public void Library_Load(Stream _s)
{
_s.ReadInteger();
int num = _s.ReadInteger();
for (int i = 0; i < num; i++)
{
Libraries.Add(_s.ReadString());
}
}
public Program()
{
_fileName = null;
_isModified = false;
Procedures = new ProgramProcedureList(this, new ObservableCollection <Procedure>());
_isOptimized = false;
Libraries = LibraryList.Create();
Libraries.Add(Library.Standard);
}
public void Execute(string sourceCode)
{
libs = new Libraries();
libs.Add(new LibrarySystem());
Parser = new Parser(libs);
State = new ParserState(sourceCode);
Parser.GetAst(Parser.Root, State);
Parser.Root.Execute();
}
public void ReadLibrariesFromFile(string filename)
{
StreamReader w = new StreamReader(filename);
string line = "";
while ((line = w.ReadLine()) != null)
{
Libraries.Add(new Library(line.Trim()));
}
w.Close();
}
public Query(CodeSentence codeSentence)
{
if (codeSentence == null)
{
throw new ArgumentNullException("codeSentence");
}
CodeSentence = codeSentence;
Libraries = LibraryList.Create();
Libraries.Add(Library.Standard);
}
public ActionLibrary GetActionLibrary(int libid)
{
ActionLibrary lib;
if (Libraries.TryGetValue(libid, out lib))
{
return(lib);
}
lib = new ActionLibrary(this, libid);
Libraries.Add(libid, lib);
return(lib);
}
public void GenerateLibraryData()
{
for (int i = 0; i < 5000; i++)
{
string name = _cities[_generator.Next(0, _cities.Length)];
if (name != "")
{
char part = (char)_generator.Next(65, 90);
Libraries.Add(new Library(name + " " + part + i % 8));
}
}
}
private static IExternalApiProvider Register(IEmulatorServiceProvider serviceProvider)
{
foreach (var api in Assembly.GetAssembly(typeof(ApiSubsetContainer)).GetTypes()
.Concat(Assembly.GetAssembly(typeof(ApiContainer)).GetTypes())
.Where(t => typeof(IExternalApi).IsAssignableFrom(t) && t.IsSealed && ServiceInjector.IsAvailable(serviceProvider, t)))
{
var instance = (IExternalApi)Activator.CreateInstance(api);
ServiceInjector.UpdateServices(serviceProvider, instance);
Libraries.Add(api, instance);
}
_container = new ApiContainer(Libraries);
return(new BasicApiProvider(_container));
}
public Il2CppOutputProgram(string name) : base(name)
{
AddLibIl2CppAsLibraryFor(this);
var distRoot = Distribution.Path.ResolveWithFileSystem();
Libraries.Add(BoehmGCProgram);
Sources.Add(distRoot.Combine("external").Combine("xxHash/xxhash.c"));
this.DynamicLinkerSettingsForMsvc()
.Add(l => l.WithSubSystemType(SubSystemType.Console).WithEntryPoint("wWinMainCRTStartup"));
Libraries.Add(c => c.ToolChain.Platform is WindowsPlatform, new SystemLibrary("kernel32.lib"));
this.DynamicLinkerSettingsForMsvc().Add(l => l
.WithSubSystemType(SubSystemType.Console)
.WithEntryPoint("wWinMainCRTStartup")
);
Defines.Add(c => c.ToolChain.DynamicLibraryFormat == null, "FORCE_PINVOKE_INTERNAL=1");
this.DynamicLinkerSettingsForAndroid().Add(c =>
((DotsRuntimeNativeProgramConfiguration)c).CSharpConfig.DotsConfiguration == DotsConfiguration.Release, l => l.WithStripAll(true));
Libraries.Add(c => c.Platform is WebGLPlatform, new PreJsLibrary(BuildProgram.BeeRoot.Parent.Combine("LowLevelSupport~", "WebSupport", "tiny_runtime.js")));
Defines.Add(ManagedDebuggingIsEnabled, "IL2CPP_MONO_DEBUGGER=1");
Defines.Add(ManagedDebuggingIsEnabled, "IL2CPP_DEBUGGER_PORT=56000");
// Remove this comment to enable the managed debugger log file. It will be written to the working directory. For Web builds, the output will go to the browser's console.
//Defines.Add(ManagedDebuggingIsEnabled, "IL2CPP_MONO_DEBUGGER_LOGFILE=il2cpp-debugger.log");
Defines.Add(c => ((DotsRuntimeNativeProgramConfiguration)c).CSharpConfig.DotsConfiguration != DotsConfiguration.Release, "IL2CPP_TINY_DEBUG_METADATA");
CompilerSettings().Add(ManagedDebuggingIsEnabled, c => c.WithExceptions(true));
CompilerSettings().Add(ManagedDebuggingIsEnabled, c => c.WithRTTI(true));
IncludeDirectories.Add(ManagedDebuggingIsEnabled, distRoot.Combine("libil2cpp/pch"));
CompilerSettings().Add(s => s.WithCppLanguageVersion(CppLanguageVersion.Cpp11));
this.CompilerSettingsForMsvc().Add(c => c.WithWarningPolicies(new [] { new WarningAndPolicy("4102", WarningPolicy.Silent) }));
this.CompilerSettingsForGcc().Add(s => s.WithWarningPolicies(GetGccLikeWarningPolicies()));
this.CompilerSettingsForClang().Add(s => s.WithWarningPolicies(GetGccLikeWarningPolicies()));
this.CompilerSettingsForEmscripten().Add(s => s.WithWarningPolicies(GetGccLikeWarningPolicies()));
this.CompilerSettingsForIos().Add(s => s.WithWarningPolicies(GetGccLikeWarningPolicies()));
NativeJobsPrebuiltLibrary.AddToNativeProgram(this); // Only required for managed debugging
this.CompilerSettingsForEmscripten().Add(ManagedDebuggingIsEnabled,
c => c.WithMultithreading_Compiler(EmscriptenMultithreadingMode.Enabled));
this.CompilerSettingsForGccLike().Add(s => s.WithCustomFlags(new[] { "-fno-strict-overflow" }));
}
public void ReadDefineLibrary(string linea, int libraryId)
{
string[] dta = linea.Split(' ');
int numeroLibro = int.Parse(dta[0]);
int numeroDias = int.Parse(dta[1]);
int numeroEnvio = int.Parse(dta[2]);
Library libra = new Library();
libra.LibraryId = libraryId;
libra.NumeroLibrosEnvioDia = numeroEnvio;
libra.DiasTotalesRegistro = numeroDias;
Libraries.Add(libra);
Console.WriteLine(numeroLibro + " " + numeroDias);
}
public void SetupConditionalSourcesAndLibrariesForConfig(DotsRuntimeCSharpProgramConfiguration config, DotNetAssembly setupGame)
{
NPath[] il2cppGeneratedFiles = SetupInvocation(setupGame, config).ResolveWithFileSystem();
//todo: stop comparing identifier.
Sources.Add(npc => ((DotsRuntimeNativeProgramConfiguration)npc).CSharpConfig == config, il2cppGeneratedFiles);
var staticLibs = setupGame.RecursiveRuntimeDependenciesIncludingSelf.SelectMany(r => r.Deployables.OfType <StaticLibrary>());
Libraries.Add(npc => ((DotsRuntimeNativeProgramConfiguration)npc).CSharpConfig == config, staticLibs);
// force pinvoke internal for static libraries
staticLibs.ForEach(l => Defines.Add(npc => ((DotsRuntimeNativeProgramConfiguration)npc).CSharpConfig == config, PinvokeInternalDefineFor(l)));
if (config.EnableManagedDebugging)
{
SupportFiles.Add(c => c == config.NativeProgramConfiguration, new DeployableFile(Il2CppTargetDirForAssembly(setupGame).Combine(metadataFilePath), new NPath(metadataFilePath)));
}
}
private void AddLibraryInternal(StyleLibrary library)
{
if (Libraries.Contains(library))
{
return;
}
if (library.Dependencies != null)
{
foreach (var dependentLibrary in library.Dependencies)
{
AddLibraryInternal(dependentLibrary);
}
}
Libraries.Add(library);
LibraryOrder.Add(library);
}
private static Library GetLibrary(string libName)
{
var libFName = Path.ChangeExtension(libName, ".dll");
var nameSp = Path.GetFileNameWithoutExtension(libName);
var baseClassName = $"{nameSp}.{GREETER_COLLECTION_NAME_SPACE}";
if (libFName == null || nameSp == null)
{
return(null);
}
if (Libraries.ContainsKey(nameSp))
{
return(Libraries[nameSp]);
}
var rootDir = AppDomain.CurrentDomain.RelativeSearchPath;
var libPath = Path.Combine(rootDir, libFName);
if (!File.Exists(libPath))
{
return(null);
}
//загружаем библиотеку
try
{
var assembly = Assembly.LoadFile(libPath);
var t = assembly.GetType(baseClassName);
var baseObject = (IGreeterLib)t.InvokeMember(null, BindingFlags.CreateInstance, null, null, null);
var lib = new Library(baseObject);
Libraries.Add(nameSp, lib);
return(lib);
}
catch (Exception e)
{
throw new IOException("Ошибка при открытии библиотеки репозиториев. \n" +
$"Библиотека - \"{libPath}\" \n" +
$"Имя класса - \"{baseClassName}\"", e);
}
}
public static void GetAvailableLibraries(string instanceDirectory, string libraryDirectory, Libraries libraries, bool setLibraryDirectory)
{
string libraryName;
string libraryFileName;
string[] localLibraries = System.IO.Directory.GetDirectories(libraryDirectory);
for (int index = 0; index < localLibraries.Length; index++)
{
libraryName = Path.GetFileName(localLibraries[index]);
libraryFileName = Path.Combine(localLibraries[index], GetFileName(libraryName));
if (File.Exists(libraryFileName))
{
Schema.Library library = LoadFromFile(libraryFileName, instanceDirectory);
if (setLibraryDirectory)
{
library.Directory = localLibraries[index];
}
libraries.Add(library);
}
}
}
/// <summary>
/// Loads paths to all user steam libraries.
/// </summary>
private void LoadLibraries()
{
Libraries.Clear();
Libraries.Add(new Library(this, RootPath));
var librariesPath = Path.Combine(RootPath, "steamapps", "libraryfolders.vdf");
if (!File.Exists(librariesPath))
{
return;
}
var folders = (VdfTable)VdfDeserializer.FromFile(librariesPath).Deserialize();
var index = 1;
while (folders.TryGetValue(index.ToString(), out var value))
{
Libraries.Add(new Library(this, ((VdfString)value).Content));
index++;
}
}
public void AddLibrary(string name, string url)
{
if (Directory.Exists(url))
{
LoadMediaInfoFromNewLibrary(url);
var playlistname = "lib_" + name;
var playlist = GetPlaylistFromMediaCollection(playlistname);
var audio = mPlayer.mediaCollection.getByAttribute("MediaType", "audio");
for (var i = 0; i < audio.count; i++)
{
var media = audio.Item[i];
if (media.sourceURL.ToLower().Contains(url.ToLower()))
{
var count = mPlayer.mediaCollection.getAll().count;
playlist.appendItem(media);
allLibrariesPlaylist.appendItem(media);
}
}
Libraries.Add(new Library(name, url, playlist));
}
}
private void LoadLibraries()
{
Logger.Log.Debug("Loading");
var libraries = GetLibraries();
if (libraries.Count == 0)
{
CreateDefaultLibraries();
libraries = GetLibraries();
}
foreach (FileInfo file in libraries)
{
var library = DeserializeFromFile(file.Name.Replace(".xml", string.Empty));
Libraries.Add(new LibraryViewModel(this, library));
}
ActiveLibrary = Libraries[0];
WindowManager.LibraryManagementViewModel.ActiveLibrary = Libraries[0];
Logger.Log.DebugFormat("Loaded Libraries[{0}]", Libraries.Count);
}
public Il2CppOutputProgram(string name) : base(name)
{
Libraries.Add(LibIL2Cpp);
Libraries.Add(BoehmGCProgram);
Sources.Add(Distribution.Path.Combine("external").Combine("xxHash/xxhash.c"));
this.DynamicLinkerSettingsForMsvc()
.Add(l => l.WithSubSystemType(SubSystemType.Console).WithEntryPoint("wWinMainCRTStartup"));
Libraries.Add(c => c.ToolChain.Platform is WindowsPlatform, new SystemLibrary("kernel32.lib"));
Defines.Add(c => c.Platform is WebGLPlatform, "IL2CPP_DISABLE_GC=1");
this.DynamicLinkerSettingsForMsvc().Add(l => l
.WithSubSystemType(SubSystemType.Console)
.WithEntryPoint("wWinMainCRTStartup")
);
Defines.Add(c => c.ToolChain.DynamicLibraryFormat == null, "FORCE_PINVOKE_INTERNAL=1");
this.DynamicLinkerSettingsForEmscripten().Add(c =>
c.WithShellFile(BuildProgram.BeeRoot.Combine("shell.html")));
Libraries.Add(c => c.Platform is WebGLPlatform, new PreJsLibrary(BuildProgram.BeeRoot.Combine("tiny_runtime.js")));
}
private void ParseManagedSemantics()
{
var stringTable = m_context.PathTable.StringTable;
var magicNugetMarker = PathAtom.Create(stringTable, "_._");
var dllExtension = PathAtom.Create(stringTable, ".dll");
foreach (var relativePath in PackageOnDisk.Contents.OrderBy(path => path.ToString(stringTable)))
{
// This is a dll. Check if it is in a lib folder or ref folder.
// This code handles two layouts
// Case 1: /runtimes/{targetRuntime}/[lib|ref]/{targetFramework}/{fileName}
// Case 2: /[lib|ref]/{targetFramework}/{fileName}
// In case 1, /runtimes/{targetRuntime} is removed and then rest of string is processed as in
// case 2.
// Case 2 treats files under 'lib' folder as runtime dependencies (and optionally compile-time
// references if missing a corresponding set of compile-time references for the target framework
// under the 'ref' folder). Files under 'ref' folder are treated strictly as compile-time only references.
var atoms = new ReadOnlySpan <PathAtom>(relativePath.GetAtoms());
if (atoms.Length == 5)
{
var isRuntime = NugetFrameworkMonikers.RuntimesFolderName.CaseInsensitiveEquals(stringTable, atoms[0]) &&
NugetFrameworkMonikers.SupportedTargetRuntimeAtoms.Contains(atoms[1].StringId);
if (isRuntime)
{
atoms = atoms.Slice(2);
}
}
if (atoms.Length == 3)
{
var libOrRef = atoms[0];
var targetFrameworkFolder = atoms[1];
var fileName = atoms[2];
var isLib = NugetFrameworkMonikers.LibFolderName.CaseInsensitiveEquals(stringTable, libOrRef);
var isRef = NugetFrameworkMonikers.RefFolderName.CaseInsensitiveEquals(stringTable, libOrRef);
if (isLib || isRef)
{
if (!TryGetKnownTargetFramework(targetFrameworkFolder, out NugetTargetFramework targetFramework))
{
// We skip unknown frameworks, packages are not necessarily well constructed. We log this
// as a verbose message (i.e., this is not an error).
Logger.Log.NugetUnknownFramework(m_context.LoggingContext, PackageOnDisk.Package.Id,
targetFrameworkFolder.ToString(stringTable), relativePath.ToString(stringTable));
continue;
}
var isManagedEntry = false;
var ext = fileName.GetExtension(stringTable);
if (dllExtension.CaseInsensitiveEquals(stringTable, ext))
{
isManagedEntry = true;
if (isRef)
{
References.Add(targetFramework, relativePath);
}
if (isLib)
{
Libraries.Add(targetFramework, relativePath);
}
}
else if (fileName == magicNugetMarker)
{
isManagedEntry = true;
}
if (isManagedEntry)
{
IsManagedPackage = true;
if (!TargetFrameworks.Contains(targetFramework.Moniker))
{
TargetFrameworks.Add(targetFramework.Moniker);
}
// The magic marker is there so the framework is declared as supported, but no actual files are listed
// So we don't want to add a magic marker as a real artifact that can be referenced.
if (fileName != magicNugetMarker)
{
AssemblyToTargetFramework.Add(fileName, targetFramework);
}
}
}
}
}
if (TargetFrameworks.Count == 0)
{
var history = ForceFullFrameworkQualifiersOnly ?
NugetFrameworkMonikers.FullFrameworkVersionHistory :
NugetFrameworkMonikers.WellknownMonikers.ToList();
foreach (var moniker in history)
{
TargetFrameworks.Add(moniker);
}
}
// For the refs without lib, copy them to refs.
foreach (var kv in Libraries)
{
if (!References.ContainsKey(kv.Key))
{
References.Add(kv.Key, kv.Value.ToArray());
}
}
}
