def enumerate_artifacts(self, artifact_enumerator):
   typecheck(artifact_enumerator, ArtifactEnumerator)
   value = artifact_enumerator.read(self.__condition_artifact)
   if value == "true":
     self.__true_command.enumerate_artifacts(artifact_enumerator)
   elif value == "false" and self.__false_command is not None:
     self.__false_command.enumerate_artifacts(artifact_enumerator)

 def read(self, filename):
   typecheck(filename, basestring)
   path = os.path.join(self.__path, filename)
   f = open(path, "rU")
   result = f.read()
   f.close()
   return result

  def build(self, action_runner):
    self.__lock.acquire()
    try:
      typecheck(action_runner, ActionRunner)

      while self.__num_pending > 0 and not self.failed:
        if len(self.__action_queue) == 0:
          # wait for actions
          # TODO(kenton):  Use a semaphore or something?
          self.__lock.release()
          try:
            time.sleep(1)
          finally:
            self.__lock.acquire()
          continue

        action_state = self.__action_queue.popleft()
        self.do_one_action(
            action_state.config, action_state.action, action_runner)
    except KeyboardInterrupt:
      if not self.failed:
        self.__console.write(ColoredText(ColoredText.RED, "INTERRUPTED"))
      self.failed = True
    except:
      self.failed = True
      raise
    finally:
      self.__lock.release()

def _args_to_rules(loader, args):
  """Given a list of command-line arguments like 'foo/bar.sebs:baz', return an
  iterator of rules which should be built."""

  typecheck(args, list, basestring)

  for arg in args:
    if arg.startswith("src/") or arg.startswith("src\\"):
      # For ease of use, we allow files to start with "src/", so tab completion
      # can be used.
      arg = arg[4:]
    elif arg.startswith("//"):
      # We also allow files to start with "//" which mimics to the syntax given
      # to sebs.import_.
      arg = arg[2:]
    print arg
    target = loader.load(arg)

    if isinstance(target, BuildFile):
      for name, value in target.__dict__.items():
        if isinstance(value, Rule):
          yield value
    elif not isinstance(target, Rule):
      raise UsageError("%s: Does not name a rule." % arg)
    else:
      yield target

  def add_rule(self, config, rule):
    typecheck(rule, Rule)

    rule.expand_once()

    for artifact in rule.outputs:
      self.add_artifact(config, artifact)

  def __init__(self, loader, context):
    typecheck(loader, Loader)
    typecheck(context, _ContextImpl)
    self.Rule = Rule
    self.Test = Test
    self.ArgumentSpec = ArgumentSpec
    self.Artifact = Artifact
    self.Action = Action
    self.DefinitionError = DefinitionError
    self.typecheck = typecheck

    self.Command            = command.Command
    self.EchoCommand        = command.EchoCommand
    self.EnvironmentCommand = command.EnvironmentCommand
    self.DoAllCommand       = command.DoAllCommand
    self.ConditionalCommand = command.ConditionalCommand
    self.SubprocessCommand  = command.SubprocessCommand
    self.DepFileCommand     = command.DepFileCommand
    self.MirrorCommand      = command.MirrorCommand

    self.__loader = loader
    self.__context = context
    parts = context.filename.rsplit("/", 1)
    if len(parts) == 1:
      self.__prefix = ""
    else:
      self.__prefix = parts[0] + "/"

  def mkdir(self, filename):
    typecheck(filename, basestring)

    if filename in self.__files:
      raise os.error("Can't make directory because file exists: %s" % filename)
    if filename != "":
      self.mkdir(os.path.dirname(filename))
      self.__dirs.add(filename)

  def action_state(self, config, action):
    typecheck(action, Action)

    result = self.__actions.get((config, action))
    if result is None:
      result = _ActionState(action, config.root_dir, self, config)
      self.__actions[(config, action)] = result
    return result

 def touch(self, filename, mtime=None):
   typecheck(filename, basestring)
   if filename not in self.__files:
     raise os.error("File not found: " + filename)
   if mtime is None:
     mtime = time.time()
   oldtime, content = self.__files[filename]
   self.__files[filename] = (mtime, content)

  def get_disk_path(self, filename):
    """If the file is a real, on-disk file, return its path, suitable to be
    passed to open() or other file I/O routines.  If the file is not on disk,
    returns None.  The file does not necessarily have to actually exist; if it
    doesn't, this method will still return the path that the file would have
    if it did exist."""

    typecheck(filename, basestring)
    return None

  def action_state(self, action):
    typecheck(action, Action)

    result = self.__actions.get((action))
    if result is None:
      result = _ScriptActionState(action)
      action.command.write_script(_ScriptWriterImpl(result, self))
      self.__actions[(action)] = result
    return result

  def source_artifact(self, filename):
    typecheck(filename, basestring)

    if filename in self.__source_artifacts:
      return self.__source_artifacts[filename]

    result = Artifact(filename, None)
    self.__source_artifacts[filename] = result
    return result

 def execfile(self, filename, globals):
   typecheck(filename, basestring)
   if filename not in self.__files:
     raise os.error("File not found: " + filename)
   (mtime, content) = self.__files[filename]
   # Can't just exec because we want the filename in tracebacks
   # to exactly match the filename parameter to this method.
   ast = compile(content, filename, "exec")
   exec ast in globals

  def __init__(self, state_map, config, action):
    typecheck(state_map, _StateMap)
    typecheck(action, Action)

    self.__state_map = state_map
    self.__config = config
    self.__action = action
    self.inputs = []
    self.outputs = []
    self.disk_inputs = []

  def intermediate_artifact(self, filename, action, configured_name=None):
    self.__validate_artifact_name(filename, configured_name)
    typecheck(action, Action)

    if configured_name is not None:
      configured_name = ["tmp/%s/" % self.directory] + configured_name

    return self.__loader.derived_artifact(
      os.path.join("tmp", self.directory, filename), action,
      configured_name = configured_name)

  def add_artifact(self, config, artifact):
    typecheck(artifact, Artifact)

    artifact_state = self.__state_map.artifact_state(config, artifact)
    if not artifact_state.is_dirty:
      return   # Source file; nothing to do.

    # The artifact is dirty, therefore it must have an action.  Note that
    # artifact_state.artifact and artifact_state.config may differ from
    # the local artifact and config if the artifact is a reference to one
    # in another config.
    self.add_action(artifact_state.config, artifact_state.artifact.action)

  def __validate_artifact_name(self, filename, configured_name=None):
    typecheck(filename, basestring)
    normalized = os.path.normpath(filename).replace("\\", "/")
    if filename != normalized:
      raise DefinitionError(
        "File '%s' is not a normalized path name.  Please use '%s' "
        "instead." % (filename, normalized))

    if filename.startswith("../") or filename.startswith("/"):
      raise DefinitionError(
        "File '%s' points outside the surrounding directory.  To "
        "include a file from another directory, that directory must explicitly "
        "export it." % filename)

  def local_filename(self, artifact):
    if isinstance(artifact, str):
      return artifact
    typecheck(artifact, Artifact)

    parts = artifact.filename.split("/")
    if parts[0] not in ["src", "tmp", "mem"]:
      return None

    parts = parts[1:]
    dir_parts = self.directory.split("/")
    if len(parts) < len(dir_parts) or parts[:len(dir_parts)] != dir_parts:
      return None
    return "/".join(parts[len(dir_parts):])

 def run(self, context, log):
   typecheck(context, CommandContext)
   value = context.read(self.__condition_artifact)
   if value == "true":
     return self.__true_command.run(context, log)
   elif value == "false":
     if self.__false_command is not None:
       return self.__false_command.run(context, log)
     else:
       return True
   else:
     log.write("Condition artifact was not true or false: %s\n" %
               self.__condition_artifact)
     return False

  def derived_artifact(self, filename, action, configured_name=None):
    typecheck(filename, basestring)
    typecheck(action, Action)

    if filename in self.__derived_artifacts:
      raise DefinitionError(
        "Two different rules claim to build file '%s'.  Conflicting rules are "
        "'%s' and '%s'." %
        (filename, action.rule.name,
         self.__derived_artifacts[filename].action.rule.name))

    filename = os.path.normpath(filename).replace("\\", "/")
    result = Artifact(filename, action, configured_name = configured_name)
    self.__derived_artifacts[filename] = result
    return result