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;
}
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);
}
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]);
}
/*
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;
}
public boolean hasFlag(Flag f) {
return flags.contains(f);
}