Apply patch from Richard Purdie to fix the --force support in the bitbake script.
[bitbake.git] / bin / bitbake
1 #!/usr/bin/env python
2 # ex:ts=4:sw=4:sts=4:et
3 # -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*-
4 #
5 # Copyright (C) 2003, 2004  Chris Larson
6 # Copyright (C) 2003, 2004  Phil Blundell
7 #
8 # This program is free software; you can redistribute it and/or modify it under
9 # the terms of the GNU General Public License as published by the Free Software
10 # Foundation; either version 2 of the License, or (at your option) any later
11 # version.
12
13 # This program is distributed in the hope that it will be useful, but WITHOUT
14 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
15 # FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
16
17 # You should have received a copy of the GNU General Public License along with
18 # this program; if not, write to the Free Software Foundation, Inc., 59 Temple
19 # Place, Suite 330, Boston, MA 02111-1307 USA. 
20
21 import sys, os, getopt, glob, copy, os.path, re
22 sys.path.append(os.path.join(os.path.dirname(os.path.dirname(sys.argv[0])), 'lib'))
23 import bb
24 from bb import make
25 from sets import Set
26 import itertools, optparse
27
28 parsespin = itertools.cycle( r'|/-\\' )
29
30 __version__ = 1.2
31 __build_cache_fail = []
32 __build_cache = []
33 __building_list = []
34 __build_path = []
35
36 __preferred = {}
37 __world_target = Set()
38 __ignored_dependencies = Set()
39
40 __stats = {}
41
42 bbfile_config_priorities = []
43 bbfile_priority = {}
44 bbdebug = 0
45
46 def handle_options( args ):
47     parser = optparse.OptionParser( version = "BitBake Build Tool Core version %s, %%prog version %s" % ( bb.__version__, __version__ ),
48     usage = """%prog [options] [package ...]
49
50 Executes the specified task (default is 'build') for a given set of BitBake files.
51 It expects that BBFILES is defined, which is a space seperated list of files to
52 be executed.  BBFILES does support wildcards.
53 Default BBFILES are the .bb files in the current directory.""" )
54
55     parser.add_option( "-b", "--buildfile", help = "execute the task against this .bb file, rather than a package from BBFILES.",
56                action = "store", dest = "buildfile", default = None )
57
58     parser.add_option( "-k", "--continue", help = "continue as much as possible after an error. While the target that failed, and those that depend on it, cannot be remade, the other dependencies of these targets can be processed all the same.",
59                action = "store_false", dest = "abort", default = True )
60
61     parser.add_option( "-f", "--force", help = "force run of specified cmd, regardless of stamp status",
62                action = "store_true", dest = "force", default = False )
63
64
65     parser.add_option( "-c", "--cmd", help = "Specify task to execute",
66                action = "store", dest = "cmd", default = "build" )
67
68     parser.add_option( "-r", "--read", help = "read the specified file before bitbake.conf",
69                action = "append", dest = "file", default = [] )
70
71     parser.add_option( "-v", "--verbose", help = "output more chit-chat to the terminal",
72                action = "store_true", dest = "verbose", default = False )
73     parser.add_option( "-D", "--debug", help = "Increase the debug level",
74                action = "count", dest="debug", default = 0)
75
76     parser.add_option( "-n", "--dry-run", help = "don't execute, just go through the motions",
77                action = "store_true", dest = "dry_run", default = False )
78
79     parser.add_option( "-p", "--parse-only", help = "quit after parsing the BB files (developers only)",
80                action = "store_true", dest = "parse_only", default = False )
81
82     parser.add_option( "-d", "--disable-psyco", help = "disable using the psyco just-in-time compiler (not recommended)",
83                action = "store_true", dest = "disable_psyco", default = False )
84
85     parser.add_option( "-s", "--show-versions", help = "show current and preferred versions of all packages",
86                action = "store_true", dest = "show_versions", default = False )
87
88     options, args = parser.parse_args( args )
89     return options, args[1:]
90
91 def try_build(fn, virtual):
92     if fn in __building_list:
93         bb.error("%s depends on itself (eventually)" % fn)
94         bb.error("upwards chain is: %s" % (" -> ".join(__build_path)))
95         return False
96
97     __building_list.append(fn)
98
99     the_data = make.pkgdata[fn]
100     item = bb.data.getVar('PN', the_data, 1)
101     pathstr = "%s (%s)" % (item, virtual)
102     __build_path.append(pathstr)
103
104     depends_list = (bb.data.getVar('DEPENDS', the_data, 1) or "").split()
105     if make.options.verbose:
106         bb.note("current path: %s" % (" -> ".join(__build_path)))
107         bb.note("dependencies for %s are: %s" % (item, " ".join(depends_list)))
108
109     try:
110         failed = False
111
112         depcmd = make.options.cmd
113         bbdepcmd = bb.data.getVarFlag('do_%s' % make.options.cmd, 'bbdepcmd', make.pkgdata[fn])
114         if bbdepcmd is not None:
115             if bbdepcmd == "":
116                 depcmd = None
117             else:
118                 depcmd = bbdepcmd
119
120         if depcmd:
121             oldcmd = make.options.cmd
122             make.options.cmd = depcmd
123
124         for d in depends_list:
125             if d in __ignored_dependencies:
126                 continue
127             if not depcmd:
128                 continue
129             if buildPackage(d) == 0:
130                 bb.error("dependency %s (for %s) not satisfied" % (d,item))
131                 failed = True
132                 if make.options.abort:
133                     break
134
135         if depcmd:
136             make.options.cmd = oldcmd
137
138         if failed:
139             __stats["deps"] += 1
140             return False
141
142         bb.event.fire(bb.event.PkgStarted(item, make.pkgdata[fn]))
143         try:
144             __stats["attempt"] += 1
145             if not make.options.dry_run:
146                 bb.build.exec_task('do_%s' % make.options.cmd, make.pkgdata[fn])
147             bb.event.fire(bb.event.PkgSucceeded(item, make.pkgdata[fn]))
148             __build_cache.append(fn)
149             return True
150         except bb.build.FuncFailed:
151             __stats["fail"] += 1
152             bb.error("task stack execution failed")
153             bb.event.fire(bb.event.PkgFailed(item, make.pkgdata[fn]))
154             __build_cache_fail.append(fn)
155             raise
156         except bb.build.EventException:
157             __stats["fail"] += 1
158             (type, value, traceback) = sys.exc_info()
159             e = value.event
160             bb.error("%s event exception, aborting" % bb.event.getName(e))
161             bb.event.fire(bb.event.PkgFailed(item, make.pkgdata[fn]))
162             __build_cache_fail.append(fn)
163             raise
164     finally:
165         __building_list.remove(fn)
166         __build_path.remove(pathstr)
167
168 def showVersions():
169     pkg_pn = {}
170     preferred_versions = {}
171     latest_versions = {}
172
173     for p in make.pkgdata.keys():
174         pn = bb.data.getVar('PN', make.pkgdata[p], 1)
175         if not pkg_pn.has_key(pn):
176             pkg_pn[pn] = []
177         pkg_pn[pn].append(p)
178     
179     # Sort by priority
180     for pn in pkg_pn.keys():
181         files = pkg_pn[pn]
182         priorities = {}
183         for f in files:
184             priority = bbfile_priority[f]
185             if not priorities.has_key(priority):
186                 priorities[priority] = []
187             priorities[priority].append(f)
188         p_list = priorities.keys()
189         p_list.sort(lambda a, b: a - b)
190         pkg_pn[pn] = []
191         for p in p_list:
192             pkg_pn[pn] = [ priorities[p] ] + pkg_pn[pn]
193
194     # If there is a PREFERRED_VERSION, find the highest-priority bbfile providing that
195     # version.  If not, find the latest version provided by an bbfile in the
196     # highest-priority set.
197     for pn in pkg_pn.keys():
198         preferred_file = None
199         
200         preferred_v = bb.data.getVar('PREFERRED_VERSION_%s' % pn, make.cfg, 1)
201         if preferred_v:
202             preferred_r = None
203             m = re.match('(.*)_(.*)', preferred_v)
204             if m:
205                 preferred_v = m.group(1)
206                 preferred_r = m.group(2)
207                 
208             for file_set in pkg_pn[pn]:
209                 for f in file_set:
210                     the_data = make.pkgdata[f]
211                     pv = bb.data.getVar('PV', the_data, 1)
212                     pr = bb.data.getVar('PR', the_data, 1)
213                     if preferred_v == pv and (preferred_r == pr or preferred_r == None):
214                         preferred_file = f
215                         preferred_ver = (pv, pr)
216                         break
217                 if preferred_file:
218                     break
219             if preferred_r:
220                 pv_str = '%s-%s' % (preferred_v, preferred_r)
221             else:
222                 pv_str = preferred_v
223             if preferred_file is None:
224                 bb.note("preferred version %s of %s not available" % (pv_str, pn))
225             else:
226                 bb.debug(1, "selecting %s as PREFERRED_VERSION %s of package %s" % (preferred_file, pv_str, pn))
227                
228         # get highest priority file set
229         files = pkg_pn[pn][0]
230         latest = None
231         latest_p = 0
232         latest_f = None
233         for f in files:
234             the_data = make.pkgdata[f]
235             pv = bb.data.getVar('PV', the_data, 1)
236             pr = bb.data.getVar('PR', the_data, 1)
237             dp = int(bb.data.getVar('DEFAULT_PREFERENCE', the_data, 1) or "0")
238
239             if (latest is None) or ((latest_p == dp) and (make.vercmp(latest, (pv, pr)) < 0)) or (dp > latest_p):
240                 latest = (pv, pr)
241                 latest_f = f
242                 latest_p = dp
243         if preferred_file is None:
244             preferred_file = latest_f
245             preferred_ver = latest
246             
247         preferred_versions[pn] = (preferred_ver, preferred_file)
248         latest_versions[pn] = (latest, latest_f)
249
250     pkg_list = pkg_pn.keys()
251     pkg_list.sort()
252     
253     for p in pkg_list:
254         pref = preferred_versions[p]
255         latest = latest_versions[p]
256
257         if pref != latest:
258             prefstr = pref[0][0] + "-" + pref[0][1]
259         else:
260             prefstr = ""
261
262         print "%-30s %20s %20s" % (p, latest[0][0] + "-" + latest[0][1],
263                                    prefstr)
264
265 def buildPackage(item):
266     fn = None
267
268     discriminated = False
269
270     if not providers.has_key(item):
271         bb.error("Nothing provides %s" % item)
272         return 0
273
274     all_p = providers[item]
275
276     for p in all_p:
277         if p in __build_cache:
278             bb.debug(1, "already built %s in this run\n" % p)
279             return 1
280
281     eligible = []
282     preferred_versions = {}
283
284     # Collate providers by PN
285     pkg_pn = {}
286     for p in all_p:
287         the_data = make.pkgdata[p]
288         pn = bb.data.getVar('PN', the_data, 1)
289         if not pkg_pn.has_key(pn):
290             pkg_pn[pn] = []
291         pkg_pn[pn].append(p)
292
293     bb.debug(1, "providers for %s are: %s" % (item, pkg_pn.keys()))
294
295     # Sort by priority
296     for pn in pkg_pn.keys():
297         files = pkg_pn[pn]
298         priorities = {}
299         for f in files:
300             priority = bbfile_priority[f]
301             if not priorities.has_key(priority):
302                 priorities[priority] = []
303             priorities[priority].append(f)
304         p_list = priorities.keys()
305         p_list.sort(lambda a, b: a - b)
306         pkg_pn[pn] = []
307         for p in p_list:
308             pkg_pn[pn] = [ priorities[p] ] + pkg_pn[pn]
309
310     # If there is a PREFERRED_VERSION, find the highest-priority bbfile providing that
311     # version.  If not, find the latest version provided by an bbfile in the
312     # highest-priority set.
313     for pn in pkg_pn.keys():
314         preferred_file = None
315         
316         preferred_v = bb.data.getVar('PREFERRED_VERSION_%s' % pn, make.cfg, 1)
317         if preferred_v:
318             preferred_r = None
319             m = re.match('(.*)_(.*)', preferred_v)
320             if m:
321                 preferred_v = m.group(1)
322                 preferred_r = m.group(2)
323                 
324             for file_set in pkg_pn[pn]:
325                 for f in file_set:
326                     the_data = make.pkgdata[f]
327                     pv = bb.data.getVar('PV', the_data, 1)
328                     pr = bb.data.getVar('PR', the_data, 1)
329                     if preferred_v == pv and (preferred_r == pr or preferred_r == None):
330                         preferred_file = f
331                         preferred_ver = (pv, pr)
332                         break
333                 if preferred_file:
334                     break
335             if preferred_r:
336                 pv_str = '%s-%s' % (preferred_v, preferred_r)
337             else:
338                 pv_str = preferred_v
339             if preferred_file is None:
340                 bb.note("preferred version %s of %s not available" % (pv_str, pn))
341             else:
342                 bb.debug(1, "selecting %s as PREFERRED_VERSION %s of package %s" % (preferred_file, pv_str, pn))
343                 
344         if preferred_file is None:
345             # get highest priority file set
346             files = pkg_pn[pn][0]
347             latest = None
348             latest_p = 0
349             latest_f = None
350             for f in files:
351                 the_data = make.pkgdata[f]
352                 pv = bb.data.getVar('PV', the_data, 1)
353                 pr = bb.data.getVar('PR', the_data, 1)
354                 dp = int(bb.data.getVar('DEFAULT_PREFERENCE', the_data, 1) or "0")
355
356                 if (latest is None) or ((latest_p == dp) and (make.vercmp(latest, (pv, pr)) < 0)) or (dp > latest_p):
357                     latest = (pv, pr)
358                     latest_f = f
359                     latest_p = dp
360             preferred_file = latest_f
361             preferred_ver = latest
362             
363             bb.debug(1, "selecting %s as latest version of provider %s" % (preferred_file, pn))
364
365         preferred_versions[pn] = (preferred_ver, preferred_file)
366         eligible.append(preferred_file)
367
368     for p in eligible:
369         if p in __build_cache_fail:
370             bb.debug(1, "rejecting already-failed %s" % p)
371             eligible.remove(p)
372
373     if len(eligible) == 0:
374         bb.error("no eligible providers for %s" % item)
375         return 0
376
377     # look to see if one of them is already staged, or marked as preferred.
378     # if so, bump it to the head of the queue
379     for p in all_p:
380         the_data = make.pkgdata[p]
381         pn = bb.data.getVar('PN', the_data, 1)
382         pv = bb.data.getVar('PV', the_data, 1)
383         pr = bb.data.getVar('PR', the_data, 1)
384         tmpdir = bb.data.getVar('TMPDIR', the_data, 1)
385         stamp = '%s/stamps/%s-%s-%s.do_populate_staging' % (tmpdir, pn, pv, pr)
386         if os.path.exists(stamp):
387             (newvers, fn) = preferred_versions[pn]
388             if not fn in eligible:
389                 # package was made ineligible by already-failed check
390                 continue
391             oldver = "%s-%s" % (pv, pr)
392             newver = '-'.join(newvers)
393             if (newver != oldver):
394                 extra_chat = "; upgrading from %s to %s" % (oldver, newver)
395             else:
396                 extra_chat = ""
397             if make.options.verbose:
398                 bb.note("selecting already-staged %s to satisfy %s%s" % (pn, item, extra_chat))
399             eligible.remove(fn)
400             eligible = [fn] + eligible
401             discriminated = True
402             break
403
404     prefervar = bb.data.getVar('PREFERRED_PROVIDER_%s' % item, make.cfg, 1)
405     if prefervar:
406         __preferred[item] = prefervar
407
408     if __preferred.has_key(item):
409         for p in eligible:
410             the_data = make.pkgdata[p]
411             pn = bb.data.getVar('PN', the_data, 1)
412             if __preferred[item] == pn:
413                 if make.options.verbose:
414                     bb.note("selecting %s to satisfy %s due to PREFERRED_PROVIDERS" % (pn, item))
415                 eligible.remove(p)
416                 eligible = [p] + eligible
417                 discriminated = True
418                 break
419
420     if len(eligible) > 1 and discriminated == False:
421         providers_list = []
422         for fn in eligible:
423             providers_list.append(bb.data.getVar('PN', make.pkgdata[fn], 1))
424         bb.note("multiple providers are available (%s);" % ", ".join(providers_list))
425         bb.note("consider defining PREFERRED_PROVIDER_%s" % item)
426
427     # run through the list until we find one that we can build
428     for fn in eligible:
429         bb.debug(2, "selecting %s to satisfy %s" % (fn, item))
430         if try_build(fn, item):
431             return 1
432
433     bb.note("no buildable providers for %s" % item)
434     return 0
435
436 def build_depgraph():
437     all_depends = Set()
438     pn_provides = {}
439
440     def progress(p):
441         if bbdebug or progress.p == p: return 
442         progress.p = p
443         if os.isatty(sys.stdout.fileno()):
444             sys.stdout.write("\rNOTE: Building provider hash: [%s%s] (%02d%%)" % ( "#" * (p/5), " " * ( 20 - p/5 ), p ) )
445             sys.stdout.flush()
446         else:
447             if p == 0:
448                 sys.stdout.write("NOTE: Building provider hash, please wait...\n")
449             if p == 100:
450                 sys.stdout.write("done.\n")
451     progress.p = 0
452
453     def calc_bbfile_priority(filename):
454         for (regex, pri) in bbfile_config_priorities:
455             if regex.match(filename):
456                 return pri
457         return 0
458
459     # Handle PREFERRED_PROVIDERS
460     for p in (bb.data.getVar('PREFERRED_PROVIDERS', make.cfg, 1) or "").split():
461         (providee, provider) = p.split(':')
462         if __preferred.has_key(providee) and __preferred[providee] != provider:
463             bb.error("conflicting preferences for %s: both %s and %s specified" % (providee, provider, __preferred[providee]))
464         __preferred[providee] = provider
465
466     # Calculate priorities for each file
467     for p in make.pkgdata.keys():
468         bbfile_priority[p] = calc_bbfile_priority(p)
469     
470     n = len(make.pkgdata.keys())
471     i = 0
472
473     op = -1
474
475     bb.debug(1, "BBMAKE building providers hashes")
476
477     # Build forward and reverse provider hashes
478     # Forward: virtual -> [filenames]
479     # Reverse: PN -> [virtuals]
480     for f in make.pkgdata.keys():
481         d = make.pkgdata[f]
482
483         pn = bb.data.getVar('PN', d, 1)
484         provides = Set([pn] + (bb.data.getVar("PROVIDES", d, 1) or "").split())
485
486         if not pn_provides.has_key(pn):
487             pn_provides[pn] = Set()
488         pn_provides[pn] |= provides
489
490         for provide in provides:
491             if not providers.has_key(provide):
492                 providers[provide] = []
493             providers[provide].append(f)
494
495         deps = (bb.data.getVar("DEPENDS", d, 1) or "").split()
496         for dep in deps:
497             all_depends.add(dep)
498
499         i += 1
500         p = (100 * i) / n
501         if p != op:
502             op = p
503             progress(p)
504
505     if bbdebug == 0:
506         sys.stdout.write("\n")
507
508     # Build package list for "bitbake world"
509     bb.debug(1, "BBMAKE collating packages for \"world\"")
510     for f in make.pkgdata.keys():
511         d = make.pkgdata[f]
512         if bb.data.getVar('BROKEN', d, 1) or bb.data.getVar('EXCLUDE_FROM_WORLD', d, 1):
513             bb.debug(2, "BBMAKE skipping %s due to BROKEN/EXCLUDE_FROM_WORLD" % f)
514             continue
515         terminal = True
516         pn = bb.data.getVar('PN', d, 1)
517         for p in pn_provides[pn]:
518             if p.startswith('virtual/'):
519                 bb.debug(2, "BBMAKE skipping %s due to %s provider starting with virtual/" % (f, p))
520                 terminal = False
521                 break
522             for pf in providers[p]:
523                 if bb.data.getVar('PN', make.pkgdata[pf], 1) != pn:
524                     bb.debug(2, "BBMAKE skipping %s due to both us and %s providing %s" % (f, pf, p))
525                     terminal = False
526                     break
527         if terminal:
528             __world_target.add(pn)
529
530 def myProgressCallback( x, y, f ):
531     if bbdebug > 0:
532         return
533     if os.isatty(sys.stdout.fileno()):
534         sys.stdout.write("\rNOTE: Handling BitBake files: %s (%04d/%04d) [%2d %%]" % ( parsespin.next(), x, y, x*100/y ) )
535         sys.stdout.flush()
536     else:
537         if x == 1:
538             sys.stdout.write("Parsing .bb files, please wait...")
539             sys.stdout.flush()
540         if x == y:
541             sys.stdout.write("done.")
542             sys.stdout.flush()
543
544 def executeOneBB( fn ):
545         try:
546             d = bb.parse.handle(fn, make.cfg)
547         except IOError:
548             bb.fatal("Unable to open %s" % fn)
549
550         name = bb.data.getVar('PN', d, 1)
551         bb.event.fire(bb.event.PkgStarted(name, d))
552         try:
553             __stats["attempt"] += 1
554             if make.options.force:          
555                 bb.data.setVarFlag('do_%s' % make.options.cmd, 'force', 1, d)
556             if not make.options.dry_run:
557                 bb.build.exec_task('do_%s' % make.options.cmd, d)
558             bb.event.fire(bb.event.PkgSucceeded(name, d))
559             __build_cache.append(fn)
560         except bb.build.FuncFailed:
561             __stats["fail"] += 1
562             bb.error("task stack execution failed")
563             bb.event.fire(bb.event.PkgFailed(name, d))
564             __build_cache_fail.append(fn)
565         except bb.build.EventException:
566             __stats["fail"] += 1
567             (type, value, traceback) = sys.exc_info()
568             e = value.event
569             bb.error("%s event exception, aborting" % bb.event.getName(e))
570             bb.event.fire(bb.event.PkgFailed(name, d))
571             __build_cache_fail.append(fn)
572
573 #
574 # main
575 #
576
577 __stats["attempt"] = 0
578 __stats["success"] = 0
579 __stats["fail"] = 0
580 __stats["deps"] = 0
581
582 def printStats( ):
583     print "Build statistics:"
584     print "  Attempted builds: %d" % __stats["attempt"]
585     if __stats["fail"] != 0:
586         print "  Failed builds: %d" % __stats["fail"]
587     if __stats["deps"] != 0:
588         print "  Dependencies not satisfied: %d" % __stats["deps"]
589     if __stats["fail"] != 0 or __stats["deps"] != 0:
590         sys.exit(1)
591     sys.exit(0)
592
593 if __name__ == "__main__":
594
595     make.options, args = handle_options( sys.argv )
596
597     if not make.options.cmd:
598         make.options.cmd = "build"
599
600     if make.options.debug:
601         bb.debug_level = make.options.debug
602
603     make.pkgdata = {}
604     make.cfg = bb.data.init()
605     providers = {}
606
607     for f in make.options.file:
608         try:
609             make.cfg = bb.parse.handle(f, make.cfg)
610         except IOError:
611             bb.fatal("Unable to open %s" % f)
612
613     try:
614         make.cfg = bb.parse.handle(os.path.join('conf', 'bitbake.conf'), make.cfg)
615     except IOError:
616         bb.fatal("Unable to open %s" % os.path.join('conf', 'bitbake.conf'))
617
618     if not bb.data.getVar("BUILDNAME", make.cfg):
619         bb.data.setVar("BUILDNAME", os.popen('date +%Y%m%d%H%M').readline().strip(), make.cfg)
620
621     buildname = bb.data.getVar("BUILDNAME", make.cfg)
622
623     bf = make.options.buildfile
624     if bf:
625         executeOneBB( os.path.abspath(bf) )
626         printStats()
627
628     ignore = bb.data.getVar("ASSUME_PROVIDED", make.cfg, 1) or ""
629     __ignored_dependencies = ignore.split()
630
631     collections = bb.data.getVar("BBFILE_COLLECTIONS", make.cfg, 1)
632     if collections:
633         collection_list = collections.split()
634         for c in collection_list:
635             regex = bb.data.getVar("BBFILE_PATTERN_%s" % c, make.cfg, 1)
636             if regex == None:
637                 bb.error("BBFILE_PATTERN_%s not defined" % c)
638                 continue
639             priority = bb.data.getVar("BBFILE_PRIORITY_%s" % c, make.cfg, 1)
640             if priority == None:
641                 bb.error("BBFILE_PRIORITY_%s not defined" % c)
642                 continue
643             try:
644                 cre = re.compile(regex)
645             except re.error:
646                 bb.error("BBFILE_PATTERN_%s \"%s\" is not a valid regular expression" % (c, regex))
647                 continue
648             try:
649                 pri = int(priority)
650                 bbfile_config_priorities.append((cre, pri))
651             except ValueError:
652                 bb.error("invalid value for BBFILE_PRIORITY_%s: \"%s\"" % (c, priority))
653
654     pkgs_to_build = None
655     if args:
656         if not pkgs_to_build:
657             pkgs_to_build = []
658         pkgs_to_build.extend(args)
659     if not pkgs_to_build:
660             bbpkgs = bb.data.getVar('BBPKGS', make.cfg, 1)
661             if bbpkgs:
662                     pkgs_to_build = bbpkgs.split()
663     if not pkgs_to_build and not make.options.show_versions:
664             print "Nothing to do.  Use 'bitbake world' to build everything, or run 'bitbake --help'"
665             print "for usage information."
666             sys.exit(0)
667
668
669     # Import Psyco if available and not disabled
670     if not make.options.disable_psyco:
671         try:
672             import psyco
673         except ImportError:
674             if bbdebug == 0:
675                 bb.note("Psyco JIT Compiler (http://psyco.sf.net) not available. Install it to increase performance.")
676         else:
677             psyco.bind( make.collect_bbfiles )
678     else:
679         bb.note("You have disabled Psyco. This decreases performance.")
680
681     try:
682         bb.debug(1, "BBMAKE collecting .bb files")
683         make.collect_bbfiles( myProgressCallback )
684         bb.debug(1, "BBMAKE parsing complete")
685         if bbdebug == 0:
686             print
687         if make.options.parse_only:
688             print "Requested parsing .bb files only.  Exiting."
689             sys.exit(0)
690
691         build_depgraph()
692
693         if make.options.show_versions:
694             showVersions()
695             sys.exit(0)
696             
697         if 'world' in pkgs_to_build:
698             pkgs_to_build.remove('world')
699             for t in __world_target:
700                 pkgs_to_build.append(t)
701
702         bb.event.fire(bb.event.BuildStarted(buildname, pkgs_to_build, make.cfg))
703
704         for k in pkgs_to_build:
705             failed = False
706             try:
707                 if buildPackage(k) == 0:
708                     # already diagnosed
709                     failed = True
710             except bb.build.EventException:
711                 bb.error("Build of " + k + " failed")
712                 failed = True
713
714             if failed:
715                 if make.options.abort:
716                     sys.exit(1)
717
718         bb.event.fire(bb.event.BuildCompleted(buildname, pkgs_to_build, make.cfg))
719
720         printStats()
721
722     except KeyboardInterrupt:
723         print "\nNOTE: KeyboardInterrupt - Build not completed."
724         sys.exit(1)