public SourcePackage CreateSourcePackage()
{
var upk = new SourcePackage(
Name,
Version,
Filename,
SourceDirectory ?? RootDirectory,
CacheDirectory,
SourcePackageFlags.Cached | (
IsTransitive
? SourcePackageFlags.Transitive
: 0),
BuildCondition);
upk.SourceFiles.AddRange(SourceFiles);
upk.ExtensionsFiles.AddRange(ExtensionsFiles);
upk.ForeignSourceFiles.AddRange(ForeignSourceFiles);
upk.BundleFiles.AddRange(BundleFiles);
upk.StuffFiles.AddRange(StuffFiles);
foreach (var p in InternalsVisibleTo)
upk.InternalsVisibleTo.Add(p);
foreach (var b in ExtensionsBackends)
upk.CachedExtensionsBackends.Add(b);
foreach (var b in Namespaces)
upk.CachedNamespaces.Add(b);
return upk;
}
public static AstReader Open(SourcePackage upk, string filename)
{
var r = new AstReader(upk, filename);
r.VerifyMagic(AstSerialization.Magic);
return(r);
}
public SourcePackage CreateSourcePackage(bool isStartup = false)
{
var upk = new SourcePackage(
Name,
Version,
FullPath,
RootDirectory,
CacheDirectory,
SourcePackageFlags.Project | (
IsTransitive
? SourcePackageFlags.Transitive
: 0) | (
isStartup
? SourcePackageFlags.Startup
: 0),
BuildCondition);
upk.AdditionalFiles.AddRange(AdditionalFiles);
upk.BundleFiles.AddRange(BundleFiles);
upk.SourceFiles.AddRange(SourceFiles);
upk.ExtensionsFiles.AddRange(ExtensionsFiles);
upk.ForeignSourceFiles.AddRange(ForeignSourceFiles);
upk.StuffFiles.AddRange(StuffFiles);
upk.UXFiles.AddRange(UXFiles);
foreach (var p in InternalsVisibleTo)
{
upk.InternalsVisibleTo.Add(p.String);
}
return(upk);
}
public override bool Parse(SourcePackage upk, string filename, List <AstDocument> result)
{
var p = new Parser(Log, upk, filename, File.ReadAllText(filename));
p.Parse(result);
return(!p.HasErrors);
}
public override BackendResult Build(SourcePackage package)
{
if (package.CanLink)
{
package.Tag = _linker.AddAssemblyFile(Path.Combine(_outputDir, package.Name + ".dll"));
return(null);
}
var g = new CilGenerator(Disk, Data, Essentials,
this, _linker, package, _outputDir);
g.Configure(Environment.Debug);
using (Log.StartProfiler(g.GetType().FullName + ".Generate"))
g.Generate();
if (Log.HasErrors)
{
return(null);
}
using (Log.StartProfiler(g.GetType().FullName + ".Save"))
g.Save();
return(new CilResult(g.Assembly, _linker.TypeMap, g.Locations));
}
public PackageItem(SourcePackage upk)
{
Package = upk;
SourceFiles = new PackageFolderItem(upk, "Source Files");
ExtensionsFiles = new PackageFolderItem(upk, "Extensions Files");
BundleFiles = new PackageFolderItem(upk, "Bundle Files");
ForeignSourceFiles = new PackageFolderItem(upk, "Foreign Source Files");
AdditionalFiles = new PackageFolderItem(upk, "Additional Files");
StuffFiles = new PackageFolderItem(upk, "Stuff Files");
if (upk.Version != null)
{
Suffix = "(" + upk.Version + ")";
}
foreach (var reference in upk.References)
{
References.AddChild(new ReferenceItem(reference));
}
foreach (var f in upk.SourceFiles)
{
SourceFiles.AddFile(upk.SourceDirectory, f.UnixPath);
}
foreach (var f in upk.ExtensionsFiles)
{
ExtensionsFiles.AddFile(upk.SourceDirectory, f.UnixPath);
}
foreach (var f in upk.BundleFiles)
{
BundleFiles.AddFile(upk.SourceDirectory, f.UnixPath);
}
foreach (var f in upk.ForeignSourceFiles)
{
ForeignSourceFiles.AddFile(upk.SourceDirectory, f.UnixPath);
}
foreach (var f in upk.AdditionalFiles)
{
AdditionalFiles.AddFile(upk.SourceDirectory, f.UnixPath);
}
foreach (var f in upk.StuffFiles)
{
StuffFiles.AddFile(upk.SourceDirectory, f.UnixPath);
}
SourceFiles.Collapse();
ExtensionsFiles.Collapse();
BundleFiles.Collapse();
ForeignSourceFiles.Collapse();
AdditionalFiles.Collapse();
StuffFiles.Collapse();
AddChild(References);
AddChild(Resources);
AddChild(SourceFiles);
AddChild(ExtensionsFiles);
AddChild(BundleFiles);
AddChild(ForeignSourceFiles);
AddChild(AdditionalFiles);
AddChild(StuffFiles);
}
internal BuildEnvironment(
Backend backend,
SourcePackage project,
CompilerOptions options,
ExtensionRoot extensions,
ILFactory ilf,
Compiler compiler)
: base(compiler)
{
if (string.IsNullOrEmpty(options.Configuration))
{
options.Configuration = "Debug";
}
if (string.IsNullOrEmpty(options.BuildTarget))
{
throw new ArgumentNullException(nameof(options.BuildTarget));
}
if (string.IsNullOrEmpty(options.OutputDirectory))
{
throw new ArgumentNullException(nameof(options.OutputDirectory));
}
Extensions = extensions;
Options = options;
BundleDirectory = Path.Combine(project.CacheDirectory, "bundle");
CacheDirectory = Path.Combine(project.CacheDirectory, options.BuildTarget, options.Configuration);
Essentials = ilf.Essentials;
MacroExpander = new MacroExpander(backend, this, extensions, ilf, compiler);
Compiler = compiler;
Set("Target", options.BuildTarget);
Set("Configuration", options.Configuration);
Set("OutputDirectory", OutputDirectory = ExpandSingleLine(options.OutputDirectory).UnixToNative());
}
public MetadataGenerator(Disk disk, IBuildData data, IEssentials essentials,
MetadataBackend backend, CilLinker linker, SourcePackage package,
string outputDir)
: base(disk)
{
_data = data;
_essentials = essentials;
_backend = backend;
_package = package;
_linker = linker;
_outputDir = outputDir;
_assembly = _linker.Universe.DefineDynamicAssembly(
new AssemblyName(package.Name)
{
Version = package.ParseVersion(Log)
},
AssemblyBuilderAccess.Save,
outputDir);
var module = _assembly.DefineDynamicModule(
package.Name,
package.Name + ".dll",
true);
_types = new CilTypeFactory(backend, essentials, linker, module);
}
internal static CacheReader CreateReader(SourcePackage upk, string filename)
{
var r = new CacheReader(upk, filename);
r.VerifyMagic(Magic);
return(r);
}
public void ParseSourceCode(SourcePackage upk, string filename, string text)
{
var ast = new List <AstDocument>();
new Parser(Log, upk, filename, text).Parse(ast);
AstProcessor.AddRange(ast);
}
public BundleFile(SourcePackage package, string bundleName, string targetName, string sourcePath)
{
Package = package;
BundleName = bundleName;
TargetName = targetName;
SourcePath = sourcePath;
}
public Compiler(Log log, Backend backend, SourcePackage package, CompilerOptions options)
: base(log)
{
// This is a block of dependency injection to initialize the Compiler
var il = new Namespace();
var extensions = new ExtensionRoot();
Backend = backend;
var disk = Disk = new Disk(log, true);
Shell = new Shell(log);
var essentials = Essentials = new Essentials();
var resolver = NameResolver = new NameResolver(this);
var ilf = ILFactory = new ILFactory(backend, il, essentials, resolver, this);
var data = Data = new BuildData(il, extensions, ilf);
var environment = Environment = new BuildEnvironment(backend, package, options, extensions, ilf, this);
var input = Input = new SourceReader(log, package, environment);
var blockBuilder = BlockBuilder = new BlockBuilder(backend, il, ilf, resolver, this);
var typeBuilder = TypeBuilder = new TypeBuilder(environment, ilf, resolver, this);
var bundle = BundleBuilder = new BundleBuilder(backend, environment, ilf, this);
AstProcessor = new AstProcessor(il, blockBuilder, typeBuilder, resolver, environment);
UxlProcessor = new UxlProcessor(disk, backend.Name, il, extensions, environment, ilf);
Plugins = new PluginCache(log, bundle, ilf, environment);
var pass = Pass = new CompilerPass(disk, data, environment, ilf, backend, input.Package, typeBuilder, resolver);
Utilities = new Utilities(il, pass);
ILVerifier = new ILVerifier(pass);
ConstantFolder = new ConstantFolder(pass);
ILStripper = new ILStripper(pass);
}
public static Compiler.Core.Compiler Create(Log log, SourcePackage project)
{
var backend = new ILCacheBackend();
var compiler = new Compiler.Core.Compiler(log, backend, project, new CompilerOptions
{
Debug = true,
CodeCompletionMode = true,
OutputDirectory = Path.Combine(project.SourceDirectory, "Output"),
BuildTarget = "UXValidator",
Strip = false
});
ParseUxDummyFiles(compiler, project);
compiler.ParseSourceFiles();
compiler.InitializeIL();
compiler.Backend.Begin(compiler);
try
{
compiler.TypeBuilder.BuildTypes();
}
catch (Exception)
{
}
return(compiler);
}
BestMainClassSelector(List <DataType> foundMainClasses, Log log, SourcePackage mainProject, DataType mainClassAttribute)
{
_foundMainClasses = foundMainClasses;
_log = log;
_mainProject = mainProject;
_mainClassAttribute = mainClassAttribute;
}
public ImportContext(Source src, DataType[] types, object[] arguments)
{
Source = src;
TypeArguments = types;
Arguments = arguments;
Package = src.Package;
}
public static void Serialize(this IEnumerable <UxlDocument> list, SourcePackage upk, string filename)
{
using (var w = UxlDocument.CreateWriter(upk, filename))
foreach (var e in list)
{
e.Write(w);
}
}
protected XmlParserBase(Log log, SourcePackage upk, string filename)
: base(log)
{
File = new SourceFile(upk, filename);
StartErrorCount = log.ErrorCount;
Source = XmlPreprocessor.ProcessFile(filename);
Reader = new XmlTextReader(Source, XmlNodeType.Document, null);
}
public SuggestionDependentData(SourcePackage mainPackage, Compiler compiler, AbsoluteFilePath filePath, string srcCode, int caretOffset)
{
MainPackage = mainPackage;
Compiler = compiler;
FilePath = filePath;
SrcCode = srcCode;
CaretOffset = caretOffset;
}
public GotoDefinitionData(SourcePackage mainPackage, Compiler compiler, AbsoluteFilePath filePath, string srcCode, int caretOffset)
{
MainPackage = mainPackage;
Compiler = compiler;
FilePath = filePath;
SrcCode = srcCode;
CaretOffset = caretOffset;
}
public static void Serialize(this IEnumerable <AstDocument> list, SourcePackage upk, string filename, AstSerializationFlags flags)
{
using (var w = AstWriter.Create(upk, filename, flags))
foreach (var e in list)
{
w.WriteDocument(e);
}
}
public bool IsVisibleInPackage(SourcePackage package)
{
return
(Level == VisibilityLevel.Global ||
(Level == VisibilityLevel.Package && Package.Equals(package)) ||
(Level == VisibilityLevel.SameTypeOrSubclassOfOrPackage && Package.Equals(package)) ||
Package.InternalsVisibleTo.Contains(package.Name));
}
public SourceReader(Log log, SourcePackage upk, IFrontendEnvironment env)
: base(log)
{
_upk = upk;
_env = env;
AstCache = new AstCache(log, _filenames);
UxlCache = new UxlCache(log, _filenames);
ResolvePackageOrder(upk, new HashSet <SourcePackage>());
}
public ForeignFilePass(
ExtensionRoot extensions,
SourcePackage package,
CppBackend backend)
: base(backend)
{
Extensions = extensions;
Package = package;
Backend = backend;
}
//--------------------------------------------------------------------------
// IDisposable Members
//--------------------------------------------------------------------------
/// <summary>
/// <see cref="MS.Internal.Documents.Application.Document"/>
/// </summary>
protected override void Dispose(bool disposing)
{
try
{
if (disposing)
{
// our base is StreamDocument, as these packages support
// the stream we want our base to release them first
ReleaseStreams();
// The only code that actually requires this assert are the
// calls to Close. Regardless I've put the assert around the
// whole block since the rest of the code under it is almost
// all just checking packages for null or setting them to null.
// This is much cleaner than having three separate asserts (and
// three more try/finally blocks) for each Close call.
try
{
if (DestinationPackage != null)
{
if (DestinationPackage == SourcePackage)
{
SourcePackage = null;
}
DestinationPackage.Close();
DestinationPackage = null;
}
}
finally
{
try
{
if (WorkspacePackage != null)
{
WorkspacePackage.Close();
WorkspacePackage = null;
}
}
finally
{
if (SourcePackage != null)
{
SourcePackage.Close();
SourcePackage = null;
}
}
}
}
}
finally
{
base.Dispose(disposing);
}
}
public PackageGenerator(
IEnvironment env,
SourcePackage upk,
Log log,
Disk disk)
{
_env = env;
_upk = upk;
_log = log;
_disk = disk;
}
public static AstWriter Create(SourcePackage upk, string filename, AstSerializationFlags flags)
{
if (upk.IsUnknown)
{
throw new InvalidOperationException("AstWriter: Unknown source package");
}
var w = new AstWriter(upk, filename, flags);
w.Write(AstSerialization.Magic);
return(w);
}
public CompilerPass(CompilerPass parent)
: base(parent)
{
Backend = parent.Backend;
Package = parent.Package;
TypeBuilder = parent.TypeBuilder;
Data = parent.Data;
Environment = parent.Environment;
Essentials = parent.Essentials;
ILFactory = parent.ILFactory;
NameResolver = parent.NameResolver;
}
public static void Deserialize(SourcePackage upk, string filename, List <AstDocument> resultAsync)
{
using (var r = AstReader.Open(upk, filename))
{
while (r.BaseStream.Position < r.BaseStream.Length)
{
var ast = r.ReadDocument();
lock (resultAsync)
resultAsync.Add(ast);
}
}
}
internal static CacheWriter CreateWriter(SourcePackage upk, string filename)
{
if (upk.IsUnknown)
{
throw new InvalidOperationException("UxlDocument: Unknown source package");
}
var w = new CacheWriter(upk, filename);
w.Write(Magic);
return(w);
}
void AddExtensionsFiles(SourcePackage upk, string backendName, List <Task> tasks, List <IEnumerable <UxlDocument> > files)
{
// 1) See if SourcePackage already has UXL cached in memory
List <UxlDocument> result;
if (upk.TryGetCache(backendName, out result))
{
Log.UltraVerbose("Using UXL from memory cache in " + upk);
files.Add(result);
return;
}
// 2) If no cache was available we must load from disk
result = new List <UxlDocument>();
upk.Cache[backendName] = result;
files.Add(result);
if (upk.IsCached)
{
if (backendName == null ||
!_env.Test(upk.Source, upk.BuildCondition) ||
!upk.CachedExtensionsBackends.Contains(backendName))
{
return;
}
BeginTask(tasks,
() =>
{
try
{
UxlCache.Deserialize(upk, Path.Combine(upk.CacheDirectory, backendName + "." + UxlCache.MagicString), result);
}
catch (Exception e)
{
Log.Error(upk.Source, ErrorCode.E0000, "Failed to load UXL cache: " + e.Message);
}
});
}
else
{
foreach (var rf in upk.ExtensionsFiles)
{
if (_env.Test(_upk.Source, rf.Condition))
{
BeginTask(tasks, () => UxlCache.Load(upk, rf.UnixPath, result));
}
}
}
}
public void AddPackage(SourcePackage package)
{
_packages.Add(package);
}
