code.vuplus.com Git - vuplus_bitbake/blob - bin/bbmake

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