1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
|
#!/System/Library/Frameworks/Ruby.framework/Versions/1.8/usr/bin/ruby -W0
# This script is called by formula_installer as a separate instance.
# Rationale: Formula can use __END__, Formula can change ENV
# Thrown exceptions are propogated back to the parent process over a pipe
STD_TRAP = trap("INT") { exit! 130 } # no backtrace thanks
at_exit do
# the whole of everything must be run in at_exit because the formula has to
# be the run script as __END__ must work for *that* formula.
main
end
require 'global'
require 'cxxstdlib'
require 'debrew' if ARGV.debug?
def main
# The main Homebrew process expects to eventually see EOF on the error
# pipe in FormulaInstaller#build. However, if any child process fails to
# terminate (i.e, fails to close the descriptor), this won't happen, and
# the installer will hang. Set close-on-exec to prevent this.
# Whether it is *wise* to launch daemons from formulae is a separate
# question altogether.
if ENV['HOMEBREW_ERROR_PIPE']
require 'fcntl'
error_pipe = IO.new(ENV['HOMEBREW_ERROR_PIPE'].to_i, 'w')
error_pipe.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
end
raise $! if $! # an exception was already thrown when parsing the formula
trap("INT", STD_TRAP) # restore default CTRL-C handler
require 'hardware'
require 'keg'
require 'extend/ENV'
# Force any future invocations of sudo to require the user's password to be
# re-entered. This is in-case any build script call sudo. Certainly this is
# can be inconvenient for the user. But we need to be safe.
system "/usr/bin/sudo", "-k"
Build.new(Formula.factory($0)).install
rescue Exception => e
unless error_pipe.nil?
e.continuation = nil if ARGV.debug?
Marshal.dump(e, error_pipe)
error_pipe.close
exit! 1
else
onoe e
puts e.backtrace
exit! 2
end
end
class Build
attr_reader :f, :deps, :reqs
def initialize(f)
@f = f
if ARGV.ignore_deps?
@deps = []
@reqs = []
else
@deps = expand_deps
@reqs = expand_reqs
end
end
def post_superenv_hacks
# Only allow Homebrew-approved directories into the PATH, unless
# a formula opts-in to allowing the user's path.
if f.env.userpaths? || reqs.any? { |rq| rq.env.userpaths? }
ENV.userpaths!
end
end
def pre_superenv_hacks
# Allow a formula to opt-in to the std environment.
ARGV.unshift '--env=std' if (f.env.std? or deps.any? { |d| d.name == 'scons' }) and
not ARGV.include? '--env=super'
end
def expand_reqs
f.recursive_requirements do |dependent, req|
if (req.optional? || req.recommended?) && dependent.build.without?(req)
Requirement.prune
elsif req.build? && dependent != f
Requirement.prune
elsif req.satisfied? && req.default_formula? && (dep = req.to_dependency).installed?
deps << dep
Requirement.prune
end
end
end
def expand_deps
f.recursive_dependencies do |dependent, dep|
if (dep.optional? || dep.recommended?) && dependent.build.without?(dep)
Dependency.prune
elsif dep.build? && dependent != f
Dependency.prune
elsif dep.build?
Dependency.keep_but_prune_recursive_deps
end
end
end
def install
keg_only_deps = deps.map(&:to_formula).select(&:keg_only?)
pre_superenv_hacks
ENV.activate_extensions!
deps.map(&:to_formula).each do |dep|
opt = HOMEBREW_PREFIX/:opt/dep
fixopt(dep) unless opt.directory?
end
if superenv?
ENV.keg_only_deps = keg_only_deps.map(&:name)
ENV.deps = deps.map { |d| d.to_formula.name }
ENV.x11 = reqs.any? { |rq| rq.kind_of?(X11Dependency) }
ENV.setup_build_environment(f)
post_superenv_hacks
reqs.each(&:modify_build_environment)
deps.each(&:modify_build_environment)
else
ENV.setup_build_environment(f)
reqs.each(&:modify_build_environment)
deps.each(&:modify_build_environment)
keg_only_deps.each do |dep|
opt = dep.opt_prefix
ENV.prepend_path 'PATH', "#{opt}/bin"
ENV.prepend_path 'PKG_CONFIG_PATH', "#{opt}/lib/pkgconfig"
ENV.prepend_path 'PKG_CONFIG_PATH', "#{opt}/share/pkgconfig"
ENV.prepend_path 'ACLOCAL_PATH', "#{opt}/share/aclocal"
ENV.prepend_path 'CMAKE_PREFIX_PATH', opt
ENV.prepend 'LDFLAGS', "-L#{opt}/lib" if (opt/:lib).directory?
ENV.prepend 'CPPFLAGS', "-I#{opt}/include" if (opt/:include).directory?
end
end
f.brew do
if ARGV.flag? '--git'
system "git init"
system "git add -A"
end
if ARGV.interactive?
ohai "Entering interactive mode"
puts "Type `exit' to return and finalize the installation"
puts "Install to this prefix: #{f.prefix}"
if ARGV.flag? '--git'
puts "This directory is now a git repo. Make your changes and then use:"
puts " git diff | pbcopy"
puts "to copy the diff to the clipboard."
end
interactive_shell f
else
f.prefix.mkpath
f.resources.each { |r| r.extend(ResourceDebugger) } if ARGV.debug?
begin
f.install
# This first test includes executables because we still
# want to record the stdlib for something that installs no
# dylibs.
stdlibs = Keg.new(f.prefix).detect_cxx_stdlibs
# This currently only tracks a single C++ stdlib per dep,
# though it's possible for different libs/executables in
# a given formula to link to different ones.
stdlib_in_use = CxxStdlib.new(stdlibs.first, ENV.compiler)
begin
stdlib_in_use.check_dependencies(f, deps)
rescue IncompatibleCxxStdlibs => e
opoo e.message
end
# This second check is recorded for checking dependencies,
# so executable are irrelevant at this point. If a piece
# of software installs an executable that links against libstdc++
# and dylibs against libc++, libc++-only dependencies can safely
# link against it.
stdlibs = Keg.new(f.prefix).detect_cxx_stdlibs :skip_executables => true
Tab.create(f, ENV.compiler, stdlibs.first,
Options.coerce(ARGV.options_only)).write
rescue Exception => e
if ARGV.debug?
debrew e, f
else
raise e
end
end
# Find and link metafiles
f.prefix.install_metafiles Pathname.pwd
end
end
end
end
def fixopt f
path = if f.linked_keg.directory? and f.linked_keg.symlink?
f.linked_keg.realpath
elsif f.prefix.directory?
f.prefix
elsif (kids = f.rack.children).size == 1 and kids.first.directory?
kids.first
else
raise
end
Keg.new(path).optlink
rescue StandardError
raise "#{f.opt_prefix} not present or broken\nPlease reinstall #{f}. Sorry :("
end
|
