@Override
public void execute(final GUI gui) {
final DialogExport dialog = new DialogExport(gui);
if (!dialog.ok()) return;
final IOFile root = new IOFile(dialog.path());
// check if existing files will be overwritten
if (root.exists()) {
IO file = null;
boolean overwrite = false;
final Data d = gui.context.data();
final IntList il = d.resources.docs();
final int is = il.size();
for (int i = 0; i < is; i++) {
file = root.merge(Token.string(d.text(il.get(i), true)));
if (file.exists()) {
if (overwrite) {
// more than one file will be overwritten; check remaining tests
file = null;
break;
}
overwrite = true;
}
}
if (overwrite) {
// show message for overwriting files or directories
final String msg = file == null ? FILES_REPLACE_X : FILE_EXISTS_X;
if (file == null) file = root;
if (!BaseXDialog.confirm(gui, Util.info(msg, file))) return;
}
}
DialogProgress.execute(gui, new Export(root.path()));
}
/**
* Fills in all used scopes of the given one.
*
* @param curr current scope
* @return IDs of all directly reachable scopes
* @throws QueryException if a variable directly calls itself
*/
private int[] neighbors(final Scope curr) throws QueryException {
final IntList adj = new IntList(0);
final boolean ok =
curr.visit(
new ASTVisitor() {
@Override
public boolean staticVar(final StaticVar var) {
return var != curr && neighbor(var);
}
@Override
public boolean staticFuncCall(final StaticFuncCall call) {
return neighbor(call.func());
}
@Override
public boolean inlineFunc(final Scope sub) {
return sub.visit(this);
}
@Override
public boolean funcItem(final FuncItem func) {
return neighbor(func);
}
/**
* Adds a neighbor of the currently inspected scope.
*
* @param scp the neighbor
* @return {@code true} for convenience
*/
private boolean neighbor(final Scope scp) {
final int old = id(scp), id = old == -1 ? add(scp) : old;
if (old == -1 || !adj.contains(id)) adj.add(id);
return true;
}
});
if (!ok) {
final StaticVar var = (StaticVar) curr;
throw CIRCREF_X.get(var.info, "$" + var.name);
}
return adj.finish();
}
/**
* Algorithm of Tarjan for computing the strongly connected components of a graph.
*
* @param v current node
* @throws QueryException if a variable directly calls itself
*/
private void tarjan(final int v) throws QueryException {
final int ixv = 2 * v, llv = ixv + 1, idx = next++;
while (list.size() <= llv) list.add(-1);
list.set(ixv, idx);
list.set(llv, idx);
stack.push(v);
for (final int w : adjacentTo(v)) {
final int ixw = 2 * w, llw = ixw + 1;
if (list.size() <= ixw || list.get(ixw) < 0) {
// Successor w has not yet been visited; recurse on it
tarjan(w);
list.set(llv, Math.min(list.get(llv), list.get(llw)));
} else if (stack.contains(w)) {
// Successor w is in stack S and hence in the current SCC
list.set(llv, Math.min(list.get(llv), list.get(ixw)));
}
}
// If v is a root node, pop the stack and generate an SCC
if (list.get(llv) == list.get(ixv)) {
int w;
Scope[] out = null;
do {
w = stack.pop();
final Scope scp = scopes.get(w);
out = out == null ? new Scope[] {scp} : Array.add(out, scp);
} while (w != v);
result.add(out);
}
}