source: trunk/dports/math/atlas/Portfile @ 105384

Last change on this file since 105384 was 105384, checked in by vince@…, 7 years ago

Disable the clang family compilers.

  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 25.2 KB
Line 
1# $Id: Portfile 105384 2013-04-19 10:31:54Z vince@macports.org $
2
3PortSystem              1.0
4PortGroup               muniversal 1.0
5
6categories              math
7license                 BSD
8name                    atlas
9version                 3.10.1
10revision                3
11
12# additional versions
13set lapackversion       3.4.2
14set lapackname          lapack
15set atlasdist           ${name}${version}.tar.bz2
16set lapackdist          ${lapackname}-${lapackversion}.tgz
17
18maintainers             vince
19platforms               darwin
20
21description             Portable optimal linear algebra software
22long_description        Provides a complete BLAS and LAPACK API.\nATLAS\
23                        achieves performance on par\
24                        with machine-specific tuned libraries.
25
26# No precompiled binaries
27archive_sites
28
29homepage                http://math-atlas.sourceforge.net/
30
31master_sites            sourceforge:math-atlas:atlas \
32                        http://www.netlib.org/lapack:lapack
33
34distfiles               ${atlasdist}:atlas \
35                        ${lapackdist}:lapack
36
37patchfiles              patch-emit_mm_c.diff \
38                        patch-ATL_cmm4x4x128_av_c.diff
39
40
41checksums               atlas3.10.1.tar.bz2 \
42rmd160  67f928ad900caa300b23e2f824b8a495f416c8d6 \
43sha256  a215b492204aae0205f4028e7c4076492a5d6a564f8f859ff062fd79587bcc86 \
44                        lapack-3.4.2.tgz \
45rmd160  8740c35c9a85b71424fe1ffeed192256aebeb431 \
46sha256  60a65daaf16ec315034675942618a2230521ea7adf85eea788ee54841072faf0
47
48
49compiler.blacklist          macports-clang-3.1 macports-clang-3.0
50compiler.blacklist          macports-clang-2.9
51
52set     gcc_version         0
53set     use_clang           ""
54
55variant gcc48               conflicts   gcc46 gcc47 \
56                                        clang mpclang32 mpclang33 \
57                            description {build using macports-gcc-4.8} {
58
59    depends_build-append    port:gcc48
60    configure.compiler      macports-gcc-4.8
61}
62
63if {[variant_isset gcc48]} {
64
65    set gcc_version         48
66    set use_clang           ""
67}
68
69variant gcc47               conflicts   gcc46 gcc48 \
70                                        clang mpclang32 mpclang33 \
71                            description {build using macports-gcc-4.7} {
72
73    depends_build-append    port:gcc47
74    configure.compiler      macports-gcc-4.7
75}
76
77if {[variant_isset gcc47]} {
78
79    set gcc_version         47
80    set use_clang           ""
81}
82
83variant gcc46               conflicts   gcc47 gcc48 \
84                                        clang mpclang32 mpclang33 \
85                            description {build using macports-gcc-4.6} {
86
87    depends_build-append    port:gcc46
88    configure.compiler      macports-gcc-4.6
89}
90
91if {[variant_isset gcc46]} {
92
93    set gcc_version         46
94    set use_clang           ""
95
96}
97
98variant clang               conflicts   gcc46 gcc47 gcc48 \
99                                        mpclang32 mpclang33 \
100                            description {use XCode clang and gfortran} {
101
102    pre-fetch {
103        return -code error        "Use of clang is temporarily disabled.\
104                                   Please choose gcc47 instead."
105    }
106
107    configure.compiler      clang
108}
109
110if {[variant_isset clang]} {
111
112    set use_clang           "XCode"
113    set gcc_version         0
114}
115
116variant mpclang32           conflicts   gcc46 gcc47 gcc48 \
117                                        clang mpclang33 \
118                            description {use mp-clang-3.2 and gfortran} {
119
120    pre-fetch {
121        return -code error        "Use of clang is temporarily disabled.\
122                                   Please choose gcc47 instead."
123    }
124
125    depends_build-append    port:clang-3.2
126    configure.compiler      macports-clang-3.2
127}
128
129if {[variant_isset mpclang32]} {
130
131    set use_clang           "32"
132    set gcc_version         0
133}
134
135variant mpclang33           conflicts   gcc46 gcc47 gcc48 \
136                                        clang mpclang32 \
137                            description {use mp-clang-3.3 and gfortran} {
138
139    pre-fetch {
140        return -code error        "Use of clang is temporarily disabled.\
141                                   Please choose gcc47 instead."
142    }
143
144    depends_build-append    port:clang-3.3
145    configure.compiler      macports-clang-3.3
146}
147
148if {[variant_isset mpclang33]} {
149
150    set use_clang           "33"
151    set gcc_version         0
152}
153
154variant nofortran       description {Forgo use of fortran compiler} {
155}
156
157# AVX or higher?
158
159if {${os.major} > 10 && \
160        ![catch {sysctl hw.optional.avx1_0} result1] && $result1 == 1} {
161
162    set has_avx "yes"
163} else {
164
165    set has_avx "no"
166}
167
168# If none of the above variants is chosen, make gcc47 the default for
169# up to SSE4.2 (Core i1) capable processors, and mp-clang-3.3 for newer
170
171if {![variant_isset gcc46] && ![variant_isset gcc47] && \
172    ![variant_isset gcc48] && ![variant_isset clang] && \
173    ![variant_isset mpclang32] && ![variant_isset mpclang33]} {
174
175    if {${has_avx} == "no"} {
176   
177        # Defaults to gcc47
178        default_variants    +gcc47
179        set gcc_version     47
180        set use_clang       ""
181    } else {
182   
183        # Until clang is fixed…
184        default_variants    +gcc47
185        set gcc_version     47
186        set use_clang       ""
187
188        # Defaults to clang-mp-3.3
189        #default_variants    +mpclang33
190        #set gcc_version     0
191        #set use_clang       "33"
192    }
193}
194
195set universal           [variant_isset universal]
196
197# Finds the type of CPU we are running on
198set native_arch ${build_arch}
199
200if {${os.arch} == "i386"} {
201
202    set universal_archs_supported {i386 x86_64}
203    if {![catch {exec sysctl -n hw.machine} result]} {
204        set native_arch ${result}
205    }
206} elseif {${os.arch} == "powerpc"} {
207
208    set universal_archs_supported {ppc  ppc64}
209    if {![catch {exec sysctl -n hw.cpusubtype} result] && $result == 100} {
210        set native_arch "ppc64"
211    } else {
212   
213        set native_arch "ppc"
214    }
215}
216
217configure.args \
218    --with-netlib-lapack-tarfile=${distpath}/${lapackdist} \
219    -O 12 \
220    -v 5 \
221    --dylibs
222
223# Chose the right flags for GCC and Clang compilers
224
225if {${build_arch} == "i386" || ${build_arch} == "x86_64"} {
226
227    # General flags
228    # GCC
229    set gcc_flags   "-fomit-frame-pointer -mfpmath=sse -O3\
230                     -fno-schedule-insns2 -fPIC"
231
232    # Clang
233    if {${use_clang} == "32" || ${use_clang} == "XCode" } {
234
235        pre-fetch {       
236            #ui_warn "Compiling Atlas with this version of clang is\
237            #        likely *NOT* to work. Please use clang-3.3 or\
238            #        higher."
239        }
240        set clang_flags "-O3 -fomit-frame-pointer -fPIC"
241    } else {
242
243        # Clang 3.3 – Use loop and straight vectorizer
244        #set clang_flags "-O3 -fomit-frame-pointer -fPIC\
245        #                 -fvectorize -fslp-vectorize"
246        set clang_flags "-O3 -fomit-frame-pointer -fPIC"
247
248    }
249
250    # Vectorizing unit flags
251    if {${has_avx} == "yes"} {
252
253        # GCC compilers do not support AVX on OS X
254        set gvct_flag   "-msse4.2"
255        set cvct_flag   "-mavx"
256    } elseif {${os.major} > 9 && \
257            ![catch {sysctl hw.optional.sse4_2} result1] && $result1 == 1} {
258
259        set gvct_flag   "-msse4.2"
260        set cvct_flag   "-msse4.2"
261    } elseif {${os.major} > 9 && \
262            ![catch {sysctl hw.optional.sse4_1} result1] && $result1 == 1} {
263
264        set gvct_flag   "-msse4.1"
265        set cvct_flag   "-msse4.1"
266    } elseif {${os.major} > 8 && \
267    ![catch {sysctl hw.optional.supplementalsse3} result1] && $result1 == 1} {
268
269        set gvct_flag   "-mssse3"
270        set cvct_flag   "-mssse3"
271    } else {
272
273        # Default vectorization flag is sse3 (CoreSolo / CoreDuo)
274        set gvct_flag   "-msse3"
275        set cvct_flag   "-msse3"
276    }
277} elseif {${build_arch} == "ppc"} {
278
279    # PPC
280    set gcc_flags           "-O3 -mcpu=7400 -mtune=7400\
281                            -fno-schedule-insns -fschedule-insns2 -fPIC \
282                            -force_cpusubtype_ALL"
283    set clang_flags         "-O3 -arch ppc -fPIC"
284
285    set gvct_flag           "-maltivec -mabi=altivec"
286    set cvct_flag           "-maltivec"
287   
288    configure.args-append   -A 4
289
290    # On Leopard, we may warn the user that ppc
291    # is not as efficient as ppc64
292    pre-fetch {
293        if {${native_arch} == "ppc64"} {
294
295                ui_msg "Compiling for ppc on a G5 machine.\
296                        This could lead to reduced performance."
297        }
298    }
299
300} else {
301
302    # PPC64
303    set gcc_flags           "-mcpu=970 -mtune=970 -mvrsave -mpowerpc64\
304                            -fno-schedule-insns -fschedule-insns2 -fPIC \
305                            -force_cpusubtype_ALL"
306    # Clang has no PPC64 target so compile for PPC
307    set clang_flags         "-O3 -arch ppc -fPIC"
308
309    set gvct_flag           "-maltivec -mabi=altivec"
310    set cvct_flag           "-maltivec"
311}
312
313# Basic universal config
314# Advanced config (flags) is done during pre-configure phase
315
316if {${universal} == 1} {
317
318    configure.universal_args-delete         --disable-dependency-tracking
319
320    lappend merger_configure_args(ppc)      --cflags=-m32 \
321                                            -b 32 \
322                                            -A 4 \
323                                            -V 4 \
324                                            -s gas_ppc \
325                                            -Fa alg -force_cpusubtype_ALL
326
327    lappend merger_configure_args(ppc64)    --cflags=-m64 \
328                                            -b 64 \
329                                            -A 5 \
330                                            -V 4 \
331                                            -s gas_ppc \
332                                            -Fa alg -force_cpusubtype_ALL
333
334    lappend merger_configure_args(i386)     --cflags=-m32 \
335                                            -b 32 \
336                                            -A 22 \
337                                            -V 448 \
338                                            -t 2 \
339                                            -s gas_x86_32
340
341    lappend merger_configure_args(x86_64)   --cflags=-m64 \
342                                            -b 64 \
343                                            -s gas_x86_64
344}
345
346# Threading
347# If we run on a mono-processor machine (PPC), then disable threading
348
349if {![catch {sysctl hw.logicalcpu} result] && $result == 1} {
350
351    configure.args-append    -t 0
352    set no_threads  1
353} else {
354
355    set no_threads  0
356
357    # Threading relies on OpenMP if gcc compilers are selected
358    if {${gcc_version} != 0} {
359
360        configure.args-append   -Si omp 1
361    }
362}
363
364# Phases (moonlike)
365
366extract {
367    # extract Atlas and move to a consistent working directory name
368    system -W ${workpath}   "bunzip2 -dc ${distpath}/${atlasdist} | \
369                             gnutar --no-same-owner -xf -"
370    system  "mv ${workpath}/ATLAS ${workpath}/${name}-${version}"
371}
372
373post-patch {
374    if {${build_arch} == "ppc" || ${build_arch} == "ppc64"} {
375   
376        reinplace \
377        "s|cMVFLAGS=\\\\\"%s\\\\\"|cMVFLAGS=\\\\\"-force_cpusubtype_ALL\ %s\\\\\"|" \
378         ${worksrcpath}/include/atlas_mvtesttime.h
379    }
380
381    if {${no_threads} == 1} {
382        exec sed -i bak -E "/.*threads.*/d" ${worksrcpath}/Make.top
383    }
384}
385
386# Change the default compilers
387pre-configure {
388
389    # Inform user of selected C compiler
390    ui_msg "Selected C compiler: ${configure.cc}"
391
392    # Fortran stuff
393    set fortran [expr ! [variant_isset nofortran]]
394
395    # If we use clang, we must grasp a gfortran compiler to build
396    # Fortran sources (do not impact overall Atlas performance)
397
398    if {${use_clang} != "" && ${fortran} == 1} {
399
400        set gflist  [glob -noc ${prefix}/bin/gfortran-mp-4.*]
401        if {[llength ${gflist}] == 0} {
402
403            # No fortran compiler found. Act as if nofortran was set.
404            ui_warn "No gfortran-mp-4.* compiler found.\
405                     Disabling fortran API."
406            set fortran  0
407        } else {
408
409            # Select most recent gfortran
410            global gcc_version
411
412            configure.f77   [lindex [lsort -dec ${gflist}] 0]
413            set gcc_version   \
414            [join [split [string range ${configure.f77} end-2 end] "."] ""]           
415        }
416    }
417
418    if {${fortran} == 1} {
419
420        # Output the F77 selected compiler
421        ui_msg "Selected F77 compiler: gfortran${gcc_version}"
422    } else {
423
424        # No Fortran
425        configure.args-append   --nof77
426    }
427   
428    # Now set the flags according to the compiler family chosen
429    # Also set “width” of the processor (32 or 64-bit)
430
431    if {${gcc_version} != 0} {
432        set libgccpath                  ${prefix}/lib/gcc${gcc_version}
433    }
434
435    # Some tweaks on the original source before universal build
436    # duplicates it
437    # Overrides goodgcc
438    reinplace -E "s|GOODGCC =.*|GOODGCC = ${configure.cc}\");|" \
439        ${worksrcpath}/CONFIG/src/SpewMakeInc.c
440
441    # Some further tweaks
442    reinplace    "s|cc=gcc|cc=${configure.cc}|g" \
443                    ${worksrcpath}/configure
444    reinplace    "s|-no-cpp-precomp||g" \
445                    ${worksrcpath}/CONFIG/src/atlcomp.txt
446               
447    # Non-universal builds
448    if {${universal} == 0} {
449
450        configure.args-append   -C acg ${configure.cc}
451       
452        # If we build for the CPU of the machine, use
453        # machine arch tuning (except on ppc)
454        # -march=natives supersedes -msse4.2 so disable it on AVX
455        # capable machines
456        if {${has_avx} == "no" && ${build_arch} != "ppc"} {
457
458            append gcc_flags    " -march=native"
459        }
460        append clang_flags  " -march=native"
461       
462        # AVX stuff. GCC compilers cannot use AVX instruction set because the
463        # system as(1) is outdated
464        # Clang 3.2 has a bug affecting some AVX instructions
465        # Clang 3.3 should be fine
466
467        if {${has_avx} == "yes"} {
468
469            if {${use_clang} == ""} {
470
471                # Force Core i1 arch for ASM kernels
472                ui_warn "GCC compilers on MacOS do not support AVX:\
473                        downgrading."
474                configure.args-append   -A 25
475            } else {
476
477                # Clang: AVX only on versions >= 3.3
478                if {${use_clang} == "32" || ${use_clang} == "XCode" } {
479
480                    ui_warn "AVX support is broken in these versions\
481                             of clang. Please use clang-3.3 or higher.\
482                            Downgrading."
483                    configure.args-append   -A 25
484                }
485            }
486        }
487       
488        if {${build_arch} == "ppc"} {
489       
490            # ppc uses altivec vectorizing unit
491            configure.args-append       -V 4
492        }
493
494        if {${use_clang} == ""} {
495       
496            # GCC
497            configure.args-append       -F acg "'${gcc_flags} ${gvct_flag}'"
498           
499            if {${fortran} == 1} {
500           
501                configure.args-append   -C if ${configure.f77}
502                configure.args-append   -F if "'${gcc_flags} ${gvct_flag}'"
503                configure.args-append   -Ss f77lib \
504                                            ${libgccpath}/libgfortran.dylib
505            }
506            if {${build_arch} == "x86_64" || ${build_arch} == "ppc64"} {
507
508                configure.args-append   -b 64
509            } else {
510
511                configure.args-append   -b 32
512            }
513        } else {
514
515            # clang
516            configure.args-append   -F acg  "'${clang_flags} ${cvct_flag}'"
517            if {${fortran} == 1} {
518
519                configure.args-append   -C if ${configure.f77}           
520                configure.args-append   -F if "'${gcc_flags} ${gvct_flag}'"
521                configure.args-append   -Ss f77lib \
522                                            ${libgccpath}/libgfortran.dylib
523            }
524
525            if {${build_arch} == "x86_64"} {
526
527                configure.args-append   -b 64
528            } else {
529
530                # Clang has no ppc64 target so ppc64 ➸ regular ppc (32 bit)
531                configure.args-append   -b 32
532            }
533        }
534       
535        # Create build directory
536        file mkdir ${worksrcpath}/build
537    } else {
538   
539        # Universal builds
540        foreach arch ${universal_archs_to_use} {
541           
542            # Init ‘universal’ flags
543            set gcc_univ_flags          ${gcc_flags}
544            set gvct_univ_flag          ${gvct_flag}
545            set clang_univ_flags        ${clang_flags}
546            set cvct_univ_flag          ${cvct_flag}
547            set gcc_supp_flags          ""
548            set clang_supp_flags        ""
549           
550            # We build for the native architecture
551            if {${arch} == ${native_arch} && ${build_arch} != "ppc"} {
552               
553                # Don’t add -march=native to a GCC build on an AVX
554                # machine because this flag overrides -msse4.2
555                if {${has_avx} == "no"} {
556               
557                    append gcc_supp_flags   "-march=native "
558                }
559                append clang_supp_flags     "-march=native "
560            }
561           
562            # Non-native targets. Apply a priori flags.
563
564            # Clamp i386 optimization to -sse3 in universal builds and
565            # forces clang/gcc to use -m32 flag
566            if {${arch} == "i386" && ${native_arch} != "i386"} {
567
568                set gvct_univ_flag      "-msse3"
569                set cvct_univ_flag      "-msse3"
570       
571                append gcc_supp_flags   "-m32"
572                append clang_supp_flags "-m32"
573            }
574           
575            # For x86_64 builds, be conservative and use only -ssse3
576            # Core2 CPU and SSE3 ASM kernels
577            if {${arch} == "x86_64" && ${native_arch} != "x86_64"} {
578           
579                set gvct_univ_flag      "-mssse3"
580                set cvct_univ_flag      "-mssse3"
581               
582                append gcc_supp_flags   "-m64"
583                append clang_supp_flags "-m64"
584               
585                lappend merger_configure_args("x86_64") -A 25 -V 448
586            }
587           
588            # ppc (on Intel or ppc64 machines)
589            if {${arch} == "ppc" && ${native_arch} != "ppc"} {
590           
591                set gcc_univ_flags      "-O3 -mcpu=7400 -mtune=7400\
592                                         -fno-schedule-insns -fschedule-insns2\
593                                         -fPIC"
594                set clang_univ_flags    "-O3 -arch ppc -fPIC"
595
596                set gvct_univ_flag      "-maltivec -mabi=altivec"
597                set cvct_univ_flag      "-maltivec"
598
599                append gcc_supp_flags   "-m32"
600                append clang_supp_flags "-m32"
601            }
602           
603            # ppc64 (only for gcc, for clang this is taken to be the
604            # same target as ppc)
605            if {${arch} == "ppc64" && ${native_arch} != "ppc64"} {
606           
607                set gcc_univ_flags      "-mcpu=970 -mtune=970 -mvrsave \
608                                         -mpowerpc64 -fno-schedule-insns\
609                                         -fschedule-insns2 -fPIC"
610                set clang_univ_flags    "-O3 -arch ppc -fPIC"
611
612                set gvct_univ_flag      "-maltivec -mabi=altivec"
613                set cvct_univ_flag      "-maltivec"
614
615                append gcc_supp_flags   "-m64"
616                append clang_supp_flags "-m64"
617            }
618           
619            # Now add the flags to merger_configure_args(${arch})
620            # Same code as the non-universal case
621            lappend merger_configure_args(${arch})  -C acg ${configure.cc}
622            if {${use_clang} == ""} {
623       
624                # GCC
625                lappend merger_configure_args(${arch}) \
626                    -F acg "'${gcc_univ_flags} ${gcc_supp_flags}\
627                             ${gvct_univ_flag}'"
628           
629                if {${fortran} == 1} {
630           
631                    lappend merger_configure_args(${arch}) \
632                        -C if ${configure.f77} \
633                        -F if "'${gcc_univ_flags} ${gcc_supp_flags}\
634                                ${gvct_univ_flag}'"
635               
636                    set libgccarchpath    ${libgccpath}/${arch}
637                    if {[file exists ${libgccarchpath}/libgfortran.dylib]} {
638
639                        lappend merger_configure_args(${arch}) \
640                            -Ss f77lib ${libgccarchpath}/libgfortran.dylib
641                    } else {
642
643                        lappend merger_configure_args(${arch}) \
644                            -Ss f77lib ${libgccpath}/libgfortran.dylib
645                    }
646                }
647            } else {
648
649                # clang
650                lappend merger_configure_args(${arch}) \
651                    -F acg "'${clang_univ_flags} ${clang_supp_flags}\
652                             ${cvct_univ_flag}'"
653           
654                if {${fortran} == 1} {
655           
656                    lappend merger_configure_args(${arch}) \
657                        -C if ${configure.f77} \
658                        -F if "'${gcc_univ_flags} ${gcc_supp_flags}\
659                                ${gvct_univ_flag}'"
660               
661                    set libgccarchpath    ${libgccpath}/${arch}
662                    if {[file exists ${libgccarchpath}/libgfortran.dylib]} {
663
664                        lappend merger_configure_args(${arch}) \
665                            -Ss f77lib ${libgccarchpath}/libgfortran.dylib
666                    } else {
667
668                        lappend merger_configure_args(${arch}) \
669                            -Ss f77lib ${libgccpath}/libgfortran.dylib
670                    }
671                }
672            }
673           
674            # Remove spurious { } from arguments list
675            set merger_configure_args(${arch}) \
676                [join [split $merger_configure_args(${arch}) "{}"]]
677               
678            # Create ${arch} build tree
679            copy ${workpath}/${name}-${version} \
680                ${workpath}/${name}-${version}-${arch}
681            file mkdir ${workpath}/${name}-${version}-${arch}/build
682        }
683    }
684   
685    # On PPC64 we need extra flags for configuring
686    if {${native_arch} == "ppc64"} {
687        configure.args-append   --cc="\"${configure.cc} -m32 \
688                                 -force_cpusubtype_ALL\""
689    }
690
691    # Get some system specific variables for maximum optimization
692    set cpufreq [expr {[sysctl hw.cpufrequency] / 1000000}]
693
694    if {${os.arch} == "powerpc"} {
695
696        configure.args-append    -D c -DWALL
697    } else {
698
699        configure.args-append    -D c -DPentiumCPS=${cpufreq}
700    }   
701}
702
703# We configure from the build directory
704configure.dir            ${worksrcpath}/build
705configure.cmd            ../configure
706
707post-configure {
708
709    # Store in ${atlas_paths} the ${worksrcpath}s corresponding to the
710    # archs Atlas is being built for.
711    set     atlas_paths {}
712    if {${universal} == 1} {
713
714        foreach arch ${universal_archs_to_use} {
715
716            lappend atlas_paths ${workpath}/${name}-${version}-${arch}
717        }
718    } else {
719
720        lappend atlas_paths ${worksrcpath}
721    }
722
723    foreach path ${atlas_paths} {
724
725        # Recursively remove directories
726        ui_debug    "Patch to recursively remove directories on clean."
727        reinplace   "s|rm -f|rm -rf|g" ${path}/build/Makefile
728
729        # Threading — ensure libgomp is correctly pulled in during link
730        if {${gcc_version} != 0 && ${no_threads} == 0} {
731
732            set gmpfx    ${prefix}/lib/gcc${gcc_version}
733            set arch     [lindex [split [lindex [split $path "/"] end] "-"] 2]
734            if {${arch} != "" && \
735                [file exists ${gmpfx}/${arch}/libgomp.dylib]} {
736
737                reinplace -E \
738                    "s|(LIBS =.*)|\\1 ${gmpfx}/${arch}/libgomp.dylib|" \
739                    ${path}/build/Make.inc
740            } else {
741
742                reinplace -E \
743                    "s|(LIBS =.*)|\\1 ${gmpfx}/libgomp.dylib|" \
744                    ${path}/build/Make.inc
745            }
746        }
747    }
748}
749
750build.env-append        "CC=${configure.cc} CXX=${configure.cxx}"
751use_parallel_build      no
752build.target            build
753build.dir               ${worksrcpath}/build
754
755post-build {
756    if {${universal} == 0} {
757
758        set libdir ${build.dir}/lib
759        reinplace "s|^LIBTOOL=.*$|LIBTOOL=\$\(GCC\) \$\(GCCFLAGS\)|" \
760            ${libdir}/Makefile
761        reinplace "s|dynamic|dynamiclib|g" ${libdir}/Makefile
762
763        # On mono-processors machines, build libsatlas.dylib only
764        if {${no_threads} == 1} {
765
766            system -W ${libdir} "${build.cmd} dylib"
767        } else {
768
769            system -W ${libdir} "${build.cmd} shared_all"
770        }
771    } else {
772
773        foreach arch ${universal_archs_to_use} {
774
775            set libdir ${workpath}/${name}-${version}-${arch}/build/lib
776            reinplace "s|^LIBTOOL=.*$|LIBTOOL=\$\(GCC\) \$\(GCCFLAGS\)|" \
777                ${libdir}/Makefile
778            reinplace "s|dynamic|dynamiclib|g" ${libdir}/Makefile
779
780            # Same as above
781            if {${no_threads} == 1} {
782
783                system -W ${libdir} "${build.cmd} dylib"
784            } else {
785
786                system -W ${libdir} "${build.cmd} shared_all"
787            }
788        }
789    }
790}
791
792destroot.dir          ${build.dir}
793destroot.destdir      DESTDIR=${destroot}${prefix}
794
795post-destroot {
796    # On monoprocessor machines, make tatlas and satlas synonymous
797    if {${no_threads} == 1} {
798
799        set libdir ${destroot}${prefix}/lib
800        system -W ${libdir} "ln -s libsatlas.dylib libtatlas.dylib"
801    }
802}
803
804livecheck.name        math-atlas
805livecheck.distname    Stable
Note: See TracBrowser for help on using the repository browser.