/**
* Sets a mnemomic for the specified button.
*
* @param b button
* @param mnem mnemonics that have already been assigned
*/
public static void setMnemonic(final AbstractButton b, final StringBuilder mnem) {
// do not set mnemonics for Mac! Alt+key used for special characters.
if (Prop.MAC) return;
// find and assign unused mnemomic
final String label = b.getText();
final int ll = label.length();
for (int l = 0; l < ll; l++) {
final char ch = Character.toLowerCase(label.charAt(l));
if (!letter(ch) || mnem.indexOf(Character.toString(ch)) != -1) continue;
b.setMnemonic(ch);
mnem.append(ch);
break;
}
}
/**
* Handles info messages resulting from a query execution.
*
* @param msg info message
* @return true if error was found
*/
private boolean error(final String msg) {
final String line = msg.replaceAll("[\\r\\n].*", "");
Matcher m = XQERROR.matcher(line);
int el, ec = 2;
if (!m.matches()) {
m = XMLERROR.matcher(line);
if (!m.matches()) return true;
el = Integer.parseInt(m.group(1));
errFile = getEditor().file.path();
} else {
el = Integer.parseInt(m.group(1));
ec = Integer.parseInt(m.group(2));
errFile = m.group(3);
}
final EditorArea edit = find(IO.get(errFile), false);
if (edit == null) return true;
// find approximate error position
final int ll = edit.last.length;
int ep = ll;
for (int e = 1, l = 1, c = 1; e < ll; ++c, e += cl(edit.last, e)) {
if (l > el || l == el && c == ec) {
ep = e;
break;
}
if (edit.last[e] == '\n') {
++l;
c = 0;
}
}
if (ep < ll && Character.isLetterOrDigit(cp(edit.last, ep))) {
while (ep > 0 && Character.isLetterOrDigit(cp(edit.last, ep - 1))) ep--;
}
edit.error(ep);
errPos = ep;
return true;
}
/**
* Reads the configuration file and initializes the project properties. The file is located in the
* project home directory.
*
* @param prop property file extension
*/
protected synchronized void read(final String prop) {
file = new IOFile(HOME + IO.BASEXSUFFIX + prop);
final StringList read = new StringList();
final TokenBuilder err = new TokenBuilder();
if (!file.exists()) {
err.addExt("Saving properties in \"%\"..." + NL, file);
} else {
BufferedReader br = null;
try {
br = new BufferedReader(new FileReader(file.file()));
for (String line; (line = br.readLine()) != null; ) {
line = line.trim();
if (line.isEmpty() || line.charAt(0) == '#') continue;
final int d = line.indexOf('=');
if (d < 0) {
err.addExt("%: \"%\" ignored. " + NL, file, line);
continue;
}
final String val = line.substring(d + 1).trim();
String key = line.substring(0, d).trim();
// extract numeric value in key
int num = 0;
final int ss = key.length();
for (int s = 0; s < ss; ++s) {
if (Character.isDigit(key.charAt(s))) {
num = Integer.parseInt(key.substring(s));
key = key.substring(0, s);
break;
}
}
read.add(key);
final Object entry = props.get(key);
if (entry == null) {
err.addExt("%: \"%\" not found. " + NL, file, key);
} else if (entry instanceof String) {
props.put(key, val);
} else if (entry instanceof Integer) {
props.put(key, Integer.parseInt(val));
} else if (entry instanceof Boolean) {
props.put(key, Boolean.parseBoolean(val));
} else if (entry instanceof String[]) {
if (num == 0) {
props.put(key, new String[Integer.parseInt(val)]);
} else {
((String[]) entry)[num - 1] = val;
}
} else if (entry instanceof int[]) {
((int[]) entry)[num] = Integer.parseInt(val);
}
}
} catch (final Exception ex) {
err.addExt("% could not be parsed." + NL, file);
Util.debug(ex);
} finally {
if (br != null)
try {
br.close();
} catch (final IOException ex) {
}
}
}
// check if all mandatory files have been read
try {
if (err.isEmpty()) {
boolean ok = true;
for (final Field f : getClass().getFields()) {
final Object obj = f.get(null);
if (!(obj instanceof Object[])) continue;
final String key = ((Object[]) obj)[0].toString();
ok &= read.contains(key);
}
if (!ok) err.addExt("Saving properties in \"%\"..." + NL, file);
}
} catch (final IllegalAccessException ex) {
Util.notexpected(ex);
}
if (!err.isEmpty()) {
Util.err(err.toString());
write();
}
}
/**
* Returns the specified function.
*
* @param name name of the function
* @param args optional arguments
* @param dyn compile-/run-time flag
* @param ctx query context
* @param ii input info
* @return function instance
* @throws QueryException query exception
*/
public TypedFunc get(
final QNm name,
final Expr[] args,
final boolean dyn,
final QueryContext ctx,
final InputInfo ii)
throws QueryException {
// find function
final byte[] uri = name.uri();
final byte[] ln = name.local();
// parse data type constructors
if (eq(uri, XSURI)) {
final Type type = AtomType.find(name, true);
if (type == null || type == AtomType.NOT || type == AtomType.AAT) {
final Levenshtein ls = new Levenshtein();
for (final AtomType t : AtomType.values()) {
if (t.par != null && ls.similar(lc(ln), lc(t.string()), 0))
FUNSIMILAR.thrw(ii, name.string(), t.string());
}
FUNCUNKNOWN.thrw(ii, name.string());
}
if (args.length != 1) FUNCTYPE.thrw(ii, name.string());
final SeqType to = SeqType.get(type, SeqType.Occ.ZO);
return TypedFunc.constr(new Cast(ii, args[0], to), to);
}
// check Java functions - only allowed with administrator permissions
if (startsWith(uri, JAVAPRE) && ctx.context.user.perm(User.ADMIN)) {
final String c = string(substring(uri, JAVAPRE.length));
// convert dashes to upper-case initials
final TokenBuilder tb = new TokenBuilder().add(c).add('.');
boolean dash = false;
for (int p = 0; p < ln.length; p += cl(ln, p)) {
final int ch = cp(ln, p);
if (dash) {
tb.add(Character.toUpperCase(ch));
dash = false;
} else {
dash = ch == '-';
if (!dash) tb.add(ch);
}
}
final String java = tb.toString();
final int i = java.lastIndexOf(".");
final Class<?> cls = Reflect.find(java.substring(0, i));
if (cls == null) FUNCJAVA.thrw(ii, java);
final String mth = java.substring(i + 1);
return TypedFunc.java(new JavaFunc(ii, cls, mth, args));
}
// check predefined functions
final FuncCall fun = Functions.get().get(ln, uri, args, ctx, ii);
if (fun != null) {
for (final Function f : Function.UPDATING) {
if (fun.def == f) {
ctx.updating = true;
break;
}
}
return new TypedFunc(fun, fun.def.type(args.length));
}
// find local function
for (int l = 0; l < func.length; ++l) {
final QNm qn = func[l].name;
if (eq(ln, qn.local()) && eq(uri, qn.uri()) && args.length == func[l].args.length)
return new TypedFunc(add(ii, qn, l, args), FuncType.get(func[l]));
}
// add function call for function that has not been defined yet
if (!dyn && Types.find(name, false) == null) {
return new TypedFunc(
add(ii, name, add(new UserFunc(ii, name, new Var[args.length], null, false), ii), args),
FuncType.arity(args.length));
}
return null;
}
