source: trunk/base/src/port1.0/portconfigure.tcl @ 116457

Last change on this file since 116457 was 116457, checked in by larryv@…, 6 years ago

portconfigure.tcl: Fold list of compiler ports into compiler_port_name.

  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 30.0 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 116457 2014-01-25 19:16:13Z larryv@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      {-isystem${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 5.0] >= 0} {
434        return {clang macports-llvm-gcc-4.2 apple-gcc-4.2 macports-clang-3.3}
435    } elseif {[vercmp $xcodeversion 4.2] >= 0} {
436        return {clang llvm-gcc-4.2 apple-gcc-4.2 macports-clang-3.3}
437    } elseif {[vercmp $xcodeversion 4.0] >= 0} {
438        return {llvm-gcc-4.2 clang gcc-4.2 macports-clang-3.3 apple-gcc-4.2}
439    } elseif {[vercmp $xcodeversion 3.2] >= 0} {
440        if {[string match *10.4u* ${configure.sdkroot}]} {
441            return {gcc-4.0}
442        } else {
443            return {gcc-4.2 clang llvm-gcc-4.2 macports-clang-3.3 macports-llvm-gcc-4.2 apple-gcc-4.2 gcc-4.0}
444        }
445    } elseif {[vercmp $xcodeversion 3.0] >= 0} {
446        return {gcc-4.2 apple-gcc-4.2 gcc-4.0 macports-clang-3.3}
447    } else {
448        return {apple-gcc-4.2 gcc-4.0 gcc-3.3 macports-clang-3.3}
449    }
450}
451
452# Find a developer tool
453proc portconfigure::find_developer_tool {name} {
454        global developer_dir
455
456    # first try /usr/bin since this doesn't move around
457    set toolpath "/usr/bin/${name}"
458    if {[file executable $toolpath]} {
459        return $toolpath
460    }
461
462        # Use xcode's xcrun to find the named tool.
463        if {![catch {exec [findBinary xcrun $portutil::autoconf::xcrun_path] -find ${name}} toolpath]} {
464                return ${toolpath}
465        }
466
467        # If xcrun failed to find the tool, return a path from
468        # the developer_dir.
469        # The tool may not be there, but we'll leave it up to
470        # the invoking code to figure out that it doesn't have
471        # a valid compiler
472        return "${developer_dir}/usr/bin/${name}"
473}
474
475
476# internal function to find correct compilers
477proc portconfigure::configure_get_compiler {type {compiler {}}} {
478    global configure.compiler prefix
479    if {$compiler eq ""} {
480        set compiler ${configure.compiler}
481    }
482    # Tcl 8.4's switch doesn't support -matchvar.
483    if {[regexp {^apple-gcc(-4\.[02])$} $compiler -> suffix]} {
484        switch $type {
485            cc      -
486            objc    { return ${prefix}/bin/gcc-apple${suffix} }
487            cxx     -
488            objcxx  {
489                if {$suffix eq "-4.2"} {
490                    return ${prefix}/bin/g++-apple${suffix}
491                }
492            }
493            cpp     { return ${prefix}/bin/cpp-apple${suffix} }
494        }
495    } elseif {[regexp {^clang$} $compiler]} {
496        switch $type {
497            cc      -
498            objc    { return [find_developer_tool clang] }
499            cxx     -
500            objcxx  {
501                set clangpp [find_developer_tool clang++]
502                if {[file executable $clangpp]} {
503                    return $clangpp
504                }
505                return [find_developer_tool llvm-g++-4.2]
506            }
507        }
508    } elseif {[regexp {^gcc(-3\.3|-4\.[02])?$} $compiler -> suffix]} {
509        switch $type {
510            cc      -
511            objc    { return [find_developer_tool "gcc${suffix}"] }
512            cxx     -
513            objcxx  { return [find_developer_tool "g++${suffix}"] }
514            cpp     { return [find_developer_tool "cpp${suffix}"] }
515        }
516    } elseif {[regexp {^llvm-gcc-4\.2$} $compiler]} {
517        switch $type {
518            cc      -
519            objc    { return [find_developer_tool llvm-gcc-4.2] }
520            cxx     -
521            objcxx  { return [find_developer_tool llvm-g++-4.2] }
522            cpp     { return [find_developer_tool llvm-cpp-4.2] }
523        }
524    } elseif {[regexp {^macports-clang(-\d+\.\d+)?$} $compiler -> suffix]} {
525        if {$suffix ne ""} {
526            set suffix "-mp${suffix}"
527        }
528        switch $type {
529            cc      -
530            objc    { return ${prefix}/bin/clang${suffix} }
531            cxx     -
532            objcxx  { return ${prefix}/bin/clang++${suffix} }
533        }
534    } elseif {[regexp {^macports-dragonegg(-\d+\.\d+)(?:-gcc(-\d+\.\d+))?$} $compiler \
535                -> infix suffix]} {
536        if {$suffix ne ""} {
537            set suffix "-mp${suffix}"
538        }
539        switch $type {
540            cc      -
541            objc    { return ${prefix}/bin/dragonegg${infix}-gcc${suffix} }
542            cxx     -
543            objcxx  { return ${prefix}/bin/dragonegg${infix}-g++${suffix} }
544            cpp     { return ${prefix}/bin/dragonegg${infix}-cpp${suffix} }
545            fc      -
546            f77     -
547            f90     { return ${prefix}/bin/dragonegg${infix}-gfortran${suffix} }
548        }
549    } elseif {[regexp {^macports-gcc(-\d+\.\d+)?$} $compiler -> suffix]} {
550        if {$suffix ne ""} {
551            set suffix "-mp${suffix}"
552        }
553        switch $type {
554            cc      -
555            objc    { return ${prefix}/bin/gcc${suffix} }
556            cxx     -
557            objcxx  { return ${prefix}/bin/g++${suffix} }
558            cpp     { return ${prefix}/bin/cpp${suffix} }
559            fc      -
560            f77     -
561            f90     { return ${prefix}/bin/gfortran${suffix} }
562        }
563    } elseif {[regexp {^macports-llvm-gcc-4\.2$} $compiler]} {
564        switch $type {
565            cc      -
566            objc    { return ${prefix}/bin/llvm-gcc-4.2 }
567            cxx     -
568            objcxx  { return ${prefix}/bin/llvm-g++-4.2 }
569            cpp     { return ${prefix}/bin/llvm-cpp-4.2 }
570        }
571    }
572    # Fallbacks
573    switch $type {
574        cc      -
575        objc    { return [find_developer_tool cc] }
576        cxx     -
577        objcxx  { return [find_developer_tool c++] }
578        cpp     { return [find_developer_tool cpp] }
579    }
580    return ""
581}
582
583# Automatically called from macports1.0 after evaluating the Portfile
584# Some of the compilers we use are provided by MacPorts itself; ensure we
585# automatically add a dependency when needed
586proc portconfigure::add_automatic_compiler_dependencies {} {
587    global configure.compiler configure.compiler.add_deps
588
589    if {!${configure.compiler.add_deps}} {
590        return
591    }
592
593    # The default value requires substitution before use.
594    set compiler [subst ${configure.compiler}]
595    if {![compiler_is_port $compiler]} {
596        return
597    }
598
599    ui_debug "Chosen compiler ${compiler} is provided by a port, adding dependency"
600
601    set compiler_port [portconfigure::compiler_port_name ${compiler}]
602    set deptype "build"
603    if {[string first "macports-gcc-" $compiler] == 0} {
604        set deptype "lib"
605    }
606    ui_debug "Adding depends_${deptype} port:$compiler_port"
607    depends_${deptype}-delete port:$compiler_port
608    depends_${deptype}-append port:$compiler_port
609
610    if {[arch_flag_supported $compiler]} {
611        ui_debug "Adding depends_skip_archcheck $compiler_port"
612        depends_skip_archcheck-delete $compiler_port
613        depends_skip_archcheck-append $compiler_port
614    }
615}
616# Register the above procedure as a callback after Portfile evaluation
617port::register_callback portconfigure::add_automatic_compiler_dependencies
618# and an option to turn it off if required
619options configure.compiler.add_deps
620default configure.compiler.add_deps yes
621
622proc portconfigure::configure_main {args} {
623    global [info globals]
624    global worksrcpath use_configure use_autoreconf use_autoconf use_automake use_xmkmf \
625           configure.env configure.pipe configure.libs configure.classpath configure.universal_args \
626           configure.perl configure.python configure.ruby configure.install configure.awk configure.bison \
627           configure.pkg_config configure.pkg_config_path \
628           configure.ccache configure.distcc configure.cpp configure.javac configure.sdkroot \
629           configure.march configure.mtune configure.cxx_stdlib \
630           os.platform os.major
631    foreach tool {cc cxx objc objcxx f77 f90 fc ld} {
632        global configure.${tool} configure.${tool}_archflags
633    }
634    foreach flags {cflags cppflags cxxflags objcflags objcxxflags ldflags fflags f90flags fcflags} {
635        global configure.${flags} configure.universal_${flags}
636    }
637   
638    if {[tbool use_autoreconf]} {
639        if {[catch {command_exec autoreconf} result]} {
640            return -code error "[format [msgcat::mc "%s failure: %s"] autoreconf $result]"
641        }
642    }
643   
644    if {[tbool use_automake]} {
645        if {[catch {command_exec automake} result]} {
646            return -code error "[format [msgcat::mc "%s failure: %s"] automake $result]"
647        }
648    }
649   
650    if {[tbool use_autoconf]} {
651        if {[catch {command_exec autoconf} result]} {
652            return -code error "[format [msgcat::mc "%s failure: %s"] autoconf $result]"
653        }
654    }
655
656    if {[tbool use_xmkmf]} {
657        parse_environment xmkmf
658        append_to_environment_value xmkmf "IMAKECPP" ${configure.cpp}
659        if {[catch {command_exec xmkmf} result]} {
660            return -code error "[format [msgcat::mc "%s failure: %s"] xmkmf $result]"
661        }
662
663        parse_environment xmkmf
664        append_to_environment_value xmkmf "IMAKECPP" ${configure.cpp}
665        if {[catch {command_exec "cd ${worksrcpath} && make Makefiles" -varprefix xmkmf} result]} {
666            return -code error "[format [msgcat::mc "%s failure: %s"] "make Makefiles" $result]"
667        }
668    } elseif {[tbool use_configure]} {
669        # Merge (ld|c|cpp|cxx)flags into the environment variable.
670        parse_environment configure
671
672        # Set pre-compiler filter to use (ccache/distcc), if any.
673        if {[tbool configure.ccache] && [tbool configure.distcc]} {
674            set filter ccache
675            append_to_environment_value configure "CCACHE_PREFIX" "distcc"
676        } elseif {[tbool configure.ccache]} {
677            set filter ccache
678        } elseif {[tbool configure.distcc]} {
679            set filter distcc
680        } else {
681            set filter ""
682        }
683        foreach env_var {CC CXX OBJC OBJCXX} {
684            append_to_environment_value configure $env_var $filter
685        }
686
687        # Set flags controlling the kind of compiler output.
688        if {[tbool configure.pipe]} {
689            set output -pipe
690        } else {
691            set output ""
692        }
693        foreach env_var {CFLAGS CXXFLAGS OBJCFLAGS OBJCXXFLAGS FFLAGS F90FLAGS FCFLAGS} {
694            append_to_environment_value configure $env_var $output
695        }
696
697        # Append configure flags.
698        foreach env_var { \
699            CC CXX OBJC OBJCXX FC F77 F90 JAVAC \
700            CFLAGS CPPFLAGS CXXFLAGS OBJCFLAGS OBJCXXFLAGS \
701            FFLAGS F90FLAGS FCFLAGS LDFLAGS LIBS CLASSPATH \
702            PERL PYTHON RUBY INSTALL AWK BISON PKG_CONFIG PKG_CONFIG_PATH \
703        } {
704            set value [option configure.[string tolower $env_var]]
705            eval [linsert $value 0 append_to_environment_value configure $env_var]
706        }
707
708        # https://trac.macports.org/ticket/34221
709        if {${os.platform} eq "darwin" && ${os.major} == 12} {
710            append_to_environment_value configure "__CFPREFERENCES_AVOID_DAEMON" 1
711        }
712
713        # add SDK flags if cross-compiling (or universal on ppc tiger)
714        if {${configure.sdkroot} ne ""} {
715            foreach env_var {CPPFLAGS CFLAGS CXXFLAGS OBJCFLAGS OBJCXXFLAGS} {
716                append_to_environment_value configure $env_var -isysroot ${configure.sdkroot}
717            }
718            append_to_environment_value configure "LDFLAGS" -Wl,-syslibroot,${configure.sdkroot}
719        }
720
721        # add extra flags that are conditional on whether we're building universal
722        eval [linsert [get_canonical_archflags cc] 0 append_to_environment_value configure CFLAGS]
723        foreach tool {cxx objc objcxx cpp f77 f90 fc ld} {
724            if {[catch {get_canonical_archflags $tool} flags]} {
725                continue
726            }
727            set env_var [string toupper $tool]FLAGS
728            eval [linsert $flags 0 append_to_environment_value configure $env_var]
729        }
730        if {[variant_exists universal] && [variant_isset universal]} {
731            eval [linsert ${configure.universal_args} 0 configure.pre_args-append]
732        } else {
733            foreach env_var {CFLAGS CXXFLAGS OBJCFLAGS OBJCXXFLAGS FFLAGS F90FLAGS FCFLAGS LDFLAGS} {
734                if {${configure.march} ne ""} {
735                    append_to_environment_value configure $env_var -march=${configure.march}
736                }
737                if {${configure.mtune} ne ""} {
738                    append_to_environment_value configure $env_var -mtune=${configure.mtune}
739                }
740            }
741        }
742
743        # Add flags to specify C++ STL implementation
744        if {${configure.cxx_stdlib} ne "" && [string match "*clang*" [option configure.cxx]]} {
745            append_to_environment_value configure CXXFLAGS -stdlib=${configure.cxx_stdlib}
746            append_to_environment_value configure OBJCXXFLAGS -stdlib=${configure.cxx_stdlib}
747        }
748
749        # Execute the command (with the new environment).
750        if {[catch {command_exec configure} result]} {
751            global configure.dir
752            if {[file exists ${configure.dir}/config.log]} {
753                ui_error "[format [msgcat::mc "Failed to configure %s, consult %s/config.log"] [option subport] ${configure.dir}]"
754            }
755            return -code error "[format [msgcat::mc "%s failure: %s"] configure $result]"
756        }
757    }
758    return 0
759}
Note: See TracBrowser for help on using the repository browser.