private static bool GetStandardClassLibraryEntryPoint(NativeCompilerParameters parameters, string classLibrary)
{
if (parameters.IsBaseLibrary)
{
return(true);
}
if (classLibrary == "")
{
return(true);
}
Assembly assembly;
try
{
assembly = Assembly.LoadFile(classLibrary);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
Console.WriteLine("Cannot find or load the standard class library assembly: {0}.", classLibrary);
return(false);
}
foreach (Type type in assembly.GetExportedTypes())
{
foreach (MethodInfo method in type.GetMethods())
{
if (method.GetCustomAttribute(typeof(ScopeInitializerAttribute)) != null)
{
ParameterInfo[] ps = method.GetParameters();
if ((ps != null) && (ps.Length == 2))
{
if ((ps[0].ParameterType == typeof(SmalltalkRuntime)) && (ps[1].ParameterType == typeof(SmalltalkNameScope)))
{
if (parameters.ExtensionScopeInitializer != null)
{
Console.WriteLine("The assembly {0} does not appear to be IronSmalltalk class library.", classLibrary);
Console.WriteLine("Several public methods were decorated with the [ScopeInitializer] attribute.");
return(false);
}
parameters.ExtensionScopeInitializer = method;
}
}
}
}
}
if (parameters.ExtensionScopeInitializer == null)
{
Console.WriteLine("The assembly {0} does not appear to be IronSmalltalk class library.", classLibrary);
Console.WriteLine("IronSmalltalk class libraries have a public method decorated with the [ScopeInitializer] attribute.");
return(false);
}
return(true);
}
private static string Compile(NativeCompilerParameters parameters, bool installMetaAnnotations, IEnumerable <string> sourceFiles)
{
List <PathFileInInformation> fileIns = new List <PathFileInInformation>();
foreach (string sourceFile in sourceFiles)
{
SymbolDocumentInfo symbolDocument = null;
if (parameters.EmitDebugSymbols)
{
symbolDocument = Expression.SymbolDocument(sourceFile, GlobalConstants.LanguageGuid, GlobalConstants.VendorGuid);
}
PathFileInInformation fileIn = new PathFileInInformation(sourceFile, System.Text.Encoding.UTF8, new FileInErrorSink(sourceFile), symbolDocument);
fileIns.Add(fileIn);
}
if (fileIns.Count == 0)
{
return(null);
}
SmalltalkRuntime runtime;
if (parameters.ExtensionScopeInitializer == null)
{
runtime = new SmalltalkRuntime();
}
else
{
runtime = NativeLoadHelper.CreateRuntime(false,
(rt, scope) => { parameters.ExtensionScopeInitializer.Invoke(null, new object[] { rt, scope }); },
(rt, scope) => { /* Nothing here */ });
}
FileInService compilerService = new FileInService(runtime, installMetaAnnotations, fis =>
parameters.IsBaseLibrary ? new InternalInstallerContext(fis.Runtime) : new InterchangeInstallerContext(fis.Runtime));
InterchangeInstallerContext installer = compilerService.Read(fileIns);
foreach (var fileIn in fileIns)
{
if (((FileInErrorSink)fileIn.ErrorSink).HadError)
{
return(null); // Some of the source file had errors, do not attempt the rest - it's meaningless
}
}
installer.ErrorSink = new InstallErrorSink();
installer.InstallMetaAnnotations = compilerService.InstallMetaAnnotations;
if (!installer.Install())
{
return(null);
}
parameters.Runtime = runtime;
return(NativeCompiler.NativeCompiler.GenerateNativeAssembly(parameters));
}
private static void PrintParameters(NativeCompilerParameters parameters, bool installMetaAnnotations, IEnumerable <string> sourceFiles)
{
string classLibrary = "N/A";
if (!parameters.IsBaseLibrary)
{
classLibrary = parameters.ExtensionScopeInitializer.DeclaringType.Assembly.Location;
}
Console.WriteLine(@"
Assembly Name: {0}
Namespace: {1}
Output Location: {2}
Target Type: {3}
Class Library: {4}
Debug Info: {5}
Meta Annotations: {6}
IST Base Library: {7}
Assembly Version: {8}
Company: {9}
Copyright: {10}
Description: {11}
File Version: {12}
Product: {13}
Product Title: {14}
Product Version: {15}
Trademark: {16}
Source Files:",
parameters.AssemblyName,
parameters.RootNamespace,
parameters.OutputDirectory,
parameters.AssemblyType,
classLibrary,
parameters.EmitDebugSymbols,
installMetaAnnotations,
parameters.IsBaseLibrary,
parameters.AssemblyVersion,
parameters.Company,
parameters.Copyright,
parameters.ProductDescription,
parameters.FileVersion,
parameters.Product,
parameters.ProductTitle,
parameters.ProductVersion,
parameters.Trademark);
foreach (string file in sourceFiles)
{
Console.WriteLine(" " + file);
}
Console.WriteLine();
}
private void SetFileVersion(NativeCompilerParameters parameters)
{
if (!String.IsNullOrWhiteSpace(parameters.ProductTitle))
{
this.AssemblyBuilder.SetCustomAttribute(new CustomAttributeBuilder(NativeGenerator.AssemblyTitleCtor, new object[] { parameters.ProductTitle }));
}
if (!String.IsNullOrWhiteSpace(parameters.ProductDescription))
{
this.AssemblyBuilder.SetCustomAttribute(new CustomAttributeBuilder(NativeGenerator.AssemblyDescriptionCtor, new object[] { parameters.ProductDescription }));
}
if (!String.IsNullOrWhiteSpace(parameters.Company))
{
this.AssemblyBuilder.SetCustomAttribute(new CustomAttributeBuilder(NativeGenerator.AssemblyCompanyCtor, new object[] { parameters.Company }));
}
if (!String.IsNullOrWhiteSpace(parameters.Product))
{
this.AssemblyBuilder.SetCustomAttribute(new CustomAttributeBuilder(NativeGenerator.AssemblyProductCtor, new object[] { parameters.Product }));
}
if (!String.IsNullOrWhiteSpace(parameters.Copyright))
{
this.AssemblyBuilder.SetCustomAttribute(new CustomAttributeBuilder(NativeGenerator.AssemblyCopyrightCtor, new object[] { parameters.Copyright }));
}
if (!String.IsNullOrWhiteSpace(parameters.Trademark))
{
this.AssemblyBuilder.SetCustomAttribute(new CustomAttributeBuilder(NativeGenerator.AssemblyTrademarkCtor, new object[] { parameters.Trademark }));
}
if (!String.IsNullOrWhiteSpace(parameters.ProductVersion))
{
this.AssemblyBuilder.SetCustomAttribute(new CustomAttributeBuilder(NativeGenerator.AssemblyVersionCtor, new object[] { parameters.ProductVersion }));
}
if (!String.IsNullOrWhiteSpace(parameters.ProductVersion))
{
this.AssemblyBuilder.SetCustomAttribute(new CustomAttributeBuilder(NativeGenerator.AssemblyInformationalVersionCtor, new object[] { parameters.ProductVersion }));
}
if (!String.IsNullOrWhiteSpace(parameters.FileVersion))
{
this.AssemblyBuilder.SetCustomAttribute(new CustomAttributeBuilder(NativeGenerator.AssemblyFileVersionCtor, new object[] { parameters.FileVersion }));
}
}
internal NativeGenerator(NativeCompilerParameters parameters)
{
this.Parameters = parameters;
this.AssemblyName = new AssemblyName(parameters.AssemblyName);
if (!String.IsNullOrWhiteSpace(parameters.AssemblyVersion))
{
this.AssemblyName.Version = new Version(parameters.AssemblyVersion);
}
string filename = String.Format("{0}.{1}", this.AssemblyName.Name, parameters.FileExtension);
this.OutputPath = System.IO.Path.Combine(parameters.OutputDirectory, filename);
if (this.Parameters.EmitDebugSymbols)
{
this.DebugInfoGenerator = DebugInfoGenerator.CreatePdbGenerator();
}
CustomAttributeBuilder[] attributes = new CustomAttributeBuilder[] {};
this.AssemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(
this.AssemblyName,
AssemblyBuilderAccess.Save,
this.Parameters.OutputDirectory,
false,
attributes);
if (this.Parameters.EmitDebugSymbols)
{
this.SetDebuggableAttributes();
}
this.SetFileVersion(parameters);
this.AssemblyBuilder.DefineVersionInfoResource();
this.ModuleBuilder = this.AssemblyBuilder.DefineDynamicModule(this.AssemblyName.Name, filename, this.Parameters.EmitDebugSymbols);
}
internal static string Compile(string[] args)
{
if (args == null)
{
return(CommandLineCompiler.PrintUsage());
}
bool showCopyrightMessage = true;
bool printParameters = true;
string classLibrary = null;
bool installMetaAnnotations = false;
NativeCompilerParameters parameters = new NativeCompilerParameters();
parameters.Product = "IronSmalltalk Application";
parameters.ProductTitle = "IronSmalltalk Application";
parameters.AssemblyType = NativeCompilerParameters.AssemblyTypeEnum.Exe;
List <string> sourceFiles = new List <string>();
string option = null;
foreach (string arg in args)
{
if (arg == null)
{
return(CommandLineCompiler.PrintUsage());
}
if (option != null)
{
if ((option == "a") || (option == "assemblyname"))
{
parameters.AssemblyName = arg;
}
else if ((option == "n") || (option == "namespace"))
{
parameters.RootNamespace = arg;
}
else if ((option == "o") || (option == "out"))
{
parameters.OutputDirectory = Path.GetFullPath(arg);
}
else if ((option == "t") || (option == "target"))
{
option = arg.ToLower().Trim();
if (option == "dll")
{
parameters.AssemblyType = NativeCompilerParameters.AssemblyTypeEnum.Dll;
}
else if (option == "exe")
{
parameters.AssemblyType = NativeCompilerParameters.AssemblyTypeEnum.Exe;
}
else if (option == "exe32")
{
parameters.AssemblyType = NativeCompilerParameters.AssemblyTypeEnum.Exe32;
}
else if (option == "exe64")
{
parameters.AssemblyType = NativeCompilerParameters.AssemblyTypeEnum.Exe64;
}
else
{
return(CommandLineCompiler.PrintUsage());
}
}
else if ((option == "c") || (option == "classlibrary"))
{
string cl = arg.Trim();
if (String.IsNullOrWhiteSpace(cl))
{
return(CommandLineCompiler.PrintUsage());
}
classLibrary = Path.GetFullPath(cl);
}
else if ((option == "v") || (option == "version"))
{
parameters.AssemblyVersion = arg;
parameters.FileVersion = arg;
parameters.ProductVersion = arg;
}
else if (option == "company")
{
parameters.Company = arg;
}
else if (option == "copyright")
{
parameters.Copyright = arg;
}
else if (option == "product")
{
parameters.Product = arg;
}
else if (option == "assemblyversion")
{
parameters.AssemblyVersion = arg;
}
else if (option == "fileversion")
{
parameters.FileVersion = arg;
}
else if (option == "productversion")
{
parameters.ProductVersion = arg;
}
else if (option == "producttitle")
{
parameters.ProductTitle = arg;
}
else if (option == "productdescription")
{
parameters.ProductDescription = arg;
}
else if (option == "trademark")
{
parameters.Trademark = arg;
}
else
{
return(CommandLineCompiler.PrintUsage());
}
option = null;
}
else if (arg.StartsWith("-") || arg.StartsWith("/"))
{
option = arg.Substring(1).ToLower().Trim();
if (option.Length == 0)
{
return(CommandLineCompiler.PrintUsage());
}
if (option[option.Length - 1] == ':')
{
option = option.Substring(0, option.Length - 1);
}
if (option.Length == 0)
{
return(CommandLineCompiler.PrintUsage());
}
if ((option == "d") || (option == "debug"))
{
parameters.EmitDebugSymbols = true;
option = null;
}
else if (option == "metaannotations")
{
parameters.EmitDebugSymbols = true;
option = null;
}
else if (option == "baselibrary")
{
parameters.IsBaseLibrary = true;
option = null;
}
else if (option == "noclasslibrary")
{
classLibrary = "";
option = null;
}
else if (option == "nologo")
{
showCopyrightMessage = false;
option = null;
}
else if ((option == "q") || (option == "quiet"))
{
printParameters = false;
option = null;
}
else if (option == "istscl")
{
// Undocumented parameter .... shortcut to set the parameters for compiling the
// IronSmalltalk Standard Class Library. Pats are relative to the .Net project.
parameters.AssemblyName = "IronSmalltalk.ClassLibrary";
parameters.AssemblyName = "IronSmalltalk.ClassLibrary";
parameters.OutputDirectory = Path.GetFullPath(".");
parameters.AssemblyType = NativeCompilerParameters.AssemblyTypeEnum.Dll;
classLibrary = "";
parameters.AssemblyVersion = typeof(CommandLineCompiler).Assembly.GetName().Version.ToString();
parameters.FileVersion = parameters.AssemblyVersion;
parameters.ProductVersion = parameters.AssemblyVersion;
parameters.IsBaseLibrary = true;
parameters.Company = "The IronSmalltalk Project";
parameters.Copyright = "Copyright © The IronSmalltalk Project 2013";
parameters.Product = "IronSmalltalk";
parameters.ProductTitle = "IronSmalltalk Standard Class Library";
parameters.ProductDescription = "IronSmalltalk Standard Class Library";
#if DEBUG
parameters.EmitDebugSymbols = true;
#endif
option = null;
sourceFiles.Add(Path.GetFullPath(@"..\..\..\ClassLibraryBrowser\External\IronSmalltalk.ist"));
}
}
else
{
sourceFiles.Add(Path.GetFullPath(arg));
}
}
if (sourceFiles.Count == 0)
{
return(CommandLineCompiler.PrintUsage());
}
if (String.IsNullOrWhiteSpace(parameters.AssemblyName))
{
parameters.AssemblyName = Path.GetFileNameWithoutExtension(sourceFiles[0]);
}
if (String.IsNullOrWhiteSpace(parameters.RootNamespace))
{
parameters.RootNamespace = parameters.AssemblyName;
}
if (String.IsNullOrWhiteSpace(parameters.OutputDirectory))
{
parameters.OutputDirectory = Directory.GetCurrentDirectory();
}
if (parameters.IsBaseLibrary && (parameters.AssemblyType != NativeCompilerParameters.AssemblyTypeEnum.Dll))
{
return(CommandLineCompiler.PrintUsage());
}
if (classLibrary == null)
{
classLibrary = Path.Combine(Path.GetDirectoryName(Assembly.GetEntryAssembly().Location), "IronSmalltalk.ClassLibrary.dll");
}
try
{
if (showCopyrightMessage)
{
CommandLineCompiler.PrintCopyrightMessage();
}
if (!CommandLineCompiler.GetStandardClassLibraryEntryPoint(parameters, classLibrary))
{
return(null);
}
if (!Directory.Exists(parameters.OutputDirectory))
{
Console.WriteLine();
Console.WriteLine("Output Directory does not exists.");
return(null);
}
if (printParameters)
{
CommandLineCompiler.PrintParameters(parameters, installMetaAnnotations, sourceFiles);
}
string path = CommandLineCompiler.Compile(parameters, installMetaAnnotations, sourceFiles);
if (path == null)
{
return(null);
}
if (printParameters)
{
Console.WriteLine("Assembly saved to:\n {0}", path);
}
return(path);
}
catch (FileNotFoundException ex)
{
Console.WriteLine("Error: {0}", ex.Message);
return(null);
}
}
