Get Gentoo!
gentoo.org sites
gentoo.org Wiki Bugs Forums Packages
Planet Archives Sources
Infra Status

Gentoo Archives: gentoo-commits

From: NP Hardass <np-hardass@g.o>
To: gentoo-commits@l.g.o
Subject: [gentoo-commits] repo/gentoo:master commit in: app-emulation/wine/
Date: Wed, 24 Aug 2016 19:08:10
Message-Id: 1472065671.ba956c8e2dcedd1265a19432fc38297c4d6e2e8c.np-hardass@gentoo
1 commit: ba956c8e2dcedd1265a19432fc38297c4d6e2e8c
2 Author: NP-Hardass <NP-Hardass <AT> gentoo <DOT> org>
3 AuthorDate: Wed Aug 24 04:23:38 2016 +0000
4 Commit: NP Hardass <np-hardass <AT> gentoo <DOT> org>
5 CommitDate: Wed Aug 24 19:07:51 2016 +0000
6 URL: https://gitweb.gentoo.org/repo/gentoo.git/commit/?id=ba956c8e
7
8 app-emulation/wine: Fix use of env vars for 9999
9
10 Package-Manager: portage-2.3.0
11
12 app-emulation/wine/wine-1.8-r3.ebuild | 34 ++++++++++++++++++++++++------
13 app-emulation/wine/wine-1.8.1-r3.ebuild | 34 ++++++++++++++++++++++++------
14 app-emulation/wine/wine-1.8.2-r2.ebuild | 34 ++++++++++++++++++++++++------
15 app-emulation/wine/wine-1.8.3-r1.ebuild | 34 ++++++++++++++++++++++++------
16 app-emulation/wine/wine-1.9.10-r3.ebuild | 36 +++++++++++++++++++++++++-------
17 app-emulation/wine/wine-1.9.11-r3.ebuild | 36 +++++++++++++++++++++++++-------
18 app-emulation/wine/wine-1.9.12-r2.ebuild | 36 +++++++++++++++++++++++++-------
19 app-emulation/wine/wine-1.9.13-r2.ebuild | 36 +++++++++++++++++++++++++-------
20 app-emulation/wine/wine-1.9.14-r2.ebuild | 36 +++++++++++++++++++++++++-------
21 app-emulation/wine/wine-1.9.15-r1.ebuild | 36 +++++++++++++++++++++++++-------
22 app-emulation/wine/wine-1.9.16.ebuild | 36 +++++++++++++++++++++++++-------
23 app-emulation/wine/wine-1.9.17.ebuild | 36 +++++++++++++++++++++++++-------
24 app-emulation/wine/wine-1.9.4-r3.ebuild | 34 ++++++++++++++++++++++++------
25 app-emulation/wine/wine-1.9.5-r3.ebuild | 34 ++++++++++++++++++++++++------
26 app-emulation/wine/wine-1.9.6-r3.ebuild | 34 ++++++++++++++++++++++++------
27 app-emulation/wine/wine-1.9.7-r3.ebuild | 34 ++++++++++++++++++++++++------
28 app-emulation/wine/wine-1.9.8-r2.ebuild | 34 ++++++++++++++++++++++++------
29 app-emulation/wine/wine-1.9.9-r3.ebuild | 36 +++++++++++++++++++++++++-------
30 app-emulation/wine/wine-9999.ebuild | 36 +++++++++++++++++++++++++-------
31 19 files changed, 542 insertions(+), 124 deletions(-)
32
33 diff --git a/app-emulation/wine/wine-1.8-r3.ebuild b/app-emulation/wine/wine-1.8-r3.ebuild
34 index ad22c09..14de6ad 100644
35 --- a/app-emulation/wine/wine-1.8-r3.ebuild
36 +++ b/app-emulation/wine/wine-1.8-r3.ebuild
37 @@ -246,6 +246,27 @@ wine_build_environment_check() {
38 fi
39 }
40
41 +wine_env_vcs_vars() {
42 + local pn_live_var="${PN//[-+]/_}_LIVE_COMMIT"
43 + local pn_live_val="${pn_live_var}"
44 + eval pn_live_val='$'${pn_live_val}
45 + if [[ ! -z ${pn_live_val} ]]; then
46 + if use staging || use d3d9; then
47 + eerror "Because of the multi-repo nature of ${PN}, ${pn_live_var}"
48 + eerror "cannot be used to set the commit. Instead, you may use the"
49 + eerror "environmental variables WINE_COMMIT, STAGING_COMMIT, and D3D9_COMMIT."
50 + eerror
51 + return 1
52 + fi
53 + fi
54 + if [[ ! -z ${EGIT_COMMIT} ]]; then
55 + eerror "Commits must now be specified using the environmental variables"
56 + eerror "WINE_COMMIT, STAGING_COMMIT, and D3D9_COMMIT"
57 + eerror
58 + return 1
59 + fi
60 +}
61 +
62 pkg_pretend() {
63 wine_compiler_check || die
64 wine_build_environment_check || die
65 @@ -263,6 +284,7 @@ pkg_pretend() {
66
67 pkg_setup() {
68 wine_build_environment_check || die
69 + wine_env_vcs_vars || die
70 if ! use staging; then
71 GV=${VANILLA_GV}
72 MV=${VANILLA_MV}
73 @@ -274,19 +296,19 @@ pkg_setup() {
74
75 src_unpack() {
76 if [[ ${PV} == "9999" ]] ; then
77 - git-r3_src_unpack
78 + EGIT_COMMIT="${WINE_COMMIT}" git-r3_src_unpack
79 if use staging; then
80 - local WINE_COMMIT=${EGIT_VERSION}
81 + local CURRENT_WINE_COMMIT=${EGIT_VERSION}
82
83 - git-r3_fetch "${STAGING_EGIT_REPO_URI}"
84 + git-r3_fetch "${STAGING_EGIT_REPO_URI}" "${STAGING_COMMIT}"
85 git-r3_checkout "${STAGING_EGIT_REPO_URI}" "${STAGING_DIR}"
86
87 - local STAGING_COMMIT=$("${STAGING_DIR}/patches/patchinstall.sh" --upstream-commit) || die
88 + local COMPAT_WINE_COMMIT=$("${STAGING_DIR}/patches/patchinstall.sh" --upstream-commit) || die
89
90 - if [[ "${WINE_COMMIT}" != "${STAGING_COMMIT}" ]]; then
91 + if [[ "${CURRENT_WINE_COMMIT}" != "${COMPAT_WINE_COMMIT}" ]]; then
92 einfo "The current Staging patchset is not guaranteed to apply on this WINE commit."
93 einfo "If src_prepare fails, try emerging with the env var EGIT_COMMIT."
94 - einfo "Example: EGIT_COMMIT=${STAGING_COMMIT} emerge -1 wine"
95 + einfo "Example: WINE_COMMIT=${COMPAT_WINE_COMMIT} emerge -1 wine"
96 fi
97 fi
98 fi
99
100 diff --git a/app-emulation/wine/wine-1.8.1-r3.ebuild b/app-emulation/wine/wine-1.8.1-r3.ebuild
101 index 56ea43c..c83c20d 100644
102 --- a/app-emulation/wine/wine-1.8.1-r3.ebuild
103 +++ b/app-emulation/wine/wine-1.8.1-r3.ebuild
104 @@ -247,6 +247,27 @@ wine_build_environment_check() {
105 fi
106 }
107
108 +wine_env_vcs_vars() {
109 + local pn_live_var="${PN//[-+]/_}_LIVE_COMMIT"
110 + local pn_live_val="${pn_live_var}"
111 + eval pn_live_val='$'${pn_live_val}
112 + if [[ ! -z ${pn_live_val} ]]; then
113 + if use staging || use d3d9; then
114 + eerror "Because of the multi-repo nature of ${PN}, ${pn_live_var}"
115 + eerror "cannot be used to set the commit. Instead, you may use the"
116 + eerror "environmental variables WINE_COMMIT, STAGING_COMMIT, and D3D9_COMMIT."
117 + eerror
118 + return 1
119 + fi
120 + fi
121 + if [[ ! -z ${EGIT_COMMIT} ]]; then
122 + eerror "Commits must now be specified using the environmental variables"
123 + eerror "WINE_COMMIT, STAGING_COMMIT, and D3D9_COMMIT"
124 + eerror
125 + return 1
126 + fi
127 +}
128 +
129 pkg_pretend() {
130 wine_compiler_check || die
131 wine_build_environment_check || die
132 @@ -264,6 +285,7 @@ pkg_pretend() {
133
134 pkg_setup() {
135 wine_build_environment_check || die
136 + wine_env_vcs_vars || die
137 if ! use staging; then
138 GV=${VANILLA_GV}
139 MV=${VANILLA_MV}
140 @@ -275,19 +297,19 @@ pkg_setup() {
141
142 src_unpack() {
143 if [[ ${PV} == "9999" ]] ; then
144 - git-r3_src_unpack
145 + EGIT_COMMIT="${WINE_COMMIT}" git-r3_src_unpack
146 if use staging; then
147 - local WINE_COMMIT=${EGIT_VERSION}
148 + local CURRENT_WINE_COMMIT=${EGIT_VERSION}
149
150 - git-r3_fetch "${STAGING_EGIT_REPO_URI}"
151 + git-r3_fetch "${STAGING_EGIT_REPO_URI}" "${STAGING_COMMIT}"
152 git-r3_checkout "${STAGING_EGIT_REPO_URI}" "${STAGING_DIR}"
153
154 - local STAGING_COMMIT=$("${STAGING_DIR}/patches/patchinstall.sh" --upstream-commit) || die
155 + local COMPAT_WINE_COMMIT=$("${STAGING_DIR}/patches/patchinstall.sh" --upstream-commit) || die
156
157 - if [[ "${WINE_COMMIT}" != "${STAGING_COMMIT}" ]]; then
158 + if [[ "${CURRENT_WINE_COMMIT}" != "${COMPAT_WINE_COMMIT}" ]]; then
159 einfo "The current Staging patchset is not guaranteed to apply on this WINE commit."
160 einfo "If src_prepare fails, try emerging with the env var EGIT_COMMIT."
161 - einfo "Example: EGIT_COMMIT=${STAGING_COMMIT} emerge -1 wine"
162 + einfo "Example: WINE_COMMIT=${COMPAT_WINE_COMMIT} emerge -1 wine"
163 fi
164 fi
165 fi
166
167 diff --git a/app-emulation/wine/wine-1.8.2-r2.ebuild b/app-emulation/wine/wine-1.8.2-r2.ebuild
168 index 2276923..43c0243 100644
169 --- a/app-emulation/wine/wine-1.8.2-r2.ebuild
170 +++ b/app-emulation/wine/wine-1.8.2-r2.ebuild
171 @@ -247,6 +247,27 @@ wine_build_environment_check() {
172 fi
173 }
174
175 +wine_env_vcs_vars() {
176 + local pn_live_var="${PN//[-+]/_}_LIVE_COMMIT"
177 + local pn_live_val="${pn_live_var}"
178 + eval pn_live_val='$'${pn_live_val}
179 + if [[ ! -z ${pn_live_val} ]]; then
180 + if use staging || use d3d9; then
181 + eerror "Because of the multi-repo nature of ${PN}, ${pn_live_var}"
182 + eerror "cannot be used to set the commit. Instead, you may use the"
183 + eerror "environmental variables WINE_COMMIT, STAGING_COMMIT, and D3D9_COMMIT."
184 + eerror
185 + return 1
186 + fi
187 + fi
188 + if [[ ! -z ${EGIT_COMMIT} ]]; then
189 + eerror "Commits must now be specified using the environmental variables"
190 + eerror "WINE_COMMIT, STAGING_COMMIT, and D3D9_COMMIT"
191 + eerror
192 + return 1
193 + fi
194 +}
195 +
196 pkg_pretend() {
197 wine_compiler_check || die
198 wine_build_environment_check || die
199 @@ -264,6 +285,7 @@ pkg_pretend() {
200
201 pkg_setup() {
202 wine_build_environment_check || die
203 + wine_env_vcs_vars || die
204 if ! use staging; then
205 GV=${VANILLA_GV}
206 MV=${VANILLA_MV}
207 @@ -275,19 +297,19 @@ pkg_setup() {
208
209 src_unpack() {
210 if [[ ${PV} == "9999" ]] ; then
211 - git-r3_src_unpack
212 + EGIT_COMMIT="${WINE_COMMIT}" git-r3_src_unpack
213 if use staging; then
214 - local WINE_COMMIT=${EGIT_VERSION}
215 + local CURRENT_WINE_COMMIT=${EGIT_VERSION}
216
217 - git-r3_fetch "${STAGING_EGIT_REPO_URI}"
218 + git-r3_fetch "${STAGING_EGIT_REPO_URI}" "${STAGING_COMMIT}"
219 git-r3_checkout "${STAGING_EGIT_REPO_URI}" "${STAGING_DIR}"
220
221 - local STAGING_COMMIT=$("${STAGING_DIR}/patches/patchinstall.sh" --upstream-commit) || die
222 + local COMPAT_WINE_COMMIT=$("${STAGING_DIR}/patches/patchinstall.sh" --upstream-commit) || die
223
224 - if [[ "${WINE_COMMIT}" != "${STAGING_COMMIT}" ]]; then
225 + if [[ "${CURRENT_WINE_COMMIT}" != "${COMPAT_WINE_COMMIT}" ]]; then
226 einfo "The current Staging patchset is not guaranteed to apply on this WINE commit."
227 einfo "If src_prepare fails, try emerging with the env var EGIT_COMMIT."
228 - einfo "Example: EGIT_COMMIT=${STAGING_COMMIT} emerge -1 wine"
229 + einfo "Example: WINE_COMMIT=${COMPAT_WINE_COMMIT} emerge -1 wine"
230 fi
231 fi
232 fi
233
234 diff --git a/app-emulation/wine/wine-1.8.3-r1.ebuild b/app-emulation/wine/wine-1.8.3-r1.ebuild
235 index 8ef5cc9..c856ece 100644
236 --- a/app-emulation/wine/wine-1.8.3-r1.ebuild
237 +++ b/app-emulation/wine/wine-1.8.3-r1.ebuild
238 @@ -247,6 +247,27 @@ wine_build_environment_check() {
239 fi
240 }
241
242 +wine_env_vcs_vars() {
243 + local pn_live_var="${PN//[-+]/_}_LIVE_COMMIT"
244 + local pn_live_val="${pn_live_var}"
245 + eval pn_live_val='$'${pn_live_val}
246 + if [[ ! -z ${pn_live_val} ]]; then
247 + if use staging || use d3d9; then
248 + eerror "Because of the multi-repo nature of ${PN}, ${pn_live_var}"
249 + eerror "cannot be used to set the commit. Instead, you may use the"
250 + eerror "environmental variables WINE_COMMIT, STAGING_COMMIT, and D3D9_COMMIT."
251 + eerror
252 + return 1
253 + fi
254 + fi
255 + if [[ ! -z ${EGIT_COMMIT} ]]; then
256 + eerror "Commits must now be specified using the environmental variables"
257 + eerror "WINE_COMMIT, STAGING_COMMIT, and D3D9_COMMIT"
258 + eerror
259 + return 1
260 + fi
261 +}
262 +
263 pkg_pretend() {
264 wine_compiler_check || die
265 wine_build_environment_check || die
266 @@ -264,6 +285,7 @@ pkg_pretend() {
267
268 pkg_setup() {
269 wine_build_environment_check || die
270 + wine_env_vcs_vars || die
271 if ! use staging; then
272 GV=${VANILLA_GV}
273 MV=${VANILLA_MV}
274 @@ -275,19 +297,19 @@ pkg_setup() {
275
276 src_unpack() {
277 if [[ ${PV} == "9999" ]] ; then
278 - git-r3_src_unpack
279 + EGIT_COMMIT="${WINE_COMMIT}" git-r3_src_unpack
280 if use staging; then
281 - local WINE_COMMIT=${EGIT_VERSION}
282 + local CURRENT_WINE_COMMIT=${EGIT_VERSION}
283
284 - git-r3_fetch "${STAGING_EGIT_REPO_URI}"
285 + git-r3_fetch "${STAGING_EGIT_REPO_URI}" "${STAGING_COMMIT}"
286 git-r3_checkout "${STAGING_EGIT_REPO_URI}" "${STAGING_DIR}"
287
288 - local STAGING_COMMIT=$("${STAGING_DIR}/patches/patchinstall.sh" --upstream-commit) || die
289 + local COMPAT_WINE_COMMIT=$("${STAGING_DIR}/patches/patchinstall.sh" --upstream-commit) || die
290
291 - if [[ "${WINE_COMMIT}" != "${STAGING_COMMIT}" ]]; then
292 + if [[ "${CURRENT_WINE_COMMIT}" != "${COMPAT_WINE_COMMIT}" ]]; then
293 einfo "The current Staging patchset is not guaranteed to apply on this WINE commit."
294 einfo "If src_prepare fails, try emerging with the env var EGIT_COMMIT."
295 - einfo "Example: EGIT_COMMIT=${STAGING_COMMIT} emerge -1 wine"
296 + einfo "Example: WINE_COMMIT=${COMPAT_WINE_COMMIT} emerge -1 wine"
297 fi
298 fi
299 fi
300
301 diff --git a/app-emulation/wine/wine-1.9.10-r3.ebuild b/app-emulation/wine/wine-1.9.10-r3.ebuild
302 index 0f8b69e..5012252 100644
303 --- a/app-emulation/wine/wine-1.9.10-r3.ebuild
304 +++ b/app-emulation/wine/wine-1.9.10-r3.ebuild
305 @@ -254,6 +254,27 @@ wine_build_environment_check() {
306 fi
307 }
308
309 +wine_env_vcs_vars() {
310 + local pn_live_var="${PN//[-+]/_}_LIVE_COMMIT"
311 + local pn_live_val="${pn_live_var}"
312 + eval pn_live_val='$'${pn_live_val}
313 + if [[ ! -z ${pn_live_val} ]]; then
314 + if use staging || use d3d9; then
315 + eerror "Because of the multi-repo nature of ${PN}, ${pn_live_var}"
316 + eerror "cannot be used to set the commit. Instead, you may use the"
317 + eerror "environmental variables WINE_COMMIT, STAGING_COMMIT, and D3D9_COMMIT."
318 + eerror
319 + return 1
320 + fi
321 + fi
322 + if [[ ! -z ${EGIT_COMMIT} ]]; then
323 + eerror "Commits must now be specified using the environmental variables"
324 + eerror "WINE_COMMIT, STAGING_COMMIT, and D3D9_COMMIT"
325 + eerror
326 + return 1
327 + fi
328 +}
329 +
330 pkg_pretend() {
331 wine_compiler_check || die
332 wine_build_environment_check || die
333 @@ -271,6 +292,7 @@ pkg_pretend() {
334
335 pkg_setup() {
336 wine_build_environment_check || die
337 + wine_env_vcs_vars || die
338 if ! use staging; then
339 GV=${VANILLA_GV}
340 MV=${VANILLA_MV}
341 @@ -282,23 +304,23 @@ pkg_setup() {
342
343 src_unpack() {
344 if [[ ${PV} == "9999" ]] ; then
345 - git-r3_src_unpack
346 + EGIT_COMMIT="${WINE_COMMIT}" git-r3_src_unpack
347 if use staging; then
348 - local WINE_COMMIT=${EGIT_VERSION}
349 + local CURRENT_WINE_COMMIT=${EGIT_VERSION}
350
351 - git-r3_fetch "${STAGING_EGIT_REPO_URI}"
352 + git-r3_fetch "${STAGING_EGIT_REPO_URI}" "${STAGING_COMMIT}"
353 git-r3_checkout "${STAGING_EGIT_REPO_URI}" "${STAGING_DIR}"
354
355 - local STAGING_COMMIT=$("${STAGING_DIR}/patches/patchinstall.sh" --upstream-commit) || die
356 + local COMPAT_WINE_COMMIT=$("${STAGING_DIR}/patches/patchinstall.sh" --upstream-commit) || die
357
358 - if [[ "${WINE_COMMIT}" != "${STAGING_COMMIT}" ]]; then
359 + if [[ "${CURRENT_WINE_COMMIT}" != "${COMPAT_WINE_COMMIT}" ]]; then
360 einfo "The current Staging patchset is not guaranteed to apply on this WINE commit."
361 einfo "If src_prepare fails, try emerging with the env var EGIT_COMMIT."
362 - einfo "Example: EGIT_COMMIT=${STAGING_COMMIT} emerge -1 wine"
363 + einfo "Example: WINE_COMMIT=${COMPAT_WINE_COMMIT} emerge -1 wine"
364 fi
365 fi
366 if use d3d9; then
367 - git-r3_fetch "${D3D9_EGIT_REPO_URI}"
368 + git-r3_fetch "${D3D9_EGIT_REPO_URI}" "${D3D9_COMMIT}"
369 git-r3_checkout "${D3D9_EGIT_REPO_URI}" "${D3D9_DIR}"
370 fi
371 fi
372
373 diff --git a/app-emulation/wine/wine-1.9.11-r3.ebuild b/app-emulation/wine/wine-1.9.11-r3.ebuild
374 index 0f8b69e..5012252 100644
375 --- a/app-emulation/wine/wine-1.9.11-r3.ebuild
376 +++ b/app-emulation/wine/wine-1.9.11-r3.ebuild
377 @@ -254,6 +254,27 @@ wine_build_environment_check() {
378 fi
379 }
380
381 +wine_env_vcs_vars() {
382 + local pn_live_var="${PN//[-+]/_}_LIVE_COMMIT"
383 + local pn_live_val="${pn_live_var}"
384 + eval pn_live_val='$'${pn_live_val}
385 + if [[ ! -z ${pn_live_val} ]]; then
386 + if use staging || use d3d9; then
387 + eerror "Because of the multi-repo nature of ${PN}, ${pn_live_var}"
388 + eerror "cannot be used to set the commit. Instead, you may use the"
389 + eerror "environmental variables WINE_COMMIT, STAGING_COMMIT, and D3D9_COMMIT."
390 + eerror
391 + return 1
392 + fi
393 + fi
394 + if [[ ! -z ${EGIT_COMMIT} ]]; then
395 + eerror "Commits must now be specified using the environmental variables"
396 + eerror "WINE_COMMIT, STAGING_COMMIT, and D3D9_COMMIT"
397 + eerror
398 + return 1
399 + fi
400 +}
401 +
402 pkg_pretend() {
403 wine_compiler_check || die
404 wine_build_environment_check || die
405 @@ -271,6 +292,7 @@ pkg_pretend() {
406
407 pkg_setup() {
408 wine_build_environment_check || die
409 + wine_env_vcs_vars || die
410 if ! use staging; then
411 GV=${VANILLA_GV}
412 MV=${VANILLA_MV}
413 @@ -282,23 +304,23 @@ pkg_setup() {
414
415 src_unpack() {
416 if [[ ${PV} == "9999" ]] ; then
417 - git-r3_src_unpack
418 + EGIT_COMMIT="${WINE_COMMIT}" git-r3_src_unpack
419 if use staging; then
420 - local WINE_COMMIT=${EGIT_VERSION}
421 + local CURRENT_WINE_COMMIT=${EGIT_VERSION}
422
423 - git-r3_fetch "${STAGING_EGIT_REPO_URI}"
424 + git-r3_fetch "${STAGING_EGIT_REPO_URI}" "${STAGING_COMMIT}"
425 git-r3_checkout "${STAGING_EGIT_REPO_URI}" "${STAGING_DIR}"
426
427 - local STAGING_COMMIT=$("${STAGING_DIR}/patches/patchinstall.sh" --upstream-commit) || die
428 + local COMPAT_WINE_COMMIT=$("${STAGING_DIR}/patches/patchinstall.sh" --upstream-commit) || die
429
430 - if [[ "${WINE_COMMIT}" != "${STAGING_COMMIT}" ]]; then
431 + if [[ "${CURRENT_WINE_COMMIT}" != "${COMPAT_WINE_COMMIT}" ]]; then
432 einfo "The current Staging patchset is not guaranteed to apply on this WINE commit."
433 einfo "If src_prepare fails, try emerging with the env var EGIT_COMMIT."
434 - einfo "Example: EGIT_COMMIT=${STAGING_COMMIT} emerge -1 wine"
435 + einfo "Example: WINE_COMMIT=${COMPAT_WINE_COMMIT} emerge -1 wine"
436 fi
437 fi
438 if use d3d9; then
439 - git-r3_fetch "${D3D9_EGIT_REPO_URI}"
440 + git-r3_fetch "${D3D9_EGIT_REPO_URI}" "${D3D9_COMMIT}"
441 git-r3_checkout "${D3D9_EGIT_REPO_URI}" "${D3D9_DIR}"
442 fi
443 fi
444
445 diff --git a/app-emulation/wine/wine-1.9.12-r2.ebuild b/app-emulation/wine/wine-1.9.12-r2.ebuild
446 index 46a6f20..6e2868f 100644
447 --- a/app-emulation/wine/wine-1.9.12-r2.ebuild
448 +++ b/app-emulation/wine/wine-1.9.12-r2.ebuild
449 @@ -254,6 +254,27 @@ wine_build_environment_check() {
450 fi
451 }
452
453 +wine_env_vcs_vars() {
454 + local pn_live_var="${PN//[-+]/_}_LIVE_COMMIT"
455 + local pn_live_val="${pn_live_var}"
456 + eval pn_live_val='$'${pn_live_val}
457 + if [[ ! -z ${pn_live_val} ]]; then
458 + if use staging || use d3d9; then
459 + eerror "Because of the multi-repo nature of ${PN}, ${pn_live_var}"
460 + eerror "cannot be used to set the commit. Instead, you may use the"
461 + eerror "environmental variables WINE_COMMIT, STAGING_COMMIT, and D3D9_COMMIT."
462 + eerror
463 + return 1
464 + fi
465 + fi
466 + if [[ ! -z ${EGIT_COMMIT} ]]; then
467 + eerror "Commits must now be specified using the environmental variables"
468 + eerror "WINE_COMMIT, STAGING_COMMIT, and D3D9_COMMIT"
469 + eerror
470 + return 1
471 + fi
472 +}
473 +
474 pkg_pretend() {
475 wine_compiler_check || die
476 wine_build_environment_check || die
477 @@ -271,6 +292,7 @@ pkg_pretend() {
478
479 pkg_setup() {
480 wine_build_environment_check || die
481 + wine_env_vcs_vars || die
482 if ! use staging; then
483 GV=${VANILLA_GV}
484 MV=${VANILLA_MV}
485 @@ -282,23 +304,23 @@ pkg_setup() {
486
487 src_unpack() {
488 if [[ ${PV} == "9999" ]] ; then
489 - git-r3_src_unpack
490 + EGIT_COMMIT="${WINE_COMMIT}" git-r3_src_unpack
491 if use staging; then
492 - local WINE_COMMIT=${EGIT_VERSION}
493 + local CURRENT_WINE_COMMIT=${EGIT_VERSION}
494
495 - git-r3_fetch "${STAGING_EGIT_REPO_URI}"
496 + git-r3_fetch "${STAGING_EGIT_REPO_URI}" "${STAGING_COMMIT}"
497 git-r3_checkout "${STAGING_EGIT_REPO_URI}" "${STAGING_DIR}"
498
499 - local STAGING_COMMIT=$("${STAGING_DIR}/patches/patchinstall.sh" --upstream-commit) || die
500 + local COMPAT_WINE_COMMIT=$("${STAGING_DIR}/patches/patchinstall.sh" --upstream-commit) || die
501
502 - if [[ "${WINE_COMMIT}" != "${STAGING_COMMIT}" ]]; then
503 + if [[ "${CURRENT_WINE_COMMIT}" != "${COMPAT_WINE_COMMIT}" ]]; then
504 einfo "The current Staging patchset is not guaranteed to apply on this WINE commit."
505 einfo "If src_prepare fails, try emerging with the env var EGIT_COMMIT."
506 - einfo "Example: EGIT_COMMIT=${STAGING_COMMIT} emerge -1 wine"
507 + einfo "Example: WINE_COMMIT=${COMPAT_WINE_COMMIT} emerge -1 wine"
508 fi
509 fi
510 if use d3d9; then
511 - git-r3_fetch "${D3D9_EGIT_REPO_URI}"
512 + git-r3_fetch "${D3D9_EGIT_REPO_URI}" "${D3D9_COMMIT}"
513 git-r3_checkout "${D3D9_EGIT_REPO_URI}" "${D3D9_DIR}"
514 fi
515 fi
516
517 diff --git a/app-emulation/wine/wine-1.9.13-r2.ebuild b/app-emulation/wine/wine-1.9.13-r2.ebuild
518 index 8bedf34..8c4e720 100644
519 --- a/app-emulation/wine/wine-1.9.13-r2.ebuild
520 +++ b/app-emulation/wine/wine-1.9.13-r2.ebuild
521 @@ -254,6 +254,27 @@ wine_build_environment_check() {
522 fi
523 }
524
525 +wine_env_vcs_vars() {
526 + local pn_live_var="${PN//[-+]/_}_LIVE_COMMIT"
527 + local pn_live_val="${pn_live_var}"
528 + eval pn_live_val='$'${pn_live_val}
529 + if [[ ! -z ${pn_live_val} ]]; then
530 + if use staging || use d3d9; then
531 + eerror "Because of the multi-repo nature of ${PN}, ${pn_live_var}"
532 + eerror "cannot be used to set the commit. Instead, you may use the"
533 + eerror "environmental variables WINE_COMMIT, STAGING_COMMIT, and D3D9_COMMIT."
534 + eerror
535 + return 1
536 + fi
537 + fi
538 + if [[ ! -z ${EGIT_COMMIT} ]]; then
539 + eerror "Commits must now be specified using the environmental variables"
540 + eerror "WINE_COMMIT, STAGING_COMMIT, and D3D9_COMMIT"
541 + eerror
542 + return 1
543 + fi
544 +}
545 +
546 pkg_pretend() {
547 wine_compiler_check || die
548 wine_build_environment_check || die
549 @@ -271,6 +292,7 @@ pkg_pretend() {
550
551 pkg_setup() {
552 wine_build_environment_check || die
553 + wine_env_vcs_vars || die
554 if ! use staging; then
555 GV=${VANILLA_GV}
556 MV=${VANILLA_MV}
557 @@ -282,23 +304,23 @@ pkg_setup() {
558
559 src_unpack() {
560 if [[ ${PV} == "9999" ]] ; then
561 - git-r3_src_unpack
562 + EGIT_COMMIT="${WINE_COMMIT}" git-r3_src_unpack
563 if use staging; then
564 - local WINE_COMMIT=${EGIT_VERSION}
565 + local CURRENT_WINE_COMMIT=${EGIT_VERSION}
566
567 - git-r3_fetch "${STAGING_EGIT_REPO_URI}"
568 + git-r3_fetch "${STAGING_EGIT_REPO_URI}" "${STAGING_COMMIT}"
569 git-r3_checkout "${STAGING_EGIT_REPO_URI}" "${STAGING_DIR}"
570
571 - local STAGING_COMMIT=$("${STAGING_DIR}/patches/patchinstall.sh" --upstream-commit) || die
572 + local COMPAT_WINE_COMMIT=$("${STAGING_DIR}/patches/patchinstall.sh" --upstream-commit) || die
573
574 - if [[ "${WINE_COMMIT}" != "${STAGING_COMMIT}" ]]; then
575 + if [[ "${CURRENT_WINE_COMMIT}" != "${COMPAT_WINE_COMMIT}" ]]; then
576 einfo "The current Staging patchset is not guaranteed to apply on this WINE commit."
577 einfo "If src_prepare fails, try emerging with the env var EGIT_COMMIT."
578 - einfo "Example: EGIT_COMMIT=${STAGING_COMMIT} emerge -1 wine"
579 + einfo "Example: WINE_COMMIT=${COMPAT_WINE_COMMIT} emerge -1 wine"
580 fi
581 fi
582 if use d3d9; then
583 - git-r3_fetch "${D3D9_EGIT_REPO_URI}"
584 + git-r3_fetch "${D3D9_EGIT_REPO_URI}" "${D3D9_COMMIT}"
585 git-r3_checkout "${D3D9_EGIT_REPO_URI}" "${D3D9_DIR}"
586 fi
587 fi
588
589 diff --git a/app-emulation/wine/wine-1.9.14-r2.ebuild b/app-emulation/wine/wine-1.9.14-r2.ebuild
590 index 8bedf34..8c4e720 100644
591 --- a/app-emulation/wine/wine-1.9.14-r2.ebuild
592 +++ b/app-emulation/wine/wine-1.9.14-r2.ebuild
593 @@ -254,6 +254,27 @@ wine_build_environment_check() {
594 fi
595 }
596
597 +wine_env_vcs_vars() {
598 + local pn_live_var="${PN//[-+]/_}_LIVE_COMMIT"
599 + local pn_live_val="${pn_live_var}"
600 + eval pn_live_val='$'${pn_live_val}
601 + if [[ ! -z ${pn_live_val} ]]; then
602 + if use staging || use d3d9; then
603 + eerror "Because of the multi-repo nature of ${PN}, ${pn_live_var}"
604 + eerror "cannot be used to set the commit. Instead, you may use the"
605 + eerror "environmental variables WINE_COMMIT, STAGING_COMMIT, and D3D9_COMMIT."
606 + eerror
607 + return 1
608 + fi
609 + fi
610 + if [[ ! -z ${EGIT_COMMIT} ]]; then
611 + eerror "Commits must now be specified using the environmental variables"
612 + eerror "WINE_COMMIT, STAGING_COMMIT, and D3D9_COMMIT"
613 + eerror
614 + return 1
615 + fi
616 +}
617 +
618 pkg_pretend() {
619 wine_compiler_check || die
620 wine_build_environment_check || die
621 @@ -271,6 +292,7 @@ pkg_pretend() {
622
623 pkg_setup() {
624 wine_build_environment_check || die
625 + wine_env_vcs_vars || die
626 if ! use staging; then
627 GV=${VANILLA_GV}
628 MV=${VANILLA_MV}
629 @@ -282,23 +304,23 @@ pkg_setup() {
630
631 src_unpack() {
632 if [[ ${PV} == "9999" ]] ; then
633 - git-r3_src_unpack
634 + EGIT_COMMIT="${WINE_COMMIT}" git-r3_src_unpack
635 if use staging; then
636 - local WINE_COMMIT=${EGIT_VERSION}
637 + local CURRENT_WINE_COMMIT=${EGIT_VERSION}
638
639 - git-r3_fetch "${STAGING_EGIT_REPO_URI}"
640 + git-r3_fetch "${STAGING_EGIT_REPO_URI}" "${STAGING_COMMIT}"
641 git-r3_checkout "${STAGING_EGIT_REPO_URI}" "${STAGING_DIR}"
642
643 - local STAGING_COMMIT=$("${STAGING_DIR}/patches/patchinstall.sh" --upstream-commit) || die
644 + local COMPAT_WINE_COMMIT=$("${STAGING_DIR}/patches/patchinstall.sh" --upstream-commit) || die
645
646 - if [[ "${WINE_COMMIT}" != "${STAGING_COMMIT}" ]]; then
647 + if [[ "${CURRENT_WINE_COMMIT}" != "${COMPAT_WINE_COMMIT}" ]]; then
648 einfo "The current Staging patchset is not guaranteed to apply on this WINE commit."
649 einfo "If src_prepare fails, try emerging with the env var EGIT_COMMIT."
650 - einfo "Example: EGIT_COMMIT=${STAGING_COMMIT} emerge -1 wine"
651 + einfo "Example: WINE_COMMIT=${COMPAT_WINE_COMMIT} emerge -1 wine"
652 fi
653 fi
654 if use d3d9; then
655 - git-r3_fetch "${D3D9_EGIT_REPO_URI}"
656 + git-r3_fetch "${D3D9_EGIT_REPO_URI}" "${D3D9_COMMIT}"
657 git-r3_checkout "${D3D9_EGIT_REPO_URI}" "${D3D9_DIR}"
658 fi
659 fi
660
661 diff --git a/app-emulation/wine/wine-1.9.15-r1.ebuild b/app-emulation/wine/wine-1.9.15-r1.ebuild
662 index 8bedf34..8c4e720 100644
663 --- a/app-emulation/wine/wine-1.9.15-r1.ebuild
664 +++ b/app-emulation/wine/wine-1.9.15-r1.ebuild
665 @@ -254,6 +254,27 @@ wine_build_environment_check() {
666 fi
667 }
668
669 +wine_env_vcs_vars() {
670 + local pn_live_var="${PN//[-+]/_}_LIVE_COMMIT"
671 + local pn_live_val="${pn_live_var}"
672 + eval pn_live_val='$'${pn_live_val}
673 + if [[ ! -z ${pn_live_val} ]]; then
674 + if use staging || use d3d9; then
675 + eerror "Because of the multi-repo nature of ${PN}, ${pn_live_var}"
676 + eerror "cannot be used to set the commit. Instead, you may use the"
677 + eerror "environmental variables WINE_COMMIT, STAGING_COMMIT, and D3D9_COMMIT."
678 + eerror
679 + return 1
680 + fi
681 + fi
682 + if [[ ! -z ${EGIT_COMMIT} ]]; then
683 + eerror "Commits must now be specified using the environmental variables"
684 + eerror "WINE_COMMIT, STAGING_COMMIT, and D3D9_COMMIT"
685 + eerror
686 + return 1
687 + fi
688 +}
689 +
690 pkg_pretend() {
691 wine_compiler_check || die
692 wine_build_environment_check || die
693 @@ -271,6 +292,7 @@ pkg_pretend() {
694
695 pkg_setup() {
696 wine_build_environment_check || die
697 + wine_env_vcs_vars || die
698 if ! use staging; then
699 GV=${VANILLA_GV}
700 MV=${VANILLA_MV}
701 @@ -282,23 +304,23 @@ pkg_setup() {
702
703 src_unpack() {
704 if [[ ${PV} == "9999" ]] ; then
705 - git-r3_src_unpack
706 + EGIT_COMMIT="${WINE_COMMIT}" git-r3_src_unpack
707 if use staging; then
708 - local WINE_COMMIT=${EGIT_VERSION}
709 + local CURRENT_WINE_COMMIT=${EGIT_VERSION}
710
711 - git-r3_fetch "${STAGING_EGIT_REPO_URI}"
712 + git-r3_fetch "${STAGING_EGIT_REPO_URI}" "${STAGING_COMMIT}"
713 git-r3_checkout "${STAGING_EGIT_REPO_URI}" "${STAGING_DIR}"
714
715 - local STAGING_COMMIT=$("${STAGING_DIR}/patches/patchinstall.sh" --upstream-commit) || die
716 + local COMPAT_WINE_COMMIT=$("${STAGING_DIR}/patches/patchinstall.sh" --upstream-commit) || die
717
718 - if [[ "${WINE_COMMIT}" != "${STAGING_COMMIT}" ]]; then
719 + if [[ "${CURRENT_WINE_COMMIT}" != "${COMPAT_WINE_COMMIT}" ]]; then
720 einfo "The current Staging patchset is not guaranteed to apply on this WINE commit."
721 einfo "If src_prepare fails, try emerging with the env var EGIT_COMMIT."
722 - einfo "Example: EGIT_COMMIT=${STAGING_COMMIT} emerge -1 wine"
723 + einfo "Example: WINE_COMMIT=${COMPAT_WINE_COMMIT} emerge -1 wine"
724 fi
725 fi
726 if use d3d9; then
727 - git-r3_fetch "${D3D9_EGIT_REPO_URI}"
728 + git-r3_fetch "${D3D9_EGIT_REPO_URI}" "${D3D9_COMMIT}"
729 git-r3_checkout "${D3D9_EGIT_REPO_URI}" "${D3D9_DIR}"
730 fi
731 fi
732
733 diff --git a/app-emulation/wine/wine-1.9.16.ebuild b/app-emulation/wine/wine-1.9.16.ebuild
734 index 8bedf34..8c4e720 100644
735 --- a/app-emulation/wine/wine-1.9.16.ebuild
736 +++ b/app-emulation/wine/wine-1.9.16.ebuild
737 @@ -254,6 +254,27 @@ wine_build_environment_check() {
738 fi
739 }
740
741 +wine_env_vcs_vars() {
742 + local pn_live_var="${PN//[-+]/_}_LIVE_COMMIT"
743 + local pn_live_val="${pn_live_var}"
744 + eval pn_live_val='$'${pn_live_val}
745 + if [[ ! -z ${pn_live_val} ]]; then
746 + if use staging || use d3d9; then
747 + eerror "Because of the multi-repo nature of ${PN}, ${pn_live_var}"
748 + eerror "cannot be used to set the commit. Instead, you may use the"
749 + eerror "environmental variables WINE_COMMIT, STAGING_COMMIT, and D3D9_COMMIT."
750 + eerror
751 + return 1
752 + fi
753 + fi
754 + if [[ ! -z ${EGIT_COMMIT} ]]; then
755 + eerror "Commits must now be specified using the environmental variables"
756 + eerror "WINE_COMMIT, STAGING_COMMIT, and D3D9_COMMIT"
757 + eerror
758 + return 1
759 + fi
760 +}
761 +
762 pkg_pretend() {
763 wine_compiler_check || die
764 wine_build_environment_check || die
765 @@ -271,6 +292,7 @@ pkg_pretend() {
766
767 pkg_setup() {
768 wine_build_environment_check || die
769 + wine_env_vcs_vars || die
770 if ! use staging; then
771 GV=${VANILLA_GV}
772 MV=${VANILLA_MV}
773 @@ -282,23 +304,23 @@ pkg_setup() {
774
775 src_unpack() {
776 if [[ ${PV} == "9999" ]] ; then
777 - git-r3_src_unpack
778 + EGIT_COMMIT="${WINE_COMMIT}" git-r3_src_unpack
779 if use staging; then
780 - local WINE_COMMIT=${EGIT_VERSION}
781 + local CURRENT_WINE_COMMIT=${EGIT_VERSION}
782
783 - git-r3_fetch "${STAGING_EGIT_REPO_URI}"
784 + git-r3_fetch "${STAGING_EGIT_REPO_URI}" "${STAGING_COMMIT}"
785 git-r3_checkout "${STAGING_EGIT_REPO_URI}" "${STAGING_DIR}"
786
787 - local STAGING_COMMIT=$("${STAGING_DIR}/patches/patchinstall.sh" --upstream-commit) || die
788 + local COMPAT_WINE_COMMIT=$("${STAGING_DIR}/patches/patchinstall.sh" --upstream-commit) || die
789
790 - if [[ "${WINE_COMMIT}" != "${STAGING_COMMIT}" ]]; then
791 + if [[ "${CURRENT_WINE_COMMIT}" != "${COMPAT_WINE_COMMIT}" ]]; then
792 einfo "The current Staging patchset is not guaranteed to apply on this WINE commit."
793 einfo "If src_prepare fails, try emerging with the env var EGIT_COMMIT."
794 - einfo "Example: EGIT_COMMIT=${STAGING_COMMIT} emerge -1 wine"
795 + einfo "Example: WINE_COMMIT=${COMPAT_WINE_COMMIT} emerge -1 wine"
796 fi
797 fi
798 if use d3d9; then
799 - git-r3_fetch "${D3D9_EGIT_REPO_URI}"
800 + git-r3_fetch "${D3D9_EGIT_REPO_URI}" "${D3D9_COMMIT}"
801 git-r3_checkout "${D3D9_EGIT_REPO_URI}" "${D3D9_DIR}"
802 fi
803 fi
804
805 diff --git a/app-emulation/wine/wine-1.9.17.ebuild b/app-emulation/wine/wine-1.9.17.ebuild
806 index b5dad1f..4f8f3e9 100644
807 --- a/app-emulation/wine/wine-1.9.17.ebuild
808 +++ b/app-emulation/wine/wine-1.9.17.ebuild
809 @@ -254,6 +254,27 @@ wine_build_environment_check() {
810 fi
811 }
812
813 +wine_env_vcs_vars() {
814 + local pn_live_var="${PN//[-+]/_}_LIVE_COMMIT"
815 + local pn_live_val="${pn_live_var}"
816 + eval pn_live_val='$'${pn_live_val}
817 + if [[ ! -z ${pn_live_val} ]]; then
818 + if use staging || use d3d9; then
819 + eerror "Because of the multi-repo nature of ${PN}, ${pn_live_var}"
820 + eerror "cannot be used to set the commit. Instead, you may use the"
821 + eerror "environmental variables WINE_COMMIT, STAGING_COMMIT, and D3D9_COMMIT."
822 + eerror
823 + return 1
824 + fi
825 + fi
826 + if [[ ! -z ${EGIT_COMMIT} ]]; then
827 + eerror "Commits must now be specified using the environmental variables"
828 + eerror "WINE_COMMIT, STAGING_COMMIT, and D3D9_COMMIT"
829 + eerror
830 + return 1
831 + fi
832 +}
833 +
834 pkg_pretend() {
835 wine_compiler_check || die
836 wine_build_environment_check || die
837 @@ -271,6 +292,7 @@ pkg_pretend() {
838
839 pkg_setup() {
840 wine_build_environment_check || die
841 + wine_env_vcs_vars || die
842 if ! use staging; then
843 GV=${VANILLA_GV}
844 MV=${VANILLA_MV}
845 @@ -282,23 +304,23 @@ pkg_setup() {
846
847 src_unpack() {
848 if [[ ${PV} == "9999" ]] ; then
849 - git-r3_src_unpack
850 + EGIT_COMMIT="${WINE_COMMIT}" git-r3_src_unpack
851 if use staging; then
852 - local WINE_COMMIT=${EGIT_VERSION}
853 + local CURRENT_WINE_COMMIT=${EGIT_VERSION}
854
855 - git-r3_fetch "${STAGING_EGIT_REPO_URI}"
856 + git-r3_fetch "${STAGING_EGIT_REPO_URI}" "${STAGING_COMMIT}"
857 git-r3_checkout "${STAGING_EGIT_REPO_URI}" "${STAGING_DIR}"
858
859 - local STAGING_COMMIT=$("${STAGING_DIR}/patches/patchinstall.sh" --upstream-commit) || die
860 + local COMPAT_WINE_COMMIT=$("${STAGING_DIR}/patches/patchinstall.sh" --upstream-commit) || die
861
862 - if [[ "${WINE_COMMIT}" != "${STAGING_COMMIT}" ]]; then
863 + if [[ "${CURRENT_WINE_COMMIT}" != "${COMPAT_WINE_COMMIT}" ]]; then
864 einfo "The current Staging patchset is not guaranteed to apply on this WINE commit."
865 einfo "If src_prepare fails, try emerging with the env var EGIT_COMMIT."
866 - einfo "Example: EGIT_COMMIT=${STAGING_COMMIT} emerge -1 wine"
867 + einfo "Example: WINE_COMMIT=${COMPAT_WINE_COMMIT} emerge -1 wine"
868 fi
869 fi
870 if use d3d9; then
871 - git-r3_fetch "${D3D9_EGIT_REPO_URI}"
872 + git-r3_fetch "${D3D9_EGIT_REPO_URI}" "${D3D9_COMMIT}"
873 git-r3_checkout "${D3D9_EGIT_REPO_URI}" "${D3D9_DIR}"
874 fi
875 fi
876
877 diff --git a/app-emulation/wine/wine-1.9.4-r3.ebuild b/app-emulation/wine/wine-1.9.4-r3.ebuild
878 index 6a4d343..9f75de1 100644
879 --- a/app-emulation/wine/wine-1.9.4-r3.ebuild
880 +++ b/app-emulation/wine/wine-1.9.4-r3.ebuild
881 @@ -245,6 +245,27 @@ wine_build_environment_check() {
882 fi
883 }
884
885 +wine_env_vcs_vars() {
886 + local pn_live_var="${PN//[-+]/_}_LIVE_COMMIT"
887 + local pn_live_val="${pn_live_var}"
888 + eval pn_live_val='$'${pn_live_val}
889 + if [[ ! -z ${pn_live_val} ]]; then
890 + if use staging || use d3d9; then
891 + eerror "Because of the multi-repo nature of ${PN}, ${pn_live_var}"
892 + eerror "cannot be used to set the commit. Instead, you may use the"
893 + eerror "environmental variables WINE_COMMIT, STAGING_COMMIT, and D3D9_COMMIT."
894 + eerror
895 + return 1
896 + fi
897 + fi
898 + if [[ ! -z ${EGIT_COMMIT} ]]; then
899 + eerror "Commits must now be specified using the environmental variables"
900 + eerror "WINE_COMMIT, STAGING_COMMIT, and D3D9_COMMIT"
901 + eerror
902 + return 1
903 + fi
904 +}
905 +
906 pkg_pretend() {
907 wine_compiler_check || die
908 wine_build_environment_check || die
909 @@ -262,6 +283,7 @@ pkg_pretend() {
910
911 pkg_setup() {
912 wine_build_environment_check || die
913 + wine_env_vcs_vars || die
914 if ! use staging; then
915 GV=${VANILLA_GV}
916 MV=${VANILLA_MV}
917 @@ -273,19 +295,19 @@ pkg_setup() {
918
919 src_unpack() {
920 if [[ ${PV} == "9999" ]] ; then
921 - git-r3_src_unpack
922 + EGIT_COMMIT="${WINE_COMMIT}" git-r3_src_unpack
923 if use staging; then
924 - local WINE_COMMIT=${EGIT_VERSION}
925 + local CURRENT_WINE_COMMIT=${EGIT_VERSION}
926
927 - git-r3_fetch "${STAGING_EGIT_REPO_URI}"
928 + git-r3_fetch "${STAGING_EGIT_REPO_URI}" "${STAGING_COMMIT}"
929 git-r3_checkout "${STAGING_EGIT_REPO_URI}" "${STAGING_DIR}"
930
931 - local STAGING_COMMIT=$("${STAGING_DIR}/patches/patchinstall.sh" --upstream-commit) || die
932 + local COMPAT_WINE_COMMIT=$("${STAGING_DIR}/patches/patchinstall.sh" --upstream-commit) || die
933
934 - if [[ "${WINE_COMMIT}" != "${STAGING_COMMIT}" ]]; then
935 + if [[ "${CURRENT_WINE_COMMIT}" != "${COMPAT_WINE_COMMIT}" ]]; then
936 einfo "The current Staging patchset is not guaranteed to apply on this WINE commit."
937 einfo "If src_prepare fails, try emerging with the env var EGIT_COMMIT."
938 - einfo "Example: EGIT_COMMIT=${STAGING_COMMIT} emerge -1 wine"
939 + einfo "Example: WINE_COMMIT=${COMPAT_WINE_COMMIT} emerge -1 wine"
940 fi
941 fi
942 fi
943
944 diff --git a/app-emulation/wine/wine-1.9.5-r3.ebuild b/app-emulation/wine/wine-1.9.5-r3.ebuild
945 index e186513..c280dc5 100644
946 --- a/app-emulation/wine/wine-1.9.5-r3.ebuild
947 +++ b/app-emulation/wine/wine-1.9.5-r3.ebuild
948 @@ -244,6 +244,27 @@ wine_build_environment_check() {
949 fi
950 }
951
952 +wine_env_vcs_vars() {
953 + local pn_live_var="${PN//[-+]/_}_LIVE_COMMIT"
954 + local pn_live_val="${pn_live_var}"
955 + eval pn_live_val='$'${pn_live_val}
956 + if [[ ! -z ${pn_live_val} ]]; then
957 + if use staging || use d3d9; then
958 + eerror "Because of the multi-repo nature of ${PN}, ${pn_live_var}"
959 + eerror "cannot be used to set the commit. Instead, you may use the"
960 + eerror "environmental variables WINE_COMMIT, STAGING_COMMIT, and D3D9_COMMIT."
961 + eerror
962 + return 1
963 + fi
964 + fi
965 + if [[ ! -z ${EGIT_COMMIT} ]]; then
966 + eerror "Commits must now be specified using the environmental variables"
967 + eerror "WINE_COMMIT, STAGING_COMMIT, and D3D9_COMMIT"
968 + eerror
969 + return 1
970 + fi
971 +}
972 +
973 pkg_pretend() {
974 wine_compiler_check || die
975 wine_build_environment_check || die
976 @@ -261,6 +282,7 @@ pkg_pretend() {
977
978 pkg_setup() {
979 wine_build_environment_check || die
980 + wine_env_vcs_vars || die
981 if ! use staging; then
982 GV=${VANILLA_GV}
983 MV=${VANILLA_MV}
984 @@ -272,19 +294,19 @@ pkg_setup() {
985
986 src_unpack() {
987 if [[ ${PV} == "9999" ]] ; then
988 - git-r3_src_unpack
989 + EGIT_COMMIT="${WINE_COMMIT}" git-r3_src_unpack
990 if use staging; then
991 - local WINE_COMMIT=${EGIT_VERSION}
992 + local CURRENT_WINE_COMMIT=${EGIT_VERSION}
993
994 - git-r3_fetch "${STAGING_EGIT_REPO_URI}"
995 + git-r3_fetch "${STAGING_EGIT_REPO_URI}" "${STAGING_COMMIT}"
996 git-r3_checkout "${STAGING_EGIT_REPO_URI}" "${STAGING_DIR}"
997
998 - local STAGING_COMMIT=$("${STAGING_DIR}/patches/patchinstall.sh" --upstream-commit) || die
999 + local COMPAT_WINE_COMMIT=$("${STAGING_DIR}/patches/patchinstall.sh" --upstream-commit) || die
1000
1001 - if [[ "${WINE_COMMIT}" != "${STAGING_COMMIT}" ]]; then
1002 + if [[ "${CURRENT_WINE_COMMIT}" != "${COMPAT_WINE_COMMIT}" ]]; then
1003 einfo "The current Staging patchset is not guaranteed to apply on this WINE commit."
1004 einfo "If src_prepare fails, try emerging with the env var EGIT_COMMIT."
1005 - einfo "Example: EGIT_COMMIT=${STAGING_COMMIT} emerge -1 wine"
1006 + einfo "Example: WINE_COMMIT=${COMPAT_WINE_COMMIT} emerge -1 wine"
1007 fi
1008 fi
1009 fi
1010
1011 diff --git a/app-emulation/wine/wine-1.9.6-r3.ebuild b/app-emulation/wine/wine-1.9.6-r3.ebuild
1012 index d91273b..d77474b 100644
1013 --- a/app-emulation/wine/wine-1.9.6-r3.ebuild
1014 +++ b/app-emulation/wine/wine-1.9.6-r3.ebuild
1015 @@ -244,6 +244,27 @@ wine_build_environment_check() {
1016 fi
1017 }
1018
1019 +wine_env_vcs_vars() {
1020 + local pn_live_var="${PN//[-+]/_}_LIVE_COMMIT"
1021 + local pn_live_val="${pn_live_var}"
1022 + eval pn_live_val='$'${pn_live_val}
1023 + if [[ ! -z ${pn_live_val} ]]; then
1024 + if use staging || use d3d9; then
1025 + eerror "Because of the multi-repo nature of ${PN}, ${pn_live_var}"
1026 + eerror "cannot be used to set the commit. Instead, you may use the"
1027 + eerror "environmental variables WINE_COMMIT, STAGING_COMMIT, and D3D9_COMMIT."
1028 + eerror
1029 + return 1
1030 + fi
1031 + fi
1032 + if [[ ! -z ${EGIT_COMMIT} ]]; then
1033 + eerror "Commits must now be specified using the environmental variables"
1034 + eerror "WINE_COMMIT, STAGING_COMMIT, and D3D9_COMMIT"
1035 + eerror
1036 + return 1
1037 + fi
1038 +}
1039 +
1040 pkg_pretend() {
1041 wine_compiler_check || die
1042 wine_build_environment_check || die
1043 @@ -261,6 +282,7 @@ pkg_pretend() {
1044
1045 pkg_setup() {
1046 wine_build_environment_check || die
1047 + wine_env_vcs_vars || die
1048 if ! use staging; then
1049 GV=${VANILLA_GV}
1050 MV=${VANILLA_MV}
1051 @@ -272,19 +294,19 @@ pkg_setup() {
1052
1053 src_unpack() {
1054 if [[ ${PV} == "9999" ]] ; then
1055 - git-r3_src_unpack
1056 + EGIT_COMMIT="${WINE_COMMIT}" git-r3_src_unpack
1057 if use staging; then
1058 - local WINE_COMMIT=${EGIT_VERSION}
1059 + local CURRENT_WINE_COMMIT=${EGIT_VERSION}
1060
1061 - git-r3_fetch "${STAGING_EGIT_REPO_URI}"
1062 + git-r3_fetch "${STAGING_EGIT_REPO_URI}" "${STAGING_COMMIT}"
1063 git-r3_checkout "${STAGING_EGIT_REPO_URI}" "${STAGING_DIR}"
1064
1065 - local STAGING_COMMIT=$("${STAGING_DIR}/patches/patchinstall.sh" --upstream-commit) || die
1066 + local COMPAT_WINE_COMMIT=$("${STAGING_DIR}/patches/patchinstall.sh" --upstream-commit) || die
1067
1068 - if [[ "${WINE_COMMIT}" != "${STAGING_COMMIT}" ]]; then
1069 + if [[ "${CURRENT_WINE_COMMIT}" != "${COMPAT_WINE_COMMIT}" ]]; then
1070 einfo "The current Staging patchset is not guaranteed to apply on this WINE commit."
1071 einfo "If src_prepare fails, try emerging with the env var EGIT_COMMIT."
1072 - einfo "Example: EGIT_COMMIT=${STAGING_COMMIT} emerge -1 wine"
1073 + einfo "Example: WINE_COMMIT=${COMPAT_WINE_COMMIT} emerge -1 wine"
1074 fi
1075 fi
1076 fi
1077
1078 diff --git a/app-emulation/wine/wine-1.9.7-r3.ebuild b/app-emulation/wine/wine-1.9.7-r3.ebuild
1079 index d91273b..d77474b 100644
1080 --- a/app-emulation/wine/wine-1.9.7-r3.ebuild
1081 +++ b/app-emulation/wine/wine-1.9.7-r3.ebuild
1082 @@ -244,6 +244,27 @@ wine_build_environment_check() {
1083 fi
1084 }
1085
1086 +wine_env_vcs_vars() {
1087 + local pn_live_var="${PN//[-+]/_}_LIVE_COMMIT"
1088 + local pn_live_val="${pn_live_var}"
1089 + eval pn_live_val='$'${pn_live_val}
1090 + if [[ ! -z ${pn_live_val} ]]; then
1091 + if use staging || use d3d9; then
1092 + eerror "Because of the multi-repo nature of ${PN}, ${pn_live_var}"
1093 + eerror "cannot be used to set the commit. Instead, you may use the"
1094 + eerror "environmental variables WINE_COMMIT, STAGING_COMMIT, and D3D9_COMMIT."
1095 + eerror
1096 + return 1
1097 + fi
1098 + fi
1099 + if [[ ! -z ${EGIT_COMMIT} ]]; then
1100 + eerror "Commits must now be specified using the environmental variables"
1101 + eerror "WINE_COMMIT, STAGING_COMMIT, and D3D9_COMMIT"
1102 + eerror
1103 + return 1
1104 + fi
1105 +}
1106 +
1107 pkg_pretend() {
1108 wine_compiler_check || die
1109 wine_build_environment_check || die
1110 @@ -261,6 +282,7 @@ pkg_pretend() {
1111
1112 pkg_setup() {
1113 wine_build_environment_check || die
1114 + wine_env_vcs_vars || die
1115 if ! use staging; then
1116 GV=${VANILLA_GV}
1117 MV=${VANILLA_MV}
1118 @@ -272,19 +294,19 @@ pkg_setup() {
1119
1120 src_unpack() {
1121 if [[ ${PV} == "9999" ]] ; then
1122 - git-r3_src_unpack
1123 + EGIT_COMMIT="${WINE_COMMIT}" git-r3_src_unpack
1124 if use staging; then
1125 - local WINE_COMMIT=${EGIT_VERSION}
1126 + local CURRENT_WINE_COMMIT=${EGIT_VERSION}
1127
1128 - git-r3_fetch "${STAGING_EGIT_REPO_URI}"
1129 + git-r3_fetch "${STAGING_EGIT_REPO_URI}" "${STAGING_COMMIT}"
1130 git-r3_checkout "${STAGING_EGIT_REPO_URI}" "${STAGING_DIR}"
1131
1132 - local STAGING_COMMIT=$("${STAGING_DIR}/patches/patchinstall.sh" --upstream-commit) || die
1133 + local COMPAT_WINE_COMMIT=$("${STAGING_DIR}/patches/patchinstall.sh" --upstream-commit) || die
1134
1135 - if [[ "${WINE_COMMIT}" != "${STAGING_COMMIT}" ]]; then
1136 + if [[ "${CURRENT_WINE_COMMIT}" != "${COMPAT_WINE_COMMIT}" ]]; then
1137 einfo "The current Staging patchset is not guaranteed to apply on this WINE commit."
1138 einfo "If src_prepare fails, try emerging with the env var EGIT_COMMIT."
1139 - einfo "Example: EGIT_COMMIT=${STAGING_COMMIT} emerge -1 wine"
1140 + einfo "Example: WINE_COMMIT=${COMPAT_WINE_COMMIT} emerge -1 wine"
1141 fi
1142 fi
1143 fi
1144
1145 diff --git a/app-emulation/wine/wine-1.9.8-r2.ebuild b/app-emulation/wine/wine-1.9.8-r2.ebuild
1146 index cc1f86d..714463e 100644
1147 --- a/app-emulation/wine/wine-1.9.8-r2.ebuild
1148 +++ b/app-emulation/wine/wine-1.9.8-r2.ebuild
1149 @@ -244,6 +244,27 @@ wine_build_environment_check() {
1150 fi
1151 }
1152
1153 +wine_env_vcs_vars() {
1154 + local pn_live_var="${PN//[-+]/_}_LIVE_COMMIT"
1155 + local pn_live_val="${pn_live_var}"
1156 + eval pn_live_val='$'${pn_live_val}
1157 + if [[ ! -z ${pn_live_val} ]]; then
1158 + if use staging || use d3d9; then
1159 + eerror "Because of the multi-repo nature of ${PN}, ${pn_live_var}"
1160 + eerror "cannot be used to set the commit. Instead, you may use the"
1161 + eerror "environmental variables WINE_COMMIT, STAGING_COMMIT, and D3D9_COMMIT."
1162 + eerror
1163 + return 1
1164 + fi
1165 + fi
1166 + if [[ ! -z ${EGIT_COMMIT} ]]; then
1167 + eerror "Commits must now be specified using the environmental variables"
1168 + eerror "WINE_COMMIT, STAGING_COMMIT, and D3D9_COMMIT"
1169 + eerror
1170 + return 1
1171 + fi
1172 +}
1173 +
1174 pkg_pretend() {
1175 wine_compiler_check || die
1176 wine_build_environment_check || die
1177 @@ -261,6 +282,7 @@ pkg_pretend() {
1178
1179 pkg_setup() {
1180 wine_build_environment_check || die
1181 + wine_env_vcs_vars || die
1182 if ! use staging; then
1183 GV=${VANILLA_GV}
1184 MV=${VANILLA_MV}
1185 @@ -272,19 +294,19 @@ pkg_setup() {
1186
1187 src_unpack() {
1188 if [[ ${PV} == "9999" ]] ; then
1189 - git-r3_src_unpack
1190 + EGIT_COMMIT="${WINE_COMMIT}" git-r3_src_unpack
1191 if use staging; then
1192 - local WINE_COMMIT=${EGIT_VERSION}
1193 + local CURRENT_WINE_COMMIT=${EGIT_VERSION}
1194
1195 - git-r3_fetch "${STAGING_EGIT_REPO_URI}"
1196 + git-r3_fetch "${STAGING_EGIT_REPO_URI}" "${STAGING_COMMIT}"
1197 git-r3_checkout "${STAGING_EGIT_REPO_URI}" "${STAGING_DIR}"
1198
1199 - local STAGING_COMMIT=$("${STAGING_DIR}/patches/patchinstall.sh" --upstream-commit) || die
1200 + local COMPAT_WINE_COMMIT=$("${STAGING_DIR}/patches/patchinstall.sh" --upstream-commit) || die
1201
1202 - if [[ "${WINE_COMMIT}" != "${STAGING_COMMIT}" ]]; then
1203 + if [[ "${CURRENT_WINE_COMMIT}" != "${COMPAT_WINE_COMMIT}" ]]; then
1204 einfo "The current Staging patchset is not guaranteed to apply on this WINE commit."
1205 einfo "If src_prepare fails, try emerging with the env var EGIT_COMMIT."
1206 - einfo "Example: EGIT_COMMIT=${STAGING_COMMIT} emerge -1 wine"
1207 + einfo "Example: WINE_COMMIT=${COMPAT_WINE_COMMIT} emerge -1 wine"
1208 fi
1209 fi
1210 fi
1211
1212 diff --git a/app-emulation/wine/wine-1.9.9-r3.ebuild b/app-emulation/wine/wine-1.9.9-r3.ebuild
1213 index 24ef63d..180e41d 100644
1214 --- a/app-emulation/wine/wine-1.9.9-r3.ebuild
1215 +++ b/app-emulation/wine/wine-1.9.9-r3.ebuild
1216 @@ -254,6 +254,27 @@ wine_build_environment_check() {
1217 fi
1218 }
1219
1220 +wine_env_vcs_vars() {
1221 + local pn_live_var="${PN//[-+]/_}_LIVE_COMMIT"
1222 + local pn_live_val="${pn_live_var}"
1223 + eval pn_live_val='$'${pn_live_val}
1224 + if [[ ! -z ${pn_live_val} ]]; then
1225 + if use staging || use d3d9; then
1226 + eerror "Because of the multi-repo nature of ${PN}, ${pn_live_var}"
1227 + eerror "cannot be used to set the commit. Instead, you may use the"
1228 + eerror "environmental variables WINE_COMMIT, STAGING_COMMIT, and D3D9_COMMIT."
1229 + eerror
1230 + return 1
1231 + fi
1232 + fi
1233 + if [[ ! -z ${EGIT_COMMIT} ]]; then
1234 + eerror "Commits must now be specified using the environmental variables"
1235 + eerror "WINE_COMMIT, STAGING_COMMIT, and D3D9_COMMIT"
1236 + eerror
1237 + return 1
1238 + fi
1239 +}
1240 +
1241 pkg_pretend() {
1242 wine_compiler_check || die
1243 wine_build_environment_check || die
1244 @@ -271,6 +292,7 @@ pkg_pretend() {
1245
1246 pkg_setup() {
1247 wine_build_environment_check || die
1248 + wine_env_vcs_vars || die
1249 if ! use staging; then
1250 GV=${VANILLA_GV}
1251 MV=${VANILLA_MV}
1252 @@ -282,23 +304,23 @@ pkg_setup() {
1253
1254 src_unpack() {
1255 if [[ ${PV} == "9999" ]] ; then
1256 - git-r3_src_unpack
1257 + EGIT_COMMIT="${WINE_COMMIT}" git-r3_src_unpack
1258 if use staging; then
1259 - local WINE_COMMIT=${EGIT_VERSION}
1260 + local CURRENT_WINE_COMMIT=${EGIT_VERSION}
1261
1262 - git-r3_fetch "${STAGING_EGIT_REPO_URI}"
1263 + git-r3_fetch "${STAGING_EGIT_REPO_URI}" "${STAGING_COMMIT}"
1264 git-r3_checkout "${STAGING_EGIT_REPO_URI}" "${STAGING_DIR}"
1265
1266 - local STAGING_COMMIT=$("${STAGING_DIR}/patches/patchinstall.sh" --upstream-commit) || die
1267 + local COMPAT_WINE_COMMIT=$("${STAGING_DIR}/patches/patchinstall.sh" --upstream-commit) || die
1268
1269 - if [[ "${WINE_COMMIT}" != "${STAGING_COMMIT}" ]]; then
1270 + if [[ "${CURRENT_WINE_COMMIT}" != "${COMPAT_WINE_COMMIT}" ]]; then
1271 einfo "The current Staging patchset is not guaranteed to apply on this WINE commit."
1272 einfo "If src_prepare fails, try emerging with the env var EGIT_COMMIT."
1273 - einfo "Example: EGIT_COMMIT=${STAGING_COMMIT} emerge -1 wine"
1274 + einfo "Example: WINE_COMMIT=${COMPAT_WINE_COMMIT} emerge -1 wine"
1275 fi
1276 fi
1277 if use d3d9; then
1278 - git-r3_fetch "${D3D9_EGIT_REPO_URI}"
1279 + git-r3_fetch "${D3D9_EGIT_REPO_URI}" "${D3D9_COMMIT}"
1280 git-r3_checkout "${D3D9_EGIT_REPO_URI}" "${D3D9_DIR}"
1281 fi
1282 fi
1283
1284 diff --git a/app-emulation/wine/wine-9999.ebuild b/app-emulation/wine/wine-9999.ebuild
1285 index b5dad1f..4f8f3e9 100644
1286 --- a/app-emulation/wine/wine-9999.ebuild
1287 +++ b/app-emulation/wine/wine-9999.ebuild
1288 @@ -254,6 +254,27 @@ wine_build_environment_check() {
1289 fi
1290 }
1291
1292 +wine_env_vcs_vars() {
1293 + local pn_live_var="${PN//[-+]/_}_LIVE_COMMIT"
1294 + local pn_live_val="${pn_live_var}"
1295 + eval pn_live_val='$'${pn_live_val}
1296 + if [[ ! -z ${pn_live_val} ]]; then
1297 + if use staging || use d3d9; then
1298 + eerror "Because of the multi-repo nature of ${PN}, ${pn_live_var}"
1299 + eerror "cannot be used to set the commit. Instead, you may use the"
1300 + eerror "environmental variables WINE_COMMIT, STAGING_COMMIT, and D3D9_COMMIT."
1301 + eerror
1302 + return 1
1303 + fi
1304 + fi
1305 + if [[ ! -z ${EGIT_COMMIT} ]]; then
1306 + eerror "Commits must now be specified using the environmental variables"
1307 + eerror "WINE_COMMIT, STAGING_COMMIT, and D3D9_COMMIT"
1308 + eerror
1309 + return 1
1310 + fi
1311 +}
1312 +
1313 pkg_pretend() {
1314 wine_compiler_check || die
1315 wine_build_environment_check || die
1316 @@ -271,6 +292,7 @@ pkg_pretend() {
1317
1318 pkg_setup() {
1319 wine_build_environment_check || die
1320 + wine_env_vcs_vars || die
1321 if ! use staging; then
1322 GV=${VANILLA_GV}
1323 MV=${VANILLA_MV}
1324 @@ -282,23 +304,23 @@ pkg_setup() {
1325
1326 src_unpack() {
1327 if [[ ${PV} == "9999" ]] ; then
1328 - git-r3_src_unpack
1329 + EGIT_COMMIT="${WINE_COMMIT}" git-r3_src_unpack
1330 if use staging; then
1331 - local WINE_COMMIT=${EGIT_VERSION}
1332 + local CURRENT_WINE_COMMIT=${EGIT_VERSION}
1333
1334 - git-r3_fetch "${STAGING_EGIT_REPO_URI}"
1335 + git-r3_fetch "${STAGING_EGIT_REPO_URI}" "${STAGING_COMMIT}"
1336 git-r3_checkout "${STAGING_EGIT_REPO_URI}" "${STAGING_DIR}"
1337
1338 - local STAGING_COMMIT=$("${STAGING_DIR}/patches/patchinstall.sh" --upstream-commit) || die
1339 + local COMPAT_WINE_COMMIT=$("${STAGING_DIR}/patches/patchinstall.sh" --upstream-commit) || die
1340
1341 - if [[ "${WINE_COMMIT}" != "${STAGING_COMMIT}" ]]; then
1342 + if [[ "${CURRENT_WINE_COMMIT}" != "${COMPAT_WINE_COMMIT}" ]]; then
1343 einfo "The current Staging patchset is not guaranteed to apply on this WINE commit."
1344 einfo "If src_prepare fails, try emerging with the env var EGIT_COMMIT."
1345 - einfo "Example: EGIT_COMMIT=${STAGING_COMMIT} emerge -1 wine"
1346 + einfo "Example: WINE_COMMIT=${COMPAT_WINE_COMMIT} emerge -1 wine"
1347 fi
1348 fi
1349 if use d3d9; then
1350 - git-r3_fetch "${D3D9_EGIT_REPO_URI}"
1351 + git-r3_fetch "${D3D9_EGIT_REPO_URI}" "${D3D9_COMMIT}"
1352 git-r3_checkout "${D3D9_EGIT_REPO_URI}" "${D3D9_DIR}"
1353 fi
1354 fi
Report Message
Find on MARC Find on Google Groups