kc3-lang/SDL/build-scripts/winrtbuild.ps1

• Show log

  Commit

• Hash : b48e54aa
  Author :
  Date : 2015-01-26T22:00:29
  

  Fixed bug 2802 - [patch] Fix android build compiling in wrong filesystem implementation Jonas Kulla The configure script didn't differentiate between Linux and Android, unconditionally compiling in the unix implementation of SDL_sysfilesystem.c. I'm probably one of the very few people building SDL for android using classic configure + standalone toolchain, so this has gone undetected all along.

Download

• build-scripts/winrtbuild.ps1

• #
  # winrtbuild.ps1 -- A Powershell script to build all SDL/WinRT variants,
  #    across all WinRT platforms, in all of their supported, CPU architectures.
  #
  # Initial version written by David Ludwig <dludwig@pobox.com>
  #
  # This script can be launched from Windows Explorer by double-clicking
  # on winrtbuild.bat
  #
  # Output will be placed in the following subdirectories of the SDL source
  # tree:
  #   * VisualC-WinRT\lib\  -- final .dll, .lib, and .pdb files
  #   * VisualC-WinRT\obj\  -- intermediate build files
  #
  # Recommended Dependencies:
  #   * Windows 8.1 or higher
  #   * Powershell 4.0 or higher (included as part of Windows 8.1)
  #   * Visual C++ 2012, for building Windows 8.0 and Windows Phone 8.0 binaries.
  #   * Visual C++ 2013, for building Windows 8.1 and Windows Phone 8.1 binaries
  #   * SDKs for Windows 8.0, Windows 8.1, Windows Phone 8.0, and
  #     Windows Phone 8.1, as needed
  #
  # Commom parameters/variables may include, but aren't strictly limited to:
  #   * PlatformToolset: the name of one of Visual Studio's build platforms.
  #     Different PlatformToolsets output different binaries.  One
  #     PlatformToolset exists for each WinRT platform.  Possible values
  #     may include:
  #       - "v110": Visual Studio 2012 build tools, plus the Windows 8.0 SDK
  #       - "v110_wp80": Visual Studio 2012 build tools, plus the Windows Phone 8.0 SDK
  #       - "v120": Visual Studio 2013 build tools, plus the Windows 8.1 SDK
  #       - "v120_wp81": Visual Studio 2013 build tools, plus the Windows Phone 8.1 SDK
  #   * VSProjectPath: the full path to a Visual Studio or Visual C++ project file
  #   * VSProjectName: the internal name of a Visual Studio or Visual C++ project
  #     file.  Some of Visual Studio's own build tools use this name when
  #     calculating paths for build-output.
  #   * Platform: a Visual Studio platform name, which often maps to a CPU
  #     CPU architecture.  Possible values may include: "Win32" (for 32-bit x86),
  #     "ARM", or "x64" (for 64-bit x86).
  #
  
  
  # Gets the .bat file that sets up an MSBuild environment, given one of
  # Visual Studio's, "PlatformToolset"s.
  function Get-MSBuild-Env-Launcher
  {
      param(
          [Parameter(Mandatory=$true,Position=1)][string]$PlatformToolset
      )
  
      if ($PlatformToolset -eq "v110") {      # Windows 8.0 (not Windows Phone), via VS 2012
          return "C:\Program Files (x86)\Microsoft Visual Studio 11.0\VC\vcvarsall.bat"
      }
      if ($PlatformToolset -eq "v110_wp80") { # Windows Phone 8.0, via VS 2012
          return "C:\Program Files (x86)\Microsoft Visual Studio 11.0\VC\WPSDK\WP80\vcvarsphoneall.bat"
      }
      if ($PlatformToolset -eq "v120") {      # Windows 8.1 (not Windows Phone), via VS 2013
          return "C:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\vcvarsall.bat"
      }
      if ($PlatformToolset -eq "v120_wp81") { # Windows Phone 8.1, via VS 2013
          return "C:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\vcvarsall.bat"
      }
      return ""
  }
  
  # Gets a string that identifies the build-variant of SDL/WinRT that is specific
  # to a particular Visual Studio PlatformToolset.
  function Get-SDL-WinRT-Variant-Name
  {
      param(
          [Parameter(Mandatory=$true,Position=1)][string]$PlatformToolset,
  
          # If true, append a string to this function's output, identifying the
          # build-variant's minimum-supported version of Visual Studio.
          [switch]$IncludeVSSuffix = $false
      )
  
      if ($PlatformToolset -eq "v110") {      # Windows 8.0 (not Windows Phone), via VS 2012 project files
          if ($IncludeVSSuffix) {
              return "WinRT80_VS2012"
          } else {
              return "WinRT80"
          }
      }
      if ($PlatformToolset -eq "v110_wp80") { # Windows Phone 8.0, via VS 2012 project files
          if ($IncludeVSSuffix) {
              return "WinPhone80_VS2012"
          } else {
              return "WinPhone80"
          }
      }
      if ($PlatformToolset -eq "v120") {      # Windows 8.1 (not Windows Phone), via VS 2013 project files
          if ($IncludeVSSuffix) {
              return "WinRT81_VS2013"
          } else {
              return "WinRT81"
          }
      }
      if ($PlatformToolset -eq "v120_wp81") { # Windows Phone 8.1, via VS 2013 project files
          if ($IncludeVSSuffix) {
              return "WinPhone81_VS2013"
          } else {
              return "WinPhone81"
          }
      }
      return ""
  }
  
  # Returns the internal name of a Visual Studio Project.
  #
  # The internal name of a VS Project is encoded inside the project file
  # itself, inside a set of <ProjectName></ProjectName> XML tags.
  function Get-VS-ProjectName
  {
      param(
          [Parameter(Mandatory=$true,Position=1)]$VSProjectPath
      )
  
      # For now, just do a regex for the project name:
      $matches = (Get-Content $VSProjectPath | Select-String -Pattern ".*<ProjectName>([^<]+)<.*").Matches
      foreach ($match in $matches) {
          if ($match.Groups.Count -ge 1) {
              return $match.Groups[1].Value
          }
      }
      return $null
  }
  
  # Build a specific variant of SDL/WinRT
  function Build-SDL-WinRT-Variant
  {
      #
      # Read in arguments:
      #
      param (
          # name of an SDL project file, minus extensions and
          # platform-identifying suffixes
          [Parameter(Mandatory=$true,Position=1)][string]$SDLProjectName,
  
          [Parameter(Mandatory=$true,Position=2)][string]$PlatformToolset,
  
          [Parameter(Mandatory=$true,Position=3)][string]$Platform
      )
  
      #
      # Derive other properties from read-in arguments:
      #
  
      # The .bat file to setup a platform-appropriate MSBuild environment:
      $BatchFileForMSBuildEnv = Get-MSBuild-Env-Launcher $PlatformToolset
  
      # The full path to the VS Project that'll be built:
      $VSProjectPath = "$PSScriptRoot\..\VisualC-WinRT\$(Get-SDL-WinRT-Variant-Name $PlatformToolset -IncludeVSSuffix)\$SDLProjectName-$(Get-SDL-WinRT-Variant-Name $PlatformToolset).vcxproj"
  
      # The internal name of the VS Project, used in some post-build steps:
      $VSProjectName = Get-VS-ProjectName $VSProjectPath
  
      # Where to place output binaries (.dll, .lib, and .pdb files):
      $OutDir = "$PSScriptRoot\..\VisualC-WinRT\lib\$PlatformToolset\$Platform"
  
      # Where to place intermediate build files:
      $IntermediateDir = "$PSScriptRoot\..\VisualC-WinRT\obj\$SDLProjectName-$(Get-SDL-WinRT-Variant-Name $PlatformToolset)\$Platform"
  
      #
      # Build the VS Project:
      #
      cmd.exe /c " ""$BatchFileForMSBuildEnv"" x86 & msbuild ""$VSProjectPath"" /p:Platform=$Platform /p:OutDir=""$OutDir\\"" /p:IntDir=""$IntermediateDir\\""" | Out-Host
      $BuildResult = $?
  
      #
      # Move .dll files into place.  This fixes a problem whereby MSBuild may
      # put output files into a sub-directory of $OutDir, rather than $OutDir
      # itself.
      #
      if (Test-Path "$OutDir\$VSProjectName\") {
          Move-Item -Force "$OutDir\$VSProjectName\*" "$OutDir"
      }
  
      #
      # Clean up unneeded files in $OutDir:
      #
      if (Test-Path "$OutDir\$VSProjectName\") {
          Remove-Item -Recurse "$OutDir\$VSProjectName"
      }
      Remove-Item "$OutDir\*.exp"
      Remove-Item "$OutDir\*.ilk"
      Remove-Item "$OutDir\*.pri"
  
      #
      # All done.  Indicate success, or failure, to the caller:
      #
      #echo "RESULT: $BuildResult" | Out-Host
      return $BuildResult
  }
  
  
  #
  # Build each variant, with corresponding .dll, .lib, and .pdb files:
  #
  $DidAnyFail = $false
  
  # Build for Windows Phone 8.0, via VC++ 2012:
  if ( ! (Build-SDL-WinRT-Variant "SDL" "v110_wp80" "ARM"))   { $DidAnyFail = $true }
  if ( ! (Build-SDL-WinRT-Variant "SDL" "v110_wp80" "Win32")) { $DidAnyFail = $true }
  
  # Build for Windows Phone 8.1, via VC++ 2013:
  if ( ! (Build-SDL-WinRT-Variant "SDL" "v120_wp81" "ARM"))   { $DidAnyFail = $true }
  if ( ! (Build-SDL-WinRT-Variant "SDL" "v120_wp81" "Win32")) { $DidAnyFail = $true }
  
  # Build for Windows 8.0 and Windows RT 8.0, via VC++ 2012:
  if ( ! (Build-SDL-WinRT-Variant "SDL" "v110" "ARM"))        { $DidAnyFail = $true }
  if ( ! (Build-SDL-WinRT-Variant "SDL" "v110" "Win32"))      { $DidAnyFail = $true }
  if ( ! (Build-SDL-WinRT-Variant "SDL" "v110" "x64"))        { $DidAnyFail = $true }
  
  # Build for Windows 8.1 and Windows RT 8.1, via VC++ 2013:
  if ( ! (Build-SDL-WinRT-Variant "SDL" "v120" "ARM"))        { $DidAnyFail = $true }
  if ( ! (Build-SDL-WinRT-Variant "SDL" "v120" "Win32"))      { $DidAnyFail = $true }
  if ( ! (Build-SDL-WinRT-Variant "SDL" "v120" "x64"))        { $DidAnyFail = $true }
  
  # Let the script's caller know whether or not any errors occurred.
  # Exit codes compatible with Buildbot are used (1 for error, 0 for success).
  if ($DidAnyFail -eq $true) {
      exit 1
  } else {
      exit 0
  }
  

Download