/
winrtbuild.ps1
240 lines (211 loc) · 9.32 KB
/
winrtbuild.ps1
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
#
# 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"
}
if ($PlatformToolset -eq "v140") { # Windows 10, via VS 2015
return "C:\Program Files (x86)\Microsoft Visual Studio 14.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"
}
}
if ($PlatformToolset -eq "v140") { # Windows 10, via VS 2015 project files
if ($IncludeVSSuffix) {
return "UWP_VS2015"
} else {
return "UWP"
}
}
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:Configuration=Release /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 }
# Build for Windows 10, via VC++ 2015
if ( ! (Build-SDL-WinRT-Variant "SDL" "v140" "ARM")) { $DidAnyFail = $true }
if ( ! (Build-SDL-WinRT-Variant "SDL" "v140" "Win32")) { $DidAnyFail = $true }
if ( ! (Build-SDL-WinRT-Variant "SDL" "v140" "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
}