fuck-premake-old2/vsandroid_vcxproj.lua

--
-- android/vsandroid_vcxproj.lua
-- vs-android integration for vstudio.
-- Copyright (c) 2012-2015 Manu Evans and the Premake project
--

	local p = premake

	p.modules.vsandroid = { }

	local android = p.modules.android
	local vsandroid = p.modules.vsandroid
	local sln2005 = p.vstudio.sln2005
	local vc2010 = p.vstudio.vc2010
	local vstudio = p.vstudio
	local project = p.project
	local config = p.config


--
-- Add android tools to vstudio actions.
--

	if vstudio.vs200x_architectures ~= nil then
		vstudio.vs200x_architectures.x86 = "x86"
	end

	if vstudio.vs2010_architectures ~= nil then
		vstudio.vs2010_architectures.android = "Android"
	end


--
-- Extend configurationProperties.
--

	premake.override(vc2010.elements, "configurationProperties", function(oldfn, cfg)
		local elements = oldfn(cfg)
		if cfg.kind ~= p.UTILITY and cfg.system == premake.ANDROID then
			elements = table.join(elements, {
				android.androidAPILevel,
				android.androidStlType,
			})
		end
		return elements
	end)

	function android.androidAPILevel(cfg)
		if cfg.androidapilevel ~= nil then
			_p(2,'<AndroidAPILevel>android-%d</AndroidAPILevel>', cfg.androidapilevel)
		end
	end

	function android.androidStlType(cfg)
		if cfg.stl ~= nil then
			local static = {
				none       = "none",
				minimal    = "system",
				["stdc++"] = "gnustl_static",
				stlport    = "stlport_static",
			}
			local dynamic = {
				none       = "none",
				minimal    = "system",
				["stdc++"] = "gnustl_dynamic",
				stlport    = "stlport_dynamic",
			}
			local stl = iif(cfg.flags.StaticRuntime, static, dynamic);
			_p(2,'<AndroidStlType>%s</AndroidStlType>', stl[cfg.stl])
		end
	end

	-- Note: this function is already patched in by vs2012...
	premake.override(vc2010, "platformToolset", function(oldfn, cfg)
		if cfg.system == premake.ANDROID then
			local archMap = {
				arm = "armv5te", -- should arm5 be default? vs-android thinks so...
				arm5 = "armv5te",
				arm7 = "armv7-a",
				mips = "mips",
				x86 = "x86",
			}
			local arch = cfg.architecture or "arm"

			if (cfg.architecture ~= nil or cfg.toolchainversion ~= nil) and archMap[arch] ~= nil then
				local defaultToolsetMap = {
					arm = "arm-linux-androideabi-",
					armv5 = "arm-linux-androideabi-",
					armv7 = "arm-linux-androideabi-",
					aarch64 = "aarch64-linux-android-",
					mips = "mipsel-linux-android-",
					mips64 = "mips64el-linux-android-",
					x86 = "x86-",
					x86_64 = "x86_64-",
				}
				local toolset = defaultToolsetMap[arch]

				if cfg.toolset == "clang" then
					error("The clang toolset is not yet supported by vs-android", 2)
					toolset = toolset .. "clang"
				elseif cfg.toolset and cfg.toolset ~= "gcc" then
					error("Toolset not supported by the android NDK: " .. cfg.toolset, 2)
				end

				local version = cfg.toolchainversion or iif(cfg.toolset == "clang", "3.5", "4.9")

				_p(2,'<PlatformToolset>%s</PlatformToolset>', toolset .. version)
				_p(2,'<AndroidArch>%s</AndroidArch>', archMap[arch])
			end
		else
			oldfn(cfg)
		end
	end)


--
-- Extend outputProperties.
--

	premake.override(vc2010, "targetExt", function(oldfn, cfg)
		if cfg.system == premake.ANDROID then
			local ext = cfg.buildtarget.extension
			if ext ~= "" then
				_x(2,'<TargetExt>%s</TargetExt>', ext)
			end
		else
			oldfn(cfg)
		end
	end)


--
-- Extend clCompile.
--

	premake.override(vc2010.elements, "clCompile", function(oldfn, cfg)
		local elements = oldfn(cfg)
		if cfg.system == premake.ANDROID then
			elements = table.join(elements, {
				android.androidDebugInformation,
				android.strictAliasing,
				android.thumbMode,
				android.fpu,
				android.pic,
--				android.StrictAliasing,
--				android.ShortEnums,
			})
		end
		return elements
	end)

	function android.androidDebugInformation(cfg)
		if cfg.flags.Symbols then
			_p(3,'<GenerateDebugInformation>true</GenerateDebugInformation>')
		end
	end

	function android.strictAliasing(cfg)
		if cfg.strictaliasing ~= nil then
			_p(3,'<StrictAliasing>%s</StrictAliasing>', iif(cfg.strictaliasing == "Off", "false", "true"))
		end
	end

	function android.thumbMode(cfg)
		if cfg.flags.Thumb then
			_p(3,'<ThumbMode>true</ThumbMode>')
		end
	end

	function android.fpu(cfg)
		if cfg.fpu == "Software" then
			_p(3,'<SoftFloat>true</SoftFloat>')
		end
	end

	function android.pic(cfg)
		-- TODO: We only have a flag to turn it on, but android is on by default
		--       it seems we would rather have a flag to turn it off...
--		if cfg.flags.PIC then
--			_p(3,'<PositionIndependentCode>%s</PositionIndependentCode>', iif(cfg.flags.PIC, "true", "false"))
--		end
	end

	premake.override(vc2010, "warningLevel", function(oldfn, cfg)
		if cfg.system == premake.ANDROID then
			local map = { Off = "DisableAllWarnings", Extra = "AllWarnings" }
			if map[cfg.warnings] ~= nil then
				_p(3,'<Warnings>%s</Warnings>', map[cfg.warnings])
			end
		else
			oldfn(cfg)
		end
	end)

	premake.override(vc2010, "treatWarningAsError", function(oldfn, cfg)
		if cfg.system == premake.ANDROID then
			if cfg.flags.FatalCompileWarnings and cfg.warnings ~= "Off" then
				_p(3,'<WarningsAsErrors>true</WarningsAsErrors>')
			end
		else
			oldfn(cfg)
		end
	end)

	premake.override(vc2010, "optimization", function(oldfn, cfg, condition)
		if cfg.system == premake.ANDROID then
			local map = { Off="O0", On="O2", Debug="O0", Full="O3", Size="Os", Speed="O3" }
			local value = map[cfg.optimize]
			if value or not condition then
				vc2010.element('OptimizationLevel', condition, value or "O0")
			end
		else
			oldfn(cfg, condition)
		end
	end)

	premake.override(vc2010, "exceptionHandling", function(oldfn, cfg)
		if cfg.system == premake.ANDROID then
			-- Note: Android defaults to 'off'
			if not cfg.flags.NoExceptions then
				_p(3,'<GccExceptionHandling>true</GccExceptionHandling>')
			end
		else
			oldfn(cfg)
		end
	end)

	premake.override(vc2010, "runtimeTypeInfo", function(oldfn, cfg)
		if cfg.system == premake.ANDROID then
			-- Note: Android defaults to 'off'
			if not cfg.flags.NoRTTI then
				_p(3,'<RuntimeTypeInfo>true</RuntimeTypeInfo>')
			end
		else
			oldfn(cfg)
		end
	end)


--
-- Extend Link.
--

	premake.override(vc2010, "generateDebugInformation", function(oldfn, cfg)
		-- Note: Android specifies the debug info in the clCompile section
		if cfg.system ~= premake.ANDROID then
			oldfn(cfg)
		end
	end)


--
-- Add android tools to vstudio actions.
--

	premake.override(vc2010.elements, "itemDefinitionGroup", function(oldfn, cfg)
		local elements = oldfn(cfg)
		if cfg.system == premake.ANDROID then
			elements = table.join(elements, {
				android.antBuild,
			})
		end
		return elements
	end)

	function android.antBuild(cfg)
		if cfg.kind == premake.STATICLIB or cfg.kind == premake.SHAREDLIB then
			return
		end

		_p(2,'<AntBuild>')
		_p(3,'<AntBuildType>%s</AntBuildType>', iif(premake.config.isDebugBuild(cfg), "Debug", "Release"))
		_p(2,'</AntBuild>')
	end

	premake.override(vc2010, "additionalCompileOptions", function(oldfn, cfg, condition)
		if cfg.system == premake.ANDROID then
			vsandroid.additionalOptions(cfg, condition)
		end
		return oldfn(cfg, condition)
	end)


--
-- Add options unsupported by vs-android UI to <AdvancedOptions>.
--
	function vsandroid.additionalOptions(cfg)

		local function alreadyHas(t, key)
			for _, k in ipairs(t) do
				if string.find(k, key) then
					return true
				end
			end
			return false
		end

		if not cfg.architecture or string.startswith(cfg.architecture, "arm") then
			-- we might want to define the arch to generate better code
--			if not alreadyHas(cfg.buildoptions, "-march=") then
--				if cfg.architecture == "armv6" then
--					table.insert(cfg.buildoptions, "-march=armv6")
--				elseif cfg.architecture == "armv7" then
--					table.insert(cfg.buildoptions, "-march=armv7")
--				end
--			end

			-- ARM has a comprehensive set of floating point options
			if cfg.fpu ~= "Software" and cfg.floatabi ~= "soft" then

				if cfg.architecture == "armv7" then

					-- armv7 always has VFP, may not have NEON

					if not alreadyHas(cfg.buildoptions, "-mfpu=") then
						if cfg.vectorextensions == "NEON" then
							table.insert(cfg.buildoptions, "-mfpu=neon")
						elseif cfg.fpu == "Hardware" or cfg.floatabi == "softfp" or cfg.floatabi == "hard" then
							table.insert(cfg.buildoptions, "-mfpu=vfpv3-d16") -- d16 is the lowest common denominator
						end
					end

					if not alreadyHas(cfg.buildoptions, "-mfloat-abi=") then
						if cfg.floatabi == "hard" then
							table.insert(cfg.buildoptions, "-mfloat-abi=hard")
						else
							-- Android should probably use softfp by default for compatibility
							table.insert(cfg.buildoptions, "-mfloat-abi=softfp")
						end
					end

				else

					-- armv5/6 may not have VFP

					if not alreadyHas(cfg.buildoptions, "-mfpu=") then
						if cfg.fpu == "Hardware" or cfg.floatabi == "softfp" or cfg.floatabi == "hard" then
							table.insert(cfg.buildoptions, "-mfpu=vfp")
						end
					end

					if not alreadyHas(cfg.buildoptions, "-mfloat-abi=") then
						if cfg.floatabi == "softfp" then
							table.insert(cfg.buildoptions, "-mfloat-abi=softfp")
						elseif cfg.floatabi == "hard" then
							table.insert(cfg.buildoptions, "-mfloat-abi=hard")
						end
					end

				end

			elseif cfg.floatabi == "soft" then

				table.insert(cfg.buildoptions, "-mfloat-abi=soft")

			end

			if cfg.endian == "Little" then
				table.insert(cfg.buildoptions, "-mlittle-endian")
			elseif cfg.endian == "Big" then
				table.insert(cfg.buildoptions, "-mbig-endian")
			end

		elseif cfg.architecture == "mips" then

			-- TODO...

			if cfg.vectorextensions == "MXU" then
				table.insert(cfg.buildoptions, "-mmxu")
			end

		elseif cfg.architecture == "x86" then

			-- TODO...

		end
	end