buildrake 0.0.8

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: aa798dd479ff68a84f82cb070a2c7de8b65d18e4fd8239f4d866cb30369c8f84
+  data.tar.gz: e3dfdbd6959e36d892b390c5e19aed883a7bec5310ba4301aa820ce1e5858af1
+SHA512:
+  metadata.gz: 69cd1f2039ad14b8949e2dd4ccd2aa04de6ed26485ad6bfac7cf18a0cb58c6708bc914c3880a264767172da46e84498c372a1c78c528479ab21e5645607cd59c
+  data.tar.gz: 893daa378e18bcac3cc82fdac6a79c3178c6801dec018dedf69adbfc228fb0da79199b5698f896559b23c3d1207d90114ba31bd44bcf29806b0acc9b0613177d

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in buildrake.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 mskz-3110
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,41 @@
+# Buildrake
+
+Multiplatform build for c
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'buildrake'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install buildrake
+
+## Usage
+
+Generate Rakefile:
+```irb
+require 'buildrake'
+Buildrake::setup
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/mskz-3110/buildrake/rubygems/buildrake.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "buildrake"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/buildrake.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "buildrake/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "buildrake"
+  spec.version       = Buildrake::VERSION
+  spec.authors       = ["mskz-3110"]
+  spec.email         = ["mskz.saito@gmail.com"]
+
+  spec.summary       = %q{Multiplatform build for c.}
+  spec.description   = %q{Multiplatform build for c.}
+  spec.homepage      = "https://github.com/mskz-3110/buildrake/rubygems/buildrake"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.15"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_dependency "nokogiri"
+end

data/lib/buildrake.rb

@@ -0,0 +1,85 @@
+require "buildrake/version"
+require "buildrake/rush"
+require "buildrake/config"
+require "buildrake/comment"
+require "buildrake/github"
+
+module Buildrake
+  def self.setup
+    generate_rakefile
+    generate_gitignore
+  end
+  
+  def self.generate_rakefile
+    return if Rush.file?( "Rakefile" )
+    
+    open( "Rakefile", "wb" ){|f|
+      f.puts <<EOS
+require "buildrake"
+
+class Config < Buildrake::Config
+  method_accessor :srcs
+  
+  def initialize( *args )
+    super( "", Buildrake::Rush.full_dir_path( Buildrake::Rush.dir_path( __FILE__ ) ) )
+    
+    inc_dirs [ "\#{@root_path}/inc" ]
+    
+    # Library
+    @srcs = [  ]
+    library( project_name, @srcs )
+    
+    @platforms.each{|platform|
+      @configs.each{|config|
+        case platform
+        when :android
+          lib_dirs = [ "\#{@root_path}/lib/android/$(ANDROID_NDK_VERSION)_$(CONFIG)" ]
+        else
+          lib_dirs = [ "\#{@root_path}/lib/$(PLATFORM_PATH)" ]
+        end
+        lib_dir( platform, config, lib_dirs )
+      }
+    }
+    
+    # Execute
+    if Buildrake::Rush.windows?
+      libs = [  ]
+    else
+      libs = [  ]
+    end
+    execute( "", [  ], libs )
+  end
+end
+
+desc "Setup"
+task :setup do
+  Config.run( [ "setup" ] )
+  exit( 0 )
+end
+
+desc "Show help message"
+task :help do
+  Config.run( [ "help" ] )
+  exit( 0 )
+end
+
+desc "Build"
+task :build do
+  Config.run( [ "build" ] )
+  exit( 0 )
+end
+EOS
+    }
+  end
+  
+  def self.generate_gitignore
+    return if Rush.file?( ".gitignore" )
+    
+    open( ".gitignore", "wb" ){|f|
+      f.puts <<EOS
+/build
+/lib
+EOS
+    }
+  end
+end

data/lib/buildrake/comment.rb

@@ -0,0 +1,160 @@
+module Buildrake
+  module Comment
+    def self.parse( path, &block )
+      open( path, "rb" ){|f|
+        head_line = 0
+        tail_line = 0
+        comments = []
+        f.each_line.each{|line|
+          line.chomp!
+          tail_line = tail_line + 1
+          if 0 < head_line
+            if /^(.*)\*\/$/ =~ line
+              block.call( comments.join( "\n" ), head_line, tail_line ) if ! comments.empty?
+              head_line = 0
+              comments = []
+            else
+              comments.push line
+            end
+          else
+            if /\/\/(.*)$/ =~ line
+              block.call( $1, tail_line, tail_line ) if ! $1.empty?
+            elsif /\/\*(.*)$/ =~ line
+              comments.push $1 if ! $1.empty?
+              head_line = tail_line
+            end
+          end
+        }
+      }
+    end
+    
+    def self.parse_class( path, &block )
+      class_values = {
+        :namespace => "",
+        :class_name => "",
+        :elements => []
+      }
+      Comment.parse( path ){|comment, head_line, tail_line|
+        next if /\s*\[cc\:(.+?)\]\s*(.*)/m !~ comment
+        
+        type = $1
+        value = $2.strip
+        case type
+        when "namespace"
+          class_values[ :namespace ] = value
+        when "class_name"
+          class_values[ :class_name ] = value
+        when "enum_name"
+          class_values[ :elements ].push( { :type => :enum, :name => value, :values => [] } )
+        when "enum_value"
+          class_values[ :elements ].last[ :values ].push value
+        when "struct_name"
+          class_values[ :elements ].push( { :type => :struct, :name => value, :members => [] } )
+        when "struct_member"
+          class_values[ :elements ].last[ :members ].push value
+        when "api"
+          if /(.+)\s(.+)\((.*)\)/ =~ value
+            api = {
+              :return_type => $1,
+              :name => $2,
+              :args => $3.strip
+            }
+            api[ :interface_code ] = "#{api[ :return_type ]} #{api[ :name ]}( #{api[ :args ]} )"
+            api[ :class_interface_code ] = "#{api[ :return_type ]} #{Rush.pascal_case( api[ :name ] )}( #{api[ :args ]} )"
+            api[ :call_args ] = api[ :args ].split( "," ).map{|v| v.split( /\s/ ).last}.join( ", " )
+            api[ :call_code ] = "#{api[ :name ]}( #{api[ :call_args ]} )"
+            return_code = ( "void" == api[ :return_type ] ) ? "" : "return "
+            api[ :return_call_code ] = "#{return_code}#{api[ :call_code ]}"
+            class_values[ :elements ].push( { :type => :api, :value => api } )
+          else
+            class_values[ :elements ].push( { :type => :api } )
+          end
+        else
+          class_values[ :elements ].push( { :type => type.to_sym, :value => value } )
+        end
+      }
+      block.call( class_values ) if ! class_values[ :class_name ].empty?
+    end
+    
+    def self.generate_class_code_type_cs( dll_name, class_values )
+      codes = []
+      codes.push <<EOS
+#if ! DLL_INTERNAL
+  #if ! UNITY_EDITOR && ( UNITY_IOS || UNITY_WEBGL )
+    #define DLL_INTERNAL
+  #endif
+#endif
+
+using System;
+using System.Runtime.InteropServices;
+using System.Diagnostics;
+EOS
+      
+      codes.push "namespace #{class_values[ :namespace ]} {" if ! class_values[ :namespace ].empty?
+      codes.push "public class #{class_values[ :class_name ]} {"
+      codes.push <<EOS.chomp
+#if DLL_INTERNAL
+  public const string DllName = "__Internal";
+#else
+  public const string DllName = "#{dll_name}";
+#endif
+EOS
+      
+      class_values[ :elements ].each{|element|
+        case element[ :type ]
+        when :callback
+          codes.push <<EOS.chomp
+  public delegate #{element[ :value ]};
+  
+EOS
+        when :api
+          codes.push <<EOS.chomp
+  [DllImport(DllName, CallingConvention = CallingConvention.Cdecl)]
+EOS
+          
+          if element.key?( :value )
+            api = element[ :value ]
+            case api[ :return_type ].downcase
+            when "string"
+              codes.push <<EOS.chomp
+  static public extern IntPtr #{api[ :name ]}( #{api[ :args ]} );
+  static public #{api[ :class_interface_code ]}{ return Marshal.PtrToStringAnsi( #{api[ :call_code ]} ); }
+  
+EOS
+            else
+              codes.push <<EOS.chomp
+  static public extern #{api[ :interface_code ]};
+  static public #{api[ :class_interface_code ]}{ #{api[ :return_call_code ]}; }
+  
+EOS
+            end
+          end
+        when :code
+          codes.push <<EOS.chomp
+  #{element[ :value ]}
+  
+EOS
+        when :enum
+          codes.push <<EOS.chomp
+  public enum #{element[ :name ]} {
+    #{element[ :values ].join( ",\n    " )}
+  };
+  
+EOS
+        when :struct
+          codes.push <<EOS.chomp
+  public struct #{element[ :name ]} {
+    public #{element[ :members ].join( ";\n    public " )};
+  };
+  
+EOS
+        end
+      }
+      
+      codes.push "}" if ! class_values[ :namespace ].empty?
+      codes.push "}"
+      
+      codes.join( "\n" )
+    end
+  end
+end

data/lib/buildrake/config.rb

@@ -0,0 +1,840 @@
+module Buildrake
+  class Config
+    def self.run( argv )
+      self.new.public_send( argv.shift, *argv ) if ! argv.empty?
+    end
+    
+    def self.method_accessor( *names )
+      names.each{|name|
+        class_eval <<EOS
+def #{name}( *args )
+  args.empty? ? @#{name} : @#{name} = args.first
+end
+EOS
+      }
+    end
+    
+    method_accessor :project_name
+    method_accessor :root_path
+    method_accessor :inc_dirs
+    method_accessor :lib_dirs
+    method_accessor :c_flags, :cxx_flags, :ld_flags
+    method_accessor :platforms, :configs
+    method_accessor :windows_runtimes
+    method_accessor :macos_archs, :ios_archs
+    method_accessor :android_archs, :android_api_level
+    method_accessor :cmake_version
+    
+    def initialize( project_name, root_path )
+      @project_name = project_name
+      
+      @root_path = root_path
+      
+      @inc_dirs = []
+      
+      @lib_dirs = {}
+      
+      @c_flags = {}
+      @cxx_flags = {}
+      @ld_flags = {}
+      
+      @platforms = [ :macos, :ios, :android, :linux, :windows ]
+      @configs = [ :debug, :release ]
+      
+      @windows_runtimes = [ "MT", "MD" ]
+      
+      @macos_archs = [ "x86_64" ]
+      @ios_archs = [ "armv7", "armv7s", "arm64" ]
+      
+      @android_archs = [ "x86", "armeabi-v7a", "arm64-v8a" ]
+      @android_api_level = 21
+      
+      @cmake_version = "2.8"
+      
+      @executes = {}
+      @libraries = {}
+      
+      @platforms.each{|platform|
+        @lib_dirs[ platform ] = {}
+        @c_flags[ platform ] = {}
+        @cxx_flags[ platform ] = {}
+        @ld_flags[ platform ] = {}
+        @configs.each{|config|
+          @lib_dirs[ platform ][ config ] = []
+          @c_flags[ platform ][ config ] = []
+          @cxx_flags[ platform ][ config ] = []
+          @ld_flags[ platform ][ config ] = []
+          case platform
+          when :windows
+            c_flag( platform, config, [ "/W4" ] )
+            cxx_flag( platform, config, [ "/W4" ] )
+          else
+            c_flag( platform, config, [ "-g -Wall" ] )
+            cxx_flag( platform, config, [ "-g -Wall" ] )
+            
+            case platform
+            when :macos, :ios
+              c_flag( platform, config, [ "-fembed-bitcode" ] )
+              cxx_flag( platform, config, [ "-fembed-bitcode" ] )
+            end
+            
+            case platform
+            when :android
+              cxx_flag( platform, config, [ "-fexceptions -frtti" ] )
+            end
+          end
+        }
+      }
+    end
+    
+    def lib_dir( platform, config, dirs )
+      @lib_dirs[ platform ][ config ].concat( dirs )
+    end
+    
+    def c_flag( platform, config, flags )
+      @c_flags[ platform ][ config ].concat( flags )
+    end
+    
+    def cxx_flag( platform, config, flags )
+      @cxx_flags[ platform ][ config ].concat( flags )
+    end
+    
+    def ld_flag( platform, config, flags )
+      @ld_flags[ platform ][ config ].concat( flags )
+    end
+    
+    def execute( name, srcs, libs = [] )
+      @executes[ name ] = { :srcs => srcs, :libs => libs }
+    end
+    
+    def library( name, srcs, libs = [] )
+      @libraries[ name ] = { :srcs => srcs, :libs => libs }
+    end
+    
+    def setup
+      generate
+    end
+    
+    def build
+      platform = Rush.env( "PLATFORM" )
+      config = Rush.env( "CONFIG" )
+      if platform.nil? || config.nil?
+        help
+      else
+        Rush.changed( "build/#{platform}" ){
+          Rush.sh( "rake build" ) if Rush.file?( "Rakefile" )
+        }
+      end
+    end
+    
+    def help
+      puts "rake setup"
+      puts "rake help"
+      @platforms.each{|platform|
+        @configs.each{|config|
+          case platform
+          when :android
+            puts "ANDROID_NDK=/tmp/android-ndk-r10e PLATFORM=#{platform} CONFIG=#{config} rake build"
+            puts "ANDROID_NDK=/tmp/android-ndk-r10e ANDROID_STL=c++_static PLATFORM=#{platform} CONFIG=#{config} rake build"
+            puts "ANDROID_NDK=/tmp/android-ndk-r10e ANDROID_STL=gnustl_static PLATFORM=#{platform} CONFIG=#{config} rake build"
+          when :windows
+            @windows_runtimes.each{|runtime|
+              [ "Win32", "x64" ].each{|arch|
+                puts "WINDOWS_VISUAL_STUDIO_VERSION=2017 WINDOWS_RUNTIME=#{runtime} WINDOWS_ARCH=#{arch} CMAKE_GENERATOR=\"Visual Studio 15 2017\" PLATFORM=#{platform} CONFIG=#{config} rake build"
+              }
+            }
+          else
+            puts "PLATFORM=#{platform} CONFIG=#{config} rake build"
+          end
+        }
+      }
+    end
+    
+  private
+    def lib_name( name )
+      lib_name = name
+      if /lib([a-zA-Z0-9_]+)\.a/ =~ name
+        lib_name = $1
+      end
+      lib_name
+    end
+    
+    def generate
+      Rush.remaked( "build" ){
+        generate_common_build_files
+        generate_macos_build_files
+        generate_ios_build_files
+        generate_linux_build_files
+        generate_android_build_files
+        generate_windows_build_files
+      }
+    end
+    
+    def generate_common_build_files
+      open( "#{@project_name}.cmake", "wb" ){|f|
+        f.puts <<EOS
+message(CMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE})
+string(TOUPPER #{@project_name.upcase}_LINK_DIRS_${CMAKE_BUILD_TYPE} #{@project_name.upcase}_LINK_DIRS)
+set(#{@project_name.upcase}_LINK_DIRS ${${#{@project_name.upcase}_LINK_DIRS}})
+foreach(link_dir IN LISTS #{@project_name.upcase}_LINK_DIRS)
+  message(#{@project_name.upcase}_LINK_DIRS=${link_dir})
+  link_directories(${link_dir})
+endforeach()
+
+project(#{@project_name})
+
+set(CMAKE_EXE_LINKER_FLAGS_DEBUG "${CMAKE_EXE_LINKER_FLAGS_DEBUG} ${CMAKE_LD_FLAGS_DEBUG}")
+set(CMAKE_SHARED_LINKER_FLAGS_DEBUG "${CMAKE_SHARED_LINKER_FLAGS_DEBUG} ${CMAKE_LD_FLAGS_DEBUG}")
+set(CMAKE_STATIC_LINKER_FLAGS_DEBUG "${CMAKE_STATIC_LINKER_FLAGS_DEBUG} ${CMAKE_LD_FLAGS_DEBUG}")
+
+set(CMAKE_EXE_LINKER_FLAGS_RELEASE "${CMAKE_EXE_LINKER_FLAGS_RELEASE} ${CMAKE_LD_FLAGS_RELEASE}")
+set(CMAKE_SHARED_LINKER_FLAGS_RELEASE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} ${CMAKE_LD_FLAGS_RELEASE}")
+set(CMAKE_STATIC_LINKER_FLAGS_RELEASE "${CMAKE_STATIC_LINKER_FLAGS_RELEASE} ${CMAKE_LD_FLAGS_RELEASE}")
+
+EOS
+        
+        @inc_dirs.each{|dir|
+          dir = "${#{@project_name.upcase}_ROOT_DIR}/#{dir}" if dir =~ /^\./
+          f.puts <<EOS
+include_directories(#{dir})
+EOS
+        }
+        
+        f.puts ""
+        
+        @executes.each{|name, data|
+          f.puts "set(#{@project_name.upcase}_EXE_#{name.upcase}_SRCS)"
+          data[ :srcs ].each{|src|
+            src = "${#{@project_name.upcase}_ROOT_DIR}/#{src}" if src =~ /^\./
+            f.puts "set(#{@project_name.upcase}_EXE_#{name.upcase}_SRCS ${#{@project_name.upcase}_EXE_#{name.upcase}_SRCS} #{src})"
+          }
+          
+          link_lib_names = []
+          data[ :libs ].each{|name|
+            link_lib_names.push name
+          }
+          
+          f.puts <<EOS
+
+add_executable(#{name} ${#{@project_name.upcase}_EXE_#{name.upcase}_SRCS})
+target_link_libraries(#{name} #{link_lib_names.join( ' ' )})
+EOS
+        }
+        
+        @libraries.each{|name, data|
+          f.puts "set(#{@project_name.upcase}_LIB_#{name.upcase}_SRCS)"
+          data[ :srcs ].each{|src|
+            src = "${#{@project_name.upcase}_ROOT_DIR}/#{src}" if src =~ /^\./
+            f.puts "set(#{@project_name.upcase}_LIB_#{name.upcase}_SRCS ${#{@project_name.upcase}_LIB_#{name.upcase}_SRCS} #{src})"
+          }
+          
+          link_lib_names = []
+          data[ :libs ].each{|name|
+            link_lib_name = "#{@project_name.upcase}_LIB_#{name.upcase}"
+            f.puts <<EOS
+find_library(#{link_lib_name} NAMES lib#{name}.a #{name} PATHS ${#{@project_name.upcase}_LINK_DIRS}})
+message(#{link_lib_name}=${#{link_lib_name}})
+EOS
+            link_lib_names.push "${#{link_lib_name}}"
+          }
+          
+          f.puts <<EOS
+
+add_library(#{name}-shared SHARED ${#{@project_name.upcase}_LIB_#{name.upcase}_SRCS})
+target_link_libraries(#{name}-shared #{link_lib_names.join( ' ' )})
+SET_TARGET_PROPERTIES(#{name}-shared PROPERTIES OUTPUT_NAME #{name})
+
+add_library(#{name}-static STATIC ${#{@project_name.upcase}_LIB_#{name.upcase}_SRCS})
+target_link_libraries(#{name}-static #{link_lib_names.join( ' ' )})
+SET_TARGET_PROPERTIES(#{name}-static PROPERTIES OUTPUT_NAME #{name})
+EOS
+        }
+      }
+      
+      open( "#{@project_name}.rb", "wb" ){|f|
+        f.puts <<EOS
+require "buildrake"
+
+def lipo_create( input_libraries, output_library )
+  input_libraries = input_libraries.join( ' ' ) if input_libraries.kind_of?( Array )
+  Buildrake::Rush.sh( "lipo -create \#{input_libraries} -output \#{output_library}" )
+end
+
+def lipo_info( library )
+  Buildrake::Rush.sh( "lipo -info \#{library}" )
+end
+
+def platform_path( platform, config )
+  path = ""
+  case platform
+  when "linux"
+    if Buildrake::Rush.file?( "/etc/system-release" )
+      line = `head -n 1 /etc/system-release`
+    else
+      line = "unsupported"
+    end
+    values = line.split( "\s" )
+    linux_name = values.shift.downcase
+    values.each{|value|
+      if /^([0-9]+)\./ =~ value
+        linux_name = "\#{linux_name}\#{$1}"
+        break
+      end
+    }
+    path = "linux/\#{linux_name}"
+  when "macos"
+    path = "macos/\#{\`xcrun --sdk macosx --show-sdk-version\`.chomp}"
+  when "ios"
+    path = "ios/\#{\`xcrun --sdk iphoneos --show-sdk-version\`.chomp}"
+  when "android"
+    android_ndk_version = Buildrake::Rush.env( "ANDROID_NDK" ).split( '-' ).last.chomp( '/' )
+    Buildrake::Rush.env( "ANDROID_NDK_VERSION", android_ndk_version )
+    path = "android/\#{android_ndk_version}"
+    path = "\#{path}_\#{Buildrake::Rush.env( 'ANDROID_STL' )}" if Buildrake::Rush.env?( 'ANDROID_STL' ) && ! Buildrake::Rush.env( 'ANDROID_STL' ).empty?
+  when "windows"
+    windows_visual_studio_version = Buildrake::Rush.env( "WINDOWS_VISUAL_STUDIO_VERSION" )
+    windows_runtime = Buildrake::Rush.env( "WINDOWS_RUNTIME" )
+    windows_arch = Buildrake::Rush.env( "WINDOWS_ARCH" )
+    path = "windows/\#{windows_visual_studio_version}_\#{windows_runtime}_\#{windows_arch}"
+  end
+  "\#{path}_\#{config}"
+end
+
+def cmake_files( prefix = "" )
+  [ "CMakeCache.txt", "CMakeFiles", "CMakeScripts", "Makefile", "cmake_install.cmake" ].map{|path| "\#{prefix}\#{path}"}
+end
+
+desc "Build"
+task :build do
+  Buildrake::Rush.find( cmake_files ){|path|
+    Buildrake::Rush.remove( path )
+  }
+  
+  build
+end
+
+if Buildrake::Rush.env?( "CONFIG" )
+  config = Buildrake::Rush.env( "CONFIG", Buildrake::Rush.pascal_case( Buildrake::Rush.env( 'CONFIG' ) ) )
+else
+  config = Buildrake::Rush.env( "CONFIG", "Debug" )
+end
+puts "CONFIG=\#{config}"
+Buildrake::Rush.env( "PLATFORM_PATH", "\#{platform_path( Buildrake::Rush.base_name( Buildrake::Rush.full_dir_path ), config )}" ) if ! Buildrake::Rush.env?( "PLATFORM_PATH" )
+puts "PLATFORM_PATH=\#{Buildrake::Rush.env( 'PLATFORM_PATH' )}"
+EOS
+      }
+    end
+    
+    def generate_macos_build_files
+      Rush.maked( "macos" ){
+        open( "CMakeLists.txt", "wb" ){|f|
+          f.puts <<EOS
+cmake_minimum_required(VERSION #{@cmake_version})
+
+project(#{@project_name})
+
+if (${CMAKE_SYSTEM_NAME} STREQUAL "Darwin")
+  set(CMAKE_MACOSX_RPATH 1)
+endif()
+
+set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} #{@c_flags[ :macos ][ :debug ].join( ' ' )}")
+set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} #{@cxx_flags[ :macos ][ :debug ].join( ' ' )}")
+set(CMAKE_LD_FLAGS_DEBUG "${CMAKE_LD_FLAGS_DEBUG} #{@ld_flags[ :macos ][ :debug ].join( ' ' )}")
+
+set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} #{@c_flags[ :macos ][ :release ].join( ' ' )}")
+set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} #{@cxx_flags[ :macos ][ :release ].join( ' ' )}")
+set(CMAKE_LD_FLAGS_RELEASE "${CMAKE_LD_FLAGS_RELEASE} #{@ld_flags[ :macos ][ :release ].join( ' ' )}")
+
+set(#{@project_name.upcase}_ROOT_DIR ${CMAKE_CURRENT_LIST_DIR}/../..)
+set(#{@project_name.upcase}_LINK_DIRS_DEBUG)
+set(#{@project_name.upcase}_LINK_DIRS_RELEASE)
+EOS
+          
+          @lib_dirs[ :macos ][ :debug ].each{|dir|
+            dir = "${#{@project_name.upcase}_ROOT_DIR}/#{dir}" if dir =~ /^\./
+            f.puts <<EOS
+set(#{@project_name.upcase}_LINK_DIRS_DEBUG ${#{@project_name.upcase}_LINK_DIRS_DEBUG} #{dir})
+EOS
+          }
+          
+          @lib_dirs[ :macos ][ :release ].each{|dir|
+            dir = "${#{@project_name.upcase}_ROOT_DIR}/#{dir}" if dir =~ /^\./
+            f.puts <<EOS
+set(#{@project_name.upcase}_LINK_DIRS_RELEASE ${#{@project_name.upcase}_LINK_DIRS_RELEASE} #{dir})
+EOS
+          }
+          
+          f.puts <<EOS
+include(${CMAKE_CURRENT_LIST_DIR}/../#{@project_name}.cmake)
+EOS
+        }
+        
+        open( "Rakefile", "wb" ){|f|
+          f.puts <<EOS
+require File.expand_path( "../#{@project_name}", File.dirname( __FILE__ ) )
+
+def build
+  config = Buildrake::Rush.env( "CONFIG" )
+  platform_path = platform_path( "macos", config )
+  Buildrake::Rush.remaked( Buildrake::Rush.base_name( platform_path ) ){
+    #{@macos_archs}.each{|arch|
+      Buildrake::Rush.remaked( arch ){
+        Buildrake::Rush.sh( "cmake ../.. -DCMAKE_BUILD_TYPE=\#{config} -DCMAKE_OSX_ARCHITECTURES=\#{arch} --no-warn-unused-cli -DPLATFORM=macos -DCONFIG=\#{config} -DPLATFORM_PATH=\#{platform_path}" )
+        Buildrake::Rush.sh( "make clean all" )
+      }
+    }
+    
+    #{@libraries.keys}.each{|name|
+      ["lib\#{name}.a", "lib\#{name}.dylib"].each{|library|
+        ext_name = Buildrake::Rush.ext_name( library )
+        lipo_create( "*/*.\#{ext_name}", library )
+        lipo_info( library )
+      }
+    }
+    
+    src = Buildrake::Rush.full_dir_path
+    dst = "\#{src}/../../../lib/\#{platform_path}"
+    #{@libraries.keys}.each{|name|
+      Buildrake::Rush.find( "lib\#{name}.*" ){|path|
+        Buildrake::Rush.maked( dst ){
+          Buildrake::Rush.rename( "\#{src}/\#{path}", "." )
+        }
+      }
+    }
+  }
+end
+EOS
+        }
+      }
+    end
+    
+    def generate_ios_build_files
+      Rush.maked( "ios" ){
+        open( "CMakeLists.txt", "wb" ){|f|
+          f.puts <<EOS
+cmake_minimum_required(VERSION #{@cmake_version})
+
+project(#{@project_name})
+
+if (${CMAKE_SYSTEM_NAME} STREQUAL "Darwin")
+  set(CMAKE_MACOSX_RPATH 1)
+endif()
+
+set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} #{@c_flags[ :ios ][ :debug ].join( ' ' )}")
+set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} #{@cxx_flags[ :ios ][ :debug ].join( ' ' )}")
+set(CMAKE_LD_FLAGS_DEBUG "${CMAKE_LD_FLAGS_DEBUG} #{@ld_flags[ :ios ][ :debug ].join( ' ' )}")
+
+set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} #{@c_flags[ :ios ][ :release ].join( ' ' )}")
+set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} #{@cxx_flags[ :ios ][ :release ].join( ' ' )}")
+set(CMAKE_LD_FLAGS_RELEASE "${CMAKE_LD_FLAGS_RELEASE} #{@ld_flags[ :ios ][ :release ].join( ' ' )}")
+
+set(#{@project_name.upcase}_ROOT_DIR ${CMAKE_CURRENT_LIST_DIR}/../..)
+set(#{@project_name.upcase}_LINK_DIRS_DEBUG)
+set(#{@project_name.upcase}_LINK_DIRS_RELEASE)
+EOS
+          
+          @lib_dirs[ :ios ][ :debug ].each{|dir|
+            dir = "${#{@project_name.upcase}_ROOT_DIR}/#{dir}" if dir =~ /^\./
+            f.puts <<EOS
+set(#{@project_name.upcase}_LINK_DIRS_DEBUG ${#{@project_name.upcase}_LINK_DIRS_DEBUG} #{dir})
+EOS
+          }
+          
+          @lib_dirs[ :ios ][ :release ].each{|dir|
+            dir = "${#{@project_name.upcase}_ROOT_DIR}/#{dir}" if dir =~ /^\./
+            f.puts <<EOS
+set(#{@project_name.upcase}_LINK_DIRS_RELEASE ${#{@project_name.upcase}_LINK_DIRS_RELEASE} #{dir})
+EOS
+          }
+          
+          f.puts <<EOS
+include(${CMAKE_CURRENT_LIST_DIR}/../#{@project_name}.cmake)
+EOS
+        }
+        
+        open( "Rakefile", "wb" ){|f|
+          f.puts <<EOS
+require File.expand_path( "../#{@project_name}", File.dirname( __FILE__ ) )
+
+def build
+  config = Buildrake::Rush.env( "CONFIG" )
+  platform_path = platform_path( "ios", config )
+  Buildrake::Rush.remaked( Buildrake::Rush.base_name( platform_path ) ){
+    #{@macos_archs}.each{|arch|
+      Buildrake::Rush.remaked( arch ){
+        Buildrake::Rush.sh( "cmake ../.. -DCMAKE_BUILD_TYPE=\#{config} -DCMAKE_OSX_ARCHITECTURES=\#{arch} -DCMAKE_OSX_SYSROOT=iphonesimulator --no-warn-unused-cli -DPLATFORM=ios -DCONFIG=\#{config} -DPLATFORM_PATH=\#{platform_path}" )
+        Buildrake::Rush.sh( "make clean all" )
+      }
+    }
+    
+    #{@ios_archs}.each{|arch|
+      Buildrake::Rush.remaked( arch ){
+        Buildrake::Rush.sh( "cmake ../.. -DCMAKE_BUILD_TYPE=\#{config} -DCMAKE_OSX_ARCHITECTURES=\#{arch} -DCMAKE_OSX_SYSROOT=iphoneos --no-warn-unused-cli -DPLATFORM=ios -DCONFIG=\#{config} -DPLATFORM_PATH=\#{platform_path}" )
+        Buildrake::Rush.sh( "make clean all" )
+      }
+    }
+    
+    #{@libraries.keys}.each{|name|
+      ["lib\#{name}.a", "lib\#{name}.dylib"].each{|library|
+        ext_name = Buildrake::Rush.ext_name( library )
+        lipo_create( "*/*.\#{ext_name}", library )
+        lipo_info( library )
+      }
+    }
+    
+    src = Buildrake::Rush.full_dir_path
+    dst = "\#{src}/../../../lib/\#{platform_path}"
+    #{@libraries.keys}.each{|name|
+      Buildrake::Rush.find( "lib\#{name}.*" ){|path|
+        Buildrake::Rush.maked( dst ){
+          Buildrake::Rush.rename( "\#{src}/\#{path}", "." )
+        }
+      }
+    }
+  }
+end
+EOS
+        }
+      }
+    end
+    
+    def generate_linux_build_files
+      Rush.maked( "linux" ){
+        open( "CMakeLists.txt", "wb" ){|f|
+          f.puts <<EOS
+cmake_minimum_required(VERSION #{@cmake_version})
+
+project(#{@project_name})
+
+if (${CMAKE_SYSTEM_NAME} STREQUAL "Darwin")
+  set(CMAKE_MACOSX_RPATH 1)
+endif()
+
+set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} #{@c_flags[ :linux ][ :debug ].join( ' ' )}")
+set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} #{@cxx_flags[ :linux ][ :debug ].join( ' ' )}")
+set(CMAKE_LD_FLAGS_DEBUG "${CMAKE_LD_FLAGS_DEBUG} #{@ld_flags[ :linux ][ :debug ].join( ' ' )}")
+
+set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} #{@c_flags[ :linux ][ :release ].join( ' ' )}")
+set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} #{@cxx_flags[ :linux ][ :release ].join( ' ' )}")
+set(CMAKE_LD_FLAGS_RELEASE "${CMAKE_LD_FLAGS_RELEASE} #{@ld_flags[ :linux ][ :release ].join( ' ' )}")
+
+set(#{@project_name.upcase}_ROOT_DIR ${CMAKE_CURRENT_LIST_DIR}/../..)
+set(#{@project_name.upcase}_LINK_DIRS_DEBUG)
+set(#{@project_name.upcase}_LINK_DIRS_RELEASE)
+EOS
+          
+          @lib_dirs[ :linux ][ :debug ].each{|dir|
+            dir = "${#{@project_name.upcase}_ROOT_DIR}/#{dir}" if dir =~ /^\./
+            f.puts <<EOS
+set(#{@project_name.upcase}_LINK_DIRS_DEBUG ${#{@project_name.upcase}_LINK_DIRS_DEBUG} #{dir})
+EOS
+          }
+          
+          @lib_dirs[ :linux ][ :release ].each{|dir|
+            dir = "${#{@project_name.upcase}_ROOT_DIR}/#{dir}" if dir =~ /^\./
+            f.puts <<EOS
+set(#{@project_name.upcase}_LINK_DIRS_RELEASE ${#{@project_name.upcase}_LINK_DIRS_RELEASE} #{dir})
+EOS
+          }
+          
+          f.puts <<EOS
+include(${CMAKE_CURRENT_LIST_DIR}/../#{@project_name}.cmake)
+EOS
+        }
+        
+        open( "Rakefile", "wb" ){|f|
+          f.puts <<EOS
+require File.expand_path( "../#{@project_name}", File.dirname( __FILE__ ) )
+
+def build
+  config = Buildrake::Rush.env( "CONFIG" )
+  platform_path = platform_path( "linux", config )
+  Buildrake::Rush.remaked( Buildrake::Rush.base_name( platform_path ) ){
+    Buildrake::Rush.sh( "cmake .. -DCMAKE_BUILD_TYPE=\#{config} --no-warn-unused-cli -DPLATFORM=linux -DCONFIG=\#{config} -DPLATFORM_PATH=\#{platform_path}" )
+    Buildrake::Rush.sh( "make clean all" )
+    
+    src = Buildrake::Rush.full_dir_path
+    dst = "\#{src}/../../../lib/\#{platform_path}"
+    #{@libraries.keys}.each{|name|
+      Buildrake::Rush.find( "lib\#{name}.*" ){|path|
+        Buildrake::Rush.maked( dst ){
+          Buildrake::Rush.rename( "\#{src}/\#{path}", "." )
+        }
+      }
+    }
+  }
+end
+EOS
+        }
+      }
+    end
+    
+    def generate_android_build_files
+      project_name = @project_name.upcase
+      Rush.maked( "android" ){
+        Rush.maked( "jni" ){
+          open( "Application.mk", "wb" ){|f|
+            modules = []
+            @executes.each{|name, data|
+              modules.push name
+            }
+            @libraries.each{|name, data|
+              modules.push "#{name}-static #{name}-shared"
+            }
+            
+            f.puts <<EOS
+APP_MODULES := #{modules.join( ' ' )}
+APP_PLATFORM := android-#{@android_api_level}
+APP_ABI := #{@android_archs.join( ' ' )}
+ifeq ($(APP_OPTIM),debug)
+  APP_CFLAGS := #{@c_flags[ :android ][ :debug ].join( ' ' )}
+  APP_CPPFLAGS := #{@cxx_flags[ :android ][ :debug ].join( ' ' )}
+  APP_LDFLAGS := #{@ld_flags[ :android ][ :debug ].join( ' ' )}
+else
+  APP_CFLAGS := #{@c_flags[ :android ][ :release ].join( ' ' )}
+  APP_CPPFLAGS := #{@cxx_flags[ :android ][ :release ].join( ' ' )}
+  APP_LDFLAGS := #{@ld_flags[ :android ][ :release ].join( ' ' )}
+endif
+EOS
+          }
+          
+          open( "Android.mk", "wb" ){|f|
+            f.puts <<EOS
+LOCAL_PATH := $(call my-dir)/..
+
+#{@project_name.upcase}_ROOT_DIR := $(LOCAL_PATH)/../..
+
+EOS
+            
+            local_settings = [
+              "LOCAL_CFLAGS := ",
+              "LOCAL_CXXFLAGS := ",
+              "LOCAL_LDLIBS := ",
+            ]
+            
+            @inc_dirs.each{|dir|
+              dir = "$(#{@project_name.upcase}_ROOT_DIR)/#{dir}" if dir =~ /^\./
+              local_settings.push "LOCAL_CFLAGS += -I#{dir}"
+              local_settings.push "LOCAL_CXXFLAGS += -I#{dir}"
+            }
+            
+            local_settings.push "ifeq ($(APP_OPTIM),debug)"
+            @lib_dirs[ :android ][ :debug ].each{|dir|
+              dir = "$(#{@project_name.upcase}_ROOT_DIR)/#{dir}" if dir =~ /^\./
+              local_settings.push "  LOCAL_LDLIBS += -L#{dir}/libs/$(TARGET_ARCH_ABI)"
+            }
+            local_settings.push "else"
+            @lib_dirs[ :android ][ :release ].each{|dir|
+              dir = "$(#{@project_name.upcase}_ROOT_DIR)/#{dir}" if dir =~ /^\./
+              local_settings.push "  LOCAL_LDLIBS += -L#{dir}/libs/$(TARGET_ARCH_ABI)"
+            }
+            local_settings.push "endif"
+            
+            @executes.each{|name, data|
+              f.puts "#{@project_name.upcase}_EXE_#{name.upcase}_SRCS :="
+              data[ :srcs ].each{|src|
+                src = "$(#{@project_name.upcase}_ROOT_DIR)/#{src}" if src =~ /^\./
+                f.puts "#{@project_name.upcase}_EXE_#{name.upcase}_SRCS += #{src}"
+              }
+              
+              ld_libs = []
+              data[ :libs ].each{|lib|
+                case Rush.ext_name( lib )
+                when "a"
+                  ld_libs.push "LOCAL_LDLIBS += -l#{lib_name( lib )}"
+                else
+                  ld_libs.push "LOCAL_LDLIBS += -l#{lib}"
+                end
+              }
+              
+              f.puts <<EOS
+include $(CLEAR_VARS)
+LOCAL_MODULE := #{name}
+LOCAL_SRC_FILES := $(#{@project_name.upcase}_EXE_#{name.upcase}_SRCS)
+#{local_settings.join( "\n" )}
+#{ld_libs.join( "\n" )}
+$(info LOCAL_CFLAGS=$(LOCAL_CFLAGS))
+$(info LOCAL_CXXFLAGS=$(LOCAL_CXXFLAGS))
+$(info LOCAL_LDLIBS=$(LOCAL_LDLIBS))
+include $(BUILD_EXECUTABLE)
+EOS
+            }
+            
+            @libraries.each{|name, data|
+              f.puts "#{@project_name.upcase}_LIB_#{name.upcase}_SRCS :="
+              data[ :srcs ].each{|src|
+                src = "$(#{@project_name.upcase}_ROOT_DIR)/#{src}" if src =~ /^\./
+                f.puts "#{@project_name.upcase}_LIB_#{name.upcase}_SRCS += #{src}"
+              }
+              
+              ld_libs = []
+              data[ :libs ].each{|lib|
+                case Rush.ext_name( lib )
+                when "a"
+                  ld_libs.push "LOCAL_LDLIBS += -l#{lib_name( lib )}"
+                else
+                  ld_libs.push "LOCAL_LDLIBS += -l#{lib}"
+                end
+              }
+              
+              f.puts <<EOS
+include $(CLEAR_VARS)
+LOCAL_MODULE := #{name}-static
+LOCAL_MODULE_FILENAME := lib#{name}
+LOCAL_SRC_FILES := $(#{@project_name.upcase}_LIB_#{name.upcase}_SRCS)
+#{local_settings.join( "\n" )}
+#{ld_libs.join( "\n" )}
+$(info LOCAL_CFLAGS=$(LOCAL_CFLAGS))
+$(info LOCAL_CXXFLAGS=$(LOCAL_CXXFLAGS))
+$(info LOCAL_LDLIBS=$(LOCAL_LDLIBS))
+include $(BUILD_STATIC_LIBRARY)
+
+include $(CLEAR_VARS)
+LOCAL_MODULE := #{name}-shared
+LOCAL_MODULE_FILENAME := lib#{name}
+LOCAL_SRC_FILES := $(#{@project_name.upcase}_LIB_#{name.upcase}_SRCS)
+#{local_settings.join( "\n" )}
+#{ld_libs.join( "\n" )}
+$(info LOCAL_CFLAGS=$(LOCAL_CFLAGS))
+$(info LOCAL_CXXFLAGS=$(LOCAL_CXXFLAGS))
+$(info LOCAL_LDLIBS=$(LOCAL_LDLIBS))
+include $(BUILD_SHARED_LIBRARY)
+EOS
+            }
+          }
+        }
+        
+        open( "Rakefile", "wb" ){|f|
+          f.puts <<EOS
+require File.expand_path( "../#{@project_name}", File.dirname( __FILE__ ) )
+
+def build
+  android_ndk = Buildrake::Rush.env( "ANDROID_NDK" )
+  abort( "Not found ANDROID_NDK: \#{android_ndk}" ) if android_ndk.nil? || ! Buildrake::Rush.dir?( android_ndk )
+  android_stl = Buildrake::Rush.env( "ANDROID_STL" )
+  puts "ANDROID_NDK=\#{android_ndk}"
+  puts "ANDROID_STL=\#{android_stl}"
+  config = Buildrake::Rush.env( "CONFIG" )
+  app_optim = config.downcase
+  puts "APP_OPTIM=\#{app_optim}"
+  platform_path = platform_path( "android", config )
+  Buildrake::Rush.remaked( Buildrake::Rush.base_name( platform_path ) ){
+    ndk_out_dir = "./ndk_out"
+    ndk_build = "\#{android_ndk}/ndk-build -B NDK_APP_DST_DIR='\#{ndk_out_dir}/${TARGET_ARCH_ABI}' NDK_OUT='\#{ndk_out_dir}' APP_OPTIM=\#{app_optim} PLATFORM=android CONFIG=\#{config} PLATFORM_PATH=\#{platform_path} ANDROID_NDK_VERSION=\#{Buildrake::Rush.env( 'ANDROID_NDK_VERSION' )}"
+    ndk_build = "\#{ndk_build} APP_STL=\#{android_stl}" if ! android_stl.nil? && ! android_stl.empty?
+    Buildrake::Rush.sh( ndk_build )
+    
+    src = Buildrake::Rush.full_dir_path
+    dst = "\#{src}/../../../lib/\#{platform_path}/libs"
+    #{@libraries.keys}.each{|name|
+      Buildrake::Rush.find( "\#{src}/\#{ndk_out_dir}/local/*/lib\#{name}.*" ){|path|
+        arch = Buildrake::Rush.base_name( Buildrake::Rush.dir_path( path ) )
+        Buildrake::Rush.maked( "\#{dst}/\#{arch}" ){
+          Buildrake::Rush.rename( path, "." )
+        }
+      }
+    }
+  }
+end
+EOS
+        }
+      }
+    end
+    
+    def generate_windows_build_files
+      Rush.maked( "windows" ){
+        open( "windows.cmake", "wb" ){|f|
+          f.puts <<EOS
+set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} #{@c_flags[ :windows ][ :debug ].join( ' ' )}")
+set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} #{@cxx_flags[ :windows ][ :debug ].join( ' ' )}")
+set(CMAKE_LD_FLAGS_DEBUG "${CMAKE_LD_FLAGS_DEBUG} #{@ld_flags[ :windows ][ :debug ].join( ' ' )}")
+
+set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} #{@c_flags[ :windows ][ :release ].join( ' ' )}")
+set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} #{@cxx_flags[ :windows ][ :release ].join( ' ' )}")
+set(CMAKE_LD_FLAGS_RELEASE "${CMAKE_LD_FLAGS_RELEASE} #{@ld_flags[ :windows ][ :release ].join( ' ' )}")
+
+set(#{@project_name.upcase}_ROOT_DIR ${CMAKE_CURRENT_LIST_DIR}/../..)
+set(#{@project_name.upcase}_LINK_DIRS_DEBUG)
+set(#{@project_name.upcase}_LINK_DIRS_RELEASE)
+EOS
+          
+          @lib_dirs[ :windows ][ :debug ].each{|dir|
+            dir = "${#{@project_name.upcase}_ROOT_DIR}/#{dir}" if dir =~ /^\./
+                  f.puts <<EOS
+set(#{@project_name.upcase}_LINK_DIRS_DEBUG ${#{@project_name.upcase}_LINK_DIRS_DEBUG} #{dir})
+EOS
+          }
+          
+          @lib_dirs[ :windows ][ :release ].each{|dir|
+            dir = "${#{@project_name.upcase}_ROOT_DIR}/#{dir}" if dir =~ /^\./
+            f.puts <<EOS
+set(#{@project_name.upcase}_LINK_DIRS_RELEASE ${#{@project_name.upcase}_LINK_DIRS_RELEASE} #{dir})
+EOS
+          }
+          
+          f.puts <<EOS
+include(${CMAKE_CURRENT_LIST_DIR}/../#{@project_name}.cmake)
+EOS
+        }
+        
+        @windows_runtimes.each{|runtime|
+          Rush.maked( "#{runtime}" ){
+            open( "CMakeLists.txt", "wb" ){|f|
+              f.puts <<EOS
+cmake_minimum_required(VERSION #{@cmake_version})
+
+project(#{@project_name})
+
+include(${CMAKE_CURRENT_LIST_DIR}/../windows.cmake)
+
+set(Flags
+  CMAKE_C_FLAGS
+  CMAKE_C_FLAGS_DEBUG
+  CMAKE_C_FLAGS_RELEASE
+  CMAKE_CXX_FLAGS
+  CMAKE_CXX_FLAGS_DEBUG
+  CMAKE_CXX_FLAGS_RELEASE
+)
+foreach(Flag ${Flags})
+  string(REPLACE "/MD" "/#{runtime}" ${Flag} "${${Flag}}")
+  string(REGEX REPLACE "/Z[i|I]" "/Z7" ${Flag} "${${Flag}}")
+endforeach()
+EOS
+            }
+          }
+        }
+        
+        open( "Rakefile", "wb" ){|f|
+          f.puts <<EOS
+require File.expand_path( "../#{@project_name}", File.dirname( __FILE__ ) )
+
+def build
+  config = Buildrake::Rush.env( "CONFIG" )
+  windows_visual_studio_version = Buildrake::Rush.env( "WINDOWS_VISUAL_STUDIO_VERSION" )
+  windows_runtime = Buildrake::Rush.env( "WINDOWS_RUNTIME" )
+  windows_arch = Buildrake::Rush.env( "WINDOWS_ARCH" )
+  cmake_generator = Buildrake::Rush.env( "CMAKE_GENERATOR" )
+  platform_path = platform_path( "windows", config )
+  Buildrake::Rush.remaked( Buildrake::Rush.base_name( platform_path ) ){
+    Buildrake::Rush.sh( "cmake ../\#{windows_runtime} -DCMAKE_CONFIGURATION_TYPES=\#{config} -DCMAKE_BUILD_TYPE=\#{config} -G\\"\#{cmake_generator}\\" -A\\"\#{windows_arch}\\" --no-warn-unused-cli -DPLATFORM=windows -DCONFIG=\#{config} -DPLATFORM_PATH=\#{platform_path}" )
+    Buildrake::Rush.sh( "msbuild #{@project_name}.sln /m /t:Rebuild /p:Configuration=\#{config} /p:Platform=\\"\#{windows_arch}\\"" )
+    
+    built_files = []
+    Buildrake::Rush.changed( config ){
+      Buildrake::Rush.find( "\#{Buildrake::Rush.full_dir_path}/*" ){|path|
+        built_files.push path
+      }
+    }
+    Buildrake::Rush.maked( "../../../lib/\#{platform_path}" ){
+      built_files.each{|built_file|
+        Buildrake::Rush.rename( built_file, "." )
+      }
+    }
+  }
+end
+EOS
+        }
+      }
+    end
+  end
+end