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);
}
void Build(BuildResult build, IEnvironment env, ExtensionRoot root)
{
if (root == null)
{
return;
}
// Find typed output files
foreach (var p in root.Properties)
{
if (p.Key.EndsWith(".TargetDirectory"))
{
var key = p.Key.Replace(".TargetDirectory", "");
var containingDir = env.GetOutputPath(p.Key);
var folder = new PackageFolderItem(containingDir, key.Replace("File", " Files"));
foreach (var f in build.Compiler.Environment.Enumerate(key))
{
folder.AddFile(containingDir, f.String);
}
_buildItem.Folders.Add(folder);
}
}
}
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 ForeignFilePass(
ExtensionRoot extensions,
SourcePackage package,
CppBackend backend)
: base(backend)
{
Extensions = extensions;
Package = package;
Backend = backend;
}
internal BuildData(
Namespace il,
ExtensionRoot extensions,
ILFactory ilf)
: base(ilf)
{
_ilf = ilf;
IL = il;
Extensions = extensions;
MainClass = DataType.Invalid;
StartupCode = new Scope();
}
public UxlProcessor(
Disk disk,
string backendName,
Namespace il,
ExtensionRoot root,
BuildEnvironment env,
ILFactory ilf)
: base(disk)
{
_disk = disk;
_il = il;
_root = root;
_env = env;
_ilf = ilf;
Enum.TryParse(backendName, true, out _backendType);
}
public AndroidGenerator(IEnvironment env, ExtensionRoot extensions)
{
_env = env;
_extensions = extensions;
}
