CommandPromptReader.n

using Nemerle.Collections;
using Nemerle.Imperative;
using Nemerle.Text;
using Nemerle.Utility;
using Nemerle.Utility.Getopt;

using Nitra;
using Nitra.Declarations;
using Nitra.LanguageCompiler.Utils;

using Nitra.ProjectSystem;
using System;
using System.Collections.Generic;
using System.Console;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;

namespace Nitra.LanguageCompiler
{
  class CommandPromptReader
  {
    public LanguageName        : string           { get; private set; }
    public LanguageAssembly    : string           { get; private set; }
    public ProjectSupport      : string           { get; private set; }
    public ProjectSupportClass : System.Type      { get; private set; }
    public Language            : Language         { get; }
    public ProjectName         : string           { get; }
    public AssemblyReferences  : list[string]     { get; }
    public Binaries            : list[string]     { get; }
    public OutputPath          : string           { get; private set; }
    public NewGuids            : bool             { get; private set; }
    public Snk                 : string           { get; private set; }
    public DefaultNamespace    : string           { get; private set; }
    public Success             : bool             { get; }
    public CompilerMessages    : CompilerMessages { get; }

    public this()
    {
      CompilerMessages = ConsoleCompilerMessages("LC");
      def assemblyReferences = List();
      mutable binaries = [];
      def options = [
        CliOption.String(name = "-lang",
                    aliases = [],
                    help = "Language name",
                    handler = fun(languageName) { LanguageName = languageName }),
        CliOption.String(name = "-proj",
                    aliases = [],
                    help = "Project support class name",
                    handler = fun(projectSupport) { ProjectSupport = projectSupport }),
        CliOption.String(name = "-out",
                    aliases = [],
                    help = "Output path",
                    handler = path => OutputPath = path),
        CliOption.Boolean(name = "-guids",
                    aliases = ["-newguids", "-renewguids"],
                    help = "Generate new guid values.",
                    handler = newGuids => NewGuids = newGuids),
        CliOption.String(name = "-keyfile",
                    aliases = ["-snk"],
                    help = "Specifies a strong name key file",
                    handler = path => Snk = path),
        CliOption.String(name = "-namespace",
                    aliases = ["-ns"],
                    help = "Default namespace",
                    handler = defaultNamespace => DefaultNamespace = defaultNamespace),
        CliOption.String(name = "-bin",
                    aliases = [],
                    help = "Additional binaries.",
                    handler = bin => binaries ::= bin),
        CliOption.NonOption(name = "",
                    help = "Nitra assembly references.",
                    handler = assemblyReferences.Add),
        ];
      
      Getopt.Parse(options);
      
      //assert2(LanguageName != "Nitra.Language");

      def usage() : void
      {
        def help = Getopt.Usage(options);
        WriteLine("Usage: Nitra.LanguageCompiler.exe flags [NitraParserAssembly.dll]");
        WriteLine("flags:");
        WriteLine(help);
      }

      when (string.IsNullOrEmpty(ProjectSupport))
      {
        ProjectSupport      = "";
        ProjectSupportClass = null;
      }

      when (string.IsNullOrEmpty(LanguageName))
      {
        WriteLine("Error: 'lang' option is required.");
        usage();
        return;
      }

      when (assemblyReferences.Count == 0)
      {
        WriteLine("Error: Assembly references is required.");
        usage();
        return;
      }

      AssemblyReferences = assemblyReferences.NToList();
      Binaries = binaries;

      def asms = List();

      foreach (assemblyReference in assemblyReferences)
      {
        def asmRef = Path.GetFullPath(assemblyReference);

        when (!File.Exists(asmRef))
        {
          WriteLine($"Error: The '$asmRef' file does not exist.");
          usage();
          return;
        }

        def asm = Assembly.LoadFrom(asmRef);
        asms.Add(asm);
      }

      when (string.IsNullOrEmpty(OutputPath))
        OutputPath = Environment.CurrentDirectory;

      OutputPath = Path.GetFullPath(OutputPath);

      mutable matchedLanguages = [];
      mutable matchedProjectSupportTypes = [];
      
      foreach (asm in asms)
      {
        def languages = Language.GetLanguages(asm);
        foreach (language when language.FullName == LanguageName in languages)
          matchedLanguages ::= (asm, language);
          
        def projectSupportAttributes = asm.GetCustomAttributes(typeof(ProjectSupportAttribute));
        foreach (projectSupportAttribute is ProjectSupportAttribute when projectSupportAttribute.Caption == ProjectSupport in projectSupportAttributes)
          matchedProjectSupportTypes ::= projectSupportAttribute.Type;
      }
      
      match (matchedLanguages)
      {
        | [(asm, lang)] =>
          Language    = lang;
          LanguageAssembly = asm.CodeBase;
          ProjectName = lang.FullName + "VsPackage";

        | []     => WriteLine($"Error: Language '$LanguageName' not found."); return;
        | _      => WriteLine($"Error: Multiple languages with name '$LanguageName' found."); return;
      }

      match (matchedProjectSupportTypes)
      {
        | [type] => ProjectSupportClass = type;
        | []     => ()
        | _      => WriteLine($"Error: Multiple instance of 'proj' option (project support) with name '$ProjectSupport' found."); return;
      }

      when (DefaultNamespace == null)
      {
        WriteLine("Error: The 'namespace' parameter is required.");
        usage();
        return;
      }

      Success = true;
    }
  }
}