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

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

Fix AVX processor detection for versions of MacOS < 10.7

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