Exemple #1
0
 def collect_node_states(self):
     # returns (is_up_to_date, cached_error, cachable)
     # where is_up_to_date is 1, if the node(s) are up_to_date
     #       cached_error  is 1, if the node(s) are up_to_date, but the
     #                           build will fail
     #       cachable      is 0, if some nodes are not in our cache
     T = 0
     changed = False
     cached_error = False
     cachable = True
     for t in self.targets:
         if T: Trace('%s' % (t))
         bi = t.get_stored_info().binfo
         if isinstance(bi, SConfBuildInfo):
             if T: Trace(': SConfBuildInfo')
             if cache_mode == CACHE:
                 t.set_state(SCons.Node.up_to_date)
                 if T: Trace(': set_state(up_to-date)')
             else:
                 if T: Trace(': get_state() %s' % t.get_state())
                 if T: Trace(': changed() %s' % t.changed())
                 if (t.get_state() != SCons.Node.up_to_date
                         and t.changed()):
                     changed = True
                 if T: Trace(': changed %s' % changed)
             cached_error = cached_error or bi.result
         else:
             if T: Trace(': else')
             # the node hasn't been built in a SConf context or doesn't
             # exist
             cachable = False
             changed = (t.get_state() != SCons.Node.up_to_date)
             if T: Trace(': changed %s' % changed)
     if T: Trace('\n')
     return (not changed, cached_error, cachable)
    def changed(self, node=None):
        """
        Returns if the node is up-to-date with respect to the BuildInfo
        stored last time it was built.  The default behavior is to compare
        it against our own previously stored BuildInfo, but the stored
        BuildInfo from another Node (typically one in a Repository)
        can be used instead.

        Note that we now *always* check every dependency.  We used to
        short-circuit the check by returning as soon as we detected
        any difference, but we now rely on checking every dependency
        to make sure that any necessary Node information (for example,
        the content signature of an #included .h file) is updated.
        """
        t = 0
        if t: Trace('changed(%s [%s], %s)' % (self, classname(self), node))
        if node is None:
            node = self

        result = False

        bi = node.get_stored_info().binfo
        then = bi.bsourcesigs + bi.bdependsigs + bi.bimplicitsigs
        children = self.children()

        diff = len(children) - len(then)
        if diff:
            # The old and new dependency lists are different lengths.
            # This always indicates that the Node must be rebuilt.
            # We also extend the old dependency list with enough None
            # entries to equal the new dependency list, for the benefit
            # of the loop below that updates node information.
            then.extend([None] * diff)
            result = True

        for child, prev_ni in zip(children, then):
            if child.changed_since_last_build(self, prev_ni):
                if t: Trace(': %s changed' % child)
                result = True

        contents = self.get_executor().get_contents()
        if self.has_builder():
            import SCons.Util
            newsig = SCons.Util.MD5signature(contents)
            if bi.bactsig != newsig:
                if t: Trace(': bactsig %s != newsig %s' % (bi.bactsig, newsig))
                result = True

        if not result:
            if t: Trace(': up to date')

        if t: Trace('\n')

        return result
Exemple #3
0
def trace(token, newstate):
    from SCons.Debug import Trace
    statename = newstate.__class__.__name__
    Trace('token = %s, state = %s\n' % (repr(token), statename))