code.vuplus.com Git - vuplus_bitbake/blob - 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) 2005        Holger Hans Peter Freyther
   8 # Copyright (C) 2005        ROAD GmbH
   9 #
  10 # This program is free software; you can redistribute it and/or modify it under
  11 # the terms of the GNU General Public License as published by the Free Software
  12 # Foundation; either version 2 of the License, or (at your option) any later
  13 # version.
  14 #
  15 # This program is distributed in the hope that it will be useful, but WITHOUT
  16 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  17 # FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
  18 #
  19 # You should have received a copy of the GNU General Public License along with
  20 # this program; if not, write to the Free Software Foundation, Inc., 59 Temple
  21 # Place, Suite 330, Boston, MA 02111-1307 USA.
  22
  23 import sys, os, getopt, glob, copy, os.path, re
  24 sys.path.append(os.path.join(os.path.dirname(os.path.dirname(sys.argv[0])), 'lib'))
  25 import bb
  26 from bb import make
  27 from sets import Set
  28 import itertools, optparse
  29
  30 parsespin = itertools.cycle( r'|/-\\' )
  31
  32 __version__ = 1.2
  33 __build_cache_fail = []
  34 __build_cache = []
  35 __building_list = []
  36 __build_path = []
  37
  38 __preferred = {}
  39 __world_target = Set()
  40 __ignored_dependencies = 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 ):
 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     __ignored_dependencies = ignore.split()
 644
 645     collections = bb.data.getVar("BBFILE_COLLECTIONS", make.cfg, 1)
 646     if collections:
 647         collection_list = collections.split()
 648         for c in collection_list:
 649             regex = bb.data.getVar("BBFILE_PATTERN_%s" % c, make.cfg, 1)
 650             if regex == None:
 651                 bb.error("BBFILE_PATTERN_%s not defined" % c)
 652                 continue
 653             priority = bb.data.getVar("BBFILE_PRIORITY_%s" % c, make.cfg, 1)
 654             if priority == None:
 655                 bb.error("BBFILE_PRIORITY_%s not defined" % c)
 656                 continue
 657             try:
 658                 cre = re.compile(regex)
 659             except re.error:
 660                 bb.error("BBFILE_PATTERN_%s \"%s\" is not a valid regular expression" % (c, regex))
 661                 continue
 662             try:
 663                 pri = int(priority)
 664                 bbfile_config_priorities.append((cre, pri))
 665             except ValueError:
 666                 bb.error("invalid value for BBFILE_PRIORITY_%s: \"%s\"" % (c, priority))
 667
 668     pkgs_to_build = None
 669     if args:
 670         if not pkgs_to_build:
 671             pkgs_to_build = []
 672         pkgs_to_build.extend(args)
 673     if not pkgs_to_build:
 674             bbpkgs = bb.data.getVar('BBPKGS', make.cfg, 1)
 675             if bbpkgs:
 676                     pkgs_to_build = bbpkgs.split()
 677     if not pkgs_to_build and not make.options.show_versions:
 678             print "Nothing to do.  Use 'bitbake world' to build everything, or run 'bitbake --help'"
 679             print "for usage information."
 680             sys.exit(0)
 681
 682
 683     # Import Psyco if available and not disabled
 684     if not make.options.disable_psyco:
 685         try:
 686             import psyco
 687         except ImportError:
 688             if bbdebug == 0:
 689                 bb.note("Psyco JIT Compiler (http://psyco.sf.net) not available. Install it to increase performance.")
 690         else:
 691             psyco.bind( make.collect_bbfiles )
 692     else:
 693         bb.note("You have disabled Psyco. This decreases performance.")
 694
 695     try:
 696         bb.debug(1, "collecting .bb files")
 697         make.collect_bbfiles( myProgressCallback )
 698         bb.debug(1, "parsing complete")
 699         if bbdebug == 0:
 700             print
 701         if make.options.parse_only:
 702             print "Requested parsing .bb files only.  Exiting."
 703             sys.exit(0)
 704
 705         build_depgraph()
 706
 707         if make.options.show_versions:
 708             showVersions()
 709             sys.exit(0)
 710
 711         if 'world' in pkgs_to_build:
 712             pkgs_to_build.remove('world')
 713             for t in __world_target:
 714                 pkgs_to_build.append(t)
 715
 716         bb.event.fire(bb.event.BuildStarted(buildname, pkgs_to_build, make.cfg))
 717
 718         for k in pkgs_to_build:
 719             failed = False
 720             try:
 721                 if buildPackage(k) == 0:
 722                     # already diagnosed
 723                     failed = True
 724             except bb.build.EventException:
 725                 bb.error("Build of " + k + " failed")
 726                 failed = True
 727
 728             if failed:
 729                 if make.options.abort:
 730                     sys.exit(1)
 731
 732         bb.event.fire(bb.event.BuildCompleted(buildname, pkgs_to_build, make.cfg))
 733
 734         printStats()
 735
 736     except KeyboardInterrupt:
 737         print "\nNOTE: KeyboardInterrupt - Build not completed."
 738         sys.exit(1)