source: tags/release_2_3_1/base/src/port1.0/portconfigure.tcl

Last change on this file was 121317, checked in by jmr@…, 4 years ago

merge r120637 from trunk:

Don't use llvm-gcc or apple-gcc on Yosemite

  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 30.3 KB
Line 
1# -*- coding: utf-8; mode: tcl; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- vim:fenc=utf-8:filetype=tcl:et:sw=4:ts=4:sts=4
2# $Id: portconfigure.tcl 121317 2014-06-23 10:11:51Z jmr@macports.org $
3#
4# Copyright (c) 2007 - 2014 The MacPorts Project
5# Copyright (c) 2007 Markus W. Weissmann <mww@macports.org>
6# Copyright (c) 2002 - 2003 Apple Inc.
7# All rights reserved.
8#
9# Redistribution and use in source and binary forms, with or without
10# modification, are permitted provided that the following conditions
11# are met:
12# 1. Redistributions of source code must retain the above copyright
13#    notice, this list of conditions and the following disclaimer.
14# 2. Redistributions in binary form must reproduce the above copyright
15#    notice, this list of conditions and the following disclaimer in the
16#    documentation and/or other materials provided with the distribution.
17# 3. Neither the name of Apple Inc. nor the names of its contributors
18#    may be used to endorse or promote products derived from this software
19#    without specific prior written permission.
20#
21# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
22# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
25# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
26# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
27# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
28# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
29# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
30# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
31# POSSIBILITY OF SUCH DAMAGE.
32#
33
34package provide portconfigure 1.0
35package require portutil 1.0
36
37set org.macports.configure [target_new org.macports.configure portconfigure::configure_main]
38target_provides ${org.macports.configure} configure
39target_requires ${org.macports.configure} main fetch checksum extract patch
40target_prerun ${org.macports.configure} portconfigure::configure_start
41
42namespace eval portconfigure {
43}
44
45# define options
46commands configure autoreconf automake autoconf xmkmf
47# defaults
48default configure.env       ""
49default configure.pre_args  {--prefix=${prefix}}
50default configure.cmd       ./configure
51default configure.nice      {${buildnicevalue}}
52default configure.dir       {${worksrcpath}}
53default autoreconf.dir      {${worksrcpath}}
54default autoreconf.args     {{--install --verbose}}
55default autoconf.dir        {${worksrcpath}}
56default autoconf.args       {--verbose}
57default automake.dir        {${worksrcpath}}
58default automake.args       {--verbose}
59default xmkmf.cmd           xmkmf
60default xmkmf.dir           {${worksrcpath}}
61default use_configure       yes
62
63option_proc use_autoreconf  portconfigure::set_configure_type
64option_proc use_automake    portconfigure::set_configure_type
65option_proc use_autoconf    portconfigure::set_configure_type
66option_proc use_xmkmf       portconfigure::set_configure_type
67
68option_proc autoreconf.cmd  portconfigure::set_configure_type
69option_proc automake.cmd    portconfigure::set_configure_type
70option_proc autoconf.cmd    portconfigure::set_configure_type
71option_proc xmkmf.cmd       portconfigure::set_configure_type
72
73##
74# Local helper proc
75proc portconfigure::add_build_dep { type dep } {
76    global ${type}.cmd option_defaults
77
78    if {![info exists ${type}.cmd] || (
79        ([info exists option_defaults(${type}.cmd)] && [set ${type}.cmd] eq $option_defaults(${type}.cmd)) ||
80        (![info exists option_defaults(${type}.cmd)] && [set ${type}.cmd] eq ${type})
81        )} {
82            eval [linsert $dep 0 depends_build-append]
83    }
84}
85
86##
87# Adds dependencies for the binaries which will be called, but only if it is
88# the default. If .cmd was overwritten the port has to care for deps itself.
89proc portconfigure::set_configure_type {option action args} {
90    global autoreconf.cmd automake.cmd autoconf.cmd xmkmf.cmd
91
92    array set configure_map {
93        autoconf    {port:autoconf port:automake port:libtool}
94        xmkmf       port:imake
95    }
96
97    if {$action eq "set"} {
98        switch $option {
99            autoreconf.cmd  -
100            automake.cmd    -
101            autoconf.cmd {
102                eval [linsert $configure_map(autoconf) 0 depends_build-delete]
103            }
104            xmkmf.cmd {
105                eval [linsert $configure_map(xmkmf) 0 depends_build-delete]
106            }
107            use_xmkmf {
108                if {[tbool args]} {
109                    eval [linsert $configure_map(xmkmf) 0 depends_build-append]
110                }
111            }
112            default {
113                # strip "use_"
114                set type [string range $option 4 end]
115                if {[tbool args]} {
116                    add_build_dep $type $configure_map(autoconf)
117                }
118            }
119        }
120    }
121}
122
123options configure.asroot
124default configure.asroot no
125
126# Configure special environment variables.
127# We could have m32/m64/march/mtune be global configurable at some point.
128options configure.m32 configure.m64 configure.march configure.mtune
129default configure.march     {}
130default configure.mtune     {}
131# We could have debug/optimizations be global configurable at some point.
132options configure.optflags \
133        configure.cflags configure.cxxflags \
134        configure.objcflags configure.objcxxflags \
135        configure.cppflags configure.ldflags configure.libs \
136        configure.fflags configure.f90flags configure.fcflags \
137        configure.classpath
138# compiler flags section
139default configure.optflags      {-Os}
140default configure.cflags        {${configure.optflags}}
141default configure.cxxflags      {${configure.optflags}}
142default configure.objcflags     {${configure.optflags}}
143default configure.objcxxflags   {${configure.optflags}}
144default configure.cppflags      {-I${prefix}/include}
145default configure.ldflags       {"-L${prefix}/lib -Wl,-headerpad_max_install_names"}
146default configure.libs          {}
147default configure.fflags        {${configure.optflags}}
148default configure.f90flags      {${configure.optflags}}
149default configure.fcflags       {${configure.optflags}}
150default configure.classpath     {}
151
152# tools section
153options configure.perl configure.python configure.ruby \
154        configure.install configure.awk configure.bison \
155        configure.pkg_config configure.pkg_config_path
156default configure.perl              {}
157default configure.python            {}
158default configure.ruby              {}
159default configure.install           {${portutil::autoconf::install_command}}
160default configure.awk               {}
161default configure.bison             {}
162default configure.pkg_config        {}
163default configure.pkg_config_path   {}
164
165options configure.build_arch configure.ld_archflags \
166        configure.sdk_version configure.sdkroot
167default configure.build_arch    {[portconfigure::choose_supported_archs ${build_arch}]}
168default configure.ld_archflags  {[portconfigure::configure_get_ld_archflags]}
169default configure.sdk_version   {$macosx_sdk_version}
170default configure.sdkroot       {[portconfigure::configure_get_sdkroot ${configure.sdk_version}]}
171foreach tool {cc cxx objc objcxx f77 f90 fc} {
172    options configure.${tool}_archflags
173    default configure.${tool}_archflags  "\[portconfigure::configure_get_archflags $tool\]"
174}
175
176options configure.universal_archs configure.universal_args \
177        configure.universal_cflags configure.universal_cxxflags \
178        configure.universal_objcflags configure.universal_objcxxflags \
179        configure.universal_cppflags configure.universal_ldflags
180default configure.universal_archs       {[portconfigure::choose_supported_archs ${universal_archs}]}
181default configure.universal_args        {--disable-dependency-tracking}
182default configure.universal_cflags      {[portconfigure::configure_get_universal_cflags]}
183default configure.universal_cxxflags    {[portconfigure::configure_get_universal_cflags]}
184default configure.universal_objcflags   {${configure.universal_cflags}}
185default configure.universal_objcxxflags {${configure.universal_cxxflags}}
186default configure.universal_cppflags    {}
187default configure.universal_ldflags     {[portconfigure::configure_get_universal_ldflags]}
188
189# Select a distinct compiler (C, C preprocessor, C++)
190options configure.ccache configure.distcc configure.pipe configure.cc \
191        configure.cxx configure.cpp configure.objc configure.objcxx configure.f77 \
192        configure.f90 configure.fc configure.javac configure.compiler \
193        compiler.blacklist compiler.whitelist compiler.fallback
194default configure.ccache        {${configureccache}}
195default configure.distcc        {${configuredistcc}}
196default configure.pipe          {${configurepipe}}
197foreach tool {cc cxx objc objcxx cpp f77 f90 fc javac} {
198    default configure.$tool     "\[portconfigure::configure_get_compiler $tool\]"
199}
200default configure.compiler      {[portconfigure::configure_get_default_compiler]}
201default compiler.fallback       {[portconfigure::get_compiler_fallback]}
202default compiler.blacklist      {}
203default compiler.whitelist      {}
204
205# Select a C++ STL implementation
206options configure.cxx_stdlib
207default configure.cxx_stdlib    {$cxx_stdlib}
208
209set_ui_prefix
210
211proc portconfigure::configure_start {args} {
212    global UI_PREFIX
213
214    ui_notice "$UI_PREFIX [format [msgcat::mc "Configuring %s"] [option subport]]"
215
216    set compiler [option configure.compiler]
217    set valid_compilers {
218        {^apple-gcc-(4\.[02])$}             {MacPorts Apple GCC %s}
219        {^cc$}                              {System cc}
220        {^clang$}                           {Xcode Clang}
221        {^gcc$}                             {System GCC}
222        {^gcc-(3\.3|4\.[02])$}              {Xcode GCC %s}
223        {^llvm-gcc-4\.2$}                   {Xcode LLVM-GCC 4.2}
224        {^macports-clang$}                  {MacPorts Clang (port select}
225        {^macports-clang-(\d+\.\d+)$}       {MacPorts Clang %s}
226        {^macports-dragonegg-(\d+\.\d+)$}   {MacPorts DragonEgg %s}
227        {^macports-dragonegg-(\d+\.\d+)-gcc-(\d+\.\d+)$}
228            {MacPorts DragonEgg %s with GCC %s}
229        {^macports-gcc$}                    {MacPorts GCC (port select)}
230        {^macports-gcc-(\d+\.\d+)$}         {MacPorts GCC %s}
231        {^macports-llvm-gcc-4\.2$}          {MacPorts LLVM-GCC 4.2}
232    }
233    foreach {re fmt} $valid_compilers {
234        if {[set matches [regexp -inline $re $compiler]] ne ""} {
235            set compiler_name [eval [linsert [lrange $matches 1 end] 0 format $fmt]]
236            break
237        }
238    }
239    if {![info exists compiler_name]} {
240        return -code error "Invalid value for configure.compiler: $compiler"
241    }
242    ui_debug "Using compiler '$compiler_name'"
243
244    # Additional ccache directory setup
245    global configure.ccache ccache_dir ccache_size macportsuser
246    if {${configure.ccache}} {
247        # Create ccache directory with correct permissions with root privileges
248        elevateToRoot "configure ccache"
249        if {[catch {
250                file mkdir ${ccache_dir}
251                file attributes ${ccache_dir} -owner ${macportsuser} -permissions 0755
252            } result]} {
253            ui_warn "ccache_dir ${ccache_dir} could not be created; disabling ccache: $result"
254            set configure.ccache no
255        }
256        dropPrivileges
257
258        # Initialize ccache directory with the given maximum size
259        if {${configure.ccache}} {
260            if {[catch {
261                exec ccache -M ${ccache_size} >/dev/null
262            } result]} {
263                ui_warn "ccache_dir ${ccache_dir} could not be initialized; disabling ccache: $result"
264                set configure.ccache no
265            }
266        }
267    }
268}
269
270# internal function to choose the default configure.build_arch and
271# configure.universal_archs based on supported_archs and build_arch or
272# universal_archs
273proc portconfigure::choose_supported_archs {archs} {
274    global supported_archs
275    if {$supported_archs eq ""} {
276        return $archs
277    }
278    set ret {}
279    foreach arch $archs {
280        if {[lsearch -exact $supported_archs $arch] != -1} {
281            set add_arch $arch
282        } elseif {$arch eq "x86_64" && [lsearch -exact $supported_archs "i386"] != -1} {
283            set add_arch "i386"
284        } elseif {$arch eq "ppc64" && [lsearch -exact $supported_archs "ppc"] != -1} {
285            set add_arch "ppc"
286        } else {
287            continue
288        }
289        if {[lsearch -exact $ret $add_arch] == -1} {
290            lappend ret $add_arch
291        }
292    }
293    return $ret
294}
295
296# internal function to determine the compiler flags to select an arch
297proc portconfigure::configure_get_archflags {tool} {
298    global configure.build_arch configure.m32 configure.m64 configure.compiler
299    set flags ""
300    if {[tbool configure.m64]} {
301        set flags "-m64"
302    } elseif {[tbool configure.m32]} {
303        set flags "-m32"
304    } elseif {${configure.build_arch} ne ""} {
305        if {[arch_flag_supported ${configure.compiler}] &&
306            [regexp {^(?:cc|cxx|objc|objcxx)$} $tool]
307        } then {
308            set flags "-arch ${configure.build_arch}"
309        } elseif {${configure.build_arch} eq "x86_64" || ${configure.build_arch} eq "ppc64"} {
310            set flags "-m64"
311        } elseif {${configure.compiler} ne "gcc-3.3"} {
312            set flags "-m32"
313        }
314    }
315    return $flags
316}
317
318# internal function to determine the ld flags to select an arch
319# Unfortunately there's no consistent way to do this when the compiler
320# doesn't support -arch, because it could be used to link rather than using
321# ld directly. So we punt and let portfiles deal with that case.
322proc portconfigure::configure_get_ld_archflags {args} {
323    global configure.build_arch configure.compiler
324    if {${configure.build_arch} ne "" && [arch_flag_supported ${configure.compiler}]} {
325        return "-arch ${configure.build_arch}"
326    } else {
327        return ""
328    }
329}
330
331proc portconfigure::configure_get_sdkroot {sdk_version} {
332    global developer_dir macosx_version xcodeversion os.arch os.platform
333    if {${os.platform} eq "darwin" && ($sdk_version ne $macosx_version
334        || (${os.arch} eq "powerpc" && $macosx_version eq "10.4" && [variant_exists universal] && [variant_isset universal]))} {
335        if {[vercmp $xcodeversion 4.3] < 0} {
336            set sdks_dir ${developer_dir}/SDKs
337        } else {
338            set sdks_dir ${developer_dir}/Platforms/MacOSX.platform/Developer/SDKs
339        }
340        if {$sdk_version eq "10.4"} {
341            set sdk ${sdks_dir}/MacOSX10.4u.sdk
342        } else {
343            set sdk ${sdks_dir}/MacOSX${sdk_version}.sdk
344        }
345        if {[file exists $sdk]} {
346            return $sdk
347        }
348    }
349    return {}
350}
351
352# internal function to determine the "-arch xy" flags for the compiler
353proc portconfigure::configure_get_universal_archflags {args} {
354    global configure.universal_archs
355    set flags ""
356    foreach arch ${configure.universal_archs} {
357        if {$flags eq ""} {
358            set flags "-arch $arch"
359        } else {
360            append flags " -arch $arch"
361        }
362    }
363    return $flags
364}
365
366# internal function to determine the CFLAGS for the compiler
367proc portconfigure::configure_get_universal_cflags {args} {
368    return [configure_get_universal_archflags]
369}
370
371# internal function to determine the LDFLAGS for the compiler
372proc portconfigure::configure_get_universal_ldflags {args} {
373    return [configure_get_universal_archflags]
374}
375
376# internal proc to determine if the compiler supports -arch
377proc portconfigure::arch_flag_supported {compiler} {
378    return [regexp {^gcc-4|llvm|apple|clang} $compiler]
379}
380
381proc portconfigure::compiler_port_name {compiler} {
382    set valid_compiler_ports {
383        {^apple-gcc-(\d+)\.(\d+)$}                          {apple-gcc%s%s}
384        {^macports-clang-(\d+\.\d+)$}                       {clang-%s}
385        {^macports-dragonegg-(\d+\.\d+)(-gcc-\d+\.\d+)?$}   {dragonegg-%s%s}
386        {^macports-(llvm-)?gcc-(\d+)\.(\d+)$}               {%sgcc%s%s}
387    }
388    foreach {re fmt} $valid_compiler_ports {
389        if {[set matches [regexp -inline $re $compiler]] ne ""} {
390            return [eval [linsert [lrange $matches 1 end] 0 format $fmt]]
391        }
392    }
393    return {}
394}
395
396proc portconfigure::compiler_is_port {compiler} {
397    return [expr {[portconfigure::compiler_port_name ${compiler}] ne ""}]
398}
399
400# internal function to determine the default compiler
401proc portconfigure::configure_get_default_compiler {args} {
402    if {[option compiler.whitelist] ne ""} {
403        set search_list [option compiler.whitelist]
404    } else {
405        set search_list [option compiler.fallback]
406    }
407    foreach compiler $search_list {
408        set allowed yes
409        foreach pattern [option compiler.blacklist] {
410            if {[string match $pattern $compiler]} {
411                set allowed no
412                break
413            }
414        }
415        if {$allowed &&
416            ([file executable [configure_get_compiler cc $compiler]] ||
417             [compiler_is_port $compiler])
418        } then {
419            return $compiler
420        }
421    }
422    ui_warn "All compilers are either blacklisted or unavailable; defaulting to first fallback option"
423    return [lindex [option compiler.fallback] 0]
424}
425
426# internal function to choose compiler fallback list based on platform
427proc portconfigure::get_compiler_fallback {} {
428    global xcodeversion macosx_deployment_target default_compilers configure.sdkroot
429    if {[info exists default_compilers]} {
430        return $default_compilers
431    } elseif {$xcodeversion eq "none" || $xcodeversion eq ""} {
432        return {cc}
433    } elseif {[vercmp $xcodeversion 6.0] >= 0 && [vercmp $macosx_deployment_target 10.10] >= 0} {
434        return {clang macports-clang-3.4 macports-clang-3.3}
435    } elseif {[vercmp $xcodeversion 5.0] >= 0} {
436        return {clang macports-clang-3.4 macports-clang-3.3 macports-llvm-gcc-4.2 apple-gcc-4.2}
437    } elseif {[vercmp $xcodeversion 4.3] >= 0} {
438        return {clang llvm-gcc-4.2 macports-clang-3.4 macports-clang-3.3 apple-gcc-4.2}
439    } elseif {[vercmp $xcodeversion 4.0] >= 0} {
440        return {llvm-gcc-4.2 clang gcc-4.2 macports-clang-3.4 macports-clang-3.3 apple-gcc-4.2}
441    } elseif {[vercmp $xcodeversion 3.2] >= 0} {
442        if {[string match *10.4u* ${configure.sdkroot}]} {
443            return {gcc-4.0}
444        } else {
445            return {gcc-4.2 clang llvm-gcc-4.2 macports-clang-3.4 macports-clang-3.3 macports-llvm-gcc-4.2 apple-gcc-4.2 gcc-4.0}
446        }
447    } elseif {[vercmp $xcodeversion 3.0] >= 0} {
448        return {gcc-4.2 apple-gcc-4.2 gcc-4.0 macports-clang-3.4 macports-clang-3.3}
449    } else {
450        return {apple-gcc-4.2 gcc-4.0 gcc-3.3 macports-clang-3.3}
451    }
452}
453
454# Find a developer tool
455proc portconfigure::find_developer_tool {name} {
456        global developer_dir
457
458    # first try /usr/bin since this doesn't move around
459    set toolpath "/usr/bin/${name}"
460    if {[file executable $toolpath]} {
461        return $toolpath
462    }
463
464        # Use xcode's xcrun to find the named tool.
465        if {![catch {exec [findBinary xcrun $portutil::autoconf::xcrun_path] -find ${name}} toolpath]} {
466                return ${toolpath}
467        }
468
469        # If xcrun failed to find the tool, return a path from
470        # the developer_dir.
471        # The tool may not be there, but we'll leave it up to
472        # the invoking code to figure out that it doesn't have
473        # a valid compiler
474        return "${developer_dir}/usr/bin/${name}"
475}
476
477
478# internal function to find correct compilers
479proc portconfigure::configure_get_compiler {type {compiler {}}} {
480    global configure.compiler prefix
481    if {$compiler eq ""} {
482        set compiler ${configure.compiler}
483    }
484    # Tcl 8.4's switch doesn't support -matchvar.
485    if {[regexp {^apple-gcc(-4\.[02])$} $compiler -> suffix]} {
486        switch $type {
487            cc      -
488            objc    { return ${prefix}/bin/gcc-apple${suffix} }
489            cxx     -
490            objcxx  {
491                if {$suffix eq "-4.2"} {
492                    return ${prefix}/bin/g++-apple${suffix}
493                }
494            }
495            cpp     { return ${prefix}/bin/cpp-apple${suffix} }
496        }
497    } elseif {[regexp {^clang$} $compiler]} {
498        switch $type {
499            cc      -
500            objc    { return [find_developer_tool clang] }
501            cxx     -
502            objcxx  {
503                set clangpp [find_developer_tool clang++]
504                if {[file executable $clangpp]} {
505                    return $clangpp
506                }
507                return [find_developer_tool llvm-g++-4.2]
508            }
509        }
510    } elseif {[regexp {^gcc(-3\.3|-4\.[02])?$} $compiler -> suffix]} {
511        switch $type {
512            cc      -
513            objc    { return [find_developer_tool "gcc${suffix}"] }
514            cxx     -
515            objcxx  { return [find_developer_tool "g++${suffix}"] }
516            cpp     { return [find_developer_tool "cpp${suffix}"] }
517        }
518    } elseif {[regexp {^llvm-gcc-4\.2$} $compiler]} {
519        switch $type {
520            cc      -
521            objc    { return [find_developer_tool llvm-gcc-4.2] }
522            cxx     -
523            objcxx  { return [find_developer_tool llvm-g++-4.2] }
524            cpp     { return [find_developer_tool llvm-cpp-4.2] }
525        }
526    } elseif {[regexp {^macports-clang(-\d+\.\d+)?$} $compiler -> suffix]} {
527        if {$suffix ne ""} {
528            set suffix "-mp${suffix}"
529        }
530        switch $type {
531            cc      -
532            objc    { return ${prefix}/bin/clang${suffix} }
533            cxx     -
534            objcxx  { return ${prefix}/bin/clang++${suffix} }
535        }
536    } elseif {[regexp {^macports-dragonegg(-\d+\.\d+)(?:-gcc(-\d+\.\d+))?$} $compiler \
537                -> infix suffix]} {
538        if {$suffix ne ""} {
539            set suffix "-mp${suffix}"
540        }
541        switch $type {
542            cc      -
543            objc    { return ${prefix}/bin/dragonegg${infix}-gcc${suffix} }
544            cxx     -
545            objcxx  { return ${prefix}/bin/dragonegg${infix}-g++${suffix} }
546            cpp     { return ${prefix}/bin/dragonegg${infix}-cpp${suffix} }
547            fc      -
548            f77     -
549            f90     { return ${prefix}/bin/dragonegg${infix}-gfortran${suffix} }
550        }
551    } elseif {[regexp {^macports-gcc(-\d+\.\d+)?$} $compiler -> suffix]} {
552        if {$suffix ne ""} {
553            set suffix "-mp${suffix}"
554        }
555        switch $type {
556            cc      -
557            objc    { return ${prefix}/bin/gcc${suffix} }
558            cxx     -
559            objcxx  { return ${prefix}/bin/g++${suffix} }
560            cpp     { return ${prefix}/bin/cpp${suffix} }
561            fc      -
562            f77     -
563            f90     { return ${prefix}/bin/gfortran${suffix} }
564        }
565    } elseif {[regexp {^macports-llvm-gcc-4\.2$} $compiler]} {
566        switch $type {
567            cc      -
568            objc    { return ${prefix}/bin/llvm-gcc-4.2 }
569            cxx     -
570            objcxx  { return ${prefix}/bin/llvm-g++-4.2 }
571            cpp     { return ${prefix}/bin/llvm-cpp-4.2 }
572        }
573    }
574    # Fallbacks
575    switch $type {
576        cc      -
577        objc    { return [find_developer_tool cc] }
578        cxx     -
579        objcxx  { return [find_developer_tool c++] }
580        cpp     { return [find_developer_tool cpp] }
581    }
582    return ""
583}
584
585# Automatically called from macports1.0 after evaluating the Portfile
586# Some of the compilers we use are provided by MacPorts itself; ensure we
587# automatically add a dependency when needed
588proc portconfigure::add_automatic_compiler_dependencies {} {
589    global configure.compiler configure.compiler.add_deps
590
591    if {!${configure.compiler.add_deps}} {
592        return
593    }
594
595    # The default value requires substitution before use.
596    set compiler [subst ${configure.compiler}]
597    if {![compiler_is_port $compiler]} {
598        return
599    }
600
601    ui_debug "Chosen compiler ${compiler} is provided by a port, adding dependency"
602
603    set compiler_port [portconfigure::compiler_port_name ${compiler}]
604    set deptype "build"
605    if {[string first "macports-gcc-" $compiler] == 0} {
606        set deptype "lib"
607    }
608    ui_debug "Adding depends_${deptype} port:$compiler_port"
609    depends_${deptype}-delete port:$compiler_port
610    depends_${deptype}-append port:$compiler_port
611
612    if {[arch_flag_supported $compiler]} {
613        ui_debug "Adding depends_skip_archcheck $compiler_port"
614        depends_skip_archcheck-delete $compiler_port
615        depends_skip_archcheck-append $compiler_port
616    }
617}
618# Register the above procedure as a callback after Portfile evaluation
619port::register_callback portconfigure::add_automatic_compiler_dependencies
620# and an option to turn it off if required
621options configure.compiler.add_deps
622default configure.compiler.add_deps yes
623
624proc portconfigure::configure_main {args} {
625    global [info globals]
626    global worksrcpath use_configure use_autoreconf use_autoconf use_automake use_xmkmf \
627           configure.env configure.pipe configure.libs configure.classpath configure.universal_args \
628           configure.perl configure.python configure.ruby configure.install configure.awk configure.bison \
629           configure.pkg_config configure.pkg_config_path \
630           configure.ccache configure.distcc configure.cpp configure.javac configure.sdkroot \
631           configure.march configure.mtune configure.cxx_stdlib \
632           os.platform os.major
633    foreach tool {cc cxx objc objcxx f77 f90 fc ld} {
634        global configure.${tool} configure.${tool}_archflags
635    }
636    foreach flags {cflags cppflags cxxflags objcflags objcxxflags ldflags fflags f90flags fcflags} {
637        global configure.${flags} configure.universal_${flags}
638    }
639   
640    if {[tbool use_autoreconf]} {
641        if {[catch {command_exec autoreconf} result]} {
642            return -code error "[format [msgcat::mc "%s failure: %s"] autoreconf $result]"
643        }
644    }
645   
646    if {[tbool use_automake]} {
647        if {[catch {command_exec automake} result]} {
648            return -code error "[format [msgcat::mc "%s failure: %s"] automake $result]"
649        }
650    }
651   
652    if {[tbool use_autoconf]} {
653        if {[catch {command_exec autoconf} result]} {
654            return -code error "[format [msgcat::mc "%s failure: %s"] autoconf $result]"
655        }
656    }
657
658    if {[tbool use_xmkmf]} {
659        parse_environment xmkmf
660        append_to_environment_value xmkmf "IMAKECPP" ${configure.cpp}
661        if {[catch {command_exec xmkmf} result]} {
662            return -code error "[format [msgcat::mc "%s failure: %s"] xmkmf $result]"
663        }
664
665        parse_environment xmkmf
666        append_to_environment_value xmkmf "IMAKECPP" ${configure.cpp}
667        if {[catch {command_exec "cd ${worksrcpath} && make Makefiles" -varprefix xmkmf} result]} {
668            return -code error "[format [msgcat::mc "%s failure: %s"] "make Makefiles" $result]"
669        }
670    } elseif {[tbool use_configure]} {
671        # Merge (ld|c|cpp|cxx)flags into the environment variable.
672        parse_environment configure
673
674        # Set pre-compiler filter to use (ccache/distcc), if any.
675        if {[tbool configure.ccache] && [tbool configure.distcc]} {
676            set filter ccache
677            append_to_environment_value configure "CCACHE_PREFIX" "distcc"
678        } elseif {[tbool configure.ccache]} {
679            set filter ccache
680        } elseif {[tbool configure.distcc]} {
681            set filter distcc
682        } else {
683            set filter ""
684        }
685        foreach env_var {CC CXX OBJC OBJCXX} {
686            append_to_environment_value configure $env_var $filter
687        }
688
689        # Set flags controlling the kind of compiler output.
690        if {[tbool configure.pipe]} {
691            set output -pipe
692        } else {
693            set output ""
694        }
695        foreach env_var {CFLAGS CXXFLAGS OBJCFLAGS OBJCXXFLAGS FFLAGS F90FLAGS FCFLAGS} {
696            append_to_environment_value configure $env_var $output
697        }
698
699        # Append configure flags.
700        foreach env_var { \
701            CC CXX OBJC OBJCXX FC F77 F90 JAVAC \
702            CFLAGS CPPFLAGS CXXFLAGS OBJCFLAGS OBJCXXFLAGS \
703            FFLAGS F90FLAGS FCFLAGS LDFLAGS LIBS CLASSPATH \
704            PERL PYTHON RUBY INSTALL AWK BISON PKG_CONFIG PKG_CONFIG_PATH \
705        } {
706            set value [option configure.[string tolower $env_var]]
707            eval [linsert $value 0 append_to_environment_value configure $env_var]
708        }
709
710        # https://trac.macports.org/ticket/34221
711        if {${os.platform} eq "darwin" && ${os.major} == 12} {
712            append_to_environment_value configure "__CFPREFERENCES_AVOID_DAEMON" 1
713        }
714
715        # add SDK flags if cross-compiling (or universal on ppc tiger)
716        if {${configure.sdkroot} ne ""} {
717            foreach env_var {CPPFLAGS CFLAGS CXXFLAGS OBJCFLAGS OBJCXXFLAGS} {
718                append_to_environment_value configure $env_var -isysroot ${configure.sdkroot}
719            }
720            append_to_environment_value configure "LDFLAGS" -Wl,-syslibroot,${configure.sdkroot}
721        }
722
723        # add extra flags that are conditional on whether we're building universal
724        eval [linsert [get_canonical_archflags cc] 0 append_to_environment_value configure CFLAGS]
725        foreach tool {cxx objc objcxx cpp f77 f90 fc ld} {
726            if {[catch {get_canonical_archflags $tool} flags]} {
727                continue
728            }
729            set env_var [string toupper $tool]FLAGS
730            eval [linsert $flags 0 append_to_environment_value configure $env_var]
731        }
732        if {[variant_exists universal] && [variant_isset universal]} {
733            eval [linsert ${configure.universal_args} 0 configure.pre_args-append]
734        } else {
735            foreach env_var {CFLAGS CXXFLAGS OBJCFLAGS OBJCXXFLAGS FFLAGS F90FLAGS FCFLAGS LDFLAGS} {
736                if {${configure.march} ne ""} {
737                    append_to_environment_value configure $env_var -march=${configure.march}
738                }
739                if {${configure.mtune} ne ""} {
740                    append_to_environment_value configure $env_var -mtune=${configure.mtune}
741                }
742            }
743        }
744
745        # Add flags to specify C++ STL implementation
746        if {${configure.cxx_stdlib} ne "" && [string match "*clang*" [option configure.cxx]]} {
747            append_to_environment_value configure CXXFLAGS -stdlib=${configure.cxx_stdlib}
748            append_to_environment_value configure OBJCXXFLAGS -stdlib=${configure.cxx_stdlib}
749        }
750
751        # Execute the command (with the new environment).
752        if {[catch {command_exec configure} result]} {
753            global configure.dir
754            if {[file exists ${configure.dir}/config.log]} {
755                ui_error "[format [msgcat::mc "Failed to configure %s, consult %s/config.log"] [option subport] ${configure.dir}]"
756            }
757            return -code error "[format [msgcat::mc "%s failure: %s"] configure $result]"
758        }
759    }
760    return 0
761}
Note: See TracBrowser for help on using the repository browser.