Ejemplo n.º 1
1
 public Set /*<PCNode>*/ matchClass(Pattern simple_name_pattern) {
   Set this_class = matchSpecific(simple_name_pattern);
   Set this_class_names = new HashSet();
   Iterator tsi = this_class.iterator();
   while (tsi.hasNext()) {
     PCNode pc = (PCNode) tsi.next();
     this_class_names.add(pc.name);
   }
   Iterator pi = parents.iterator();
   while (pi.hasNext()) {
     PCNode parent = (PCNode) pi.next();
     // System.out.println("Parent: "+parent);
     Set parent_class = parent.matchClass(simple_name_pattern);
     Iterator osi = parent_class.iterator();
     while (osi.hasNext()) {
       PCNode pc = (PCNode) osi.next();
       if (!this_class_names.contains(pc.name)) {
         this_class.add(pc);
       }
     }
   }
   if (abc.main.Debug.v().namePatternProcessing)
     System.out.println(this + ".matchClass " + simple_name_pattern.pattern() + ": " + this_class);
   return this_class;
 }
Ejemplo n.º 2
0
  private void checkStartup(
      Map<String, ServiceData> map,
      List<ServiceData> start,
      ServiceData sd,
      Set<ServiceData> cyclic) {
    if (sd.after.isEmpty() || start.contains(sd)) return;

    if (cyclic.contains(sd)) {
      reporter.error("Cyclic dependency for " + sd.name);
      return;
    }

    cyclic.add(sd);

    for (String dependsOn : sd.after) {
      if (dependsOn.equals("boot")) continue;

      ServiceData deps = map.get(dependsOn);
      if (deps == null) {
        reporter.error("No such service " + dependsOn + " but " + sd.name + " depends on it");
      } else {
        checkStartup(map, start, deps, cyclic);
      }
    }
    start.add(sd);
  }
Ejemplo n.º 3
0
  public static void dfs(int x) {
    Set<Integer> L = new HashSet<Integer>();
    while (!L.contains(x)) {
      if (S[x]) return;
      L.add(x);
      S[x] = true;
      x = f[x];
    }
    if (cycle[x]) return;

    cycle_cnt++;
    do {
      cycle[x] = true;
      x = f[x];
    } while (!cycle[x]);
  }
Ejemplo n.º 4
0
  /*
     public String transformedName() {
  if (outer != null) {
      String ps = outer.toString();
      if (ps.equals("")) {
  	return name;
      } else {
  	if (outer.isClass()) {
  	    return ps+"$"+name;
  	} else {
  	    return ps+"."+name;
  	}
      }
  }
  return "";
     }
     */
  public Set /*<PCNode>*/ matchScope(
      Pattern simple_name_pattern, Set /*<PCNode>*/ classes, Set /*<PCNode>*/ packages) {
    Set this_scope = matchClass(simple_name_pattern);
    Set this_scope_names = new HashSet();
    Iterator tsi = this_scope.iterator();
    while (tsi.hasNext()) {
      PCNode pc = (PCNode) tsi.next();
      // Add name to shadow outer classes
      this_scope_names.add(pc.name);
    }
    if (is_class) {
      // Match inner classes of outer classes or same package
      Set outer_scope = outer.matchScope(simple_name_pattern, classes, packages);
      Iterator osi = outer_scope.iterator();
      while (osi.hasNext()) {
        PCNode pc = (PCNode) osi.next();
        if (!this_scope_names.contains(pc.name)) {
          this_scope.add(pc);
          // Nothing to shadow here
        }
      }
    } else {
      // Match specifically imported classes
      Iterator ci = classes.iterator();
      while (ci.hasNext()) {
        PCNode c = (PCNode) ci.next();
        if (!this_scope_names.contains(c.name)) {
          // Add name to list to shadow nonspecifically imported classes
          this_scope_names.add(c.name);
          // If it matches the pattern, add it to the list of matches
          if (simple_name_pattern.matcher(c.name).matches()) {
            this_scope.add(c);
          }
        }
      }
      // Match nonspecifically imported classes
      Set /*<String>*/ new_names = new HashSet();
      Iterator pi = packages.iterator();
      while (pi.hasNext()) {
        PCNode p = (PCNode) pi.next();
        Set /*<PCNode>*/ p_matches = p.matchSpecific(simple_name_pattern);
        Iterator pci = p_matches.iterator();
        while (pci.hasNext()) {
          PCNode pc = (PCNode) pci.next();
          if (!this_scope_names.contains(pc.name)) {
            // Nonspecifically imported classes do not shadow each other,
            // but they may shadow toplevel packages
            new_names.add(pc.name);
            // If it matches the pattern, add it to the list of matches
            if (simple_name_pattern.matcher(pc.name).matches()) {
              this_scope.add(pc);
            }
          }
        }
      }
      this_scope_names.addAll(new_names);

      // Finally, match toplevel classes and packages
      Iterator tli = root.root.matchSpecific(simple_name_pattern).iterator();
      while (tli.hasNext()) {
        PCNode tl = (PCNode) tli.next();
        if (!this_scope_names.contains(tl.name)) {
          // If it matches the pattern, add it to the list of matches
          if (simple_name_pattern.matcher(tl.name).matches()) {
            this_scope.add(tl);
          }
        }
      }
    }
    if (abc.main.Debug.v().namePatternProcessing)
      System.out.println(this + ".matchScope " + simple_name_pattern.pattern() + ": " + this_scope);
    return this_scope;
  }
Ejemplo n.º 5
0
 public boolean hasFlag(Flag f) {
   return flags.contains(f);
 }