ryb 0.1.3.1 → 0.2.0.2

data/lib/ryb/name.rb

@@ -1,9 +1,7 @@
 module Ryb
-  class Name < String
-    attr_reader :pretty
-    def initialize(name, pretty)
-      super(name)
-      @pretty = pretty
+  class Name < Helpers::PrettyString
+    def canonicalize
+      self.to_s
     end
   end
 end

data/lib/ryb/ninja.rb

@@ -1,200 +1,257 @@
-require 'ryb/project'
-require 'ryb/windows'
-require 'ryb/visual_studio'
-
-module Ryb
-  module Ninja
-    def self.generate_build_file_for(project, opts={})
-      case Ryb.platform
-        when :windows
-          raise 'Unable to find Windows SDK.' unless Ryb::Windows.sdk?
-          raise 'Unable to find Visual Studio.' unless Ryb::VisualStudio.installed?
-
-          puts "Generating build.ninja..."
-          ::Ninja::File.new "#{opts[:root]}/build.ninja" do
-            variable 'root', opts[:root]
-            variable 'built', opts[:built]
-
-            # TODO(mtwilliams): Respect project.targets[:windows].sdk.
-            variable 'WindowsSdkDir', Ryb::Windows.sdk
-            variable 'VCInstallDir', Ryb::VisualStudio.install
-
-            variable 'cl', "cl.exe"
-            variable 'lib', "lib.exe"
-            variable 'link', "link.exe"
-
-            project.configurations.each do |_, config|
-              [:windows].map{|target| project.targets[target]}.compact.each do |target|
-                [:x86, :x86_64].map{|arch| project.architectures[arch]}.compact.each do |arch|
-                  triplet = "#{config.name}_#{target.name}_#{arch.name}"
-                  (project.applications+project.libraries).each do |buildable|
-                    name = "#{buildable.name.pretty||buildable.name.capitalize} (#{config.name.pretty||config.name.capitalize}) for #{target.name.pretty||target.name.capitalize} (#{arch.name.pretty||arch.name.capitalize})"
-                    puts " Adding '#{name}'..."
-                    quadruplet = "#{buildable.name}_#{triplet}"
-                    variable "#{quadruplet}_name", name
-                    variable "#{quadruplet}_suffix",
-                             "#{config.suffix||''}#{target.suffix||''}#{arch.suffix||''}"
-                    defines = {}
-                    flags = {}
-                    if buildable.configurations[config.name]
-                      defines = buildable.defines.merge(buildable.configurations[config.name].defines)
-                      flags = buildable.flags.merge(buildable.configurations[config.name].flags)
-                     else
-                      defines = buildable.defines
-                      flags = buildable.flags
-                    end
-                    defines = project.defines.merge(arch.defines.merge(target.defines.merge(config.defines.merge(defines))))
-                    flags = arch.flags.merge(target.flags.merge(config.flags.merge(flags)))
-                    # TODO(mtwilliams): Union paths after expansion.
-                    paths = {:includes => project.paths[:includes] | buildable.paths[:includes],
-                             :libraries => project.paths[:libraries] | buildable.paths[:libraries],
-                             :binaries => project.paths[:binaries] | buildable.paths[:binaries]}
-                    expand_path_variables = lambda {|path| path.gsub(/\$built/i, "${built}")}
-                    includes = paths[:includes].map(&expand_path_variables).map{|path| File.expand_path(path)}
-                    libraries = paths[:libraries].map(&expand_path_variables).map{|path| File.expand_path(path)}
-                    binaries = paths[:binaries].map(&expand_path_variables).map{|path| File.expand_path(path)}
-                    variable "#{quadruplet}_defines", defines.map{|name, value| "/D#{name}=#{value}"}.join(' ')
-                    cflags = []
-                    cflags.push("/I\"${WindowsSdkDir}/Include\" /I\"${VCInstallDir}/include\"")
-                    cflags.push('/arch:IA32') if arch.name == 'x86'
-                    if flags[:generate_debug_symbols]
-                      cflags.push('/MDd /Zi')
-                    else
-                      cflags.push('/MD')
-                    end
-                    cflags.push({:none => '/Od /RTCsu /fp:precise /fp:except',
-                                 :size => '/O1 /fp:fast /fp:except-',
-                                 :speed => '/Ox /fp:fast /fp:except-'}[flags[:optimization]||:none])
-                    includes.each{|includes_search_dir| cflags.push("/I\"#{includes_search_dir}\"")}
-                    ldflags = []
-                    if arch.name == 'x86'
-                      ldflags.push('/machine:X86')
-                      ldflags.push("/LIBPATH:\"${WindowsSdkDir}/Lib\" /LIBPATH:\"${VCInstallDir}/Lib\"")
-                    elsif arch.name == 'x86_64'
-                      ldflags.push('/machine:X64')
-                      ldflags.push("/LIBPATH:\"${WindowsSdkDir}/Lib/x64\" /LIBPATH:\"${VCInstallDir}/Lib/amd64\"")
-                    end
-                    ldflags.push('/DEBUG') if flags[:generate_debug_symbols]
-                    libraries.each{|libraries_search_dir| ldflags.push("/LIBPATH:\"#{libraries_search_dir}\"")}
-                    binaries.each{|binaries_search_dir| ldflags.push("/LIBPATH:\"#{binaries_search_dir}\"")}
-                    variable "#{quadruplet}_cflags", cflags.join(' ')
-                    variable "#{quadruplet}_ldflags", ldflags.join(' ')
-                    arflags = []
-                    variable "#{quadruplet}_arflags", arflags.join(' ')
-                    # TODO(mtwilliams): Refactor into cc, ld, and ar rules, using variables under build(s) for uncommonalities.
-                    rule "cc_#{quadruplet}",
-                         "${cl} /nologo /c /showIncludes /favor:blend /GF /GR- /W4 ${#{quadruplet}_cflags} ${#{quadruplet}_defines} /Fo$out $in",
-                         :dependencies => :msvc
-                    rule "ld_#{quadruplet}",
-                         "${link} /nologo /manifest:no ${#{quadruplet}_ldflags} /OUT:$out $in"
-                    rule "ar_#{quadruplet}",
-                         "${lib} /nologo ${#{quadruplet}_arflags} /OUT:$out $in"
-                    sources = buildable.files[:source].select{|file| /\.(c|cc|cpp)\z/.match(file)}
-                    outputs_to_inputs = Hash[sources.map{|source| ["${built}/obj/#{source.gsub(/\.[^.]+\z/,'')}.#{triplet}.obj", "${root}/#{source}"]}]
-                    build "cc_#{quadruplet}", outputs_to_inputs
-                    output = "#{buildable.name}${#{quadruplet}_suffix}"
-                    inputs = outputs_to_inputs.map{|object,_| object}
-                    dependencies = []
-                    buildable.dependencies.each do |dependency|
-                      as_buildable = (project.libraries.select{|buildable| buildable.name == dependency}).first
-                      if as_buildable
-                        case as_buildable.linkage
-                          when :static
-                            dependencies.push("${built}/lib/#{as_buildable.name}${#{as_buildable.name}_#{triplet}_suffix}.lib")
-                          when :dynamic
-                            # TODO(mtwilliams): Move import libraries to ${built}/lib.
-                            dependencies.push("${built}/bin/#{as_buildable.name}${#{as_buildable.name}_#{triplet}_suffix}.lib")
-                          end
-                      else
-                        # TODO(mtwilliams): Check search paths for the existence of the library.
-                        dependencies.push(dependency)
-                      end
-                    end
-                    if buildable.is_a? Ryb::Application
-                      build "ld_#{quadruplet}", "${built}/bin/#{output}.exe" => inputs+dependencies
-                      defaults "${built}/bin/#{output}.exe"
-                    elsif buildable.is_a? Ryb::Library
-                      case buildable.linkage
-                      when :static
-                        build "ar_#{quadruplet}", "${built}/lib/#{output}.lib" => inputs
-                      when :dynamic
-                        # TODO(mtwilliams): Specify -DLL.
-                        build "ld_#{quadruplet}", "${built}/bin/#{output}.dll" => inputs+dependencies
-                      end
-                    end
-                  end
-                end
-              end
-            end
-          end
-
-          # TODO(mtwilliams): Generate shell and batch scripts, instead.
-          puts "Generating Makefile..."
-          ::File.open("#{opts[:root]}/Makefile", 'w') do |f|
-            f.write "# This file was auto-generated by \"#{::File.basename($PROGRAM_NAME, ::File.extname($0))}\".\n"
-            f.write "# Do not modify! Instead, modify the aforementioned program.\n\n"
-
-            f.write "WindowsSdkDir := /#{Ryb::Windows.sdk.gsub(/\\/,'/').gsub(/\:/,'')}\n\n"
-            f.write "VCInstallDir := /#{Ryb::VisualStudio.install.gsub(/\\/,'/').gsub(/\:/,'')}\n"
-
-            f.write "# HACK: The Common7/IDE path might not exist in older versions of Microsoft Visual Studio.\n"
-            f.write "CommonTools := $(shell readlink -f \"$(VCInstallDir)/../Common7\")\n\n"
-
-            targets = []
-            project.configurations.each do |_, config|
-              [:windows].map{|target| project.targets[target]}.compact.each do |target|
-                [:x86, :x86_64].map{|arch| project.architectures[arch]}.compact.each do |arch|
-                  triplet = "#{config.name}-#{target.name}-#{arch.name}"
-                  (project.applications + project.libraries).each do |buildable|
-                    quadruplet = "#{buildable.name}-#{triplet}"
-                    targets.push(quadruplet)
-                  end
-                end
-              end
-            end
-
-            f.write ".PHONY: all clean #{targets.join(' ')}\n"
-            f.write "all: #{targets.join(' ')}\n\n"
-            f.write "clean: \n"
-            f.write "\t@rm -rf #{opts[:built]}\n\n"
-
-            project.configurations.each do |_, config|
-              [:windows].map{|target| project.targets[target]}.compact.each do |target|
-                [:x86, :x86_64].map{|arch| project.architectures[arch]}.compact.each do |arch|
-                  triplet = [config.name, target.name, arch.name]
-                  (project.applications + project.libraries).each do |buildable|
-                    quadruplet = [buildable.name, triplet]
-                    case arch.name
-                      when 'x86'
-                        f.write "#{quadruplet.join('-')}: export PATH := $(WindowsSdkDir)/bin:$(CommonTools)/IDE:$(VCInstallDir)/bin:$(PATH)\n"
-                      when 'x86_64'
-                        f.write "#{quadruplet.join('-')}: export PATH := $(WindowsSdkDir)/bin/x64:$(CommonTools)/IDE:$(VCInstallDir)/bin/x86_amd64:$(VCInstallDir)/bin:$(PATH)\n"
-                      end
-                    f.write "#{quadruplet.join('-')}:\n"
-                    suffix = "#{config.suffix||''}#{target.suffix||''}#{arch.suffix||''}"
-                    if buildable.is_a? Ryb::Application
-                      f.write "\t@ninja #{opts[:built]}/bin/#{buildable.name}#{suffix}.exe\n\n"
-                    elsif buildable.is_a? Ryb::Library
-                      case buildable.linkage
-                      when :static
-                        f.write "\t@ninja #{opts[:built]}/lib/#{buildable.name}#{suffix}.lib\n\n"
-                      when :dynamic
-                        f.write "\t@ninja #{opts[:built]}/bin/#{buildable.name}#{suffix}.dll\n\n"
-                      end
-                    end
-                  end
-                end
-              end
-            end
-          end
-
-          puts "Done."
-        # when :macosx
-        # when :linux
-        # when :bsd
-        else
-          raise 'Unsupported platform!'
-        end
-    end
-  end
-end
+module Ryb
+  module Ninja
+    class Generator
+      def initialize(rybfile, opts)
+        @rybfile = rybfile
+        @root = opts.fetch(:root, '.')
+        @build = opts.fetch(:build, '_build')
+        @ninjafile = ::Ninja::File.new
+        @path = opts.fetch(:ninjafile, "#{@root}/build.ninja")
+
+        # HACK(mtwilliams): Create directory structure.
+        require 'fileutils'
+        FileUtils.mkdir_p(["#@build/bin", "#@build/lib", "#@build/obj"])
+
+        # HACK(mtwilliams): Assume VisualStudio.
+        @vs = ::VisualStudio.latest
+        @vc = @vs.products[:c_and_cpp]
+      end
+
+      def generate
+        @ninjafile.save(@path)
+      end
+
+      # TODO(mtwilliams): Generate phony commands that proxy to all triplets.
+      def on_project(project)
+        puts "=> #{project.name.pretty || project.name}"
+      end
+
+      def on_product(project, product)
+        puts " -> Generating for #{product.name.pretty || product.name}"
+      end
+
+      def on_project_triplet(project, tripletised)
+      end
+
+      def on_product_triplet(project, product, tripletised)
+        tripletised = tripletised.()
+
+        config = tripletised.configuration.name.to_sym
+        platform = tripletised.platform.name.to_sym
+        arch = tripletised.architecture.name.to_sym
+
+        puts "  ~> #{config} for #{platform} (#{arch})"
+
+        name = product.name.canonicalize
+        namespace = "#{name}_#{tripletised.triplet.join('_')}"
+
+        sdk = @vc.sdks[:windows].select{|sdk| sdk.version == '7.1'}.first
+        sys_include_paths = @vc.includes + sdk.includes
+        sys_lib_paths = @vc.libraries[arch] + sdk.libraries[arch]
+
+        @ninjafile.variable "#{namespace}_cflags_sys", VisualStudio::Compiler.include_paths_to_flags(sys_include_paths).join(' ')
+        @ninjafile.variable "#{namespace}_ldflags_sys", VisualStudio::Linker.library_paths_to_flags(sys_lib_paths).join(' ')
+
+        cflags = cflags_for_product(project, product, tripletised)
+        arflags = arflags_for_product(project, product, tripletised)
+        ldflags = ldflags_for_product(project, product, tripletised)
+
+        @ninjafile.variable "#{namespace}_cflags", cflags.join(' ')
+        @ninjafile.variable "#{namespace}_cxxflags", "$#{namespace}_cflags"
+        @ninjafile.variable "#{namespace}_arflags", arflags.join(' ')
+        @ninjafile.variable "#{namespace}_ldflags", ldflags.join(' ')
+
+        sources = sources_for_product(product, tripletised)
+        @ninjafile.variable "#{namespace}_sources", sources.map{|src| "#@root/#{src.path}"}.join(' ')
+
+        deps = deps_for_product(product, tripletised)
+        @ninjafile.variable "#{namespace}_deps", deps.join(' ')
+
+        artifacts = artifacts_for_product(product, tripletised)
+        @ninjafile.variable "#{namespace}_artifacts", artifacts.join(' ')
+        @ninjafile.variable("#{namespace}_as_linkable", artifacts[0]) if product.is_a? Ryb::Library
+        @ninjafile.variable "#{namespace}_symbols", artifacts[0].gsub(/\.(exe|lib|dll)/, ".pdb")
+
+        # https://github.com/ninja-build/ninja/blob/d1763746b65cc7349d4ed9478befdb651aa24589/src/msvc_helper_main-win32.cc#L38
+        # ninja -t msvc -e _build/#{namespace}.env -- cl.exe ...
+        env_block = "#@build/#{namespace}.env_block"
+        env = @vc.environment(target: {platform: :windows, architecture: arch})
+        # "PATH=#{(@vc.binaries[arch] + sdk.binaries[arch]).join(';')}\0"
+        File.write(env_block, env.map{|env_var, value| "#{env_var}=#{value}"}.join("\0"))
+
+        @ninjafile.rule(
+          "cc_#{namespace}",
+          "ninja -t msvc -e #{env_block} -- cl.exe $#{namespace}_cflags_sys $#{namespace}_cflags /Fd$#{namespace}_symbols /Fo$out /Tc$in"
+        )
+
+        @ninjafile.rule(
+          "cxx_#{namespace}",
+          "ninja -t msvc -e #{env_block} -- cl.exe $#{namespace}_cxxflags_sys $#{namespace}_cxxflags /Fd$#{namespace}_symbols /Fo$out /Tp$in"
+        )
+
+        @ninjafile.rule(
+          "ar_#{namespace}",
+          "ninja -t msvc -e #{env_block} -- lib.exe $#{namespace}_arflags /OUT:$out $in"
+        )
+
+        @ninjafile.rule(
+          "ld_#{namespace}",
+          "ninja -t msvc -e #{env_block} -- link.exe $#{namespace}_ldflags_sys $#{namespace}_ldflags /OUT:$out $#{namespace}_deps $in"
+        )
+
+        @ninjafile.rule(
+          "so_#{namespace}",
+          "ninja -t msvc -e #{env_block} -- link.exe $#{namespace}_ldflags_sys $#{namespace}_ldflags /DLL /OUT:$out $#{namespace}_deps $in"
+        )
+
+        c_sources = sources.select{|src| src.language == :c}.map(&:path).map{|src| "#@root/#{src}"}
+        c_objects = c_sources.map{|src| src.gsub(/\.(c)/, ".#{namespace}.obj")}.map{|obj| "#@build/obj/#{obj}"}
+        cxx_sources = sources.select{|src| src.language == :cpp}.map(&:path).map{|src| "#@root/#{src}"}
+        cxx_objects = cxx_sources.map{|src| src.gsub(/\.(cc|cpp|cxx|c++)/, ".#{namespace}.obj")}.map{|obj| "#@build/obj/#{obj}"}
+
+        @ninjafile.build "cc_#{namespace}", Hash[c_objects.zip(c_sources)]
+        @ninjafile.build "cxx_#{namespace}", Hash[cxx_objects.zip(cxx_sources)]
+
+        case product
+          when Ryb::Application
+            @ninjafile.build "ld_#{namespace}", {artifacts[0] => c_objects + cxx_objects}
+          when Ryb::Library
+            case product.linkage
+              when :static
+                @ninjafile.build "ar_#{namespace}", {artifacts[0] => c_objects + cxx_objects}
+              when :dynamic
+                @ninjafile.build "so_#{namespace}", {artifacts[1] => c_objects + cxx_objects}
+              end
+          end
+      end
+
+      private
+        def sources_for_product(product, tripletised)
+          sources = [*product.sources] |
+                    [*tripletised.configuration.sources] |
+                    [*tripletised.platform.sources] |
+                    [*tripletised.architecture.sources]
+          sources.reject{|src| src.inconsequential}.compact.uniq
+        end
+
+        def deps_for_product(product, tripletised)
+          deps = [*product.dependencies] |
+                 [*tripletised.configuration.dependencies] |
+                 [*tripletised.platform.dependencies] |
+                 [*tripletised.architecture.dependencies]
+          deps.map do |dep|
+            case dep
+              when Ryb::InternalDependency
+                "${#{dep.product}_#{tripletised.triplet.join('_')}_as_linkable}"
+              when Ryb::ExternalDependency
+                dep.lib_or_framework
+              end
+          end
+        end
+
+        def artifacts_for_product(product, tripletised)
+          name = product.name.canonicalize
+          config_suffix = tripletised.configuration.suffix || "_#{tripletised.configuration.name}"
+          platform_suffix = tripletised.platform.suffix || "_#{tripletised.platform.name}"
+          arch_suffix = tripletised.architecture.suffix || "_#{tripletised.architecture.name}"
+          suffix = [config_suffix, platform_suffix, arch_suffix].join('')
+
+          if product.is_a? Ryb::Application
+            ["#@build/bin/#{name}#{suffix}.exe"]
+          elsif product.is_a? Ryb::Library
+            case product.linkage
+              when :static
+                ["#@build/lib/#{name}#{suffix}.lib"]
+              when :dynamic
+                ["#@build/lib/#{name}#{suffix}.lib", "#@build/bin/#{name}#{suffix}.dll"]
+              end
+          end
+        end
+
+      private
+        def cflags_for_product(project, product, tripletised)
+          flags = VisualStudio::Compiler::STANDARD_FLAGS +
+                  cflags_for_configuration(tripletised.configuration) +
+                  cflags_for_platform(tripletised.platform) +
+                  cflags_for_architecture(tripletised.architecture)
+          flags += VisualStudio::Compiler.include_paths_to_flags(product.paths.includes) if product.paths
+          flags += VisualStudio::Compiler.defines_to_flags(project.defines)
+          flags += VisualStudio::Compiler.architecture_to_flags(tripletised.architecture.name.to_sym)
+          flags
+        end
+
+        def arflags_for_product(_project, _product, _tripletised)
+          %w{/nologo}
+        end
+
+        def ldflags_for_product(_project, product, tripletised)
+          flags = VisualStudio::Linker::STANDARD_FLAGS +
+                  ldflags_for_configuration(tripletised.configuration) +
+                  ldflags_for_platform(tripletised.platform) +
+                  ldflags_for_architecture(tripletised.architecture)
+          flags += VisualStudio::Linker.architecture_to_flags(tripletised.architecture.name.to_sym)
+          # TODO: Linkage.
+          flags
+        end
+
+      private
+        def cflags_for_configuration(config)
+          flags = []
+          # TODO(mtwilliams): @toolchains.for(target)
+          flags += VisualStudio::Compiler.include_paths_to_flags(config.paths.includes) if config.paths
+          flags += VisualStudio::Compiler.defines_to_flags(config.defines)
+          flags += VisualStudio::Compiler.treat_warnings_as_errors_to_flag(config.treat_warnings_as_errors)
+          flags += VisualStudio::Compiler.generate_debug_symbols_to_flag(config.generate_debug_symbols)
+          flags += VisualStudio::Compiler.optimization_to_flags(config.optimize)
+          flags
+        end
+
+        def cflags_for_platform(platform)
+          flags = []
+          # TODO(mtwilliams): @toolchains.for(target)
+          flags += VisualStudio::Compiler.include_paths_to_flags(platform.paths.includes) if platform.paths
+          flags += VisualStudio::Compiler.defines_to_flags(platform.defines)
+          flags
+        end
+
+        def cflags_for_architecture(arch)
+          flags = []
+          # TODO(mtwilliams): @toolchains.for(target)
+          flags += VisualStudio::Compiler.architecture_to_flags(arch.name.canonicalize.to_sym)
+          flags += VisualStudio::Compiler.include_paths_to_flags(arch.paths.includes) if arch.paths
+          flags += VisualStudio::Compiler.defines_to_flags(arch.defines)
+          flags
+        end
+
+        def ldflags_for_configuration(config)
+          flags = []
+          # TODO(mtwilliams): @toolchains.for(target)
+          flags += VisualStudio::Linker.library_paths_to_flags(config.paths.libraries) if config.paths
+          flags += VisualStudio::Linker.generate_debug_symbols_to_flag(config.generate_debug_symbols)
+          flags
+        end
+
+        def ldflags_for_platform(platform)
+          flags = []
+          # TODO(mtwilliams): @toolchains.for(target)
+          flags += VisualStudio::Linker.library_paths_to_flags(platform.paths.libraries) if platform.paths
+          flags
+        end
+
+        def ldflags_for_architecture(arch)
+          flags = []
+          # TODO(mtwilliams): @toolchains.for(target)
+          flags += VisualStudio::Linker.library_paths_to_flags(arch.paths.libraries) if arch.paths
+          flags
+        end
+    end
+
+    def self.generate_from(rybfile, opts={})
+      puts "Generating..."
+      generator = ::Ryb::Ninja::Generator.new(rybfile, opts)
+      ::Rybfile::Walker.new(generator, rybfile, opts).walk
+      generator.generate
+      puts "Done!"
+    end
+  end
+end