# Part of the A-A-P recipe executive: Dependency rules

# Copyright (C) 2002 Stichting NLnet Labs
# Permission to copy and use this file is specified in the file COPYING.
# If this file is missing you can find it here: http://www.a-a-p.org/COPYING


# A Depend object contains:
#  targetlist   - dictlist of targets
#  build_attr   - dictlist of build attributes (right after the ":")
#  sourcelist   - dictlist of sources
#  rpstack      - RecPos stack for where the commands were defined
#  commands     - string of command lines
#  builddir     - directory where "commands" are to be executed
#  matchstr     - for a rule: the string that matched %
#
# Illustration:
#       targetlist : {build_attr} sourcelist
#               commands

import os
import os.path
import string

from Error import *
import Filetype
from Util import *
from Message import *

class Depend:
   def __init__(self, targetlist, build_attr, sourcelist,
                                    work, rpstack, commands, builddir = None):
       self.targetlist = targetlist
       self.build_attr = build_attr
       self.sourcelist = sourcelist
       self.rpstack = rpstack
       self.commands = commands
       if builddir is None:
           self.builddir = os.getcwd()
       else:
           self.builddir = builddir
       self.matchstr = ''

       # Add nodes for all sources and targets, with a pointer back to the
       # node.  Also carries over the attributes to the node.
       work.dictlist_nodes(self.targetlist)
       work.dictlist_nodes(self.sourcelist)

   def __str__(self):
       from Dictlist import dictlist2str, dictlistattr2str

       return (dictlist2str(self.targetlist)
                   + " : "
                   + dictlistattr2str(self.build_attr)
                   + dictlist2str(self.sourcelist)
                   + "\n" + self.commands)


def depend_auto(work, node):
   """Find the implied dependencies for "node".  They are returned in
      node.auto_depend.
      If "node" changed since last time, regenerate the dependencies."""
   # Return quickly when the automatic dependencies were already generated.
   if not node.auto_depend is None:
       return

   # Don't generate automatic dependencies when "autodepend" is "off".
   if ((work.globals.has_key("autodepend")
               and work.globals["autodepend"] == "off")
           or (node.attributes.has_key("autodepend")
               and node.attributes["autodepend"] == "off")):
       return

   # Get the file type.
   node_name = node.get_name()
   if node.attributes.has_key("filetype"):
       ftype = node.attributes["filetype"]
   else:
       ftype = Filetype.ft_detect(node_name)
       if not ftype:
           msg_depend(_('Unknown type of file, no dependency check for "%s"')
                                                          % node.short_name())
           return

   # Make the name for the recipe that contains the automatic dependencies for
   # this node: "node_directory/aap/node_basename.aap"
   recipe_name = os.path.join(os.path.dirname(node_name),
                    os.path.join("aap", os.path.basename(node_name))) + ".aap"
   recipe = work.get_node(recipe_name, 1)

   # Trigger the rule to produce a dependency recipe for this node.
   from DoBuild import build_autodepend
   if not build_autodepend(work, recipe, ftype, node):
       return
   if not os.path.exists(recipe.name):
       msg_warning(_('Dependency file was not created: "%s"') % recipe.name)
       return

   # Read the generated recipe file.
   node.auto_depend = read_auto_depend(recipe, node_name)


def read_auto_depend(recipe, skipname):
   """Read a generated recipe file from node "recipe".
      We only want the part after the ":", the item before it may be wrong
      (gcc generates foo.o: foo.c foo.h).
      Ignore "skipname".
      Don't read the recipe as a normal recipe, that would cause trouble with
      things we don't want to find in there. """
   try:
       file = open(recipe.name, "r")
   except:
       raise UserError, _('Cannot open "%s" for reading.') % recipe.name

   from RecPos import RecPos
   from ParsePos import ParsePos
   rpstack = [ RecPos(recipe.name) ]

   # create an object to contain the file position
   fp = ParsePos(rpstack, file = file)
   fp.nextline()           # read the first (and only) line
   if fp.line is None:
       raise UserError, _('Nothing to read from "%s".') % recipe.name
   i = string.find(fp.line, ":")
   if i < 0:
       raise UserError, _('No colon found in "%s".') % recipe.name

   auto_depend = None
   if i + 1 < fp.line_len:
       from Dictlist import string2dictlist
       auto_depend = string2dictlist(rpstack, fp.line[i + 1:])

       # Remove the node itself.
       for k in auto_depend:
           if k["name"] == skipname:
               auto_depend.remove(k)

   # Check for trailing text.
   fp.nextline()
   if not fp.line is None:
       msg_warning(_('Found trailing text in "%s"') % recipe.name)

   file.close()
   return auto_depend



# vim: set sw=4 sts=4 tw=79 fo+=l:

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.