mirrors/brew
1
0
Fork 0
mirror of https://github.com/Homebrew/brew.git synced 2025-07-14 16:09:03 +08:00
Code Issues Packages Projects Releases Wiki Activity
brew/Library/Homebrew/extend/ENV/super.rb

298 lines
9.5 KiB
Ruby
Raw Normal View History

Rename MacOS to OS::Mac
2013-10-18 12:56:51 -05:00
require 'os/mac'
Move common ENV methods to a shared module
2013-08-19 12:32:59 -05:00
require 'extend/ENV/shared'
superenv: build-environments that just work 1. A minimal build environment, we don't set CFLAGS, CPPFLAGS, LDFLAGS, etc. the rationale being, the less that is set, the less variables we are introducing that can break builds. 2. A set of scripts that replace cc, ld, etc. and inject the -I, -L, etc. flags we need into the args passed to the build-tools. Because we now have complete control over compiler instantiations we do a variety of clean-up tasks, like removing bad flags, enforcing universal builds and ensuring makefiles don't try to change the order of library and include paths from ones that work to ones that don't. The previous ENV-system is still available when --env=std is specified. superenv applies to Xcode >= 4.3 only currently.
2012-08-11 12:30:51 -04:00
### Why `superenv`?
# 1) Only specify the environment we need (NO LDFLAGS for cmake)
# 2) Only apply compiler specific options when we are calling that compiler
# 3) Force all incpaths and libpaths into the cc instantiation (less bugs)
# 4) Cater toolchain usage to specific Xcode versions
# 5) Remove flags that we don't want or that will break builds
# 6) Simpler code
# 7) Simpler formula that *just work*
# 8) Build-system agnostic configuration of the tool-chain
Extend Superenv onto ENV instead of defining it on the singleton class
2013-08-19 12:32:55 -05:00
module Superenv
Move common ENV methods to a shared module
2013-08-19 12:32:59 -05:00
include SharedEnvExtension
Rename these collections for clarity
2013-03-09 16:56:32 -06:00
attr_accessor :keg_only_deps, :deps, :x11
superenv only adds X11 paths if required Since we are moving towards only depending on X11 for X-headers, superenv now doesn't automatically add X11 compilation. I was reluctant to do this, but it is the right thing to do now that X11 is not automatically installed by OS X or Xcode. I didn't implement ENV.x11 because the order that the X headers are inserted is important. It must be done at initial setup to ensure that brewed versions of e.g. freetype and Cairo are used and not the ones installed by XQuartz.
2012-08-29 11:19:39 -04:00
alias_method :x11?, :x11
superenv: build-environments that just work 1. A minimal build environment, we don't set CFLAGS, CPPFLAGS, LDFLAGS, etc. the rationale being, the less that is set, the less variables we are introducing that can break builds. 2. A set of scripts that replace cc, ld, etc. and inject the -I, -L, etc. flags we need into the args passed to the build-tools. Because we now have complete control over compiler instantiations we do a variety of clean-up tasks, like removing bad flags, enforcing universal builds and ensuring makefiles don't try to change the order of library and include paths from ones that work to ones that don't. The previous ENV-system is still available when --env=std is specified. superenv applies to Xcode >= 4.3 only currently.
2012-08-11 12:30:51 -04:00
Move setup into an extended callback
2013-08-19 12:32:56 -05:00
def self.extended(base)
base.keg_only_deps = []
base.deps = []
Re-enable superenv ENV[] hack
2013-08-19 12:32:58 -05:00
# Many formula assume that CFLAGS etc. will not be nil. This should be
# a safe hack to prevent that exception cropping up. Main consequence of
# this is that self['CFLAGS'] is never nil even when it is which can break
# if checks, but we don't do such a check in our code. Redefinition must be
# done on the singleton class, because in MRI all ENV methods are defined
# on its singleton class, precluding the use of extend.
class << base
def [] key
if has_key? key
fetch(key)
elsif %w{CPPFLAGS CFLAGS LDFLAGS}.include? key
Fix superenv ENV[] hack We override ENV[] to always return strings under superenv, because legacy formulae assume that CFLAGS, etc. are non-nil. However, the current implementation has a bug. If I simply concatenate ENV['CFLAGS'] with another string, it mutates ENV['CFLAGS']: irb> ENV['CFLAGS'] => "" irb> ENV['CFLAGS'] + 'a' => "a" irb> ENV['CFLAGS'] => "a" Instead, let's simply return an empty string if the key doesn't exist. This is sufficient because the following are equivalent: 1. ENV['CFLAGS'] += "string" 2. ENV['CFLAGS'] = ENV['CFLAGS'] + "string"
2013-08-19 12:32:58 -05:00
self[key] = ""
Re-enable superenv ENV[] hack
2013-08-19 12:32:58 -05:00
end
end
end
Move setup into an extended callback
2013-08-19 12:32:56 -05:00
end
Move superbin into Superenv module
2013-08-19 12:32:56 -05:00
def self.bin
@bin ||= (HOMEBREW_REPOSITORY/"Library/ENV").children.reject{|d| d.basename.to_s > MacOS::Xcode.version }.max
end
superenv: build-environments that just work 1. A minimal build environment, we don't set CFLAGS, CPPFLAGS, LDFLAGS, etc. the rationale being, the less that is set, the less variables we are introducing that can break builds. 2. A set of scripts that replace cc, ld, etc. and inject the -I, -L, etc. flags we need into the args passed to the build-tools. Because we now have complete control over compiler instantiations we do a variety of clean-up tasks, like removing bad flags, enforcing universal builds and ensuring makefiles don't try to change the order of library and include paths from ones that work to ones that don't. The previous ENV-system is still available when --env=std is specified. superenv applies to Xcode >= 4.3 only currently.
2012-08-11 12:30:51 -04:00
def reset
Python 2.x and 3.x support New `depends_on :python` Dependency. New `depends_on :python3` Dependency. To avoid having multiple formulae with endings -py2 and -py3, we will handle support for different pythons (2.x vs. 3.x) in the same formula. Further brewed vs. external python will be transparently supported. The formula also gets a new object `python`, which is false if no Python is available or the user has disabled it. Otherwise it is defined and provides several support methods: python.site_packages # the site-packages in the formula's Cellar python.global_site_packages python.binary # the full path to the python binary python.prefix python.version python.version.major python.version.minor python.xy # => e.g. "python2.7" python.incdir # includes of python python.libdir # the python dylib library python.pkg_config_path # used internally by brew python.from_osx? python.framework? python.universal? python.pypy? python.standard_caveats # Text to set PYTHONPATH for python.from_osx? python.if3then3 # => "" for 2.x and to "3" for 3.x. Further, to avoid code duplication, `python` takes an optional block that is run twice if the formula defines depends_on :python AND :python3. python do system python, 'setup.py', "--prefix=#{prefix}" end Read more in the Homebrew wiki.
2013-01-21 10:33:56 +01:00
%w{CC CXX OBJC OBJCXX CPP MAKE LD LDSHARED
superenv: build-environments that just work 1. A minimal build environment, we don't set CFLAGS, CPPFLAGS, LDFLAGS, etc. the rationale being, the less that is set, the less variables we are introducing that can break builds. 2. A set of scripts that replace cc, ld, etc. and inject the -I, -L, etc. flags we need into the args passed to the build-tools. Because we now have complete control over compiler instantiations we do a variety of clean-up tasks, like removing bad flags, enforcing universal builds and ensuring makefiles don't try to change the order of library and include paths from ones that work to ones that don't. The previous ENV-system is still available when --env=std is specified. superenv applies to Xcode >= 4.3 only currently.
2012-08-11 12:30:51 -04:00
CFLAGS CXXFLAGS OBJCFLAGS OBJCXXFLAGS LDFLAGS CPPFLAGS
MACOS_DEPLOYMENT_TARGET SDKROOT
ENV: clear influential include path vars
2013-03-16 13:50:44 -05:00
CMAKE_PREFIX_PATH CMAKE_INCLUDE_PATH CMAKE_FRAMEWORK_PATH
CPATH C_INCLUDE_PATH CPLUS_INCLUDE_PATH OBJC_INCLUDE_PATH}.
superenv: build-environments that just work 1. A minimal build environment, we don't set CFLAGS, CPPFLAGS, LDFLAGS, etc. the rationale being, the less that is set, the less variables we are introducing that can break builds. 2. A set of scripts that replace cc, ld, etc. and inject the -I, -L, etc. flags we need into the args passed to the build-tools. Because we now have complete control over compiler instantiations we do a variety of clean-up tasks, like removing bad flags, enforcing universal builds and ensuring makefiles don't try to change the order of library and include paths from ones that work to ones that don't. The previous ENV-system is still available when --env=std is specified. superenv applies to Xcode >= 4.3 only currently.
2012-08-11 12:30:51 -04:00
each{ |x| delete(x) }
delete('CDPATH') # avoid make issues that depend on changing directories
delete('GREP_OPTIONS') # can break CMake
delete('CLICOLOR_FORCE') # autotools doesn't like this
end
Move CompilerSelector logic into build env setup This moves the CompilerSelector fails_with logic into the build environment setup, making the compiler selection available before performing actions that depends on knowing what the compiler is, e.g. setting up PATH. ENV.setup_build_environment now optionally takes a Formula argument to provide the information necessary to do the fails_with, and the new ENV.validate_cc! extracts the fails_with logic from Build.install.
2013-09-10 23:08:17 -07:00
def setup_build_environment(formula=nil)
superenv: build-environments that just work 1. A minimal build environment, we don't set CFLAGS, CPPFLAGS, LDFLAGS, etc. the rationale being, the less that is set, the less variables we are introducing that can break builds. 2. A set of scripts that replace cc, ld, etc. and inject the -I, -L, etc. flags we need into the args passed to the build-tools. Because we now have complete control over compiler instantiations we do a variety of clean-up tasks, like removing bad flags, enforcing universal builds and ensuring makefiles don't try to change the order of library and include paths from ones that work to ones that don't. The previous ENV-system is still available when --env=std is specified. superenv applies to Xcode >= 4.3 only currently.
2012-08-11 12:30:51 -04:00
reset
Move CompilerSelector logic into build env setup This moves the CompilerSelector fails_with logic into the build environment setup, making the compiler selection available before performing actions that depends on knowing what the compiler is, e.g. setting up PATH. ENV.setup_build_environment now optionally takes a Formula argument to provide the information necessary to do the fails_with, and the new ENV.validate_cc! extracts the fails_with logic from Build.install.
2013-09-10 23:08:17 -07:00
ENV: add cc and cxx setters
2013-08-30 16:44:49 -05:00
self.cc = 'cc'
self.cxx = 'c++'
Move CompilerSelector logic into build env setup This moves the CompilerSelector fails_with logic into the build environment setup, making the compiler selection available before performing actions that depends on knowing what the compiler is, e.g. setting up PATH. ENV.setup_build_environment now optionally takes a Formula argument to provide the information necessary to do the fails_with, and the new ENV.validate_cc! extracts the fails_with logic from Build.install.
2013-09-10 23:08:17 -07:00
self['HOMEBREW_CC'] = determine_cc
validate_cc!(formula) unless formula.nil?
Reference self rather than ENV in Superenv module We want to be able to extend this module onto an arbitrary hash and use it without mutating ENV, for testing purposes.
2013-08-19 12:32:57 -05:00
self['DEVELOPER_DIR'] = determine_developer_dir
self['MAKEFLAGS'] ||= "-j#{determine_make_jobs}"
self['PATH'] = determine_path
self['PKG_CONFIG_PATH'] = determine_pkg_config_path
self['PKG_CONFIG_LIBDIR'] = determine_pkg_config_libdir
self['HOMEBREW_CCCFG'] = determine_cccfg
self['HOMEBREW_BREW_FILE'] = HOMEBREW_BREW_FILE
self['HOMEBREW_SDKROOT'] = "#{MacOS.sdk_path}" if MacOS::Xcode.without_clt?
self['HOMEBREW_DEVELOPER_DIR'] = determine_developer_dir # used by our xcrun shim
Move verbose ENV setup out of brew.rb
2013-10-19 10:41:09 -05:00
self['HOMEBREW_VERBOSE'] = "1" if ARGV.verbose?
Reference self rather than ENV in Superenv module We want to be able to extend this module onto an arbitrary hash and use it without mutating ENV, for testing purposes.
2013-08-19 12:32:57 -05:00
self['CMAKE_PREFIX_PATH'] = determine_cmake_prefix_path
self['CMAKE_FRAMEWORK_PATH'] = determine_cmake_frameworks_path
self['CMAKE_INCLUDE_PATH'] = determine_cmake_include_path
self['CMAKE_LIBRARY_PATH'] = determine_cmake_library_path
self['ACLOCAL_PATH'] = determine_aclocal_path
superenv: find Homebrew's gcc-4.2 If we're using a homebrewed gcc-4.2, xcrun may fail to find it (or, worse, find superenv's shim instead). Explicitly add it to the PATH and search all path elements for the requested tool. Also make sure to specify 'gcc-4.2' as the compiler name, not plain 'gcc'. That can resolve to llvm-gcc and to gcc-4.0 on various Xcodes.
2013-05-27 15:17:49 -05:00
Allow building bottles with custom architectures This allows overriding the "oldest CPU" behaviour - for instance, to build Intel bottles for a newer CPU than Core 2, to build a PPC bottle with or without Altivec on the same computer, etc.
2013-08-25 14:14:53 -07:00
# For custom bottles, need to specify the arch in the environment
# so that the compiler shims have access
if (arch = ARGV.bottle_arch)
self['HOMEBREW_ARCHFLAGS'] = Hardware::CPU.optimization_flags[arch]
end
Document superenv HOMEBREW_CCFG flags
2013-08-01 11:36:44 -07:00
# The HOMEBREW_CCCFG ENV variable is used by the ENV/cc tool to control
# compiler flag stripping. It consists of a string of characters which act
# as flags. Some of these flags are mutually exclusive.
#
# u - A universal build was requested
# 3 - A 32-bit build was requested
# b - Installing from a bottle
Allow building bottles with custom architectures This allows overriding the "oldest CPU" behaviour - for instance, to build Intel bottles for a newer CPU than Core 2, to build a PPC bottle with or without Altivec on the same computer, etc.
2013-08-25 14:14:53 -07:00
# c - Installing from a bottle with a custom architecture
Document superenv HOMEBREW_CCFG flags
2013-08-01 11:36:44 -07:00
# i - Installing from a bottle on Intel
# 6 - Installing from a bottle on 64-bit Intel
superenv: support PPC bottles Allows for building bottles on PPC both with and without Altivec. This is currently not active but will be enabled once superenv is stable on Leopard.
2013-08-25 14:29:55 -07:00
# p - Installing from a bottle on PPC
# A - Installing from a bottle on PPC with Altivec
superenv: document O CCCFG flag
2013-08-04 22:37:52 -07:00
# O - Enables argument refurbishing. Only active under the
# make/bsdmake wrappers currently.
Document superenv HOMEBREW_CCFG flags
2013-08-01 11:36:44 -07:00
#
# On 10.8 and newer, these flags will also be present:
# s - apply fix for sed's Unicode support
# a - apply fix for apr-1-config path
Move CompilerSelector logic into build env setup This moves the CompilerSelector fails_with logic into the build environment setup, making the compiler selection available before performing actions that depends on knowing what the compiler is, e.g. setting up PATH. ENV.setup_build_environment now optionally takes a Formula argument to provide the information necessary to do the fails_with, and the new ENV.validate_cc! extracts the fails_with logic from Build.install.
2013-09-10 23:08:17 -07:00
warn_about_non_apple_gcc($1) if ENV['HOMEBREW_CC'] =~ GNU_GCC_REGEXP
superenv: build-environments that just work 1. A minimal build environment, we don't set CFLAGS, CPPFLAGS, LDFLAGS, etc. the rationale being, the less that is set, the less variables we are introducing that can break builds. 2. A set of scripts that replace cc, ld, etc. and inject the -I, -L, etc. flags we need into the args passed to the build-tools. Because we now have complete control over compiler instantiations we do a variety of clean-up tasks, like removing bad flags, enforcing universal builds and ensuring makefiles don't try to change the order of library and include paths from ones that work to ones that don't. The previous ENV-system is still available when --env=std is specified. superenv applies to Xcode >= 4.3 only currently.
2012-08-11 12:30:51 -04:00
end
def universal_binary
Reference self rather than ENV in Superenv module We want to be able to extend this module onto an arbitrary hash and use it without mutating ENV, for testing purposes.
2013-08-19 12:32:57 -05:00
self['HOMEBREW_ARCHS'] = Hardware::CPU.universal_archs.join(',')
superenv: build-environments that just work 1. A minimal build environment, we don't set CFLAGS, CPPFLAGS, LDFLAGS, etc. the rationale being, the less that is set, the less variables we are introducing that can break builds. 2. A set of scripts that replace cc, ld, etc. and inject the -I, -L, etc. flags we need into the args passed to the build-tools. Because we now have complete control over compiler instantiations we do a variety of clean-up tasks, like removing bad flags, enforcing universal builds and ensuring makefiles don't try to change the order of library and include paths from ones that work to ones that don't. The previous ENV-system is still available when --env=std is specified. superenv applies to Xcode >= 4.3 only currently.
2012-08-11 12:30:51 -04:00
append 'HOMEBREW_CCCFG', "u", ''
end
Document superenv HOMEBREW_CCFG flags
2013-08-01 11:36:44 -07:00
# m32 on superenv does not add any CC flags. It prevents "-m32" from being erased.
superenv: Allow ENV.m32 (for 32bit builds) Superenv normally filters out "-m32" flag, preventing 32bit builds. Some software, however, still only work in 32bit mode. If ENV.m32 is called, superenv does not filter out the "-m32" flag. Also note, superenv, does not explicitly add the -m32 flag and expects the build system of the software to know when and where to provide this flag. Closes Homebrew/homebrew#16350. Signed-off-by: Adam Vandenberg <flangy@gmail.com>
2012-12-01 19:42:22 +01:00
def m32
append 'HOMEBREW_CCCFG', "3", ''
end
superenv: build-environments that just work 1. A minimal build environment, we don't set CFLAGS, CPPFLAGS, LDFLAGS, etc. the rationale being, the less that is set, the less variables we are introducing that can break builds. 2. A set of scripts that replace cc, ld, etc. and inject the -I, -L, etc. flags we need into the args passed to the build-tools. Because we now have complete control over compiler instantiations we do a variety of clean-up tasks, like removing bad flags, enforcing universal builds and ensuring makefiles don't try to change the order of library and include paths from ones that work to ones that don't. The previous ENV-system is still available when --env=std is specified. superenv applies to Xcode >= 4.3 only currently.
2012-08-11 12:30:51 -04:00
private
def determine_cc
Unify compiler selection logic This unifies the logic for selecting a compiler between superenv and stdenv. A variation of superenv's `determine_cc`, which now returns a symbol, has been moved into the shared ENV extension. Stdenv uses the result of this directly (as it's always used symbols), while superenv translates that back into a compiler string. This also has the effect of disabling HOMEBREW_USE_(gcc|llvm|clang) in stdenv, which have already been marked as deprecated for some time, and enables the HOMEBREW_CC= environment variable syntax from superenv in stdenv.
2013-08-24 14:03:16 -07:00
cc = compiler
COMPILER_SYMBOL_MAP.invert.fetch(cc, cc)
superenv: build-environments that just work 1. A minimal build environment, we don't set CFLAGS, CPPFLAGS, LDFLAGS, etc. the rationale being, the less that is set, the less variables we are introducing that can break builds. 2. A set of scripts that replace cc, ld, etc. and inject the -I, -L, etc. flags we need into the args passed to the build-tools. Because we now have complete control over compiler instantiations we do a variety of clean-up tasks, like removing bad flags, enforcing universal builds and ensuring makefiles don't try to change the order of library and include paths from ones that work to ones that don't. The previous ENV-system is still available when --env=std is specified. superenv applies to Xcode >= 4.3 only currently.
2012-08-11 12:30:51 -04:00
end
def determine_path
Move superbin into Superenv module
2013-08-19 12:32:56 -05:00
paths = [Superenv.bin]
Move MacOS.xcode43_without_clt? into Xcode module
2013-08-09 20:47:28 -05:00
if MacOS::Xcode.without_clt?
Better superenv support for Xcode elsewhere - The Library/ENV/4.3/xcrun shim now respects ENV['DEVELOPER_DIR'] instead assuming the location of /Applications/Xcode.app/Contents/Developer. - The env var DEVELOPER_DIR is set if it is not already. So, during superenv this var is always set and we no longer have to care about people with unset or wrongly set xcode-select stuff. This has been a major PITA in the past. - determine_developer_dir (which is used to set the DEVELOPER_DIR var) now uses MacOS::Xcode.prefix which is proven and very capable and uses splotlight correctly. - Replace (and remove) MacSystem.xcode43_developer_dir with Xcode.prefix Closes Homebrew/homebrew#18618
2013-03-20 18:20:18 +01:00
paths << "#{MacOS::Xcode.prefix}/usr/bin"
paths << "#{MacOS::Xcode.prefix}/Toolchains/XcodeDefault.xctoolchain/usr/bin"
superenv: build-environments that just work 1. A minimal build environment, we don't set CFLAGS, CPPFLAGS, LDFLAGS, etc. the rationale being, the less that is set, the less variables we are introducing that can break builds. 2. A set of scripts that replace cc, ld, etc. and inject the -I, -L, etc. flags we need into the args passed to the build-tools. Because we now have complete control over compiler instantiations we do a variety of clean-up tasks, like removing bad flags, enforcing universal builds and ensuring makefiles don't try to change the order of library and include paths from ones that work to ones that don't. The previous ENV-system is still available when --env=std is specified. superenv applies to Xcode >= 4.3 only currently.
2012-08-11 12:30:51 -04:00
end
Rename these collections for clarity
2013-03-09 16:56:32 -06:00
paths += deps.map{|dep| "#{HOMEBREW_PREFIX}/opt/#{dep}/bin" }
Use MacOS::X11 path helpers
2013-08-06 19:24:19 -05:00
paths << MacOS::X11.bin if x11?
superenv: build-environments that just work 1. A minimal build environment, we don't set CFLAGS, CPPFLAGS, LDFLAGS, etc. the rationale being, the less that is set, the less variables we are introducing that can break builds. 2. A set of scripts that replace cc, ld, etc. and inject the -I, -L, etc. flags we need into the args passed to the build-tools. Because we now have complete control over compiler instantiations we do a variety of clean-up tasks, like removing bad flags, enforcing universal builds and ensuring makefiles don't try to change the order of library and include paths from ones that work to ones that don't. The previous ENV-system is still available when --env=std is specified. superenv applies to Xcode >= 4.3 only currently.
2012-08-11 12:30:51 -04:00
paths += %w{/usr/bin /bin /usr/sbin /sbin}
Move CompilerSelector logic into build env setup This moves the CompilerSelector fails_with logic into the build environment setup, making the compiler selection available before performing actions that depends on knowing what the compiler is, e.g. setting up PATH. ENV.setup_build_environment now optionally takes a Formula argument to provide the information necessary to do the fails_with, and the new ENV.validate_cc! extracts the fails_with logic from Build.install.
2013-09-10 23:08:17 -07:00
# Homebrew's apple-gcc42 will be outside the PATH in superenv,
# so xcrun may not be able to find it
if self['HOMEBREW_CC'] == 'gcc-4.2'
apple_gcc42 = begin
Formulary.factory('apple-gcc42')
rescue Exception # in --debug, catch bare exceptions too
nil
end
paths << apple_gcc42.opt_prefix/'bin' if apple_gcc42
end
if self['HOMEBREW_CC'] =~ GNU_GCC_REGEXP
gcc_name = 'gcc' + $1.delete('.')
gcc = Formulary.factory(gcc_name)
paths << gcc.opt_prefix/'bin'
end
superenv: build-environments that just work 1. A minimal build environment, we don't set CFLAGS, CPPFLAGS, LDFLAGS, etc. the rationale being, the less that is set, the less variables we are introducing that can break builds. 2. A set of scripts that replace cc, ld, etc. and inject the -I, -L, etc. flags we need into the args passed to the build-tools. Because we now have complete control over compiler instantiations we do a variety of clean-up tasks, like removing bad flags, enforcing universal builds and ensuring makefiles don't try to change the order of library and include paths from ones that work to ones that don't. The previous ENV-system is still available when --env=std is specified. superenv applies to Xcode >= 4.3 only currently.
2012-08-11 12:30:51 -04:00
paths.to_path_s
end
def determine_pkg_config_path
Rename these collections for clarity
2013-03-09 16:56:32 -06:00
paths = deps.map{|dep| "#{HOMEBREW_PREFIX}/opt/#{dep}/lib/pkgconfig" }
paths += deps.map{|dep| "#{HOMEBREW_PREFIX}/opt/#{dep}/share/pkgconfig" }
Exclude global pkgconfig dirs under superenv
2013-03-08 18:14:00 -06:00
paths.to_path_s
end
def determine_pkg_config_libdir
paths = %W{/usr/lib/pkgconfig #{HOMEBREW_REPOSITORY}/Library/ENV/pkgconfig/#{MacOS.version}}
Use MacOS::X11 path helpers
2013-08-06 19:24:19 -05:00
paths << "#{MacOS::X11.lib}/pkgconfig" << "#{MacOS::X11.share}/pkgconfig" if x11?
superenv: build-environments that just work 1. A minimal build environment, we don't set CFLAGS, CPPFLAGS, LDFLAGS, etc. the rationale being, the less that is set, the less variables we are introducing that can break builds. 2. A set of scripts that replace cc, ld, etc. and inject the -I, -L, etc. flags we need into the args passed to the build-tools. Because we now have complete control over compiler instantiations we do a variety of clean-up tasks, like removing bad flags, enforcing universal builds and ensuring makefiles don't try to change the order of library and include paths from ones that work to ones that don't. The previous ENV-system is still available when --env=std is specified. superenv applies to Xcode >= 4.3 only currently.
2012-08-11 12:30:51 -04:00
paths.to_path_s
end
def determine_cmake_prefix_path
Rename these collections for clarity
2013-03-09 16:56:32 -06:00
paths = keg_only_deps.map{|dep| "#{HOMEBREW_PREFIX}/opt/#{dep}" }
Put X11 last in the libpath and cpath It was after HOMEBREW_PREFIX but not after everything else too.
2012-09-03 14:17:40 -04:00
paths << HOMEBREW_PREFIX.to_s # put ourselves ahead of everything else
Move MacOS.xcode43_without_clt? into Xcode module
2013-08-09 20:47:28 -05:00
paths << "#{MacOS.sdk_path}/usr" if MacOS::Xcode.without_clt?
superenv: build-environments that just work 1. A minimal build environment, we don't set CFLAGS, CPPFLAGS, LDFLAGS, etc. the rationale being, the less that is set, the less variables we are introducing that can break builds. 2. A set of scripts that replace cc, ld, etc. and inject the -I, -L, etc. flags we need into the args passed to the build-tools. Because we now have complete control over compiler instantiations we do a variety of clean-up tasks, like removing bad flags, enforcing universal builds and ensuring makefiles don't try to change the order of library and include paths from ones that work to ones that don't. The previous ENV-system is still available when --env=std is specified. superenv applies to Xcode >= 4.3 only currently.
2012-08-11 12:30:51 -04:00
paths.to_path_s
end
Python 2.x and 3.x support New `depends_on :python` Dependency. New `depends_on :python3` Dependency. To avoid having multiple formulae with endings -py2 and -py3, we will handle support for different pythons (2.x vs. 3.x) in the same formula. Further brewed vs. external python will be transparently supported. The formula also gets a new object `python`, which is false if no Python is available or the user has disabled it. Otherwise it is defined and provides several support methods: python.site_packages # the site-packages in the formula's Cellar python.global_site_packages python.binary # the full path to the python binary python.prefix python.version python.version.major python.version.minor python.xy # => e.g. "python2.7" python.incdir # includes of python python.libdir # the python dylib library python.pkg_config_path # used internally by brew python.from_osx? python.framework? python.universal? python.pypy? python.standard_caveats # Text to set PYTHONPATH for python.from_osx? python.if3then3 # => "" for 2.x and to "3" for 3.x. Further, to avoid code duplication, `python` takes an optional block that is run twice if the formula defines depends_on :python AND :python3. python do system python, 'setup.py', "--prefix=#{prefix}" end Read more in the Homebrew wiki.
2013-01-21 10:33:56 +01:00
def determine_cmake_frameworks_path
# XXX: keg_only_deps perhaps? but Qt does not link its Frameworks because of Ruby's Find.find ignoring symlinks!!
paths = deps.map{|dep| "#{HOMEBREW_PREFIX}/opt/#{dep}/Frameworks" }
Move MacOS.xcode43_without_clt? into Xcode module
2013-08-09 20:47:28 -05:00
paths << "#{MacOS.sdk_path}/System/Library/Frameworks" if MacOS::Xcode.without_clt?
Python 2.x and 3.x support New `depends_on :python` Dependency. New `depends_on :python3` Dependency. To avoid having multiple formulae with endings -py2 and -py3, we will handle support for different pythons (2.x vs. 3.x) in the same formula. Further brewed vs. external python will be transparently supported. The formula also gets a new object `python`, which is false if no Python is available or the user has disabled it. Otherwise it is defined and provides several support methods: python.site_packages # the site-packages in the formula's Cellar python.global_site_packages python.binary # the full path to the python binary python.prefix python.version python.version.major python.version.minor python.xy # => e.g. "python2.7" python.incdir # includes of python python.libdir # the python dylib library python.pkg_config_path # used internally by brew python.from_osx? python.framework? python.universal? python.pypy? python.standard_caveats # Text to set PYTHONPATH for python.from_osx? python.if3then3 # => "" for 2.x and to "3" for 3.x. Further, to avoid code duplication, `python` takes an optional block that is run twice if the formula defines depends_on :python AND :python3. python do system python, 'setup.py', "--prefix=#{prefix}" end Read more in the Homebrew wiki.
2013-01-21 10:33:56 +01:00
paths.to_path_s
end
superenv: build-environments that just work 1. A minimal build environment, we don't set CFLAGS, CPPFLAGS, LDFLAGS, etc. the rationale being, the less that is set, the less variables we are introducing that can break builds. 2. A set of scripts that replace cc, ld, etc. and inject the -I, -L, etc. flags we need into the args passed to the build-tools. Because we now have complete control over compiler instantiations we do a variety of clean-up tasks, like removing bad flags, enforcing universal builds and ensuring makefiles don't try to change the order of library and include paths from ones that work to ones that don't. The previous ENV-system is still available when --env=std is specified. superenv applies to Xcode >= 4.3 only currently.
2012-08-11 12:30:51 -04:00
def determine_cmake_include_path
Move MacOS.xcode43_without_clt? into Xcode module
2013-08-09 20:47:28 -05:00
sdk = MacOS.sdk_path if MacOS::Xcode.without_clt?
superenv only adds X11 paths if required Since we are moving towards only depending on X11 for X-headers, superenv now doesn't automatically add X11 compilation. I was reluctant to do this, but it is the right thing to do now that X11 is not automatically installed by OS X or Xcode. I didn't implement ENV.x11 because the order that the X headers are inserted is important. It must be done at initial setup to ensure that brewed versions of e.g. freetype and Cairo are used and not the ones installed by XQuartz.
2012-08-29 11:19:39 -04:00
paths = []
Use MacOS::X11 path helpers
2013-08-06 19:24:19 -05:00
paths << "#{MacOS::X11.include}/freetype2" if x11?
superenv: build-environments that just work 1. A minimal build environment, we don't set CFLAGS, CPPFLAGS, LDFLAGS, etc. the rationale being, the less that is set, the less variables we are introducing that can break builds. 2. A set of scripts that replace cc, ld, etc. and inject the -I, -L, etc. flags we need into the args passed to the build-tools. Because we now have complete control over compiler instantiations we do a variety of clean-up tasks, like removing bad flags, enforcing universal builds and ensuring makefiles don't try to change the order of library and include paths from ones that work to ones that don't. The previous ENV-system is still available when --env=std is specified. superenv applies to Xcode >= 4.3 only currently.
2012-08-11 12:30:51 -04:00
paths << "#{sdk}/usr/include/libxml2" unless deps.include? 'libxml2'
Move MacOS.xcode43_without_clt? into Xcode module
2013-08-09 20:47:28 -05:00
paths << "#{sdk}/usr/include/apache2" if MacOS::Xcode.without_clt?
ENV: remove trailing slash from OpenGL header path
2013-09-06 12:38:42 -05:00
paths << "#{sdk}/System/Library/Frameworks/OpenGL.framework/Versions/Current/Headers" unless x11?
Use MacOS::X11 path helpers
2013-08-06 19:24:19 -05:00
paths << MacOS::X11.include if x11?
superenv: build-environments that just work 1. A minimal build environment, we don't set CFLAGS, CPPFLAGS, LDFLAGS, etc. the rationale being, the less that is set, the less variables we are introducing that can break builds. 2. A set of scripts that replace cc, ld, etc. and inject the -I, -L, etc. flags we need into the args passed to the build-tools. Because we now have complete control over compiler instantiations we do a variety of clean-up tasks, like removing bad flags, enforcing universal builds and ensuring makefiles don't try to change the order of library and include paths from ones that work to ones that don't. The previous ENV-system is still available when --env=std is specified. superenv applies to Xcode >= 4.3 only currently.
2012-08-11 12:30:51 -04:00
paths.to_path_s
end
Cram GL headers and includes into superenv Fixes Homebrew/homebrew#14554. We justify doing this because pre 10.8 X11 came with GL for all Homebrew-capable systems and as such is a default that we'd prefer not to have to address.
2012-08-31 14:12:03 -04:00
def determine_cmake_library_path
Move MacOS.xcode43_without_clt? into Xcode module
2013-08-09 20:47:28 -05:00
sdk = MacOS.sdk_path if MacOS::Xcode.without_clt?
Put X11 last in the libpath and cpath It was after HOMEBREW_PREFIX but not after everything else too.
2012-09-03 14:17:40 -04:00
paths = []
Cram GL headers and includes into superenv Fixes Homebrew/homebrew#14554. We justify doing this because pre 10.8 X11 came with GL for all Homebrew-capable systems and as such is a default that we'd prefer not to have to address.
2012-08-31 14:12:03 -04:00
# things expect to find GL headers since X11 used to be a default, so we add them
Don't add GL paths to superenv if depends_on X Fixes Homebrew/homebrew#14780.
2012-09-13 12:10:01 -04:00
paths << "#{sdk}/System/Library/Frameworks/OpenGL.framework/Versions/Current/Libraries" unless x11?
Use MacOS::X11 path helpers
2013-08-06 19:24:19 -05:00
paths << MacOS::X11.lib if x11?
Put X11 last in the libpath and cpath It was after HOMEBREW_PREFIX but not after everything else too.
2012-09-03 14:17:40 -04:00
paths.to_path_s
Cram GL headers and includes into superenv Fixes Homebrew/homebrew#14554. We justify doing this because pre 10.8 X11 came with GL for all Homebrew-capable systems and as such is a default that we'd prefer not to have to address.
2012-08-31 14:12:03 -04:00
end
superenv: build-environments that just work 1. A minimal build environment, we don't set CFLAGS, CPPFLAGS, LDFLAGS, etc. the rationale being, the less that is set, the less variables we are introducing that can break builds. 2. A set of scripts that replace cc, ld, etc. and inject the -I, -L, etc. flags we need into the args passed to the build-tools. Because we now have complete control over compiler instantiations we do a variety of clean-up tasks, like removing bad flags, enforcing universal builds and ensuring makefiles don't try to change the order of library and include paths from ones that work to ones that don't. The previous ENV-system is still available when --env=std is specified. superenv applies to Xcode >= 4.3 only currently.
2012-08-11 12:30:51 -04:00
def determine_aclocal_path
Rename these collections for clarity
2013-03-09 16:56:32 -06:00
paths = keg_only_deps.map{|dep| "#{HOMEBREW_PREFIX}/opt/#{dep}/share/aclocal" }
superenv: build-environments that just work 1. A minimal build environment, we don't set CFLAGS, CPPFLAGS, LDFLAGS, etc. the rationale being, the less that is set, the less variables we are introducing that can break builds. 2. A set of scripts that replace cc, ld, etc. and inject the -I, -L, etc. flags we need into the args passed to the build-tools. Because we now have complete control over compiler instantiations we do a variety of clean-up tasks, like removing bad flags, enforcing universal builds and ensuring makefiles don't try to change the order of library and include paths from ones that work to ones that don't. The previous ENV-system is still available when --env=std is specified. superenv applies to Xcode >= 4.3 only currently.
2012-08-11 12:30:51 -04:00
paths << "#{HOMEBREW_PREFIX}/share/aclocal"
superenv: fix hardcoded X11 aclocal path
2013-10-04 21:06:19 -05:00
paths << "#{MacOS::X11.share}/aclocal" if x11?
superenv: build-environments that just work 1. A minimal build environment, we don't set CFLAGS, CPPFLAGS, LDFLAGS, etc. the rationale being, the less that is set, the less variables we are introducing that can break builds. 2. A set of scripts that replace cc, ld, etc. and inject the -I, -L, etc. flags we need into the args passed to the build-tools. Because we now have complete control over compiler instantiations we do a variety of clean-up tasks, like removing bad flags, enforcing universal builds and ensuring makefiles don't try to change the order of library and include paths from ones that work to ones that don't. The previous ENV-system is still available when --env=std is specified. superenv applies to Xcode >= 4.3 only currently.
2012-08-11 12:30:51 -04:00
paths.to_path_s
end
Support HOMEBREW_MAKE_JOBS
2012-08-23 16:15:26 -04:00
def determine_make_jobs
Reference self rather than ENV in Superenv module We want to be able to extend this module onto an arbitrary hash and use it without mutating ENV, for testing purposes.
2013-08-19 12:32:57 -05:00
if (j = self['HOMEBREW_MAKE_JOBS'].to_i) < 1
Use Hardware::CPU module
2013-06-13 12:04:58 -05:00
Hardware::CPU.cores
Support HOMEBREW_MAKE_JOBS
2012-08-23 16:15:26 -04:00
else
j
end
end
Superenv wrapper for sed Fixes Mountain Lion specific sed issue. Provided scripts don't use the full-path to see we are fine. They never do though, that would assume too much.
2012-08-27 08:48:02 -04:00
def determine_cccfg
s = ""
Fix --build-bottle CFLAGS. The CFLAGS were previously not generic enough. References Homebrew/homebrew#18944. References Homebrew/homebrew#19179.
2013-05-11 12:18:25 +01:00
if ARGV.build_bottle?
Allow building bottles with custom architectures This allows overriding the "oldest CPU" behaviour - for instance, to build Intel bottles for a newer CPU than Core 2, to build a PPC bottle with or without Altivec on the same computer, etc.
2013-08-25 14:14:53 -07:00
s << if ARGV.bottle_arch
'bc'
elsif Hardware::CPU.type == :intel
Fix --build-bottle CFLAGS. The CFLAGS were previously not generic enough. References Homebrew/homebrew#18944. References Homebrew/homebrew#19179.
2013-05-11 12:18:25 +01:00
if Hardware::CPU.is_64_bit?
'bi6'
else
'bi'
end
superenv: support PPC bottles Allows for building bottles on PPC both with and without Altivec. This is currently not active but will be enabled once superenv is stable on Leopard.
2013-08-25 14:29:55 -07:00
elsif Hardware::CPU.type == :ppc
if Hardware::CPU.altivec?
'bpA'
else
'bp'
end
Fix --build-bottle CFLAGS. The CFLAGS were previously not generic enough. References Homebrew/homebrew#18944. References Homebrew/homebrew#19179.
2013-05-11 12:18:25 +01:00
else
'b'
end
end
Superenv wrapper for sed Fixes Mountain Lion specific sed issue. Provided scripts don't use the full-path to see we are fine. They never do though, that would assume too much.
2012-08-27 08:48:02 -04:00
# Fix issue with sed barfing on unicode characters on Mountain Lion
Clean up MacOS version method usage The MacOS.version? family of methods (other than "leopard?") are poorly defined and lead to confusing code. Replace them in formulae with more explicit comparisons. "MacOS.version" is a special version object that can be compared to numerics, symbols, and strings using the standard Ruby comparison methods. The old methods were moved to compat when the version comparison code was merged, and they must remain there "forever", but they should not be used in new code. Signed-off-by: Jack Nagel <jacknagel@gmail.com>
2012-09-04 23:04:01 -05:00
s << 's' if MacOS.version >= :mountain_lion
superenv: apply apr-1-config fix to 10.8+ Fixes Homebrew/homebrew#20417. Closes Homebrew/homebrew#20474. Signed-off-by: Jack Nagel <jacknagel@gmail.com>
2013-06-13 17:19:27 +02:00
# Fix issue with >= 10.8 apr-1-config having broken paths
s << 'a' if MacOS.version >= :mountain_lion
Superenv wrapper for sed Fixes Mountain Lion specific sed issue. Provided scripts don't use the full-path to see we are fine. They never do though, that would assume too much.
2012-08-27 08:48:02 -04:00
s
end
Set DEVELOPER_DIR; Fixes bad xcode-select path In cases where the xcode-select -print-path is '/' xcrun still hangs indefinitely, setting DEVELOPER_DIR to something (preferably the Xcode path) fixes that. So let's.
2012-09-23 20:57:41 -04:00
def determine_developer_dir
# If Xcode path is fucked then this is basically a fix. In the case where
# nothing is valid, it still fixes most usage to supply a valid path that
# is not "/".
Reference self rather than ENV in Superenv module We want to be able to extend this module onto an arbitrary hash and use it without mutating ENV, for testing purposes.
2013-08-19 12:32:57 -05:00
MacOS::Xcode.prefix || self['DEVELOPER_DIR']
Set DEVELOPER_DIR; Fixes bad xcode-select path In cases where the xcode-select -print-path is '/' xcrun still hangs indefinitely, setting DEVELOPER_DIR to something (preferably the Xcode path) fixes that. So let's.
2012-09-23 20:57:41 -04:00
end
superenv: build-environments that just work 1. A minimal build environment, we don't set CFLAGS, CPPFLAGS, LDFLAGS, etc. the rationale being, the less that is set, the less variables we are introducing that can break builds. 2. A set of scripts that replace cc, ld, etc. and inject the -I, -L, etc. flags we need into the args passed to the build-tools. Because we now have complete control over compiler instantiations we do a variety of clean-up tasks, like removing bad flags, enforcing universal builds and ensuring makefiles don't try to change the order of library and include paths from ones that work to ones that don't. The previous ENV-system is still available when --env=std is specified. superenv applies to Xcode >= 4.3 only currently.
2012-08-11 12:30:51 -04:00
public
### NO LONGER NECESSARY OR NO LONGER SUPPORTED
def noop(*args); end
superenv: Allow ENV.m32 (for 32bit builds) Superenv normally filters out "-m32" flag, preventing 32bit builds. Some software, however, still only work in 32bit mode. If ENV.m32 is called, superenv does not filter out the "-m32" flag. Also note, superenv, does not explicitly add the -m32 flag and expects the build system of the software to know when and where to provide this flag. Closes Homebrew/homebrew#16350. Signed-off-by: Adam Vandenberg <flangy@gmail.com>
2012-12-01 19:42:22 +01:00
%w[m64 gcc_4_0_1 fast O4 O3 O2 Os Og O1 libxml2 minimal_optimization
Use fortran from std-env in superenv Fixes Homebrew/homebrew#14524.
2012-08-29 14:36:30 -04:00
no_optimization enable_warnings x11
set_cpu_flags
superenv: build-environments that just work 1. A minimal build environment, we don't set CFLAGS, CPPFLAGS, LDFLAGS, etc. the rationale being, the less that is set, the less variables we are introducing that can break builds. 2. A set of scripts that replace cc, ld, etc. and inject the -I, -L, etc. flags we need into the args passed to the build-tools. Because we now have complete control over compiler instantiations we do a variety of clean-up tasks, like removing bad flags, enforcing universal builds and ensuring makefiles don't try to change the order of library and include paths from ones that work to ones that don't. The previous ENV-system is still available when --env=std is specified. superenv applies to Xcode >= 4.3 only currently.
2012-08-11 12:30:51 -04:00
macosxsdk remove_macosxsdk].each{|s| alias_method s, :noop }
### DEPRECATE THESE
def deparallelize
delete('MAKEFLAGS')
end
alias_method :j1, :deparallelize
def gcc
superenv: don't set CC in ENV.clang/etc. These methods were overriding CC and causing superenv to potentially skip the compiler wrapper - especially if no wrapper existed for the compiler being used, e.g. GNU GCCs. Closes Homebrew/homebrew#22443. Fixes Homebrew/homebrew#22249. Fixes Homebrew/homebrew#22424. Fixes Homebrew/homebrew#22506. Fixes Homebrew/homebrew#22521. Fixes Homebrew/versions#207.
2013-09-10 23:09:20 -07:00
self['HOMEBREW_CC'] = "gcc-4.2"
ENV: Ensure @compiler is set If @compiler isn't set/checked by ENV.compiler and the ENV.clang/etc. methods, ENV.compiler may return unexpected results after fails_with picks a fallback compiler. See Homebrew/homebrew#22674.
2013-09-19 23:35:53 -07:00
@compiler = :gcc
superenv: build-environments that just work 1. A minimal build environment, we don't set CFLAGS, CPPFLAGS, LDFLAGS, etc. the rationale being, the less that is set, the less variables we are introducing that can break builds. 2. A set of scripts that replace cc, ld, etc. and inject the -I, -L, etc. flags we need into the args passed to the build-tools. Because we now have complete control over compiler instantiations we do a variety of clean-up tasks, like removing bad flags, enforcing universal builds and ensuring makefiles don't try to change the order of library and include paths from ones that work to ones that don't. The previous ENV-system is still available when --env=std is specified. superenv applies to Xcode >= 4.3 only currently.
2012-08-11 12:30:51 -04:00
end
superenv: add gcc-4.0 to superenv
2013-10-13 19:00:18 -07:00
def gcc_4_0
self['HOMEBREW_CC'] = "gcc-4.0"
@compiler = :gcc_4_0
end
superenv: build-environments that just work 1. A minimal build environment, we don't set CFLAGS, CPPFLAGS, LDFLAGS, etc. the rationale being, the less that is set, the less variables we are introducing that can break builds. 2. A set of scripts that replace cc, ld, etc. and inject the -I, -L, etc. flags we need into the args passed to the build-tools. Because we now have complete control over compiler instantiations we do a variety of clean-up tasks, like removing bad flags, enforcing universal builds and ensuring makefiles don't try to change the order of library and include paths from ones that work to ones that don't. The previous ENV-system is still available when --env=std is specified. superenv applies to Xcode >= 4.3 only currently.
2012-08-11 12:30:51 -04:00
def llvm
superenv: don't set CC in ENV.clang/etc. These methods were overriding CC and causing superenv to potentially skip the compiler wrapper - especially if no wrapper existed for the compiler being used, e.g. GNU GCCs. Closes Homebrew/homebrew#22443. Fixes Homebrew/homebrew#22249. Fixes Homebrew/homebrew#22424. Fixes Homebrew/homebrew#22506. Fixes Homebrew/homebrew#22521. Fixes Homebrew/versions#207.
2013-09-10 23:09:20 -07:00
self['HOMEBREW_CC'] = "llvm-gcc"
ENV: Ensure @compiler is set If @compiler isn't set/checked by ENV.compiler and the ENV.clang/etc. methods, ENV.compiler may return unexpected results after fails_with picks a fallback compiler. See Homebrew/homebrew#22674.
2013-09-19 23:35:53 -07:00
@compiler = :llvm
superenv: build-environments that just work 1. A minimal build environment, we don't set CFLAGS, CPPFLAGS, LDFLAGS, etc. the rationale being, the less that is set, the less variables we are introducing that can break builds. 2. A set of scripts that replace cc, ld, etc. and inject the -I, -L, etc. flags we need into the args passed to the build-tools. Because we now have complete control over compiler instantiations we do a variety of clean-up tasks, like removing bad flags, enforcing universal builds and ensuring makefiles don't try to change the order of library and include paths from ones that work to ones that don't. The previous ENV-system is still available when --env=std is specified. superenv applies to Xcode >= 4.3 only currently.
2012-08-11 12:30:51 -04:00
end
def clang
superenv: don't set CC in ENV.clang/etc. These methods were overriding CC and causing superenv to potentially skip the compiler wrapper - especially if no wrapper existed for the compiler being used, e.g. GNU GCCs. Closes Homebrew/homebrew#22443. Fixes Homebrew/homebrew#22249. Fixes Homebrew/homebrew#22424. Fixes Homebrew/homebrew#22506. Fixes Homebrew/homebrew#22521. Fixes Homebrew/versions#207.
2013-09-10 23:09:20 -07:00
self['HOMEBREW_CC'] = "clang"
ENV: Ensure @compiler is set If @compiler isn't set/checked by ENV.compiler and the ENV.clang/etc. methods, ENV.compiler may return unexpected results after fails_with picks a fallback compiler. See Homebrew/homebrew#22674.
2013-09-19 23:35:53 -07:00
@compiler = :clang
superenv: build-environments that just work 1. A minimal build environment, we don't set CFLAGS, CPPFLAGS, LDFLAGS, etc. the rationale being, the less that is set, the less variables we are introducing that can break builds. 2. A set of scripts that replace cc, ld, etc. and inject the -I, -L, etc. flags we need into the args passed to the build-tools. Because we now have complete control over compiler instantiations we do a variety of clean-up tasks, like removing bad flags, enforcing universal builds and ensuring makefiles don't try to change the order of library and include paths from ones that work to ones that don't. The previous ENV-system is still available when --env=std is specified. superenv applies to Xcode >= 4.3 only currently.
2012-08-11 12:30:51 -04:00
end
Implement fails_with for non-Apple compilers This adds support for non-Apple GCC compilers in the fails_with code. A fails_with block for a non-Apple compiler looks like: fails_with :gcc => '4.8.1' do cause 'Foo' end Non-Apple compilers don't have build numbers, so compiler failures are based on version strings instead. Internally non-Apple compilers can be distinguished because they are passed around as strings instead of symbols. In addition, this alters the priority list for compilers, with the following changes: * Apple GCC 4.2 and LLVM-GCC swap positions, with GCC now taking priority. (Maybe LLVM-GCC should just go away.) * Non-Apple GCC compilers are ranked below GCC 4.2 but above LLVM-GCC and Apple GCC 4.0.
2013-06-28 01:38:09 -05:00
GNU_GCC_VERSIONS.each do |n|
define_method(:"gcc-4.#{n}") do
ENV: Ensure @compiler is set If @compiler isn't set/checked by ENV.compiler and the ENV.clang/etc. methods, ENV.compiler may return unexpected results after fails_with picks a fallback compiler. See Homebrew/homebrew#22674.
2013-09-19 23:35:53 -07:00
@compiler = self['HOMEBREW_CC'] = "gcc-4.#{n}"
Implement fails_with for non-Apple compilers This adds support for non-Apple GCC compilers in the fails_with code. A fails_with block for a non-Apple compiler looks like: fails_with :gcc => '4.8.1' do cause 'Foo' end Non-Apple compilers don't have build numbers, so compiler failures are based on version strings instead. Internally non-Apple compilers can be distinguished because they are passed around as strings instead of symbols. In addition, this alters the priority list for compilers, with the following changes: * Apple GCC 4.2 and LLVM-GCC swap positions, with GCC now taking priority. (Maybe LLVM-GCC should just go away.) * Non-Apple GCC compilers are ranked below GCC 4.2 but above LLVM-GCC and Apple GCC 4.0.
2013-06-28 01:38:09 -05:00
end
end
superenv: build-environments that just work 1. A minimal build environment, we don't set CFLAGS, CPPFLAGS, LDFLAGS, etc. the rationale being, the less that is set, the less variables we are introducing that can break builds. 2. A set of scripts that replace cc, ld, etc. and inject the -I, -L, etc. flags we need into the args passed to the build-tools. Because we now have complete control over compiler instantiations we do a variety of clean-up tasks, like removing bad flags, enforcing universal builds and ensuring makefiles don't try to change the order of library and include paths from ones that work to ones that don't. The previous ENV-system is still available when --env=std is specified. superenv applies to Xcode >= 4.3 only currently.
2012-08-11 12:30:51 -04:00
def make_jobs
Reference self rather than ENV in Superenv module We want to be able to extend this module onto an arbitrary hash and use it without mutating ENV, for testing purposes.
2013-08-19 12:32:57 -05:00
self['MAKEFLAGS'] =~ /-\w*j(\d)+/
superenv: build-environments that just work 1. A minimal build environment, we don't set CFLAGS, CPPFLAGS, LDFLAGS, etc. the rationale being, the less that is set, the less variables we are introducing that can break builds. 2. A set of scripts that replace cc, ld, etc. and inject the -I, -L, etc. flags we need into the args passed to the build-tools. Because we now have complete control over compiler instantiations we do a variety of clean-up tasks, like removing bad flags, enforcing universal builds and ensuring makefiles don't try to change the order of library and include paths from ones that work to ones that don't. The previous ENV-system is still available when --env=std is specified. superenv applies to Xcode >= 4.3 only currently.
2012-08-11 12:30:51 -04:00
[$1.to_i, 1].max
end
Extend Superenv onto ENV instead of defining it on the singleton class
2013-08-19 12:32:55 -05:00
end
superenv: build-environments that just work 1. A minimal build environment, we don't set CFLAGS, CPPFLAGS, LDFLAGS, etc. the rationale being, the less that is set, the less variables we are introducing that can break builds. 2. A set of scripts that replace cc, ld, etc. and inject the -I, -L, etc. flags we need into the args passed to the build-tools. Because we now have complete control over compiler instantiations we do a variety of clean-up tasks, like removing bad flags, enforcing universal builds and ensuring makefiles don't try to change the order of library and include paths from ones that work to ones that don't. The previous ENV-system is still available when --env=std is specified. superenv applies to Xcode >= 4.3 only currently.
2012-08-11 12:30:51 -04:00
class Array
def to_path_s
Use File::PATH_SEPARATOR globally instead of ':' On Unix, the path separator is ':', whereas on Windows, it is ';'. This is the first of a series of patch to bring macbrew's and winbrew's codebases closer together. The main places the magic constant ':' was being used were: - the $PATH environment variable - CMAKE-related environment variables - pkg-config related environment variables Closes Homebrew/homebrew#21921. Signed-off-by: Jack Nagel <jacknagel@gmail.com>
2013-08-15 21:50:13 +02:00
map(&:to_s).uniq.select{|s| File.directory? s }.join(File::PATH_SEPARATOR).chuzzle
superenv: build-environments that just work 1. A minimal build environment, we don't set CFLAGS, CPPFLAGS, LDFLAGS, etc. the rationale being, the less that is set, the less variables we are introducing that can break builds. 2. A set of scripts that replace cc, ld, etc. and inject the -I, -L, etc. flags we need into the args passed to the build-tools. Because we now have complete control over compiler instantiations we do a variety of clean-up tasks, like removing bad flags, enforcing universal builds and ensuring makefiles don't try to change the order of library and include paths from ones that work to ones that don't. The previous ENV-system is still available when --env=std is specified. superenv applies to Xcode >= 4.3 only currently.
2012-08-11 12:30:51 -04:00
end
end
Reference in New Issue Copy Permalink