Added BuildTarget with enumerated data type (DEBUG|RELEASE|BOTH) to the PlatformHeade...

[mirror_edk2.git] / Tools / Source / Prototype / Module.java

import java.util.*;\r
\r
public class Module\r
{\r
  Module()\r
  {\r
  }\r
  Module(String n)\r
  {\r
    name=n;\r
  }\r
  String name;\r
\r
  public String name() { return name; }\r
\r
  public Set<LibClass> consumesLibClasses;\r
\r
  // The set of packages that this module depends upon.\r
  Set<Package> packageDepends;\r
  public Set<Package> packageDeps() { return packageDepends; }\r
\r
  public boolean autoBuild()\r
  {\r
    // This should be implemented in the derived class.\r
    return true;\r
  }\r
\r
  // Make sure that each class in this set of libclasses is declared in one\r
  // of the packages that this module depends on.\r
  public boolean validateLibClasses(Set<LibClass> classes)\r
  {\r
    for(LibClass lc : classes)\r
    {\r
      // Assume we will not find it.\r
      boolean found = false;\r
\r
      for(Package p : packageDepends)\r
      {\r
        if(p.libClassDecls.contains(lc))\r
        {\r
          found=true;\r
          break;\r
        }\r
      }\r
      if(found == false)\r
      {\r
        // Error: This LibClass is not found in any of our Packages.\r
        return false;\r
      }\r
    }\r
    // Well, we never came up empty handed, so it looks good.\r
    return true;\r
  }\r
\r
  public Set<LibClass> libClassesProduced(Collection<LibInst> instances)\r
  {\r
    // given a set of lib instances, what is the set of lib classes produced?\r
\r
    Set<LibClass> classes = new HashSet<LibClass>();\r
\r
    for(LibInst li : instances)\r
    {\r
      classes.addAll(li.producesLibClasses);\r
    }\r
    return classes;\r
  }\r
\r
  // Search the given set of lib instance to see if, among them, they\r
  // produce the same LibClass more than once.\r
  public Set<LibClass> duplicateLibClasses(Set<LibInst> libs)\r
  {\r
    // Return true iff each class produced is produced only once.\r
\r
    List<LibClass> classes = new LinkedList<LibClass>();\r
    Set<LibClass> dups = new HashSet<LibClass>();\r
\r
    for(LibInst li : libs)\r
    {\r
      classes.addAll(li.producesLibClasses);\r
    }\r
\r
    for(LibClass c : classes)\r
    {\r
      for(LibClass inner : classes)\r
      {\r
        if(c.equals(inner))\r
        {\r
          dups.add(c);\r
        }\r
      }\r
    }\r
    return dups;\r
  }\r
\r
  public Set<LibInst> getProducers(LibClass lc, Set<LibInst> libs)\r
  {\r
    // Return the subset of the given libs that produce this LibClass.\r
\r
    Set<LibInst> producers = new HashSet<LibInst>();\r
\r
    for(LibInst li : libs)\r
    {\r
      if(li.producesLibClasses.contains(lc))\r
      {\r
        producers.add(li);\r
      }\r
    }\r
    return producers;\r
  }\r
 \r
  // \r
  // The central dependency relationship between library instances is as follows.\r
  // A LibInst "A" depends upon LibInst "B" if, and only if, there exists a LibClass\r
  // "C" such that A consumes C and B produces C. This is the partial order over which \r
  // we construct a Directed Acyclic Graph (DAG). The DAG can be used to detect\r
  // cycles in the depends relation (which are illegal) and it can be used to implement a\r
  // topological sort which is a total ordering over LibInstances. This total order on \r
  // lib instances is what is needed in order to call the constructors and destructors\r
  // in the proper sequence.\r
  //\r
  public DAG<LibInst> makeDAG(Set<LibInst> libs)\r
  {\r
    DAG<LibInst> dag = new DAG<LibInst>();\r
\r
    if(duplicateLibClasses(libs).size()>0)\r
    {\r
      System.out.format("Error: The library instances implement at least one "\r
        + "library class more than once.\n");\r
    }\r
\r
    for(LibInst consumer : libs)\r
    {\r
      // Find all the producers for each LC that li consumes. \r
      for(LibClass lc : consumer.consumesLibClasses )\r
      {\r
        Set<LibInst> producers = getProducers(lc, libs);\r
        if(producers.isEmpty())\r
        {\r
          System.out.format("Error: Unmet dependency libclass:%s .", lc.name() );\r
          return null;\r
        }\r
\r
        // There is exactly one lib inst that produces this class.\r
        LibInst producer = producers.iterator().next();\r
\r
        // Now we are ready to add the dependency to the dag. It will flag  \r
        // circular dependencies for us.\r
        dag.add(consumer, producer);\r
      }\r
    }\r
    return dag;\r
  }\r
\r
  // As you evaluate each node in the graph (starting with the module node), you\r
  // must call the constructors for all the child nodes before you call the\r
  // constructor for the current node.   \r
  public List<LibInst> getConstructorOrder(Set<LibInst> libs)\r
  {\r
    List<LibInst> rev = new LinkedList<LibInst>();\r
\r
    for(LibInst li : getDestructorOrder(libs))\r
      rev.add(0, li);    \r
\r
    return rev;\r
  }\r
\r
  // The destructor order is exactly the reverese of the constructor order.\r
  // As you evaluate each node in the graph (starting with the module node), you\r
  // must call the destructor for the all the parent nodes before calling the\r
  // destructors for the current node, and then call the destructors for all the\r
  // child nodes. \r
  public List<LibInst> getDestructorOrder(Set<LibInst> libs)\r
  {\r
    DAG<LibInst> dag = makeDAG(libs);\r
\r
    return dag.sort();\r
  }\r
}\r