build

#!/usr/bin/python

import platform, sys, os, time, threading, subprocess, copy, codecs


config_file = 'config.default'


system = None
dependencies = False
verbose = False
targets = []

global todo, headers, object_deps, file_flags, thread_cflags, thread_ldflags, lock, print_lock, stop
global include_paths
todo, headers, object_deps, file_flags = {}, {}, {}, {}
lock = threading.Lock()
print_lock = threading.Lock()
stop = False

def disp (msg):
  print_lock.acquire()
  sys.stderr.write (msg)
  print_lock.release()
  




# common definitions:

bin_dir = 'bin'
cmd_dir = 'cmd'
lib_dir = 'lib'
misc_dir = 'src'
other_dir = '3rd_party'
doc_dir = 'doc'
dev_dir = 'dev'

icon = 'icons/icon.o'
icon_dep = 'icons/icon.rc'

cpp_suffix = '.cpp'
h_suffix = '.h'
libname = 'mrtrix'
config_suffix = ''




include_paths = [ misc_dir, cmd_dir ]
if os.path.exists (other_dir):
  include_paths += [ other_dir ]

# check if we are compiling a separate project:
mrtrix_dir = '.'
build_script = sys.argv[0]
separate_project = False

def get_real_name (path):
  if os.path.islink (path): return os.readlink (path)
  else: return (path)

while os.path.abspath (os.path.dirname (get_real_name (build_script))) != os.path.abspath (mrtrix_dir):
  if verbose and not separate_project:
    sys.stderr.write ('compiling separate project against:' + os.linesep)
  separate_project = True
  build_script = os.path.normpath (os.path.join (mrtrix_dir, get_real_name (build_script)))
  mrtrix_dir = os.path.dirname (build_script)
  include_paths += [ os.path.join (mrtrix_dir, misc_dir) ]
  if os.path.exists (os.path.join (mrtrix_dir, other_dir)):
    include_paths += [ os.path.join (mrtrix_dir, other_dir) ]
  if verbose: 
    sys.stderr.write ('    ' + mrtrix_dir + os.linesep)

if separate_project:
  config_file = os.path.join (mrtrix_dir, config_file)

  if verbose:
    sys.stderr.write (os.linesep);






# parse command-line:
for arg in sys.argv[1:]:
  if '-help'.startswith (arg):
    print ('''
usage: ./build [-verbose] [-dependencies] [target ...]

In most cases, a simple invocation is all that is required:

  $ ./build

If no targets are provided, the command will default to building 
all applications by scanning through the cmd/ folder. 

The special target 'clean' is used to remove all compiler-generated 
files, including objects, executables, and shared libraries. 

OPTIONS:

  -verbose       print each command as it is being invoked
  -dependencies  print the list of dependencies for every target 
''')
    exit (0)
  elif   '-verbose'.startswith(arg): 
    verbose = True
  elif '-dependencies'.startswith(arg): 
    dependencies = True
  elif arg[0] == '-':
    sys.stderr.write ('unknown command-line option "' + arg + '"\n')
    sys.exit (1)
  elif arg == 'clean':
    targets = [ 'clean' ]
    break
  elif os.path.isfile (os.path.join (mrtrix_dir, "config." + arg)):
    config_file = os.path.join (mrtrix_dir, "config." + arg)
    config_suffix = '__' + arg
  else: targets.append(arg)





# load configuration file:
try:
  if verbose:
    sys.stderr.write ('reading configuration from "' + config_file + '"...' + os.linesep)
  exec (codecs.open (config_file, mode='r', encoding='utf-8').read())
except IOError:
  sys.stderr.write ('''no configuration file found!
please run "./configure" prior to invoking this script

''')
  sys.exit (1)




if ld_enabled and len(runpath):
    ld_flags += [ runpath+os.path.relpath (lib_dir,bin_dir) ]

if separate_project:
  lib_dir = os.path.join (mrtrix_dir, lib_dir)
  if ld_enabled and len(runpath):
    ld_flags += [ runpath+os.path.relpath (lib_dir,bin_dir) ]



# get version info:

if ld_enabled:
  libname += config_suffix
  ld_flags.insert(0, '-l' + libname)
  libname = lib_prefix + libname + lib_suffix

obj_suffix = config_suffix + obj_suffix
exe_suffix = config_suffix + exe_suffix



# Qt4 settings:
#qt4_cflags += [ '-I' + entry for entry in qt4_include_path ]



# other settings:
include_paths += [ lib_dir, cmd_dir ]
cpp_flags += [ '-I' + entry for entry in include_paths ]
ld_flags += [ '-L' + lib_dir ]









###########################################################################
#                           TODO list Entry
###########################################################################

class Entry:
  def __init__ (self, name):
    global todo
    if name in todo.keys(): return
    todo[name] = self

    self.name = name
    self.cmd = []
    self.deps = set()
    self.action = 'NA'
    self.timestamp = mtime (self.name)
    self.dep_timestamp = self.timestamp
    self.currently_being_processed = False

    if is_executable (self.name): self.set_executable()
    elif is_icon (self.name): self.set_icon()
    elif is_object (self.name): self.set_object()
    elif is_library (self.name): self.set_library()
    elif is_moc (self.name): self.set_moc()
    elif not os.path.exists (self.name): 
      raise Exception ('unknown target "' + self.name + '"')

    [ Entry(item) for item in self.deps ]
    dep_timestamp = [ todo[item].dep_timestamp for item in todo.keys() if item in self.deps and not is_library(item) ]
    if len(dep_timestamp): self.dep_timestamp = max(dep_timestamp)
    

  def execute (self):
    if len(self.cmd) > 0: 
      return execute ('[' + self.action + '] ' + self.name, self.cmd)
    else: 
      return None


  def set_executable (self):
    self.action = 'LB'
    if len(exe_suffix) > 0: cc_file = self.name[:-len(exe_suffix)]
    else: cc_file = self.name
    cc_file = os.path.join (cmd_dir, os.sep.join (cc_file.split(os.sep)[1:])) + cpp_suffix
    self.deps = list_cmd_deps(cc_file)

    try: windres
    except NameError: pass
    else: self.deps.add (icon)

    skip = False
    flags = copy.copy (gsl_ldflags)
    if 'T' in file_flags[cc_file]: flags += thread_ldflags
    if 'Q' in file_flags[cc_file]: flags += qt_ldflags

    if not skip: 
      if not os.path.isdir (bin_dir): 
        os.mkdir (bin_dir)

      if not ld_enabled: 
        self.deps = self.deps.union (list_lib_deps())

      self.cmd = fillin (ld, { 
        'LDFLAGS': [ s.replace ('LIBNAME', os.path.basename (self.name)) for s in ld_flags ] + flags,
        'OBJECTS': self.deps,
        'EXECUTABLE': [ self.name ] })

      try:
        if ld_use_shell: self.cmd = [ 'sh', '-c', ' '.join(self.cmd) ]
      except NameError: pass

      if ld_enabled:
        self.deps.add (os.path.join (lib_dir, libname))



  def set_object (self):
    self.action = 'CC'
    cc_file = self.name[:-len(obj_suffix)] + cpp_suffix
    self.deps = set([ cc_file ])
    flags = copy.copy (gsl_cflags)

    if is_moc (cc_file):
      src_header = cc_file[:-len('_moc'+cpp_suffix)] + h_suffix
      list_headers (src_header)
      file_flags[cc_file] = file_flags[src_header]
    else: self.deps = self.deps.union (list_headers (cc_file))
    self.deps.add (config_file)

    skip = False
    if 'T' in file_flags[cc_file]: flags += thread_cflags
    if 'Q' in file_flags[cc_file]: flags += qt_cflags

    if not skip: 
      self.cmd = fillin (cpp, { 
        'CFLAGS': cpp_flags + flags,
        'OBJECT': [ self.name ],
        'SRC': [ cc_file ] })


  def set_moc (self):
    self.action = 'MOC'
    src_file = self.name[:-len('_moc'+cpp_suffix)] + h_suffix
    self.deps = set([ src_file ])
    self.deps = self.deps.union (list_headers (src_file))
    self.cmd = [ moc ]
    self.cmd += [ src_file, '-o', self.name ]

    
  def set_library (self):
    if not ld_enabled:
      disp ('ERROR: shared library generation is disabled in this configuration')
      exit (1)

    self.action = 'LD'
    self.deps = list_lib_deps()

    self.cmd = fillin (ld_lib, {
      'LDLIB_FLAGS': [ s.replace ('LIBNAME', os.path.basename (self.name)) for s in ld_lib_flags ],
      'OBJECTS': [ item for item in self.deps ],
      'LIB': [ self.name ] })

    try:
      if ld_use_shell: self.cmd = [ 'sh', '-c', ' '.join(self.cmd) ]
    except NameError: pass


  def set_icon (self):
    self.action = 'WR'
    self.deps = [ icon_dep ]
    self.cmd = windres + [ icon_dep, icon ]


  def display (self):
    sys.stderr.write ('[' + self.action + '] ' + self.name)
    if not self.timestamp or self.timestamp < self.dep_timestamp: 
      sys.stderr.write (' [REBUILD]')
    sys.stderr.write (''':
  deps: ''' + ' '.join(self.deps) + '''
  command: ''' + ' '.join(self.cmd) + '''
''')






###########################################################################
#                         FUNCTION DEFINITIONS
###########################################################################


def default_targets():
  if not os.path.isdir (cmd_dir): 
    sys.stderr.write ('ERROR: no "cmd" folder - unable to determine default targets' + os.linesep)
    sys.exit (1)
  for entry in os.listdir (cmd_dir):
    if entry.endswith(cpp_suffix):
      targets.append (os.path.join (bin_dir, entry[:-len(cpp_suffix)] + exe_suffix))
  return targets

def is_executable (target):
  return target.split (os.sep)[0] == bin_dir and not is_moc (target)

def is_library (target):
  return target.endswith (lib_suffix) and target.split(os.sep)[-1].startswith (lib_prefix)

def is_object (target):
  return target.endswith (obj_suffix)

def is_moc (target):
  return target.endswith ('_moc' + cpp_suffix)

def is_icon (target):
  return target == icon

def mtime (target):
  if not os.path.exists (target): return None
  return os.stat(target).st_mtime


def fillin (template, keyvalue):
  cmd = []
  for item in template:
    if item in keyvalue: 
      cmd += keyvalue[item]
    else: 
      cmd += [ item ]
  return cmd




def execute (message, cmd):
  disp (message + os.linesep)
  if verbose: 
    disp (' '.join(cmd) + os.linesep)

  try: 
    process = subprocess.Popen (cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
    ( stdout, stderr ) = process.communicate()
    if process.returncode != 0:
      disp ('\nERROR: ' + message + '\n\n' + ' '.join(cmd) + '\n\nfailed with output\n\n' + stderr.decode (errors='ignore'))
      return 1
    if len(stdout):
      disp ('STDOUT: ' + message + '\n' + stdout.decode (errors='ignore'))
    if len(stderr):
      disp ('STDERR: ' + message + '\n' + stderr.decode (errors='ignore'))

  except OSError:
    disp (cmd[0] + ': command not found')
    return 1
  except:
    disp ('unexpected exception: ' + str(sys.exc_info()))
    raise


def print_deps (file, indent=''):
  sys.stderr.write (indent + file)
  if file in file_flags: 
    if len(file_flags[file]): 
      sys.stderr.write (' [' + file_flags[file] + ']')
  sys.stderr.write (os.linesep)
  if len(todo[file].deps):
    for entry in todo[file].deps:
      print_deps (entry, indent + '    ')




def is_GUI_target (file):
  if file in file_flags: 
    if 'Q' in file_flags[file]: 
      return True
  if len(todo[file].deps):
    for entry in todo[file].deps:
      if is_GUI_target (entry):
        return True
  return False



def list_headers (file):
  global headers, file_flags

  if file not in headers.keys(): 
    headers[file] = set()

    if file not in file_flags: file_flags[file] = ''

    if not os.path.exists (file):
      sys.stderr.write ('ERROR: cannot find file "' + file + '"' + os.linesep)
      sys.exit(1)
    with codecs.open (file, mode='r', encoding='utf-8') as fd:
      for line in fd:
        line = line.strip()
        if line.startswith('#include'):
          line = line[8:].split ('//')[0].split ('/*')[0].strip()
          if line[0] == '"':
            line = line[1:].rstrip('"')
            if line == 'thread/exec.h':
              if 'T' not in file_flags[file]: 
                file_flags[file] += 'T'
            for path in include_paths:
              if os.path.exists (os.path.join (path, line)):
                line = os.path.join (path, line)
                headers[file].add (line)
                [ headers[file].add(entry) for entry in list_headers(line) ]
                break
            else:
              sys.stderr.write ('ERROR: cannot find header file \"' + line + '\" (from file \"' + file + '\")' + os.linesep)
              sys.exit(1)
          elif line.startswith ('<Q'):
            if 'Q' not in file_flags[file]:
              file_flags[file] += 'Q'
        elif line == 'Q_OBJECT':
          if 'M' not in file_flags[file]:
            file_flags[file] += 'M'

    for entry in headers[file]:
      for c in file_flags[entry]:
        if c != 'M' and c not in file_flags[file]:
          file_flags[file] += c

  return headers[file]






def list_cmd_deps (file_cc):
  global object_deps, file_flags

  if file_cc not in object_deps.keys():
    object_deps[file_cc] = set([ file_cc[:-len(cpp_suffix)] + obj_suffix ])
    for entry in list_headers (file_cc):
      if os.path.abspath(entry).startswith(os.path.abspath(lib_dir)): continue
      if 'M' in file_flags[entry]: object_deps[file_cc] = object_deps[file_cc].union ([ entry[:-len(h_suffix)] + '_moc' + obj_suffix ])
      entry_cc = entry[:-len(h_suffix)] + cpp_suffix
      if os.path.exists (entry_cc):
        object_deps[file_cc] = object_deps[file_cc].union (list_cmd_deps(entry_cc))
    if file_cc not in file_flags: file_flags[file_cc] = ''
    for entry in headers[file_cc]:
      for c in file_flags[entry]:
        if c != 'M' and c not in file_flags[file_cc]:
          file_flags[file_cc] += c

  return object_deps[file_cc]



def list_lib_deps ():
  deps = set()
  for root, dirs, files in os.walk (lib_dir):
    for file in files:
      if file[0] == '.': continue
      if file.endswith (cpp_suffix):
        deps.add (os.path.join (root, file[:-len(cpp_suffix)] + obj_suffix))

  return (deps)



def build_next (id):
  global todo, lock, stop

  try:
    while not stop:
      current = None
      lock.acquire()
      if len(todo):
        for item in todo.keys():
          if todo[item].currently_being_processed: continue
          unsatisfied_deps = set(todo[item].deps).intersection (todo.keys())
          if not len(unsatisfied_deps):
            todo[item].currently_being_processed = True
            current = item
            break
      else: stop = max (stop, 1)
      lock.release()
  
      if stop: return
      if current == None: 
        time.sleep (0.01)
        continue
  
      target = todo[current]
      if target.execute():
        stop = 2
        return

      lock.acquire()
      del todo[current]
      lock.release()

  except:
    stop = 2
    return
    
  stop = max(stop, 1)



def start_html (fid, title, left, up, home, right):
  fid.write ('<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">\n<html>\n<head>\n<meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1">\n')
  fid.write ('<title>MRtrix documentation</title>\n<link rel="stylesheet" href="../stylesheet.css" type="text/css" media=screen>\n</head>\n<body>\n\n')
  fid.write ('<table class=nav>\n<tr>\n<td><a href="' + left + '.html"><img src="../left.png"></a></td>\n')
  fid.write ('<td><a href="' + up + '.html"><img src="../up.png"></a></td>\n')
  fid.write ('<td><a href="' + home + '.html"><img src="../home.png"></a></td>\n')
  fid.write ('<th>' + title + '</th>\n')
  fid.write ('<td><a href="' + right + '.html"><img src="../right.png"></a></td>\n</tr>\n</table>\n')




def gen_command_html_help ():
  binaries = os.listdir (bin_dir)
  binaries.sort()
  description = []

  # generate each program's individual page:
  for n in range (0, len(binaries)):
    sys.stderr.write ('[DOC] ' + binaries[n] + os.linesep)
     
    process = subprocess.Popen ([ binaries[n], '__print_full_usage__' ], stdout=subprocess.PIPE)
    if process.wait() != 0:
      sys.stderr.write ('ERROR: unable to execute', binaries[n], ' - aborting' + os.linesep)
      return 1
    H = process.stdout.read().decode (errors='ignore')
    H = H.splitlines()

    with codecs.open (os.path.join (doc_dir, 'commands', binaries[n] + '.html'), mode='w', encoding='utf-8') as fid:

      if n == 0: prev = 'index'
      else: prev = binaries[n-1]

      if n == len(binaries)-1: next = 'index'
      else: next = binaries[n+1]

      start_html (fid, binaries[n], prev, 'index', '../index', next)
      fid.write ('<h2>Description</h2>\n')

      line = 0
      while not H[line].startswith ('ARGUMENT') and not H[line].startswith('OPTION'):
        if len(description) <= n: description.append (H[line])
        fid.write ('<p>\n' + H[line] + '\n</p>\n')
        line += 1
  
      arg = []
      opt = []
      while line < len(H)-2:
        if not H[line].startswith ('ARGUMENT') and not H[line].startswith ('OPTION'):
          sys.stderr.write ('ERROR: malformed usage for executable "' + binaries[n] + '" - aborting' + os.linesep)
          return 1
  
        if H[line].startswith ('ARGUMENT'):
          S = H[line].split (None, 5)
          A = [ S[1], int(S[2]), int(S[3]), S[4], H[line+1], H[line+2] ]
          if len(opt) > 0: opt[-1].append (A)
          else: arg.append(A)
  
        elif H[line].startswith ('OPTION'):
          S = H[line].split (None, 4)
          A = [ S[1], int(S[2]), int(S[3]), H[line+1], H[line+2] ]
          opt.append (A)
  
        line += 3
  
      fid.write ('<p class=indented><strong>syntax:</strong> &nbsp; &nbsp; ' + binaries[n] + ' [ options ] ')
      for A in arg:
        if A[1] == 0: fid.write ('[ ')
        fid.write (A[0] + ' ')
        if A[2] == 1: fid.write ('[ ' + A[0] + ' ... ')
        if A[1] == 0 or A[2] == 1: fid.write ('] ')
      fid.write ('</p>\n<h2>Arguments</h2>\n<table class=args>\n')
  

      for A in arg:
        fid.write ('<tr><td><b>' + A[0] + '</b>')
        if A[1] == 0 or A[2] == 1:
          fid.write (' [ ')
          if A[1] == 0: 
            fid.write ('optional')
            if A[2] == 1: fid.write (', ')
          if A[2] == 1: fid.write ('multiples allowed')
          fid.write (' ]')
        fid.write ('</td>\n<td>' + A[5] + '</td></tr>\n')
      fid.write ('</table>\n')

      fid.write ('<h2>Options</h2>\n<table class=args>\n')
      for O in opt:
        fid.write ('<tr><td><b>-' + O[0] + '</b>')
        for A in O[5:]: fid.write ('&nbsp;<i>' + A[0] + '</i>')
        fid.write ('</td>\n<td>' + O[4])
        if len(O) > 5:
          fid.write ('\n<table class=opts>\n')
          for A in O[5:]:
            fid.write ('<tr><td><i>' + A[0] + '</i></td>\n<td>' + A[5] + '</td></tr>\n')
          fid.write ('</table>')
        fid.write ('</td></tr>\n')
      fid.write ('</table>\n')
  
      fid.write ('</body>\n</html>')
  

  with codecs.open (os.path.join (doc_dir, 'commands', 'index.html'), mode='w', encoding='utf-8') as fid:
    start_html (fid, 'list of MRtrix commands', '../faq', '../index', '../index', '../appendix/index')
    fid.write ('<table class=cmdindex width=100%>\n')

    for n in range (0,len(binaries)):
      fid.write ('<tr><td><a href="' + binaries[n] + '.html">' + binaries[n] + '</a></td><td>' + description[n] + '</td></tr>\n')
    fid.write ('</table>\n</body>\n</html>')




def clean_cmd ():
  files_to_remove = []
  for root, dirs, files in os.walk ('.'):
    for file in files:
      if file[0] == '.': continue
      if file.endswith (obj_suffix) or ( file.startswith (lib_prefix) and file.endswith (lib_suffix) ) or file.endswith ('_moc'+cpp_suffix):
        files_to_remove.append (os.path.join (root, file))
        
  dirs_to_remove = []
  if os.path.isdir (bin_dir):
    for root, dirs, files in os.walk (bin_dir, topdown=False):
      for file in files: 
        files_to_remove.append (os.path.join (root, file))
      for entry in dirs: 
        dirs_to_remove.append (os.path.join (root, entry))
  
  if os.path.isdir (dev_dir):
    sys.stderr.write ('[RM] development doc' + os.linesep)
    for root, dirs, files in os.walk (dev_dir, topdown=False):
      for entry in files:
        os.remove (os.path.join (root, entry))
      for entry in dirs:
        os.rmdir (os.path.join (root, entry))
    os.rmdir (dev_dir)

  if len(files_to_remove):
    sys.stderr.write ('[RM] ' + ' '.join(files_to_remove) + os.linesep)
    for entry in files_to_remove: 
      os.remove (entry)

  if len(dirs_to_remove):
    sys.stderr.write ('[RM] ' + ' '.join (dirs_to_remove) + os.linesep)
    for entry in dirs_to_remove: 
      os.rmdir (entry)



def get_git_version (folder):
  if verbose:
    sys.stderr.write ('''
getting git version in folder "''' + folder + '"... ')

  try: 
    process = subprocess.Popen ([ 'git', 'describe', '--abbrev=8', '--dirty', '--always' ], cwd=folder, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
    ( git_version, stderr ) = process.communicate()
    if process.returncode == 0:
      git_version = git_version.decode("utf-8").strip()
      if verbose:
        sys.stderr.write (git_version + '\n')
      return git_version
  except:
    pass

  if verbose:
    sys.stderr.write ('not found\n')
  return 'unknown'


def update_git_version (folder, git_version_file, macro_name):
  git_version = get_git_version (folder)
  version_file_contents = '#define ' + macro_name + ' "' + git_version + '"\n'
  current_version_file_contents = ''
  try:
    with open (git_version_file) as fd:
      current_version_file_contents = fd.read()
  except:
    pass
    
  if not version_file_contents == current_version_file_contents:
    if verbose:
      sys.stderr.write ('version file "' + git_version_file + '" is out of date - updating\n')
    with open (git_version_file, 'w') as fd:
      fd.write (version_file_contents)



###########################################################################
#                            START OF PROGRAM
###########################################################################



if 'clean' in targets:
  clean_cmd()
  sys.exit (0)

if doc_dir in targets: 
  sys.exit (gen_command_html_help());
    
if dev_dir in targets: 
  sys.exit (execute ('[DOC] development', [ 'doxygen' ]))
    
if len(targets) == 0: 
  targets = default_targets()



# get git version info:
update_git_version (mrtrix_dir, os.path.join (mrtrix_dir, 'lib/version.h'), 'MRTRIX_GIT_VERSION')

if separate_project:
  if not os.path.exists (misc_dir):
    os.mkdir (misc_dir)
  git_version_file = os.path.join (misc_dir, 'project_version.h')
  update_git_version ('.', git_version_file, 'MRTRIX_PROJECT_VERSION');
  if not os.path.exists (git_version_file):
    with open (git_version_file, 'w'):
      pass


    




if verbose:
  sys.stderr.write ('''
compiling TODO list...
''')

try: [ Entry(item) for item in targets ]
except Exception as e: 
  sys.stderr.write ('ERROR: ' + e.args[0] + os.linesep)
  sys.exit (1)


# for nogui config, remove GUI elements from targets and todo list:
if nogui:
  nogui_targets = []
  for entry in targets:
    if not is_GUI_target (entry):
      nogui_targets.append (entry)
  targets = nogui_targets
  
  nogui_todo = {}
  for item in todo.keys():
    if not is_GUI_target (todo[item].name):
       nogui_todo[item] = todo[item]
  todo = nogui_todo




if verbose:
  sys.stderr.write ('building targets: ' + ' '.join (targets) + os.linesep)


if dependencies:
  sys.stderr.write ('''
Printing dependencies:

''')
  for entry in targets:
    print_deps (entry)
  sys.exit (0)

todo_tmp = todo
todo = {}
for item in todo_tmp.keys():
  if not ( todo_tmp[item].action == 'NA' or (todo_tmp[item].timestamp and todo_tmp[item].timestamp >= todo_tmp[item].dep_timestamp) ):
    todo[item] = todo_tmp[item]
if verbose: 
  sys.stderr.write ('TODO list contains ' + str(len(todo)) + ''' items

''')


#for entry in todo.values(): entry.display()

if not len(todo): sys.exit(0)



try: num_processors = os.sysconf('SC_NPROCESSORS_ONLN')
except:
  try: num_processors = int(os.environ['NUMBER_OF_PROCESSORS'])
  except: num_processors = 1
  
if verbose:
  sys.stderr.write ('''

launching ''' + str(num_processors) + ''' threads

''')

threads = []
for i in range (1, num_processors):
  t = threading.Thread (target=build_next, args=(i,));
  t.start()
  threads.append (t)

build_next(0)

for t in threads: t.join()

sys.exit (stop > 1)