irpack 0.1.0 → 0.2.1

data/lib/irpack/application.rb

@@ -0,0 +1,87 @@
+=begin
+Copyright (c) 2010-2011 Ryuichi Sakamoto.
+
+This software is provided 'as-is', without any express or implied
+warranty. In no event will the authors be held liable for any damages
+arising from the use of this software.
+
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it
+freely, subject to the following restrictions:
+
+    1. The origin of this software must not be misrepresented; you must not
+    claim that you wrote the original software. If you use this software
+    in a product, an acknowledgment in the product documentation would be
+    appreciated but is not required.
+
+    2. Altered source versions must be plainly marked as such, and must not be
+    misrepresented as being the original software.
+
+    3. This notice may not be removed or altered from any source
+    distribution.
+=end
+
+require 'irpack'
+require 'optparse'
+require 'pathname'
+
+module IRPack
+  module Application
+    Arguments = Struct.new(
+      :output_file,
+      :target,
+      :compress,
+      :embed_references,
+      :entry_file,
+      :files) do
+      def self.parse!(argv)
+        args = self.new
+        basedir     = nil
+        args.output_file = nil
+        args.target      = :exe
+        args.compress    = false
+        args.embed_references = true
+        args.entry_file  = nil
+        args.files = {}
+        opt = OptionParser.new
+        opt.on('-b BASEDIR',    'Specify base directory. [base of ENTRYFILE]') {|v| basedir = v }
+        opt.on('-o OUTPUTFILE', 'Specify output file name.') {|v| args.output_file = v }
+        opt.on('--window',      'Generate window app.') { args.target = :winexe }
+        opt.on('--console',     'Generate console app.[default]') { args.target = :exe }
+        opt.on('--compress',    'Compress package.') { args.compress = true }
+        opt.on('--no-embed',    'Do not embed IronRuby assemblies.') {|v| args.embed_references = v }
+        opt.banner = "Usage: #{$0} [options] ENTRYFILE [EMBEDFILES...]"
+        opt.parse!(argv)
+
+        if argv.size<1 then
+          $stderr.puts opt.help
+          nil
+        else
+          basedir = Pathname.new(File.expand_path(basedir || File.dirname(argv[0])).gsub(/\\/, '/'))
+          args.output_file ||= File.join(File.dirname(argv[0]), File.basename(argv[0], '.*')+'.exe')
+          args.entry_file = argv[0]
+          argv.each_with_index do |file, i|
+            fullpath = Pathname.new(file.gsub(/\\/, '/')).expand_path
+            relpath  = fullpath.relative_path_from(basedir)
+            args.files[fullpath.to_s] = relpath.to_s 
+            args.entry_file = relpath.to_s if i==0
+          end
+          args
+        end
+      end
+    end
+
+    def self.run(args)
+      return 1 unless args
+      IRPack.pack(
+        args.output_file,
+        args.files,
+        args.entry_file,
+        :target => args.target,
+        :compress => args.compress,
+        :embed_references => args.embed)
+      return 0
+    end
+  end
+end
+

data/lib/irpack/bootloader.rb

@@ -0,0 +1,110 @@
+=begin
+Copyright (c) 2011 Ryuichi Sakamoto.
+
+This software is provided 'as-is', without any express or implied
+warranty. In no event will the authors be held liable for any damages
+arising from the use of this software.
+
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it
+freely, subject to the following restrictions:
+
+    1. The origin of this software must not be misrepresented; you must not
+    claim that you wrote the original software. If you use this software
+    in a product, an acknowledgment in the product documentation would be
+    appreciated but is not required.
+
+    2. Altered source versions must be plainly marked as such, and must not be
+    misrepresented as being the original software.
+
+    3. This notice may not be removed or altered from any source
+    distribution.
+=end
+
+require 'erb'
+require 'irpack/cscompiler'
+
+module IRPack
+  module BootLoader
+    Source = <<CS
+    using System;
+    using System.IO;
+    using System.IO.Packaging;
+    using System.Reflection;
+
+    namespace <%= module_name %> {
+      public class BootLoader
+      {
+        private static Assembly LoadAssemblyFromPackage(AppDomain domain, Package package, string file)
+        {
+          var uri = PackUriHelper.CreatePartUri(new Uri(file, UriKind.Relative));
+          if (package.PartExists(uri)) {
+            var stream = package.GetPart(uri).GetStream(FileMode.Open, FileAccess.Read);
+            var raw = new byte[stream.Length];
+            stream.Read(raw, 0, (int)stream.Length);
+            stream.Close();
+            return domain.Load(raw);
+          }
+          else {
+            return null;
+          }
+        }
+
+        private static Assembly LoadAssembly(AppDomain domain, Package package, string file)
+        {
+          try {
+            return domain.Load(file);
+          }
+          catch (FileNotFoundException)
+          {
+            return LoadAssemblyFromPackage(domain, package, file);
+          }
+        }
+
+        public static int Main(string[] args)
+        {
+          AppDomain domain = AppDomain.CurrentDomain;
+          domain.AssemblyResolve += new ResolveEventHandler(delegate (object sender, ResolveEventArgs e) {
+            foreach (var asm in domain.GetAssemblies()) {
+              if (e.Name==asm.FullName) {
+                return asm;
+              }
+            }
+            throw new FileNotFoundException(e.Name);
+          });
+          var stream = Assembly.GetEntryAssembly().GetManifestResourceStream(@"<%= package_file %>");
+          var package = Package.Open(stream, FileMode.Open, FileAccess.Read);
+    <% preload_assemblies.each do |asm| %>
+          LoadAssembly(domain, package, @"<%= asm %>");
+    <% end %>
+          var entry_point = LoadAssemblyFromPackage(domain, package, @"<%= module_name %>.EntryPoint.dll");
+          var main = entry_point.GetType(@"<%= module_name %>.EntryPoint").GetMethod("Main");
+          int result = (int)(main.Invoke(null, new object[] { package, args }));
+          package.Close();
+          return result;
+        }
+      }
+    }
+CS
+    module_function
+    def source(module_name, package_file, preload_assemblies)
+      ERB.new(Source).result(binding)
+    end
+
+    def compile(target, output_file, module_name, references, package_file)
+      boot_src = source(
+        module_name,
+        File.basename(package_file),
+        references.collect {|fn| File.basename(fn) }
+      )
+      sysasm = IRPack::CSCompiler.system_assemblies.collect {|asm|
+        IRPack::CSCompiler.assembly_location(asm)
+      }
+      Dir.chdir(File.dirname(package_file)) do
+        IRPack::CSCompiler.compile(target, output_file, boot_src, references+sysasm, [File.basename(package_file)])
+      end
+      output_file
+    end
+  end
+end
+

data/lib/irpack/cscompiler.rb

@@ -0,0 +1,115 @@
+=begin
+Copyright (c) 2011 Ryuichi Sakamoto.
+
+This software is provided 'as-is', without any express or implied
+warranty. In no event will the authors be held liable for any damages
+arising from the use of this software.
+
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it
+freely, subject to the following restrictions:
+
+    1. The origin of this software must not be misrepresented; you must not
+    claim that you wrote the original software. If you use this software
+    in a product, an acknowledgment in the product documentation would be
+    appreciated but is not required.
+
+    2. Altered source versions must be plainly marked as such, and must not be
+    misrepresented as being the original software.
+
+    3. This notice may not be removed or altered from any source
+    distribution.
+=end
+
+module IRPack
+  include System
+  include System::Reflection
+
+  module CSCompiler
+    include Microsoft::CSharp
+    include System::CodeDom::Compiler
+    include System::Reflection
+
+    class CompileError < RuntimeError
+    end
+
+    module_function
+    def compiler_version(target_version=System::Environment.version.major)
+      case target_version
+      when 4
+        'v4.0'
+      when 2...4
+        'v3.5'
+      else
+        raise ArgumentError, "Unsupported version #{target_version}"
+      end
+    end
+
+    def system_assemblies(target_version=System::Environment.version.major)
+      case compiler_version(target_version)
+      when 'v4.0'
+        [
+          'System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089',
+          'WindowsBase, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35',
+          'System.Core, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089',
+        ]
+      when 'v3.5'
+        [
+          'System, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089',
+          'WindowsBase, Version=3.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35',
+          'System.Core, Version=3.5.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089',
+        ]
+      end
+    end
+
+    def assembly_location(sig)
+      Assembly.reflection_only_load(sig.to_clr_string).location
+    end
+
+    def compile(target, output_name, srcs, references, resources)
+      opts = System::Collections::Generic::Dictionary[System::String,System::String].new
+      opts['CompilerVersion'] = compiler_version
+      @compiler = CSharpCodeProvider.new(opts)
+      srcs = srcs.kind_of?(Array) ? srcs : [srcs]
+      icon = resources.find {|rc| File.extname(rc)=='.ico' }
+
+      params = CompilerParameters.new(
+        System::Array[System::String].new(references),
+        output_name,
+        false)
+      params.generate_in_memory = false
+      compiler_options = ['/optimize+']
+      case target
+      when :exe, 'exe'
+        params.generate_executable = true
+        compiler_options << '/target:exe'
+        compiler_options << "/win32icon:#{icon}" if icon
+      when :winexe, 'winexe'
+        params.generate_executable = true
+        compiler_options << '/target:winexe'
+        compiler_options << "/win32icon:#{icon}" if icon
+      when :dll, 'dll', :library, 'library'
+        params.generate_executable = false
+        compiler_options << '/target:library'
+      else
+        raise ArgumentError, "target must be :exe, :winexe or :library"
+      end
+      params.compiler_options = compiler_options.join(' ')
+      resources.each do |rc|
+        params.embedded_resources.add(rc)
+      end
+      result = @compiler.compile_assembly_from_source(
+        params,
+        System::Array[System::String].new(srcs))
+      result.errors.each do |err|
+        if err.is_warning then
+          $stderr.puts(err.to_s)
+        else
+          raise CompileError, err.to_s
+        end
+      end
+      result.path_to_assembly
+    end
+  end
+end
+

data/lib/irpack/entrypoint.rb

@@ -0,0 +1,217 @@
+=begin
+Copyright (c) 2011 Ryuichi Sakamoto.
+
+This software is provided 'as-is', without any express or implied
+warranty. In no event will the authors be held liable for any damages
+arising from the use of this software.
+
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it
+freely, subject to the following restrictions:
+
+    1. The origin of this software must not be misrepresented; you must not
+    claim that you wrote the original software. If you use this software
+    in a product, an acknowledgment in the product documentation would be
+    appreciated but is not required.
+
+    2. Altered source versions must be plainly marked as such, and must not be
+    misrepresented as being the original software.
+
+    3. This notice may not be removed or altered from any source
+    distribution.
+=end
+
+require 'erb'
+require 'irpack/cscompiler'
+
+module IRPack
+  module EntryPoint
+    Source = <<CS
+    using System;
+    using System.IO;
+    using System.IO.Packaging;
+    using System.Reflection;
+    using Microsoft.Scripting;
+    using Microsoft.Scripting.Hosting;
+
+    namespace <%= module_name %> {
+      public class EntryPoint
+      {
+        public class PackagePAL : PlatformAdaptationLayer
+        {
+          public Package CurrentPackage { get; set; }
+          public PackagePAL(Package pkg)
+          {
+            CurrentPackage = pkg;
+          }
+
+          private Uri ToPackageLoadPath(string path)
+          {
+            var domain = AppDomain.CurrentDomain;
+            var fullpath = Path.GetFullPath(path);
+            var searchpath = Path.GetFullPath(
+              domain.RelativeSearchPath!=null ?
+              Path.Combine(domain.BaseDirectory, domain.RelativeSearchPath) :
+              domain.BaseDirectory);
+            if (fullpath.StartsWith(searchpath)) {
+              var relpath = fullpath.Substring(searchpath.Length, fullpath.Length-searchpath.Length);
+              return PackUriHelper.CreatePartUri(new Uri(relpath, UriKind.Relative));
+            }
+            else {
+              return PackUriHelper.CreatePartUri(new Uri(path, UriKind.Relative));
+            }
+          }
+
+          private Uri ToPackagePath(string path)
+          {
+            var fullpath = Path.GetFullPath(path);
+            var searchpath = Path.GetDirectoryName(Path.GetFullPath(Assembly.GetEntryAssembly().Location));
+            if (fullpath.StartsWith(searchpath)) {
+              var relpath = fullpath.Substring(searchpath.Length, fullpath.Length-searchpath.Length);
+              return PackUriHelper.CreatePartUri(new Uri(relpath, UriKind.Relative));
+            }
+            else {
+              return PackUriHelper.CreatePartUri(new Uri(path, UriKind.Relative));
+            }
+          }
+
+          public override Assembly LoadAssembly(string name)
+          {
+            foreach (var asm in AppDomain.CurrentDomain.GetAssemblies()) {
+              if (asm.FullName==name) {
+                return asm;
+              }
+            }
+            return Assembly.Load(name);
+          }
+
+          public override Assembly LoadAssemblyFromPath(string path)
+          {
+            try {
+              return Assembly.LoadFile(path);
+            }
+            catch (FileNotFoundException e) {
+              var uri = ToPackageLoadPath(path);
+              if (CurrentPackage.PartExists(uri)) {
+                var stream = CurrentPackage.GetPart(uri).GetStream(FileMode.Open, FileAccess.Read);
+                var raw = new byte[stream.Length];
+                stream.Read(raw, 0, (int)stream.Length);
+                stream.Close();
+                return Assembly.Load(raw);
+              }
+              else {
+                throw;
+              }
+            }
+          }
+
+          public override bool FileExists(string path)
+          {
+            if (File.Exists(path)) {
+              return true;
+            }
+            else {
+              var uri = ToPackagePath(path);
+              return CurrentPackage.PartExists(uri);
+            }
+          }
+
+          public override Stream OpenInputFileStream(string path, FileMode mode, FileAccess access, FileShare share) 
+          {
+            if (mode==FileMode.Open && access==FileAccess.Read) {
+              var uri = ToPackagePath(path);
+              if (CurrentPackage.PartExists(uri)) {
+                return CurrentPackage.GetPart(uri).GetStream(mode, access);
+              }
+              else {
+                return new FileStream(path, mode, access, share);
+              }
+            }
+            else {
+              return new FileStream(path, mode, access, share);
+            }
+          }
+
+          public override Stream OpenInputFileStream(string path, FileMode mode, FileAccess access, FileShare share, int bufferSize)
+          {
+            if (mode==FileMode.Open && access==FileAccess.Read) {
+              var uri = ToPackagePath(path);
+              if (CurrentPackage.PartExists(uri)) {
+                return CurrentPackage.GetPart(uri).GetStream(mode, access);
+              }
+              else {
+                return new FileStream(path, mode, access, share, bufferSize);
+              }
+            }
+            else {
+              return new FileStream(path, mode, access, share, bufferSize);
+            }
+          }
+
+          public override Stream OpenInputFileStream(string path)
+          {
+            var uri = ToPackagePath(path);
+            if (CurrentPackage.PartExists(uri)) {
+              return CurrentPackage.GetPart(uri).GetStream(FileMode.Open, FileAccess.Read);
+            }
+            else {
+              return new FileStream(path, FileMode.Open, FileAccess.Read);
+            }
+          }
+        }
+
+        public class IRHost : ScriptHost
+        {
+          private PlatformAdaptationLayer PAL_;
+          public override PlatformAdaptationLayer PlatformAdaptationLayer { get { return PAL_; } }
+          public IRHost(Package pkg)
+          {
+            PAL_ = new PackagePAL(pkg);
+          }
+        }
+
+        public static int Main(Package package, string[] args)
+        {
+          var entry_path = Path.GetDirectoryName(Path.GetFullPath(Assembly.GetEntryAssembly().Location));
+          var entry_file = Path.Combine(entry_path, "<%= entry_file %>");
+          var runtime_setup = new ScriptRuntimeSetup();
+          runtime_setup.LanguageSetups.Add(IronRuby.Ruby.CreateRubySetup());
+          runtime_setup.Options["MainFile"]  = entry_file;
+          runtime_setup.Options["Arguments"] = args;
+          runtime_setup.HostType = typeof(IRHost);
+          runtime_setup.HostArguments = new object[] { package };
+          var engine = IronRuby.Ruby.GetEngine(IronRuby.Ruby.CreateRuntime(runtime_setup));
+          try {
+            engine.ExecuteFile(entry_file);
+            return 0;
+          }
+          catch (IronRuby.Builtins.SystemExit e) {
+            return e.Status;
+          }
+          catch (Exception e) {
+            var thread_abort = e as System.Threading.ThreadAbortException;
+            if (thread_abort==null || !(thread_abort.ExceptionState is KeyboardInterruptException)) {
+              Console.Error.WriteLine(engine.GetService<ExceptionOperations>().FormatException(e));
+            }
+            return -1;
+          }
+        }
+      }
+    }
+CS
+    module_function
+    def source(module_name, entry_file)
+      ERB.new(Source).result(binding)
+    end
+
+    def compile(output_file, module_name, entry_file, references)
+      src = source(module_name, entry_file)
+      sysasm = IRPack::CSCompiler.system_assemblies.collect {|asm|
+        IRPack::CSCompiler.assembly_location(asm)
+      }
+      IRPack::CSCompiler.compile(:dll, output_file, src, references+sysasm, [])
+      output_file
+    end
+  end
+end
+