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