/*
* static string CombineModuleType(string module, string type)
* {
* if (String.IsNullOrEmpty(module))
* {
* return type;
* }
* if (String.IsNullOrEmpty(type))
* {
* return module;
* }
* return String.Format("{0}.{1}", module, type);
* }
*/
void AddNewType(Boolean importTypeSymbol, String module, String dlangTypeIdentifier, UInt32 arity)
{
//String dModule = SemanticExtensions.NamespaceToDModule(@namespace);
TypeSymbolAndArity typeNameAndArity = new TypeSymbolAndArity(dlangTypeIdentifier, arity);
if (importTypeSymbol)
{
importTypesByModule.Add(module, typeNameAndArity);
}
modulesByTypeName.Add(typeNameAndArity, module);
if (CSharpToD.generateDebug)
{
if (typeNameAndArity.arity == 0)
{
writer.WriteLine("// Added type '{0}' (import {1}, module {2})",
typeNameAndArity.name, importTypeSymbol, module);
}
else
{
writer.WriteLine("// Added type '{0}{1}' (import {2}, module {3})",
typeNameAndArity.name, typeNameAndArity.arity, importTypeSymbol, module);
}
}
//Console.WriteLine("Namespace '{0}', from symbol '{1}'", typeSymbol.ContainingModule(), typeSymbol.Name);
//if (log != null)
//{
// log.PutLine(String.Format("Module '{0}', from symbol '{1}'", module, dlangTypeIdentifier));
//}
}
public void GenerateCode()
{
if (CSharpToD.log)
{
this.log = new BufferedNativeFileSink(NativeFile.Open(
Path.Combine(CSharpToD.logDirectory, projectModels.outputName),
FileMode.Create, FileAccess.Write, FileShare.ReadWrite), new byte[256]);
}
// Determine File Name
String projectSourceDirectory;
if (namespaceTree.subnodes.Count == 0)
{
projectSourceDirectory = null;
this.filenameFullPath = Path.Combine(CSharpToD.generatedCodePath, projectModels.outputName + ".d");
}
else
{
projectSourceDirectory = Path.Combine(CSharpToD.generatedCodePath,
projectModels.outputName);
this.filenameFullPath = Path.Combine(projectSourceDirectory, "package.d");
}
ProjectFirstPassVisitor firstPass;
SynchronizedDirectoryCreator.Create(Path.GetDirectoryName(filenameFullPath));
Console.WriteLine("Creating D Source File '{0}'...", filenameFullPath);
using (DlangWriter writer = new DlangWriter(new BufferedNativeFileSink(
NativeFile.Open(filenameFullPath, FileMode.Create, FileAccess.Write, FileShare.ReadWrite), new byte[512])))
{
writer.WriteLine("module {0};", projectModels.outputName);
writer.WriteLine();
//
// First Pass: find imports
//
firstPass = new ProjectFirstPassVisitor(writer, log);
this.namespaceTree.FirstPassVisit(firstPass);
//
// Write Imports
//
foreach (KeyValuePair <String, HashSet <TypeSymbolAndArity> > namespaceAndTypes in firstPass.typeSymbolsByNamespace)
{
String @namespace = namespaceAndTypes.Key;
if (@namespace.Length > 0)
{
writer.WriteLine("import {0}.{1} :", projectModels.outputName, @namespace);
writer.Tab();
uint typeIndex = 0;
uint lastIndex = (uint)namespaceAndTypes.Value.Count - 1;
foreach (TypeSymbolAndArity typeSymbol in namespaceAndTypes.Value)
{
writer.Write(typeSymbol.name);
if (typeSymbol.arity > 0)
{
writer.Write("{0}", typeSymbol.arity);
}
if (typeIndex < lastIndex)
{
writer.WriteLine(",");
}
else
{
writer.WriteLine(";");
}
typeIndex++;
}
writer.Untab();
}
}
//
// Generate Code
//
{
var generator = new ProjectVisitorGenerator(this, writer, firstPass);
this.namespaceTree.GenerateCode(writer, generator);
}
}
//
// Generate Namespace Alias Files
//
foreach (KeyValuePair <String, HashSet <TypeSymbolAndArity> > namespaceAndTypes in firstPass.typeSymbolsByNamespace)
{
String @namespace = namespaceAndTypes.Key;
if (@namespace.Length > 0)
{
//
// Determine Namespace Alias Filename
//
String namespaceAliasFilename;
{
Boolean namespaceHasChildNamespaces = false;
foreach (string otherNamespace in firstPass.typeSymbolsByNamespace.Keys)
{
if (otherNamespace.Length > @namespace.Length &&
otherNamespace.StartsWith(@namespace))
{
namespaceHasChildNamespaces = true;
break;
}
}
String filenameRelative;
if (namespaceHasChildNamespaces)
{
filenameRelative = Path.Combine(
@namespace.Replace('.', Path.DirectorySeparatorChar), "package.d");
}
else
{
int lastDotIndex = @namespace.LastIndexOf('.');
if (lastDotIndex < 0)
{
filenameRelative = @namespace + ".d";
}
else
{
filenameRelative = Path.Combine(
@namespace.Remove(lastDotIndex).Replace('.', Path.DirectorySeparatorChar),
@namespace.Substring(lastDotIndex + 1) + ".d");
}
}
namespaceAliasFilename = Path.Combine(projectSourceDirectory, filenameRelative);
namespaceFiles.Add(namespaceAliasFilename);
//Console.WriteLine("[DEBUG] Namespace '{0}' going to file '{1}'", @namespace, filenameFullPath);
}
SynchronizedDirectoryCreator.Create(Path.GetDirectoryName(namespaceAliasFilename));
Console.WriteLine("Creating D Source File '{0}'...", namespaceAliasFilename);
using (DlangWriter writer = new DlangWriter(new BufferedNativeFileSink(
NativeFile.Open(namespaceAliasFilename, FileMode.Create, FileAccess.Write, FileShare.ReadWrite), new byte[512])))
{
writer.WriteLine("module {0}.{1};", projectModels.outputName, @namespace);
writer.WriteLine();
writer.WriteLine("static import {0};", projectModels.outputName);
writer.WriteLine();
foreach (TypeSymbolAndArity typeSymbol in namespaceAndTypes.Value)
{
if (typeSymbol.arity > 0)
{
writer.WriteLine("alias {0}{1} = {2}.{3}.{0}{1};",
typeSymbol.name, typeSymbol.arity, projectModels.outputName, @namespace);
}
else
{
writer.WriteLine("alias {0} = {1}.{2}.{0};",
typeSymbol.name, projectModels.outputName, @namespace);
}
}
}
}
}
}
public void GenerateCode(DlangWriter writer, ProjectVisitorGenerator generator)
{
generator.currentDeclNamespace = fullNamespace;
try
{
if (fullNamespace.Length > 0)
{
writer.WriteLine("//");
writer.WriteLine("// namespace {0}", fullNamespace);
writer.WriteLine("//");
writer.WriteLine("static class {0}", name);
writer.WriteLine("{");
writer.Tab();
}
if (fileModelNodesArray != null)
{
foreach (CSharpFileModelNodes fileModelNodes in fileModelNodesArray)
{
generator.currentFileModel = fileModelNodes.fileModel;
writer.WriteLine();
writer.WriteLine("//");
writer.WriteLine("// Source Generated From '{0}'", fileModelNodes.fileModel.document.FilePath);
writer.WriteLine("//");
foreach (SyntaxList <AttributeListSyntax> attrListList in fileModelNodes.attributeLists)
{
foreach (AttributeListSyntax attrList in attrListList)
{
writer.WriteIgnored(attrList.GetText());
}
}
foreach (MemberDeclarationSyntax decl in fileModelNodes.decls)
{
/*
* if (log != null)
* {
* log.PutLine(String.Format("[{0}] Processing File '{1}'",
* Thread.CurrentThread.ManagedThreadId, fileModelNodes.fileModel.document.FilePath));
* }
*/
generator.Visit(decl);
}
}
}
for (int i = 0; i < subnodes.Count; i++)
{
subnodes[i].GenerateCode(writer, generator);
}
}
finally
{
if (fullNamespace.Length > 0)
{
writer.Untab();
writer.WriteLine("}} // end of namespace {0}", fullNamespace);
writer.WriteLine();
}
}
}
public static void MakeDProjectFile(Config config, ProjectModels[] projectModelsArray)
{
String projectFile = Path.Combine(CSharpToD.generatedCodePath, "build.d");
using (DlangWriter writer = new DlangWriter(new BufferedNativeFileSink(
NativeFile.Open(projectFile, FileMode.Create, FileAccess.Write, FileShare.ReadWrite), new byte[512])))
{
writer.WriteLine(@"import std.stdio;
import std.getopt : getopt;
import std.format : format;
import std.process : spawnShell, wait;
import std.path : setExtension, buildNormalizedPath;
enum OutputType {Library,Exe}
struct Project
{
string outputName;
OutputType outputType;
string[] sourceFiles;
}
");
writer.WriteLine(@"immutable string rootPath = `{0}`;", CSharpToD.generatedCodePath);
writer.WriteLine(@"immutable string mscorlibPath = `{0}`;", CSharpToD.mscorlibPath);
writer.WriteLine(@"enum DEFAULT_NO_MSCORLIB = {0};", config.noMscorlib ? "true" : "false");
writer.WriteLine(@"immutable string[] includePaths = [");
writer.Tab();
foreach (String includePath in config.includePaths)
{
writer.WriteLine("`{0}`,", Path.Combine(CSharpToD.conversionRoot, includePath));
}
writer.Untab();
writer.WriteLine("];");
writer.WriteLine(@"immutable string[] libraries = [");
writer.Tab();
foreach (String library in config.libraries)
{
writer.WriteLine("`{0}`,", Path.Combine(CSharpToD.conversionRoot, library));
}
writer.Untab();
writer.WriteLine("];");
{
writer.WriteLine(@"immutable Project[] projects = [");
writer.Tab();
foreach (ProjectModels project in projectModelsArray)
{
writer.WriteLine("immutable Project(\"{0}\", OutputType.{1}, [",
project.assemblyPackageName, project.outputType);
writer.Tab();
DlangGenerator[] generators = System.Linq.Enumerable.ToArray(project.namespaceGeneratorMap.Values);
// Sort so that the source files are always in the same order
// no matter the timing
Array.Sort(generators);
foreach (DlangGenerator generator in generators)
{
// TODO: make these files relative
writer.WriteLine("`{0}`,", generator.filenameFullPath);
}
writer.Untab();
writer.WriteLine("]),");
}
writer.Untab();
writer.WriteLine("];");
}
writer.WriteLine(@"
int tryRun(string command)
{
writefln(""[RUN] '%s'"", command);
auto pid = spawnShell(command);
return wait(pid);
}
void run(string command)
{
auto exitCode = tryRun(command);
if(exitCode) {
writefln(""Error: last [RUN] command failed (exit code %s)"", exitCode);
}
}
int main(string[] args)
{
bool noMscorlib = DEFAULT_NO_MSCORLIB;
bool compileSingleFiles = false;
getopt(args,
""no-mscorlib"", &noMscorlib,
""compile-single-files"", &compileSingleFiles);
foreach(project; projects)
{
writefln(""Building project '%s'..."", project.outputName);
string[] objectFiles = new string[project.sourceFiles.length];
foreach(i, sourceFile; project.sourceFiles) {
objectFiles[i] = sourceFile.setExtension(""obj"");
}
string compileCommand = format(""dmd -I%s"", rootPath);
if(!noMscorlib) {
compileCommand ~= "" -I"" ~ mscorlibPath;
}
foreach(includePath; includePaths) {
compileCommand ~= "" -I"" ~ buildNormalizedPath(includePath);
}
string linkArguments = """";
if(project.outputType == OutputType.Library) {
linkArguments ~= "" -lib"";
}
if(!noMscorlib) {
linkArguments ~= "" "" ~ buildNormalizedPath(mscorlibPath, ""mscorlib.lib"");
}
foreach(library; libraries) {
linkArguments ~= format("" %s"", library);
}
linkArguments ~= format("" -of%s"", buildNormalizedPath(rootPath, project.outputName));
// The compileSingleFiles option is MUCH slower, but I'm keeping it for now
// because compiling all source files together could cause a machine to run out of memory
if(compileSingleFiles)
{
// Compile
foreach(i, sourceFile; project.sourceFiles) {
if(tryRun(format(""%s -c -of%s %s"", compileCommand, objectFiles[i], sourceFile))) {
return 1;
}
}
// Link
string linkCommand = ""dmd""~linkArguments;
foreach(objectFile; objectFiles) {
linkCommand ~= format("" %s"", objectFile);
}
if(tryRun(linkCommand)) {
return 1;
}
} else {
string compileAndLinkCommand = compileCommand~linkArguments;
foreach(i, sourceFile; project.sourceFiles) {
compileAndLinkCommand ~= "" ""~sourceFile;
}
if(tryRun(compileAndLinkCommand)) {
return 1;
}
}
}
writeln(""Success"");
return 0;
}
");
}
}