source: trunk/dports/_resources/port1.0/group/compilers-1.0.tcl @ 116296

Last change on this file since 116296 was 116296, checked in by sean@…, 5 years ago

compilers-1.0: update gfortran variant to gcc 4.8

File size: 14.8 KB
Line 
1# -*- coding: utf-8; mode: tcl; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- vim:fenc=utf-8:ft=tcl:et:sw=4:ts=4:sts=4
2# $Id$
3#
4# Copyright (c) 2012 The MacPorts Project
5# All rights reserved.
6#
7# Redistribution and use in source and binary forms, with or without
8# modification, are permitted provided that the following conditions are
9# met:
10#
11# 1. Redistributions of source code must retain the above copyright
12#    notice, this list of conditions and the following disclaimer.
13# 2. Redistributions in binary form must reproduce the above copyright
14#    notice, this list of conditions and the following disclaimer in the
15#    documentation and/or other materials provided with the distribution.
16# 3. Neither the name of The MacPorts Project nor the names of its
17#    contributors may be used to endorse or promote products derived from
18#    this software without specific prior written permission.
19#
20# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
21# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
23# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
24# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
25# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
26# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
27# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
28# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
30# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31#
32#
33# This PortGroup sets up default variants for projects that want m
34#
35# Usage:
36#
37#   PortGroup               compilers 1.0
38
39options compilers.variants compilers.gcc_variants
40default compilers.variants {}
41default compilers.fortran_variants {}
42default compilers.gcc_variants {}
43default compilers.clang_variants {}
44default compilers.dragonegg_variants {}
45default compilers.require_fortran 0
46default compilers.setup_done 0
47
48set compilers.list {cc cxx cpp objc fc f77 f90}
49
50# build database of gcc 4{4..9} compiler attributes
51set gcc_versions {4 5 6 7 8 9}
52foreach v ${gcc_versions} {
53    lappend compilers.gcc_variants gcc4$v
54    set cdb(gcc4$v,variant)  gcc4$v
55    set cdb(gcc4$v,compiler) macports-gcc-4.$v
56    set cdb(gcc4$v,descrip)  "MacPorts gcc 4.$v"
57    set cdb(gcc4$v,depends)  port:gcc4$v
58    set cdb(gcc4$v,dependsl) path:lib/libgcc/libgcc_s.1.dylib:libgcc
59    set cdb(gcc4$v,dependsd) port:g95
60    set cdb(gcc4$v,dependsa) gcc4$v
61    set cdb(gcc4$v,conflict) "gfortran g95"
62    set cdb(gcc4$v,flags)    {
63        {{"-PIC"} {"-fPIC"}}
64    }
65    set cdb(gcc4$v,cc)       ${prefix}/bin/gcc-mp-4.$v
66    set cdb(gcc4$v,cxx)      ${prefix}/bin/g++-mp-4.$v
67    set cdb(gcc4$v,cpp)      ${prefix}/bin/cpp-mp-4.$v
68    set cdb(gcc4$v,objc)     ${prefix}/bin/gcc-mp-4.$v
69    set cdb(gcc4$v,fc)       ${prefix}/bin/gfortran-mp-4.$v
70    set cdb(gcc4$v,f77)      ${prefix}/bin/gfortran-mp-4.$v
71    set cdb(gcc4$v,f90)      ${prefix}/bin/gfortran-mp-4.$v
72}
73
74set clang_versions {0 1 2 3 4}
75foreach v ${clang_versions} {
76    lappend compilers.clang_variants clang3$v
77    set cdb(clang3$v,variant)  clang3$v
78    set cdb(clang3$v,compiler) macports-clang-3.$v
79    set cdb(clang3$v,descrip)  "MacPorts clang 3.$v"
80    set cdb(clang3$v,depends)  port:clang-3.$v
81    set cdb(clang3$v,dependsl) ""
82    set cdb(clang3$v,dependsd) ""
83    set cdb(clang3$v,dependsa) clang-3.$v
84    set cdb(clang3$v,conflict) ""
85    set cdb(clang3$v,flags)    {
86        {{"-PIC"} {"-fPIC"}}
87    }
88    set cdb(clang3$v,cc)       ${prefix}/bin/clang-mp-3.$v
89    set cdb(clang3$v,cxx)      ${prefix}/bin/clang++-mp-3.$v
90    set cdb(clang3$v,cpp)      "${prefix}/bin/clang-mp-3.$v -E"
91    set cdb(clang3$v,objc)     ""
92    set cdb(clang3$v,fc)       ""
93    set cdb(clang3$v,f77)      ""
94    set cdb(clang3$v,f90)      ""
95}
96
97# dragonegg versions will always match the corresponding clang version
98foreach v ${clang_versions} {
99    lappend compilers.dragonegg_variants dragonegg3$v
100    set cdb(dragonegg3$v,variant)  dragonegg3$v
101    set cdb(dragonegg3$v,compiler) macports-dragonegg-3.$v
102    set cdb(dragonegg3$v,descrip)  "MacPorts dragonegg 3.$v"
103    set cdb(dragonegg3$v,depends)  path:bin/dragonegg-3.$v-gcc:dragonegg-3.$v
104    set cdb(dragonegg3$v,dependsl) path:lib/libgcc/libgcc_s.1.dylib:libgcc
105    set cdb(dragonegg3$v,dependsd) port:g95
106    set cdb(dragonegg3$v,dependsa) dragonegg-3.$v
107    set cdb(dragonegg3$v,conflict) "gfortran g95"
108    set cdb(dragonegg3$v,flags)    {
109        {{"-PIC"} {"-fPIC"}}
110    }
111    set cdb(dragonegg3$v,cc)       ${prefix}/bin/dragonegg-3.$v-gcc
112    set cdb(dragonegg3$v,cxx)      ${prefix}/bin/dragonegg-3.$v-g++
113    set cdb(dragonegg3$v,cpp)      ${prefix}/bin/dragonegg-3.$v-cpp
114    set cdb(dragonegg3$v,objc)     ""
115    set cdb(dragonegg3$v,fc)       ${prefix}/bin/dragonegg-3.$v-gfortran
116    set cdb(dragonegg3$v,f77)      ${prefix}/bin/dragonegg-3.$v-gfortran
117    set cdb(dragonegg3$v,f90)      ${prefix}/bin/dragonegg-3.$v-gfortran
118}
119
120set cdb(llvm,variant)  llvm
121set cdb(llvm,compiler) llvm-gcc-4.2
122set cdb(llvm,descrip)  "Apple native llvm-gcc 4.2"
123set cdb(llvm,depends)  bin:llvm-gcc-4.2:llvm-gcc42
124set cdb(llvm,dependsl) ""
125set cdb(llvm,dependsd) ""
126set cdb(llvm,dependsa) ""
127set cdb(llvm,conflict) ""
128set cdb(llvm,flags)    {
129    {{"-fPIC"} {"-PIC"}}
130}
131set cdb(llvm,cc)       llvm-gcc-4.2
132set cdb(llvm,cxx)      llvm-g++-4.2
133set cdb(llvm,cpp)      llvm-cpp-4.2
134set cdb(llvm,objc)     llvm-gcc-4.2
135set cdb(llvm,fc)       ""
136set cdb(llvm,f77)      ""
137set cdb(llvm,f90)      ""
138
139# and lastly we add a gfortran and g95 variant for use with clang*; note that
140# we don't need gfortran when we are in an "only-fortran" mode
141set cdb(gfortran,variant)  gfortran
142set cdb(gfortran,compiler) gfortran
143set cdb(gfortran,descrip)  "Fortran compiler from gcc48"
144set cdb(gfortran,depends)  port:gcc48
145set cdb(gfortran,dependsl) path:lib/libgcc/libgcc_s.1.dylib:libgcc
146set cdb(gfortran,dependsd) ""
147set cdb(gfortran,dependsa) ""
148set cdb(gfortran,conflict) ""
149set cdb(gfortran,flags)    {
150    {{"-fPIC"} {"-PIC"}}
151}
152set cdb(gfortran,cc)       ""
153set cdb(gfortran,cxx)      ""
154set cdb(gfortran,cpp)      ""
155set cdb(gfortran,objc)     ""
156set cdb(gfortran,fc)       ${prefix}/bin/gfortran-mp-4.8
157set cdb(gfortran,f77)      ${prefix}/bin/gfortran-mp-4.8
158set cdb(gfortran,f90)      ${prefix}/bin/gfortran-mp-4.8
159
160set cdb(g95,variant)  g95
161set cdb(g95,compiler) g95
162set cdb(g95,descrip)  "Fortran compiler from g95"
163set cdb(g95,depends)  port:g95
164set cdb(g95,dependsl) ""
165set cdb(g95,dependsd) ""
166set cdb(g95,dependsa) g95
167set cdb(g95,conflict) ""
168set cdb(g95,flags)    {
169    {{"-fPIC"} {"-PIC"}}
170}
171set cdb(g95,cc)       ""
172set cdb(g95,cxx)      ""
173set cdb(g95,cpp)      ""
174set cdb(g95,objc)     ""
175set cdb(g95,fc)       ${prefix}/bin/g95
176set cdb(g95,f77)      ${prefix}/bin/g95
177set cdb(g95,f90)      ${prefix}/bin/g95
178
179foreach name [array names cdb *,variant] {
180    lappend compilers.variants $cdb($name)
181}
182
183foreach variant ${compilers.variants} {
184    if {$cdb($variant,f77) ne ""} {
185        lappend compilers.fortran_variants $variant
186    }
187}
188
189proc compilers.setup_variants {args} {
190    global cdb compilers.variants compilers.clang_variants compilers.gcc_variants
191    global compilers.dragonegg_variants compilers.fortran_variants compilers.list
192
193    foreach variant [split $args] {
194        if {$cdb($variant,f77) ne ""} {
195            lappend compilers.fortran_variants $variant
196        }
197
198        if {[variant_exists $variant]} {
199            ui_debug "$variant variant already exists, so not adding the default one"
200        } else {
201            set i [lsearch -exact ${compilers.variants} $variant]
202            set c [lreplace ${compilers.variants} $i $i]
203
204            # fortran doesn't conflict with clang
205            if {$variant eq "gfortran" || $variant eq "g95"} {
206                foreach clangcomp ${compilers.clang_variants} {
207                    set i [lsearch -exact $c $clangcomp]
208                    set c [lreplace $c $i $i]
209                }
210            } elseif {[string match clang* $variant]} {
211                set i [lsearch -exact $c gfortran]
212                set c [lreplace $c $i $i]
213                set i [lsearch -exact $c g95]
214                set c [lreplace $c $i $i]
215            }
216
217            # for each pair of flags (old,new), build a string of if statements to
218            # replace old with new
219            set f ""
220            foreach flag $cdb($variant,flags) {
221                foreach {old new} $flag {
222                    append f [subst {
223                        if {\[string first $old \${configure.cflags}\] > -1} {
224                            configure.cflags-delete $old
225                            configure.cflags-append $new
226                        }
227                    }]
228                }
229            }
230
231            foreach flag $cdb($variant,flags) {
232                foreach {old new} $flag {
233                    append f [subst {
234                        if {\[string first $old \${configure.cxxflags}\] > -1} {
235                            configure.cxxflags-delete $old
236                            configure.cxxflags-append $new
237                        }
238                    }]
239                }
240            }
241
242            # for each compiler, set the value if not empty; we can't use
243            # configure.compiler because of dragonegg and possibly other new
244            # compilers that aren't in macports portconfigure.tcl
245            set comp ""
246            foreach compiler ${compilers.list} {
247                if {$cdb($variant,$compiler) ne ""} {
248                    append comp [subst {
249                        configure.$compiler $cdb($variant,$compiler)
250
251                        # disable archflags
252                        if {"[info command configure.${compiler}_archflags]" ne ""} {
253                            configure.${compiler}_archflags
254                            configure.ld_archflags
255                        }
256                    }]
257                }
258            }
259
260            eval [subst {
261                variant ${variant} description \
262                    {Build using the $cdb($variant,descrip) compiler} \
263                    conflicts $c $cdb($variant,conflict) {
264
265                    depends_build-append   $cdb($variant,depends)
266                    depends_lib-append     $cdb($variant,dependsl)
267                    depends_lib-delete     $cdb($variant,dependsd)
268                    depends_skip_archcheck $cdb($variant,dependsa)
269
270                    $comp
271
272                    $f
273                }
274            }]
275        }
276    }
277}
278
279foreach variant ${compilers.gcc_variants} {
280    if {[variant_isset $variant]} {
281        depends_lib-delete      port:g95
282        break
283    }
284}
285
286proc compiler_variant_name {} {
287    global compilers.variants
288
289    foreach variant ${compilers.variants} {
290        if {[variant_isset $variant]} {
291            return $variant
292        }
293    }
294
295    return ""
296}
297
298proc fortran_variant_name {} {
299    global compilers.fortran_variants
300
301    foreach fc ${compilers.fortran_variants} {
302        if {[variant_isset $fc]} {
303            return $fc
304        }
305    }
306
307    return ""
308}
309
310proc fortran_variant_isset {} {
311    return [expr {[fortran_variant_name] ne ""}]
312}
313
314# remove all elements in R from L
315proc remove_from_list {L R} {
316    foreach e $R {
317        set idx [lsearch $L $e]
318        set L [lreplace $L $idx $idx]
319    }
320    return $L
321}
322
323# add all elements in R from L
324proc add_from_list {L A} {
325    return [concat $L $A]
326}
327
328proc compilers.choose {args} {
329    global compilers.list
330
331    # zero out the variable before and append args
332    set compilers.list {}
333    foreach v $args {
334        lappend compilers.list $v
335    }
336}
337
338proc compilers.is_fortran_only {} {
339    global compilers.list
340
341    foreach c {cc cxx cpp objc} {
342        if {[lsearch -exact ${compilers.list} $c] >= 0} {
343            return 0
344        }
345    }
346
347    return 1
348}
349
350proc compilers.setup {args} {
351    global cdb compilers.variants compilers.clang_variants compilers.gcc_variants
352    global compilers.dragonegg_variants compilers.fortran_variants
353    global compilers.require_fortran compilers.setup_done compilers.list
354
355    if {!${compilers.setup_done}} {
356        set add_list {}
357        set remove_list ${compilers.variants}
358
359        # if we are only setting fortran compilers, then we are in "only fortran
360        # mode", i.e. we just need +gccXY and +dragoneggXY for the fortran
361        # compilers so we remove +clangXY and +llvm
362        if {[compilers.is_fortran_only]} {
363            # remove gfortran since that only exists to "complete" clang/llvm
364            set remove_list [remove_from_list ${compilers.fortran_variants} gfortran]
365        }
366
367        foreach v $args {
368            # if any negated compiler (e.g. -gcc47) is specified then we are
369            # removing from the default, complete list
370            set mode add
371            if {[string first - $v] == 0} {
372                set mode remove
373
374                #strip the beginning '-' character
375                set v [string range $v 1 end]
376            }
377
378            # handle special cases, such as 'gcc' -> all gcc variants
379            switch -exact $v {
380                gcc {
381                    set ${mode}_list [${mode}_from_list [expr $${mode}_list] ${compilers.gcc_variants}]
382                }
383                dragonegg {
384                    set ${mode}_list [${mode}_from_list [expr $${mode}_list] ${compilers.dragonegg_variants}]
385                }
386                fortran {
387                    # here we just check gfortran and g95, not every fortran
388                    # compatible variant since it makes more sense to specify
389                    # 'fortran' to mean add just the +gfortran and +g95 variants
390                    set ${mode}_list [${mode}_from_list [expr $${mode}_list] {gfortran g95}]
391
392                }
393                clang {
394                    set ${mode}_list [${mode}_from_list [expr $${mode}_list] ${compilers.clang_variants}]
395                }
396                require_fortran {
397                    # this signals that fortran is required and not optional
398                    set compilers.require_fortran 1
399                }
400                default {
401                    if {[info exists cdb($v,variant)] == 0} {
402                        return -code error "no such compiler: $v"
403                    }
404                    set ${mode}_list [${mode}_from_list [expr $${mode}_list] $cdb($v,variant)]
405                }
406            }
407        }
408
409        # remove duplicates
410        set duplicates {}
411        foreach foo $remove_list {
412            if {[lsearch $add_list $foo] != -1} {
413                lappend duplicates $foo
414            }
415        }
416
417        set compilers.variants [lsort [concat [remove_from_list $remove_list $duplicates] $add_list]]
418        eval compilers.setup_variants ${compilers.variants}
419
420        set compilers.setup_done 1
421    }
422}
423
424pre-fetch {
425    if {${compilers.require_fortran} && [fortran_variant_name] eq ""} {
426        return -code error "must set at least one fortran variant"
427    }
428}
Note: See TracBrowser for help on using the repository browser.