source: trunk/dports/math/atlas/Portfile

Last change on this file was 144924, checked in by vince@…, 20 months ago

atlas: Correct $gcc_version when gfortran is chosen automatically (x.y > xy)

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