import javax.swing.event.AncestorListener;
import javax.swing.event.AncestorEvent;
import javax.swing.Timer;
public class main {
static class GenTesting {
Object makeGenerators; // voidfunc(L<Gen> gens, L<S> log)
// method to compare generator output & user line
String comparison = "eqic";
GenTesting(Object makeGenerators) {
this.makeGenerators = makeGenerators;}
MultiSet<String> scoreGenerators(List<String> log) {
return scoreGenerators(log, null);
}
MultiSet<String> scoreGenerators(List<String> log, BitSet interestingLines) {
new MultiSet<String> scores;
for (int i = 0; i < l(log); i++)
if (interestingLines == null || interestingLines.get(i))
scoreGenerators1(subList(log, 0, i+1), scores);
print(/*asciiHeading2("SCORES")*/);
for (String name : scores.getTopTen())
print(" [" + scores.get(name) + "] " + name);
print();
return scores;
}
void scoreGenerators1(List<String> log, MultiSet<String> scores) {
if (empty(log)) return;
String line = last(log);
log = dropLast(log);
genLog_set(log);
try {
List<Gen> gens = makeGenerators(log);
for (Gen gen : gens) {
try {
if (compare(callGen(gen), line))
scores.add(gen.name);
} catch (Throwable _e) {}
}
} finally {
genLog_clear();
}
}
String callSingle(List<String> log, Object genName) {
genLog_set(log);
try {
List<Gen> gens = makeGenerators(log);
Gen gen = findByField(gens, "name", genName);
if (gen == null) return null;
return callGen(gen);
} finally {
genLog_clear();
}
}
boolean verifySingle(List<String> log, Object genName) {
if (empty(log)) return false;
String line = last(log);
log = dropLast(log);
genLog_set(log);
try {
List<Gen> gens = makeGenerators(log);
Gen gen = findByField(gens, "name", genName);
if (gen == null) return false;
try {
if (compare(callGen(gen), line)) return true;
} catch (Throwable _e) {} return false;
} finally {
genLog_clear();
}
}
List<Gen> makeGenerators(List<String> log) {
new List<Gen> gens;
callF(makeGenerators, gens, log);
return gens;
}
// returns score
int scoreGenerator(List<String> log, String genName) {
int score = 0;
for (int i = 1; i < l(log); i++) {
String expect = log.get(i), s = null;
boolean ok = false;
try {
s = callSingle(subList(log, 0, i), genName);
ok = compare(s, expect);
} catch (Throwable e) {
s = exceptionToStringShort(e);
}
if (ok) {
++score;
print(genName + " OK: " + s + (eq(s, expect) ? "" : " / " + expect));
} else
print(genName + " NO [" + s + "]: " + expect);
}
print();
return score;
}
boolean compare(String a, String b) {
if (eq(comparison, "eq"))
return eq(a, b);
else if (eq(comparison, "eqic"))
return eqic(a, b);
else if (eq(comparison, "match"))
return match(a, b);
else
throw fail("Unknown comparison: " + comparison);
}
// run a single generator on all lines and print each line
void debugSingle(List<String> log, String name) {
for (int i = 0; i < l(log); i++)
debugSingle1(subList(log, 0, i+1), name);
}
void debugSingle1(List<String> log, String genName) {
String line = last(log);
log = dropLast(log);
genLog_set(log);
try {
List<Gen> gens = makeGenerators(log);
Gen gen = findByField(gens, "name", genName);
if (gen == null) return;
boolean ok = false;
try {
ok = compare(callGen(gen), line);
} catch (Throwable _e) {}
print((ok ? "OK" : "NO") + " " + line);
} finally {
genLog_clear();
}
}
} // GenTesting
static class Thinker {
List<String> ranking = synchroList();
int listMakingTimeout = 2000;
int maxListLength = 100;
boolean showExceptions, debug;
volatile int load;
void startUp(List<String> log) {
readLocally2(this, "ranking");
print("Ranking: " + structure(ranking));
}
MultiSet<String> scores(List<String> log) {
return makeGT().scoreGenerators(log);
}
MultiSet<String> scores(List<String> log, BitSet interestingLines) {
return makeGT().scoreGenerators(log, interestingLines);
}
GenTesting makeGT() {
return new GenTesting(new Object { void get(List<Gen> gens, List<String> log) { makeGenerators(gens, log); }
public String toString() { return "makeGenerators(gens, log);"; }});
}
// also called from outside
void recommendSolver(String solverID) {
if (!isRecommendedSolver(solverID = fsi(solverID))) {
print("Adding recommended solver: " + solverID);
logQuoted("recommendations.txt", solverID);
} else
print("Solver already recommended: " + solverID);
}
boolean isRecommendedSolver(String solverID) {
return contains(scanLog("recommendations.txt"), fsI(solverID));
}
// log = what's in the chat
// input = what user is typing
void makeListData(List<String> thelog, String input, List l) {
long started = now();
try {
long timeout = started + listMakingTimeout;
new HashMap<String, Map> seen; // maps to the line
// extended log including what user is typing
List<String> xlog = listPlus(thelog, input);
// Make generators for both modes
new List<Gen> gens;
for (boolean completing : ll(false, true)) {
new List<Gen> gens_;
try {
genLog_set(completing ? xlog : log);
gCompleting_set(completing);
makeGenerators(gens_, log);
for (Gen g : gens_)
gens.add(new Gen(g.name + gMode(), g.func));
} finally {
genLog_clear();
gCompleting_set(null);
}
}
// Rank all generators
gens = rankGenerators(gens);
// Produce list
int i = -1;
while (now() < timeout && l(l) < maxListLength && nempty(gens)) {
i = (i+1) % l(gens);
Gen gen = gens.get(i);
boolean completing = gen.name.endsWith("/i");
try {
genLog_set(completing ? xlog : log);
gCompleting_set(completing);
boolean remove = false;
if (debug)
print("Trying generator " + gen.name);
try {
String s = callGen(gen);
if (empty(s) || eq(input, s))
remove = true;
else if (seen.containsKey(s)) {
Map line = seen.get(s);
setAdd((List) line.get("Suggesters"), gen.name);
remove = true;
} else {
int k = l(l)+1;
String key = k <= 12 ? "F" + k : null;
Map line = litorderedmap("Key", key, "Suggestion", s, "Suggesters", ll(gen.name));
l.add(line);
seen.put(s, line);
}
} catch (Throwable e) {
if (showExceptions)
l.add(litorderedmap("Suggestion", "[error] " + exceptionToStringShort(e), "Suggesters", ll(gen.name)));
remove = true;
}
if (remove)
gens.remove(i--);
} finally {
genLog_clear();
gCompleting_set(null);
}
}
} catch (Throwable e) {
printStackTrace(e);
l.add(e.toString());
} finally {
load = (int) ((now()-started)*100/listMakingTimeout);
}
}
List<Gen> rankGenerators(List<Gen> gens) {
Map<String, Gen> index = indexByField(gens, "name");
new List<Gen> l;
List<String> rank = cloneList(ranking);
for (String name : rank) {
Gen g = index.get(name);
if (g != null) {
l.add(g);
index.remove(name);
}
}
l.addAll(values(index)); // add rest in unspecified order
//print("Using ranking: " + struct(rank));
//print("Ranked generators: " + struct(l));
return l;
}
void rankToTop(String name) {
if (empty(name)) return;
if (eq(first(ranking), name)) return;
ranking.remove(name);
ranking.add(0, name);
saveLocally2(this, "ranking");
print("New ranking: " + structure(ranking));
}
} // Thinker
static String generatorsID;
static JFrame frame;
static JTable table, chatTable;
//static JTextArea chat;
static JTextField input;
static List<String> log = synchroList();
static List<String> recommendations;
static List<Thread> thinkThreads = synchroList();
static JLabel status;
static String lastInput;
static int listDelay = 2000;
static int maxLineLength = 1000;
static int maxLongStringLength = 100*1000;
static Boolean thinking;
static new Thinker thinker;
static boolean showCPU = true;
static String systemPrefix = "[system]";
static String dialog = "new";
static void randomMain() {
//substanceLAF("EmeraldDusk"); // Too dark!
//substanceLAF("ChallengerDeep"); // So purple!
//substance("MistAqua");
substance("Moderate");
table = tableWithTooltips();
//chat = autoScroll(wordWrapTextArea());
chatTable = tableWithTooltips();
input = new JTextField;
status = new JLabel(" ");
frame = showFrame(vgrid(centerAndSouth(
//jtabs(1, "Chat", chat, "Details", chatTable),
chatTable,
input), centerAndSouth(table, status)));
//setFrameIconLater(frame, "#1003593");
addMenu(frame, "Random",
"Delete last line (!delete)", new Runnable() { public void run() { try { post("!delete"); } catch (Exception __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}},
"Reload generators (!gen)", new Runnable() { public void run() { try { post("!gen"); } catch (Exception __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}},
"Restart app (!restart)", new Runnable() { public void run() { try { post("!restart"); } catch (Exception __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}},
"Restart Java engine (!fresh)", new Runnable() { public void run() { try { post("!fresh"); } catch (Exception __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}},
"Execute Java code (!j ...)", new Runnable() { public void run() { try { setInput("!j 1+2"); } catch (Exception __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}},
"Switch dialog (!dialog ...)", new Runnable() { public void run() { try { setInput("!dialog bla"); } catch (Exception __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}},
"Restore last input", new Runnable() { public void run() { try { if (nempty(lastInput)) setInput(lastInput); } catch (Exception __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}},
"Show raw dialog", new Runnable() { public void run() { try { showText("Raw Dialog", rawDialog()); } catch (Exception __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}});
onEnter(input, new Runnable() { public void run() { try {
post();
} catch (Exception __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}});
onDoubleClick(table, new Object { void get(int row) {
chooseSuggestion(row);
}
public String toString() { return "chooseSuggestion(row);"; }});
for (int i = 1; i <= 12; i++) {
final int _i = i;
registerFunctionKey(frame, i, new Runnable() { public void run() { try {
chooseSuggestionForEditing(_i-1);
} catch (Exception __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}});
registerShiftFunctionKey(frame, i, new Runnable() { public void run() { try {
chooseSuggestion(_i-1);
} catch (Exception __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}});
}
onUpdate(input, new Runnable() { public void run() { try { updateOnce(); } catch (Exception __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}});
loadDialog();
logEvent("Starting");
updateOnce();
input.requestFocus();
if (isAction(last(log)) && confirmYesNo(input, "Run action? " + last(log)))
action(last(log));
}
static String getInput() {
return joinLines(" # ", input.getText().trim());
}
static void post() {
postAsUser(getInput(), null);
}
static void postAsUser(String i, Map infos) {
if (inputAllowedByUser(i))
post(i, infos);
}
static void chooseSuggestionForEditing(int row) {
Map<String, String> map = getTableLineAsMap(table, row);
if (map == null) return;
rankToTop(map);
String s = trim(unnull(map.get("Suggestion")));
logEvent("Suggestion chosen for editing", mapPlus(map, "Row", row+1, "Input", getInput(), "Top Suggesters", topSuggesters()));
setInput(s);
}
static void setInput(final String s) {
swingNowOrLater(r {
lastInput = input.getText();
input.setText(s);
input.selectAll();
input.requestFocus();
});
}
static void rankToTop(Map map) {
// Table cells have been structure'd by dataToTable
thinker.rankToTop(first((List<String>) unstructure(getString(map, "Suggesters"))));
}
static void chooseSuggestion(int row) {
Map<String, String> map = getTableLineAsMap(table, row);
if (map == null) return;
rankToTop(map);
String s = trim(unnull(map.get("Suggestion")));
if (empty(s)) return;
//logEvent("Suggestion chosen", mapPlus(map, "Row", row+1, "Input", getInput(), "Top Suggesters", topSuggesters));
setInput(s);
postAsUser(s, mapPlus(map, "Index", row+1));
}
static List topSuggesters() {
int n = 20;
n = min(n, tableRows(table));
new List topSuggesters;
for (int i = 0; i < n; i++)
topSuggesters.add(getTableLineAsMap(table, i));
//if (empty(topSuggesters)) topSuggesters = null;
return topSuggesters;
}
static void logEvent(String type) {
logEvent(type, litmap());
}
static void logEvent(String type, Map map) {
logStructure(new File(dialogDir(), "event.log"),
ll(type, chatTime(), map));
}
static boolean inputAllowedByUser(String i) {
return !swic(i, systemPrefix);
}
// may be called from other thread
static void postSystemMessage(final String msg) {
if (empty(msg)) return;
swingNowOrLater(r {
post(systemPrefix + " " + msg, litmap("By", "System"));
});
}
static void post(String i) {
post(i, null);
}
static void post(String i, Map infos) {
try {
i = trim(i);
if (empty(i)) return;
//i = escapeNewLines(i);
infos = mapPlus(infos, "Top Suggesters", topSuggesters());
boolean tooLong = l(i) > maxLongStringLength;
if (l(i) > maxLineLength) {
String id = saveLongString(i);
i = substring(i, 0, maxLineLength) + "... [" + (tooLong ? "too " : "") + "long text " + id + "]";
}
} catch (Throwable e) {
printStackTrace(e);
i = systemPrefix + " " + exceptionToStringShort(e);
}
String s = i + "\n";
//chat.append(escapeNewLines(i) + "\n");
appendToFile(logFile(), "[" + chatTime() + "] " + s);
logEvent("Posting", litmap("Text", i, "Infos", infos));
log.add(i);
updateChatTable();
input.selectAll();
updateOnce();
try {
action(i);
} catch (Throwable e) {
printStackTrace(e);
postSystemMessage(exceptionToStringShort(e));
}
}
static String dropActionPrefix(String s) {
if (s == null) return null;
s = dropBracketPrefix(s); // e.g. "[bot]"
if (!s.startsWith("!")) return null;
return s.substring(1);
}
static boolean isAction(String s) {
return dropActionPrefix(s) != null;
}
static void action(String s) {
s = dropActionPrefix(s);
if (s == null) return;
final String _s = s;
{ Thread _t_0 = new Thread("Action") {
public void run() {
try {
{ JWindow _loading_window = showLoadingAnimation(); try {
try {
genLog_set(getLog()); // 'case user needs it
randomsOwnCmds(_s);
systemCommands(_s);
} catch (Throwable e) {
printStackTrace(e);
postSystemMessage("Error - " + exceptionToStringShort(e));
}
} finally { disposeWindow(_loading_window); }}
} catch (Exception _e) {
throw _e instanceof RuntimeException ? (RuntimeException) _e : new RuntimeException(_e); } }
};
_t_0.start(); }
}
static volatile boolean again;
// This logic is bad...
static void fillList(boolean force) {
boolean t = force || shouldUpdateList();
if (neq(t, thinking)) {
thinking = t;
setFrameIcon(table, t ? "#1003603" : "#1003593");
}
if (!t) {
if (!force)
againl8r();
} else {
if (nempty(thinkThreads)) { again = true; return; }
fillListImpl();
}
}
static void fillListImpl() {
{ Thread _t_1 = new Thread("Fill List") {
public void run() {
try {
try {
thinkThreads.add(currentThread());
final new List<String> data;
thinker.makeListData(cloneList(log), getInput(), data);
swingLater(new Runnable() { public void run() { try {
try {
dataToTable_uneditable(table, data);
tableColumnMaxWidth(table, 0, 30); // "Key" column
} catch (Throwable __e) { printStackTrace(__e); }
againl8r();
} catch (Exception __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}});
} finally {
thinkThreads.remove(currentThread());
if (again) { again = false; fillListImpl(); }
}
} catch (Exception _e) {
throw _e instanceof RuntimeException ? (RuntimeException) _e : new RuntimeException(_e); } }
};
_t_1.start(); }
}
static void updateOnce() { fillList(true); }
static void againl8r() {
swingAfter(table, listDelay, new Runnable() { public void run() { try { fillList(false); } catch (Exception __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}});
}
static boolean shouldUpdateList() {
boolean result = false;
String text = " ";
if (getFrame(table).isFocused()) {
result = !mouseInComponent(table);
text = result ? " Thinking..." + (showCPU && thinker.load != 0 ? " (" + thinker.load + "%)" : "")
: "Not thinking cause you got the mouse in there";
}
status.setText(text);
return result;
}
// also called from outside
static List<String> loadLog() {
log.clear();
log.addAll(collect(scanEventLogForPosts(dialogDir()), "text"));
return log;
}
synchronized static List<String> getLastFromLog(int n) {
return cloneList(getLast(log, n));
}
synchronized static List<String> getLog() {
return cloneList(log);
}
static File dialogDir() {
return prepareProgramFile(dialog);
}
static File logFile() {
return new File(dialogDir(), "log.txt");
}
static void switchDialog(final String name) {
swingAndWait(new Runnable() { public void run() { try {
dialog = name;
loadDialog();
} catch (Exception __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}});
}
static void loadDialog() {
loadLog();
thinker = new Thinker;
thinker.startUp(log);
//chat.setText(joinLines(log));
updateChatTable();
}
static void randomsOwnCmds(String s) {
new Matches m;
if (match("dialog *", s, m)) {
switchDialog(m.unq(0));
// TODO: show current dialog somewhere else
//postSystemMessage("OK, dialog switched to " + quote(dialog));
}
if (match("gen", s, m))
generators = null;
if (match("delete", s, m))
updateChatTable();
}
static void updateChatTable() {
swingNowOrLater(r {
new List data;
List<List> l = scanLog_safeUnstructure(new File(dialogDir(), "event.log"));
for (int i = 0; i < l(l); i++) try {
List a = l.get(i), prev = get(l, i-1);
if (firstIs(a, "Posting")) {
Map map = (Map) ( get(a, 2));
String text = getString(map, "Text").trim();
if (eq(text, "!delete")) { removeLast(data); continue; }
String idx = "";
Map infos = (Map) ( map.get("Infos"));
if (infos != null && infos.containsKey("Index"))
idx = str(infos.get("Index"));
else try {
//printStruct("prev: ", prev);
if (prev != null && firstIs(prev, "Suggestion chosen for editing")) {
Map m = getMap(prev, 2);
String suggestion = getString(m, "Suggestion");
//print("Suggestion: " + structure(suggestion));
idx = str(get(m, "Row"));
if (neq(suggestion, text))
idx += "?";
}
} catch (Throwable __e) { printStackTrace(__e); }
data.add(litorderedmap("Text", escapeNewLines(text), "Sugg." /* Suggestion Index */, idx));
}
} catch (Throwable __e) { printStackTrace(__e); }
dataToTable_uneditable(chatTable, data);
tableColumnMaxWidth(chatTable, 1, 40); // enough for 2 digits and a "?"
scrollTableDown(chatTable);
});
}
static synchronized String saveLongString(String s) {
s = substring(s, 0, maxLongStringLength);
String id;
File f;
do {
id = randomID(10);
f = getProgramFile("long-strings/" + id);
} while (f.exists());
saveTextFile(f, s);
return id;
}
static Object generators;
static void makeGenerators(List<Gen> l, List<String> log) {
synchronized(main.class) {
if (!isSnippetID(generatorsID)) fail("No generators ID set");
if (generators == null)
generators = hotwire(generatorsID);
}
new List l2;
callOpt(generators, "makeGenerators", l2, log);
callOpt(generators, "deterministicGenerators", l2);
l.addAll((List) quickImport(l2));
}
static String rawDialog() {
return fromLines(log);
} // Random Main v9
p { swingLater(new Runnable() { public void run() { try {
generatorsID = "#1004039";
randomMain();
} catch (Exception __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}});}
static JTextArea showText(final String title, final String text) {
return (JTextArea) swingAndWait(new Object { Object get() {
JTextArea textArea = newTypeWriterTextArea(text);
makeFrame(title, new JScrollPane(textArea));
return textArea;
}
public String toString() { return "JTextArea textArea = newTypeWriterTextArea(text);\r\n makeFrame(title, new JScrollPane(textArea));\r\n ret textArea;"; }});
}
static JTextArea showText(Object text) {
return showText(str(text));
}
static JTextArea showText(String text) {
return showText(autoFrameTitle(), text);
}
static Object callF(Object f, Object... args) {
return callFunction(f, args);
}
static String[] dropLast(String[] a, int n) {
n = Math.min(n, a.length);
String[] b = new String[a.length-n];
System.arraycopy(a, 0, b, 0, b.length);
return b;
}
static <A> List<A> dropLast(List<A> l) {
return subList(l, 0, l(l)-1);
}
static Map<String, String> getTableLineAsMap(JTable tbl, int row) {
if (row >= 0 && row < tbl.getModel().getRowCount()) {
new Map<String, String> map;
for (int i = 0; i < tbl.getModel().getColumnCount(); i++)
map.put(tbl.getModel().getColumnName(i),
String.valueOf(tbl.getModel().getValueAt(row, i)));
return map;
}
return null;
}
static JPanel vgrid(List parts) {
return vgrid(asArray(parts));
}
static JPanel vgrid(Object... parts) {
new JPanel panel;
panel.setLayout(new GridLayout(parts.length, 1));
smartAdd(panel, parts);
return panel;
}
static String trim(String s) { return s == null ? null : s.trim(); }
static String trim(StringBuilder buf) { return buf.toString().trim(); }
static String trim(StringBuffer buf) { return buf.toString().trim(); }
// key = 1 to 12
static void registerFunctionKey(JFrame frame, int key, final Runnable r) {
String name = "F" + key;
Action action = abstractAction(name, r);
JComponent pnl = frame.getRootPane();
KeyStroke keyStroke = KeyStroke.getKeyStroke(KeyEvent.VK_F1+key-1, 0);
pnl.getActionMap().put(name, action);
pnl.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW).put(keyStroke, name);
}
static String fsI(String id) {
return formatSnippetID(id);
}
static void swingAndWait(Runnable r) { try {
if (isAWTThread())
r.run();
else
EventQueue.invokeAndWait(r);
} catch (Throwable __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}
static Object swingAndWait(final Object f) {
if (isAWTThread())
return callF(f);
else {
final new Var result;
swingAndWait(new Runnable() { public void run() { try {
result.set(callF(f));
} catch (Exception __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}});
return result.get();
}
}
static Thread currentThread() {
return Thread.currentThread();
}
static void printStackTrace(Throwable e) {
// we go to system.out now - system.err is nonsense
print(getStackTrace(e));
}
static void printStackTrace() {
printStackTrace(new Throwable());
}
static JMenu addMenu(JFrame frame, String menuName, Object... items) {
JMenuBar bar = addMenuBar(frame);
JMenu menu = new JMenu(menuName);
fillJMenu(menu, items);
bar.add(menu);
return menu;
}
static boolean mouseInComponent(Component c) {
return boundsOnScreen(c).contains(mousePosition());
}
static <A> List<A> cloneList(Collection<A> l) {
//O mutex = getOpt(l, "mutex");
/*if (mutex != null)
synchronized(mutex) {
ret new ArrayList<A>(l);
}
else
ret new ArrayList<A>(l);*/
// assume mutex is equal to collection, which will be true unless you explicitly pass a mutex to synchronizedList() which no one ever does.
synchronized(l) {
return new ArrayList<A>(l);
}
}
static Map litmap(Object... x) {
new TreeMap map;
litmap_impl(map, x);
return map;
}
static void litmap_impl(Map map, Object... x) {
for (int i = 0; i < x.length-1; i += 2)
if (x[i+1] != null)
map.put(x[i], x[i+1]);
}
// key = 1 to 12
static void registerShiftFunctionKey(JFrame frame, int key, final Runnable r) {
String name = "Shift+F" + key;
Action action = abstractAction(name, r);
JComponent pnl = frame.getRootPane();
KeyStroke keyStroke = KeyStroke.getKeyStroke(KeyEvent.VK_F1+key-1, InputEvent.SHIFT_MASK);
pnl.getActionMap().put(name, action);
pnl.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW).put(keyStroke, name);
}
static String str(Object o) {
return String.valueOf(o);
}
static RuntimeException fail() {
throw new RuntimeException("fail");
}
static RuntimeException fail(Object msg) {
throw new RuntimeException(String.valueOf(msg));
}
static RuntimeException fail(String msg) {
throw new RuntimeException(unnull(msg));
}
// disabled for now to shorten some programs
/*static RuntimeException fail(S msg, O... args) {
throw new RuntimeException(format(msg, args));
}*/
static boolean contains(Collection c, Object o) {
return c != null && c.contains(o);
}
static boolean contains(Object[] x, Object o) {
if (x != null)
for (Object a : x)
if (eq(a, o))
return true;
return false;
}
static boolean contains(String s, char c) {
return s.indexOf(c) >= 0;
}
static void logStructure(File logFile, Object o) {
logQuoted(logFile, structure(o));
}
// quick version - log to file in program directory
static void logStructure(String fileName, Object o) {
logStructure(getProgramFile(fileName), o);
}
static String fsi(String id) {
return formatSnippetID(id);
}
static String unnull(String s) {
return s == null ? "" : s;
}
static <A> List<A> unnull(List<A> l) {
return l == null ? emptyList() : l;
}
static Object[] unnull(Object[] a) {
return a == null ? new Object[0] : a;
}
static boolean swic(String a, String b) {
return startsWithIgnoreCase(a, b);
}
// runnable can be a func(O o) {} receving the selected item
static void onDoubleClick(final JList list, final Object runnable) {
list.addMouseListener(new MouseAdapter() {
public void mouseClicked(MouseEvent evt) {
if (evt.getClickCount() == 2) {
int idx = list.locationToIndex(evt.getPoint());
Object item = list.getModel().getElementAt(idx);
list.setSelectedIndex(idx);
callF(runnable, item);
}
}
});
}
// runnable can be a func(O o) {} receving the selected row index
static void onDoubleClick(final JTable table, final Object runnable) {
table.addMouseListener(new MouseAdapter() {
public void mouseClicked(MouseEvent evt) {
if (evt.getClickCount() == 2) {
int idx = table.rowAtPoint(evt.getPoint());
table.setRowSelectionInterval(idx, idx);
callF(runnable, idx);
}
}
});
}
static class DynamicObject {
String className;
new Map<String, Object> fieldValues;
}
static Object unstructure(String text) {
return unstructure(text, false);
}
// TODO: backrefs for hashmap{} etc
static Object unstructure(String text, final boolean allDynamic) {
if (text == null) return null;
final List<String> tok = javaTok(text);
final boolean debug = unstructure_debug;
class X {
int i = 1;
new HashMap<Integer, Object> refs;
Object parse() {
String t = tok.get(i);
int refID = 0;
if (t.startsWith("m") && isInteger(t.substring(1))) {
refID = parseInt(t.substring(1));
i += 2;
t = tok.get(i);
}
if (debug)
print("parse: " + quote(t));
if (t.startsWith("\"")) {
String s = unquote(tok.get(i));
i += 2;
return s;
}
if (t.startsWith("'")) {
char c = unquoteCharacter(tok.get(i));
i += 2;
return c;
}
if (t.equals("bigint"))
return parseBigInt();
if (t.equals("d"))
return parseDouble();
if (t.equals("false") || t.equals("f")) {
i += 2; return false;
}
if (t.equals("true") || t.equals("t")) {
i += 2; return true;
}
if (t.equals("-")) {
t = tok.get(i+2);
i += 4;
return isLongConstant(t) ? (Object) (-parseLong(t)) : (Object) (-parseInt(t));
}
if (isInteger(t) || isLongConstant(t)) {
i += 2;
if (debug)
print("isLongConstant " + quote(t) + " => " + isLongConstant(t));
if (isLongConstant(t)) return parseLong(t);
long l = parseLong(t);
return l != (int) l ? new Long(l) : new Integer((int) l);
}
if (t.equals("File")) {
File f = new File(unquote(tok.get(i+2)));
i += 4;
return f;
}
if (t.startsWith("r") && isInteger(t.substring(1))) {
i += 2;
int ref = Integer.parseInt(t.substring(1));
Object o = refs.get(ref);
if (o == null)
print("Warning: unsatisfied back reference " + ref);
return o;
}
return parse_inner(refID);
}
// everything that can be backreferenced
Object parse_inner(int refID) {
String t = tok.get(i);
if (debug)
print("parse_inner: " + quote(t));
if (t.equals("hashset"))
return parseHashSet();
if (t.equals("treeset"))
return parseTreeSet();
if (t.equals("hashmap"))
return parseHashMap();
if (t.equals("{"))
return parseMap();
if (t.equals("["))
return parseList();
if (t.equals("array"))
return parseArray();
if (t.equals("class"))
return parseClass();
if (t.equals("l"))
return parseLisp();
if (t.equals("null")) {
i += 2; return null;
}
if (isJavaIdentifier(t)) {
Class c = allDynamic ? null : findClass(t);
DynamicObject dO = null;
Object o = null;
if (c != null)
o = nuObject(c);
else {
dO = new DynamicObject;
dO.className = t;
}
if (refID != 0)
refs.put(refID, o);
i += 2;
if (i < tok.size() && tok.get(i).equals("(")) {
consume("(");
while (!tok.get(i).equals(")")) {
// It's like parsing a map.
//Object key = parse();
//if (tok.get(i).equals(")"))
// key = onlyField();
String key = unquote(tok.get(i));
i += 2;
consume("=");
Object value = parse();
if (o != null)
setOpt(o, key, value);
else
dO.fieldValues.put(key, value);
if (tok.get(i).equals(",")) i += 2;
}
consume(")");
}
return o != null ? o : dO;
}
throw new RuntimeException("Unknown token " + (i+1) + ": " + t);
}
Object parseSet(Set set) {
set.addAll((List) parseList());
return set;
}
Object parseLisp() {
consume("l");
consume("(");
List list = new ArrayList;
while (!tok.get(i).equals(")")) {
list.add(parse());
if (tok.get(i).equals(",")) i += 2;
}
consume(")");
return newObject("main$Lisp", (String) list.get(0), subList(list, 1));
}
Object parseList() {
consume("[");
List list = new ArrayList;
while (!tok.get(i).equals("]")) {
list.add(parse());
if (tok.get(i).equals(",")) i += 2;
}
consume("]");
return list;
}
Object parseArray() {
consume("array");
consume("{");
List list = new ArrayList;
while (!tok.get(i).equals("}")) {
list.add(parse());
if (tok.get(i).equals(",")) i += 2;
}
consume("}");
return list.toArray();
}
Object parseClass() {
consume("class");
consume("(");
String name = tok.get(i);
i += 2;
consume(")");
Class c = allDynamic ? null : findClass(name);
if (c != null) return c;
new DynamicObject dO;
dO.className = "java.lang.Class";
dO.fieldValues.put("name", name);
return dO;
}
Object parseBigInt() {
consume("bigint");
consume("(");
String val = tok.get(i);
i += 2;
if (eq(val, "-")) {
val = "-" + tok.get(i);
i += 2;
}
consume(")");
return new BigInteger(val);
}
Object parseDouble() {
consume("d");
consume("(");
String val = unquote(tok.get(i));
i += 2;
consume(")");
return Double.parseDouble(val);
}
Object parseHashMap() {
consume("hashmap");
return parseMap(new HashMap);
}
Object parseHashSet() {
consume("hashset");
return parseSet(new HashSet);
}
Object parseTreeSet() {
consume("treeset");
return parseSet(new TreeSet);
}
Object parseMap() {
return parseMap(new TreeMap);
}
Object parseMap(Map map) {
consume("{");
while (!tok.get(i).equals("}")) {
Object key = parse();
consume("=");
Object value = parse();
map.put(key, value);
if (tok.get(i).equals(",")) i += 2;
}
consume("}");
return map;
}
void consume(String s) {
if (!tok.get(i).equals(s)) {
String prevToken = i-2 >= 0 ? tok.get(i-2) : "";
String nextTokens = join(tok.subList(i, Math.min(i+4, tok.size())));
fail(quote(s) + " expected: " + prevToken + " " + nextTokens + " (" + i + "/" + tok.size() + ")");
}
i += 2;
}
}
return new X().parse();
}
static boolean unstructure_debug;
static void removeLast(List l) {
if (!l.isEmpty())
l.remove(l(l)-1);
}
public static boolean isSnippetID(String s) {
try {
parseSnippetID(s);
return true;
} catch (RuntimeException e) {
return false;
}
}
static int min(int a, int b) {
return Math.min(a, b);
}
static double min(double[] c) {
double x = Double.MAX_VALUE;
for (double d : c) x = Math.min(x, d);
return x;
}
static byte min(byte[] c) {
byte x = 127;
for (byte d : c) if (d < x) x = d;
return x;
}
static void scrollTableDown(JTable table) {
table.scrollRectToVisible(table.getCellRect(table.getRowCount()-1, 0, true));
}
// get purpose 1: access a list/array (safer version of x.get(y))
static <A> A get(List<A> l, int idx) {
return idx >= 0 && idx < l(l) ? l.get(idx) : null;
}
static <A> A get(A[] l, int idx) {
return idx >= 0 && idx < l(l) ? l[idx] : null;
}
// get purpose 2: access a field by reflection or a map
static Object get(Object o, String field) {
if (o instanceof Class) return get((Class) o, field);
if (o instanceof Map)
return ((Map) o).get(field);
if (o.getClass().getName().equals("main$DynamicObject"))
return call(get_raw(o, "fieldValues"), "get", field);
return get_raw(o, field);
}
static Object get_raw(Object o, String field) {
try {
Field f = get_findField(o.getClass(), field);
f.setAccessible(true);
return f.get(o);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
static Object get(Class c, String field) {
try {
Field f = get_findStaticField(c, field);
f.setAccessible(true);
return f.get(null);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
static Field get_findStaticField(Class<?> c, String field) {
Class _c = c;
do {
for (Field f : _c.getDeclaredFields())
if (f.getName().equals(field) && (f.getModifiers() & Modifier.STATIC) != 0)
return f;
_c = _c.getSuperclass();
} while (_c != null);
throw new RuntimeException("Static field '" + field + "' not found in " + c.getName());
}
static Field get_findField(Class<?> c, String field) {
Class _c = c;
do {
for (Field f : _c.getDeclaredFields())
if (f.getName().equals(field))
return f;
_c = _c.getSuperclass();
} while (_c != null);
throw new RuntimeException("Field '" + field + "' not found in " + c.getName());
}
static Object quickImport(Object o) {
return quickExport(o, mc());
}
static String escapeNewLines(String s) {
return s.replace("\n", " | ");
}
static JFrame showFrame() {
return makeFrame();
}
static JFrame showFrame(Object content) {
return makeFrame(content);
}
static JFrame showFrame(String title) {
return makeFrame(title);
}
static JFrame showFrame(String title, Object content) {
return makeFrame(title, content);
}
static List<String> scanLog(String progID, String fileName) {
return scanLog(getProgramFile(progID, fileName));
}
static List<String> scanLog(String fileName) {
return scanLog(getProgramFile(fileName));
}
static List<String> scanLog(File file) {
new List<String> l;
for (String s : toLines(file))
if (isProperlyQuoted(s))
l.add(unquote(s));
return l;
}
static <A> List<A> subList(List<A> l, int startIndex) {
return subList(l, startIndex, l(l));
}
static <A> List<A> subList(List<A> l, int startIndex, int endIndex) {
startIndex = max(0, min(l(l), startIndex));
endIndex = max(0, min(l(l), endIndex));
if (startIndex > endIndex) return litlist();
return l.subList(startIndex, endIndex);
}
static <A> List<A> listPlus(List<A> l, A... more) {
return concatLists(l, asList(more));
}
static int l(Object[] array) {
return array == null ? 0 : array.length;
}
static int l(byte[] array) {
return array == null ? 0 : array.length;
}
static int l(int[] array) {
return array == null ? 0 : array.length;
}
static int l(char[] array) {
return array == null ? 0 : array.length;
}
static int l(Collection c) {
return c == null ? 0 : c.size();
}
static int l(Map m) {
return m == null ? 0 : m.size();
}
static int l(String s) {
return s == null ? 0 : s.length();
}
static int l(Object o) {
return l((List) o); // incomplete
}
static String exceptionToStringShort(Throwable e) {
e = getInnerException(e);
String msg = unnull(e.getMessage());
if (msg.indexOf("Error") < 0 && msg.indexOf("Exception") < 0)
return dropPrefix("java.lang.", str(e));
else
return msg;
}
static ThreadLocal<Boolean> gCompleting;
static boolean gCompleting() {
gCompleting_init();
Boolean b = gCompleting.get();
/*if (b == null)
b = (Bool) callOpt(creator(), "gCompleting");*/
return isTrue(b);
}
static void gCompleting_set(Boolean b) {
gCompleting_init();
gCompleting.set(b);
}
static void gCompleting_init() {
if (gCompleting == null) {
gCompleting = (ThreadLocal) getOpt(creator(), "gCompleting");
if (gCompleting == null) gCompleting = new ThreadLocal;
}
}
static String gMode() {
return gCompleting() ? "/i" : "";
}
// action = runnable or method name
static void onUpdate(JTextComponent c, final Object r) {
c.getDocument().addDocumentListener(new DocumentListener() {
public void insertUpdate(DocumentEvent e) {
callFunction(r);
}
public void removeUpdate(DocumentEvent e) {
callFunction(r);
}
public void changedUpdate(DocumentEvent e) {
callFunction(r);
}
});
}
static Object first(Object list) {
return ((List) list).isEmpty() ? null : ((List) list).get(0);
}
static <A> A first(List<A> list) {
return list.isEmpty() ? null : list.get(0);
}
static <A> A first(A[] bla) {
return bla == null || bla.length == 0 ? null : bla[0];
}
static void setFrameIcon(JFrame frame, String imageID) {
try {
if (frame != null)
frame.setIconImage(imageIcon(imageID).getImage());
} catch (Throwable __e) { printStackTrace(__e); }
}
static void setFrameIcon(Component c, String imageID) {
setFrameIcon(getFrame(c), imageID);
}
static <A> ArrayList<A> ll(A... a) {
return litlist(a);
}
static LinkedHashMap litorderedmap(Object... x) {
new LinkedHashMap map;
litmap_impl(map, x);
return map;
}
static String dropBracketPrefix(String s) {
s = s.trim();
if (s.startsWith("[")) {
int i = s.indexOf(']');
return s.substring(i+1).trim();
}
return s;
}
static File prepareProgramFile(String name) {
return mkdirsForFile(getProgramFile(name));
}
static String joinLines(List<String> lines) {
return fromLines(lines);
}
static String joinLines(String glue, String text) {
return join(glue, toLines(text));
}
static <A> List<A> getLast(List<A> l, int n) {
return subList(l, l(l)-n);
}
static boolean empty(Collection c) {
return isEmpty(c);
}
static boolean empty(String s) {
return isEmpty(s);
}
static boolean empty(Map map) {
return map == null || map.isEmpty();
}
static boolean empty(Object o) {
if (o instanceof Collection) return empty((Collection) o);
if (o instanceof String) return empty((String) o);
if (o instanceof Map) return empty((Map) o);
return false;
}
static boolean confirmYesNo(Component owner, String msg) {
return JOptionPane.showConfirmDialog(owner,
msg, "JavaX", JOptionPane.YES_NO_OPTION) == JOptionPane.YES_OPTION;
}
// Let's just generally synchronize this to be safe.
static synchronized void appendToFile(String path, String s) { try {
new File(path).getParentFile().mkdirs();
//print("[Logging to " + path + "]");
Writer writer = new BufferedWriter(new OutputStreamWriter(
new FileOutputStream(path, true), "UTF-8"));
writer.write(s);
writer.close();
} catch (Throwable __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}
static void appendToFile(File path, String s) {
if (path != null)
appendToFile(path.getPath(), s);
}
static <A> A findByField(Collection<A> c, String field, Object value) {
for (A a : c)
if (eq(getOpt(a, field), value))
return a;
return null;
}
static boolean neq(Object a, Object b) {
return !eq(a, b);
}
static ThreadLocal<List<String>> genLog_log;
static List<String> genLog() {
genLog_init();
List<String> log = genLog_log.get();
/*if (log == null)
log = (L) callOpt(creator(), "genLog");*/
return assertNotNull("No log set for this thread", log);
}
static void genLog_set(List<String> log) {
genLog_init();
genLog_log.set(log);
}
static void genLog_clear() {
genLog_init();
genLog_log.set(null);
}
static void genLog_init() {
if (genLog_log == null) {
genLog_log = (ThreadLocal) getOpt(creator(), "genLog_log");
if (genLog_log == null) genLog_log = new ThreadLocal;
}
}
static <A> boolean firstIs(List<A> l, A a) {
return eq(get(l, 0), a);
}
// automatic conversion to string (for returning numbers etc.)
static String callGen(Gen gen) {
return strPreserveNull(callF(gen.func));
}
static <A> A last(List<A> l) {
return l.isEmpty() ? null : l.get(l.size()-1);
}
static boolean eq(Object a, Object b) {
if (a == null) return b == null;
if (a.equals(b)) return true;
if (a instanceof BigInteger) {
if (b instanceof Integer) return a.equals(BigInteger.valueOf((Integer) b));
if (b instanceof Long) return a.equals(BigInteger.valueOf((Long) b));
}
return false;
}
static TableWithTooltips tableWithTooltips() {
return new TableWithTooltips;
}
static class TableWithTooltips extends JTable {
public String getToolTipText(MouseEvent e) {
String tip = null;
Point p = e.getPoint();
int rowIndex = rowAtPoint(p);
int colIndex = columnAtPoint(p);
try {
return str(getValueAt(rowIndex, colIndex));
} catch (Throwable _e) { return null;
}
}
}
static Map getMap(Map map, Object key) {
return map == null ? null : (Map) map.get(key);
}
static Map getMap(List l, int idx) {
return (Map) get(l, idx);
}
static Map getMap(Object o, Object key) {
if (o instanceof Map) return getMap((Map) o, key);
if (key instanceof String)
return (Map) get(o, (String) key);
throw fail("Not a string key: " + getClassName(key));
}
static void onEnter(JTextField tf, final Runnable action) {
tf.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent evt) {
try {
action.run();
} catch (Throwable e) {
e.printStackTrace();
}
}
});
}
/** writes safely (to temp file, then rename) */
public static void saveTextFile(String fileName, String contents) throws IOException {
File file = new File(fileName);
File parentFile = file.getParentFile();
if (parentFile != null)
parentFile.mkdirs();
String tempFileName = fileName + "_temp";
if (contents != null) {
FileOutputStream fileOutputStream = new FileOutputStream(tempFileName);
OutputStreamWriter outputStreamWriter = new OutputStreamWriter(fileOutputStream, "UTF-8");
PrintWriter printWriter = new PrintWriter(outputStreamWriter);
printWriter.print(contents);
printWriter.close();
}
if (file.exists() && !file.delete())
throw new IOException("Can't delete " + fileName);
if (contents != null)
if (!new File(tempFileName).renameTo(file))
throw new IOException("Can't rename " + tempFileName + " to " + fileName);
}
public static void saveTextFile(File fileName, String contents) {
try {
saveTextFile(fileName.getPath(), contents);
} catch (IOException e) {
throw new RuntimeException(e);
}
}
static List scanLog_safeUnstructure(String progID, String fileName) {
return scanLog_safeUnstructure(getProgramFile(progID, fileName));
}
static List scanLog_safeUnstructure(String fileName) {
return scanLog_safeUnstructure(getProgramFile(fileName));
}
static List scanLog_safeUnstructure(File file) {
new List l;
for (String s : scanLog(file)) try {
l.add(safeUnstructure(s));
} catch (Throwable __e) { printStackTrace(__e); }
return l;
}
static void readLocally(String progID, String varNames) {
readLocally2(mc(), progID, varNames);
}
static void readLocally(String varNames) {
readLocally2(mc(), programID(), varNames);
}
static void readLocally2(Object obj, String varNames) {
readLocally2(obj, programID(), varNames);
}
// read a string variable from standard storage
// does not overwrite variable contents if there is no file
static synchronized void readLocally2(Object obj, String progID, String varNames) {
for (String variableName : codeTokensOnly(javaTok(varNames))) {
File textFile = new File(programDir(progID), variableName + ".text");
File structureFile = new File(programDir(progID), variableName + ".structure");
String value = loadTextFile(textFile);
if (value != null)
set(main.class, variableName, value);
else {
value = loadTextFile(structureFile);
if (value != null)
readLocally_set(obj, variableName, unstructure(value));
}
}
}
static void readLocally_set(Object c, String varName, Object value) {
Object oldValue = get(c, varName);
if (oldValue instanceof List && !(oldValue instanceof ArrayList) && value != null) {
// Assume it's a synchroList.
value = synchroList((List) value);
}
set(c, varName, value);
}
static List collect(Collection c, String field) {
return collectField(c, field);
}
static int tableRows(JTable table) {
return table.getRowCount();
}
static Object callOpt(Object o, String method, Object... args) {
try {
if (o == null) return null;
if (o instanceof Class) {
Method m = callOpt_findStaticMethod((Class) o, method, args, false);
if (m == null) return null;
m.setAccessible(true);
return m.invoke(null, args);
} else {
Method m = callOpt_findMethod(o, method, args, false);
if (m == null) return null;
m.setAccessible(true);
return m.invoke(o, args);
}
} catch (Exception e) {
throw new RuntimeException(e);
}
}
static Method callOpt_findStaticMethod(Class c, String method, Object[] args, boolean debug) {
Class _c = c;
while (c != null) {
for (Method m : c.getDeclaredMethods()) {
if (debug)
System.out.println("Checking method " + m.getName() + " with " + m.getParameterTypes().length + " parameters");;
if (!m.getName().equals(method)) {
if (debug) System.out.println("Method name mismatch: " + method);
continue;
}
if ((m.getModifiers() & Modifier.STATIC) == 0 || !callOpt_checkArgs(m, args, debug))
continue;
return m;
}
c = c.getSuperclass();
}
return null;
}
static Method callOpt_findMethod(Object o, String method, Object[] args, boolean debug) {
Class c = o.getClass();
while (c != null) {
for (Method m : c.getDeclaredMethods()) {
if (debug)
System.out.println("Checking method " + m.getName() + " with " + m.getParameterTypes().length + " parameters");;
if (m.getName().equals(method) && callOpt_checkArgs(m, args, debug))
return m;
}
c = c.getSuperclass();
}
return null;
}
private static boolean callOpt_checkArgs(Method m, Object[] args, boolean debug) {
Class<?>[] types = m.getParameterTypes();
if (types.length != args.length) {
if (debug)
System.out.println("Bad parameter length: " + args.length + " vs " + types.length);
return false;
}
for (int i = 0; i < types.length; i++)
if (!(args[i] == null || isInstanceX(types[i], args[i]))) {
if (debug)
System.out.println("Bad parameter " + i + ": " + args[i] + " vs " + types[i]);
return false;
}
return true;
}
static <A, B> Collection<B> values(Map<A, B> map) {
return map.values();
}
static JFrame getFrame(Object o) {
if (!(o instanceof Component)) return null;
Component c = (Component) o;
while (c != null) {
if (c instanceof JFrame) return (JFrame) c;
c = c.getParent();
}
return null;
}
static JPanel centerAndSouth(Component c, Component s) {
JPanel panel = new JPanel(new BorderLayout);
panel.add(BorderLayout.CENTER, wrap(c));
panel.add(BorderLayout.SOUTH, wrap(s));
return panel;
}
static JTable dataToTable_uneditable(final JTable table, final Object data) {
swingNowOrLater(r {
dataToTable(table, data, true);
makeTableUneditable(table);
});
return table;
}
static <A, B> Map<A, B> mapPlus(Map<A, B> m, Object... data) {
m = cloneTreeMap(m);
litmap_impl(m, data);
return m;
}
public static String fromLines(List<String> lines) {
StringBuilder buf = new StringBuilder();
if (lines != null)
for (String line : lines)
buf.append(line).append('\n');
return buf.toString();
}
static void logQuoted(String logFile, String line) {
logQuoted(getProgramFile(logFile), line);
}
static void logQuoted(File logFile, String line) {
appendToFile(logFile, quote(line) + "\n");
}
static String substring(String s, int x) {
return safeSubstring(s, x);
}
static String substring(String s, int x, int y) {
return safeSubstring(s, x, y);
}
static <A> List<A> synchroList() {
return Collections.synchronizedList(new ArrayList<A>());
}
static <A> List<A> synchroList(List<A> l) {
return Collections.synchronizedList(l);
}
static long now_virtualTime;
static long now() {
return now_virtualTime != 0 ? now_virtualTime : System.currentTimeMillis();
}
static void systemCommands(String s) {
postSystemMessage(systemCommands_impl(s));
}
static String systemCommands_impl(String s) {
new Matches m;
// SYSTEM COMMANDS
if (matchOneOf(s, m, "start program *", "start *")
&& isSnippetID(m.unq(0))) {
String progID = m.fsi(0);
String title = getSnippetTitle(progID);
// TODO: Show author!
String msg = "Run program " + progID + " - " + title + "?";
if (confirmOKCancel(frame, msg)) {
postSystemMessage("Starting program " + progID + " - " + quote(title));
nohupJavax(progID);
} else
postSystemMessage("Program start cancelled by user (was: " + progID + ")");
}
if (matchOneOf(s, m, "hotwire *", "hotwire * with argument *")) {
String progID = m.fsi(0), arg = unnull(m.unq(1));
String title = getSnippetTitle(progID);
String msg = "Hotwire & run program " + progID + " - " + quote(title) + (empty(arg) ? "" : " with argument " + quote(arg)) + "?";
if (confirmOKCancel(frame, msg)) {
postSystemMessage("Hotwiring & running program " + progID + " - " + quote(title) + (empty(arg) ? "" : " with argument " + quote(arg)));
run(progID, arg);
} else
postSystemMessage("Program start cancelled by user (was: " + progID + ")");
}
if (matchOneOf(s, "jfresh", "fresh")) {
return veryQuickJava_refresh() ? "OK, translator dropped." : "Nothing to do";
}
if (startsWithOneOf(s, "java ", "j ")) {
String code = onlyAfter(s, ' ');
return systemCommands_evalJava(code);
}
if (startsWith(s, "jfresh ")) {
veryQuickJava_refresh();
String code = dropPrefix("jfresh", s);
return systemCommands_evalJava(code);
}
if (match("restart", s, m)) {
postSystemMessage("Restarting...");
restart();
}
if (match("pop", s, m)) { // pop up last chat line in a window
String text = nextToLast(log);
if (empty(text))
return "Nothing to show";
else
showText(text);
} return null;
}
static Object systemCommands_lastResult;
static String systemCommands_evalJava(String code) {
code = trim(code);
code = tok_addReturn(code);
String returnType = containsReturnWithArgument(code) ? "O" : "void";
String main = "!include #1003911\n" + // functions for quick eval
"static " + returnType + " calc() { " + code + "\n" + "}";
Object obj = veryQuickJava(main);
long time = now();
Object result = callCalc(obj);
systemCommands_lastResult = result;
time = now()-time;
return time + " ms\n" + systemCommands_prettyPrint(result);
}
static String systemCommands_prettyPrint(Object o) {
if (o instanceof List)
return fromLines(map(new Object { Object get(Object o) { return systemCommands_prettyPrint(o) ; }
public String toString() { return "systemCommands_prettyPrint(o)"; }}, (List) o));
if (eq(getClassName(o), "main$Snippet"))
return formatSnippetID(getString(o, "id")) + " - " + getString(o, "title");
return structureOrText(o);
}
static <A> boolean setAdd(Collection<A> c, A a) {
if (c.contains(a)) return false;
c.add(a);
return true;
}
// compile JavaX source, load classes & return main class
// src can be a snippet ID or actual source code
// TODO: record injection?
static Class<?> hotwire(String src) {
try {
Class j = getJavaX();
synchronized(j) { // hopefully this goes well...
List<File> libraries = new ArrayList<File>();
File srcDir = (File) call(j, "transpileMain", src, libraries);
if (srcDir == null)
fail("transpileMain returned null (src=" + quote(src) + ")");
Object androidContext = get(j, "androidContext");
if (androidContext != null)
return (Class) call(j, "loadx2android", srcDir, src);
File classesDir = (File) call(j, "TempDirMaker_make");
String javacOutput = (String) call(j, "compileJava", srcDir, libraries, classesDir);
System.out.println(javacOutput);
URL[] urls = new URL[libraries.size()+1];
urls[0] = classesDir.toURI().toURL();
for (int i = 0; i < libraries.size(); i++)
urls[i+1] = libraries.get(i).toURI().toURL();
// make class loader
URLClassLoader classLoader = new URLClassLoader(urls);
// load & return main class
Class<?> theClass = classLoader.loadClass("main");
callOpt(j, "registerSourceCode", theClass, loadTextFile(new File(srcDir, "main.java")));
call(j, "setVars", theClass, isSnippetID(src) ? src: null);
if (isSnippetID(src))
callOpt(j, "addInstance", src, theClass);
if (!_inCore())
hotwire_copyOver(theClass);
return theClass;
}
} catch (Exception e) {
throw e instanceof RuntimeException ? (RuntimeException) e : new RuntimeException(e);
}
}
static File getProgramFile(String progID, String fileName) {
return new File(getProgramDir(progID), fileName);
}
static File getProgramFile(String fileName) {
return getProgramFile(getProgramID(), fileName);
}
static void saveLocally(String variableName) {
saveLocally(programID(), variableName);
}
static void saveLocally(String progID, String variableName) {
saveLocally2(mc(), progID, variableName);
}
static void saveLocally2(Object obj, String variableName) {
saveLocally2(obj, programID(), variableName);
}
static synchronized void saveLocally2(Object obj, String progID, String variableName) {
File textFile = new File(programDir(progID), variableName + ".text");
File structureFile = new File(programDir(progID), variableName + ".structure");
Object x = get(obj, variableName);
if (x == null) {
textFile.delete();
structureFile.delete();
} else if (x instanceof String) {
saveTextFile(textFile, (String) x);
structureFile.delete();
} else {
saveTextFile(structureFile, structure(x));
textFile.delete();
}
}
static void swingAfter(JFrame base, int delay, Runnable r) {
installTimer((JComponent) base.getContentPane(), r, delay, delay, false);
}
static void swingAfter(JComponent base, int delay, Runnable r) {
installTimer(base, r, delay, delay, false);
}
static void substance() {
substanceLAF();
}
static void substance(String skinName) {
substanceLAF(skinName);
}
static boolean match(String pat, String s) {
return match3(pat, s);
}
static boolean match(String pat, String s, Matches matches) {
return match3(pat, s, matches);
}
static boolean nempty(Collection c) {
return !isEmpty(c);
}
static boolean nempty(CharSequence s) {
return !isEmpty(s);
}
static boolean nempty(Object[] o) {
return !isEmpty(o);
}
static boolean eqic(String a, String b) {
if ((a == null) != (b == null)) return false;
if (a == null) return true;
return a.equalsIgnoreCase(b);
}
static String chatTime() {
return formatInt(month(), 2) + "/" + formatInt(days(), 2) + " " + formatInt(hours(), 2) + ":" + formatInt(minutes(), 2) + ":" + formatInt(seconds(), 2);
}
static String getString(Map map, Object key) {
return map == null ? null : (String) map.get(key);
}
static String getString(List l, int idx) {
return (String) get(l, idx);
}
static String getString(Object o, Object key) {
if (o instanceof Map) return getString((Map) o, key);
if (key instanceof String)
return (String) get(o, (String) key);
throw fail("Not a string key: " + getClassName(key));
}
static String structure(Object o) {
new HashSet refd;
return structure_2(structure_1(o, 0, new IdentityHashMap, refd), refd);
}
// leave to false, unless unstructure() breaks
static boolean structure_allowShortening = false;
static String structure_1(Object o, int stringSizeLimit, IdentityHashMap<Object, Integer> seen, HashSet<Integer> refd) {
if (o == null) return "null";
// these are never back-referenced (for readability)
if (o instanceof String)
return quote(stringSizeLimit != 0 ? shorten((String) o, stringSizeLimit) : (String) o);
if (o instanceof BigInteger)
return "bigint(" + o + ")";
if (o instanceof Double)
return "d(" + quote(str(o)) + ")";
if (o instanceof Long)
return o + "L";
if (o instanceof Integer)
return str(o);
if (o instanceof Boolean)
return ((Boolean) o).booleanValue() ? "t" : "f";
if (o instanceof Character)
return quoteCharacter((Character) o);
if (o instanceof File)
return "File " + quote(((File) o).getPath());
// referencable objects follow
Integer ref = seen.get(o);
if (ref != null) {
refd.add(ref);
return "r" + ref;
}
ref = seen.size()+1;
seen.put(o, ref);
String r = "m" + ref + " "; // marker
String name = o.getClass().getName();
StringBuilder buf = new StringBuilder();
if (o instanceof HashSet)
return r + "hashset " + structure_1(new ArrayList((Set) o), stringSizeLimit, seen, refd);
if (o instanceof TreeSet)
return r + "treeset " + structure_1(new ArrayList((Set) o), stringSizeLimit, seen, refd);
if (o instanceof Collection) {
for (Object x : (Collection) o) {
if (buf.length() != 0) buf.append(", ");
buf.append(structure_1(x, stringSizeLimit, seen, refd));
}
return r + "[" + buf + "]";
}
if (o instanceof Map) {
for (Object e : ((Map) o).entrySet()) {
if (buf.length() != 0) buf.append(", ");
buf.append(structure_1(((Map.Entry) e).getKey(), stringSizeLimit, seen, refd));
buf.append("=");
buf.append(structure_1(((Map.Entry) e).getValue(), stringSizeLimit, seen, refd));
}
return r + (o instanceof HashMap ? "hashmap" : "") + "{" + buf + "}";
}
if (o.getClass().isArray()) {
int n = Array.getLength(o);
for (int i = 0; i < n; i++) {
if (buf.length() != 0) buf.append(", ");
buf.append(structure_1(Array.get(o, i), stringSizeLimit, seen, refd));
}
return r + "array{" + buf + "}";
}
if (o instanceof Class)
return r + "class(" + quote(((Class) o).getName()) + ")";
if (o instanceof Throwable)
return r + "exception(" + quote(((Throwable) o).getMessage()) + ")";
if (o instanceof BitSet) {
BitSet bs = (BitSet) o;
for (int i = bs.nextSetBit(0); i >= 0; i = bs.nextSetBit(i+1)) {
if (buf.length() != 0) buf.append(", ");
buf.append(i);
}
return "bitset{" + buf + "}";
}
// Need more cases? This should cover all library classes...
if (name.startsWith("java.") || name.startsWith("javax."))
return r + String.valueOf(o);
String shortName = o.getClass().getName().replaceAll("^main\\$", "");
if (shortName.equals("Lisp")) {
buf.append("l(" + structure_1(getOpt(o, "head"), stringSizeLimit, seen, refd));
List args = (List) ( getOpt(o, "args"));
if (nempty(args))
for (int i = 0; i < l(args); i++) {
buf.append(", ");
Object arg = args.get(i);
// sweet shortening
if (arg != null && eq(arg.getClass().getName(), "main$Lisp") && isTrue(call(arg, "isEmpty")))
arg = get(arg, "head");
buf.append(structure_1(arg, stringSizeLimit, seen, refd));
}
buf.append(")");
return r + str(buf);
}
int numFields = 0;
String fieldName = "";
if (shortName.equals("DynamicObject")) {
shortName = (String) get(o, "className");
Map<String, Object> fieldValues = (Map) get(o, "fieldValues");
for (String _fieldName : fieldValues.keySet()) {
fieldName = _fieldName;
Object value = fieldValues.get(fieldName);
if (value != null) {
if (buf.length() != 0) buf.append(", ");
buf.append(fieldName + "=" + structure_1(value, stringSizeLimit, seen, refd));
}
++numFields;
}
} else {
// regular class
Class c = o.getClass();
while (c != Object.class) {
Field[] fields = c.getDeclaredFields();
for (Field field : fields) {
if ((field.getModifiers() & Modifier.STATIC) != 0)
continue;
fieldName = field.getName();
// skip outer object reference
if (fieldName.indexOf("$") >= 0) continue;
Object value;
try {
field.setAccessible(true);
value = field.get(o);
} catch (Exception e) {
value = "?";
}
// put special cases here...
if (value != null) {
if (buf.length() != 0) buf.append(", ");
buf.append(fieldName + "=" + structure_1(value, stringSizeLimit, seen, refd));
}
++numFields;
}
c = c.getSuperclass();
}
}
String b = buf.toString();
if (numFields == 1 && structure_allowShortening)
b = b.replaceAll("^" + fieldName + "=", ""); // drop field name if only one
String s = shortName;
if (buf.length() != 0)
s += "(" + b + ")";
return r + s;
}
// drop unused markers
static String structure_2(String s, HashSet<Integer> refd) {
List<String> tok = javaTok(s);
new StringBuilder out;
for (int i = 1; i < l(tok); i += 2) {
String t = tok.get(i);
if (t.startsWith("m") && isInteger(t.substring(1))
&& !refd.contains(parseInt(t.substring(1))))
continue;
out.append(t).append(tok.get(i+1));
}
return str(out);
}
// does not store null values
static Map indexByField(Collection c, String field) {
new HashMap map;
for (Object a : c) {
Object val = getOpt(a, field);
if (val != null)
map.put(val, a);
}
return map;
}
static volatile new StringBuffer local_log; // not redirected
static volatile StringBuffer print_log = local_log; // might be redirected, e.g. to main bot
// in bytes - will cut to half that
static volatile int print_log_max = 1024*1024;
static volatile int local_log_max = 100*1024;
static boolean print_silent; // total mute if set
static void print() {
print("");
}
// slightly overblown signature to return original object...
static <A> A print(A o) {
if (print_silent) return o;
String s = String.valueOf(o) + "\n";
StringBuffer loc = local_log;
StringBuffer buf = print_log;
int loc_max = print_log_max;
if (buf != loc && buf != null) {
print_append(buf, s, print_log_max);
loc_max = local_log_max;
}
if (loc != null)
print_append(loc, s, loc_max);
System.out.print(s);
return o;
}
static void print(long l) {
print(String.valueOf(l));
}
static void print(char c) {
print(String.valueOf(c));
}
static void print_append(StringBuffer buf, String s, int max) {
synchronized(buf) {
buf.append(s);
max /= 2;
if (buf.length() > max) try {
int newLength = max/2;
int ofs = buf.length()-newLength;
String newString = buf.substring(ofs);
buf.setLength(0);
buf.append("[...] ").append(newString);
} catch (Exception e) {
buf.setLength(0);
}
}
}
static void tableColumnMaxWidth(JTable table, int columnIdx, int width) {
try {
if (inRange(columnIdx, table.getColumnCount()))
table.getColumnModel().getColumn(columnIdx).setMaxWidth(width);
} catch (Throwable __e) { printStackTrace(__e); }
}
static String randomID(int length) {
return makeRandomID(length);
}
static class ELPost {
String text;
int suggestionIndex; // Which suggestion was taken?
String suggester;
}
static List<ELPost> scanEventLogForPosts(String progID, String dialogName) {
return scanEventLogForPosts(getProgramFile(progID, dialogName));
}
// dialogDir can also be the log file
static List<ELPost> scanEventLogForPosts(File dialogDir) {
if (dialogDir == null) return null;
List<List> l = scanLog_safeUnstructure(fileFromDir(dialogDir, "event.log"));
new List<ELPost> data;
for (int i = 0; i < l(l); i++) try {
List a = l.get(i), prev = get(l, i-1);
if (firstIs(a, "Posting")) {
Map map = (Map) ( get(a, 2));
String text = getString(map, "Text").trim();
if (eq(text, "!delete")) { removeLast(data); continue; }
new ELPost post;
post.text = text;
try {
if (prev != null && firstIs(prev, "Suggestion chosen")) {
Map m = getMap(prev, 2);
String suggestion = getString(m, "Suggestion");
if (eq(suggestion, post.text)) {
post.suggestionIndex = toInt(get(m, "Row"));
post.suggester = getString(m, "Suggester");
}
}
} catch (Throwable __e) { printStackTrace(__e); }
data.add(post);
}
} catch (Throwable __e) { printStackTrace(__e); }
return data;
}
static boolean startsWithOneOf(String s, String... l) {
for (String x : l) if (startsWith(s, x)) return true; return false;
}
static Object[] asArray(List l) {
return toObjectArray(l);
}
static Object[] asArray(Class type, List l) {
return l.toArray((Object[]) Array.newInstance(type, l.size()));
}
static JFrame makeFrame() {
return makeFrame((Component) null);
}
static JFrame makeFrame(Object content) {
return makeFrame(programTitle(), content);
}
static JFrame makeFrame(String title) {
return makeFrame(title, null);
}
static JFrame makeFrame(String title, Object content) {
return makeFrame(title, content, true);
}
static JFrame makeFrame(String title, Object content, boolean showIt) {
JFrame frame = new JFrame(title);
if (content != null)
frame.getContentPane().add(wrap(content));
frame.setBounds(300, 100, 500, 400);
if (showIt)
frame.setVisible(true);
//callOpt(content, "requestFocus");
//exitOnFrameClose(frame);
// standard right-click behavior on titles
if (isSubstanceLAF())
onTitleRightClick(frame, new Runnable() { public void run() { try { showConsole(); } catch (Exception __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}});
return frame;
}
static Object callFunction(Object f, Object... args) {
if (f == null) return null;
if (f instanceof Runnable) {
((Runnable) f).run();
return null;
} else if (f instanceof String)
return call(mc(), (String) f, args);
else
return call(f, "get", args);
//else throw fail("Can't call a " + getClassName(f));
}
static <A> ArrayList<A> asList(A[] a) {
return new ArrayList<A>(Arrays.asList(a));
}
static ArrayList<Integer> asList(int[] a) {
ArrayList<Integer> l = new ArrayList();
for (int i : a) l.add(i);
return l;
}
static <A> ArrayList<A> asList(Collection<A> s) {
return s == null ? new ArrayList()
: s instanceof ArrayList ? (ArrayList) s : new ArrayList(s);
}
static String quote(String s) {
if (s == null) return "null";
return "\"" + s.replace("\\", "\\\\").replace("\"", "\\\"").replace("\r", "\\r").replace("\n", "\\n") + "\"";
}
static String quote(long l) {
return quote("" + l);
}
static String quote(char c) {
return quote("" + c);
}
static <A> A assertNotNull(A a) {
assertTrue(a != null);
return a;
}
static <A> A assertNotNull(String msg, A a) {
assertTrue(msg, a != null);
return a;
}
static String quoteCharacter(char c) {
if (c == '\'') return "'\\''";
if (c == '\\') return "'\\\\'";
return "'" + c + "'";
}
static boolean isAWTThread() {
return SwingUtilities.isEventDispatchThread();
}
static void smartAdd(JPanel panel, Object... parts) {
for (Object o : parts) {
Component c;
if (o instanceof String)
c = new JLabel((String) o);
else
c = wrap(o);
panel.add(c);
}
}
static boolean isProperlyQuoted(String s) {
return s.length() >= 2
&& s.startsWith("\"")
&& s.endsWith("\"")
&& !s.endsWith("\\\"");
}
static String strPreserveNull(Object s) {
return s == null ? null : str(s);
}
static Point mousePosition() {
return MouseInfo.getPointerInfo().getLocation();
}
static JMenuBar addMenuBar(JFrame f) {
JMenuBar bar = f.getJMenuBar();
if (bar == null)
f.setJMenuBar(bar = new JMenuBar());
return bar;
}
static String programID;
static String getProgramID() {
return nempty(programID) ? formatSnippetID(programID) : "?";
}
// TODO: ask JavaX instead
static String getProgramID(Class c) {
String id = (String) getOpt(c, "programID");
if (nempty(id))
return formatSnippetID(id);
return "?";
}
static String getProgramID(Object o) {
return getProgramID(getMainClass(o));
}
// replacement for class JavaTok
// maybe incomplete, might want to add floating point numbers
// todo also: extended multi-line strings
static int javaTok_n, javaTok_elements;
static boolean javaTok_opt;
static List<String> javaTok(String s) {
return javaTok(s, null);
}
static List<String> javaTok(String s, List<String> existing) {
++javaTok_n;
int nExisting = javaTok_opt && existing != null ? existing.size() : 0;
List<String> tok = existing != null ? new ArrayList(nExisting) : new ArrayList();
int l = s.length();
int i = 0, n = 0;
while (i < l) {
int j = i;
char c; String cc;
// scan for whitespace
while (j < l) {
c = s.charAt(j);
cc = s.substring(j, Math.min(j+2, l));
if (c == ' ' || c == '\t' || c == '\r' || c == '\n')
++j;
else if (cc.equals("/*")) {
do ++j; while (j < l && !s.substring(j, Math.min(j+2, l)).equals("*/"));
j = Math.min(j+2, l);
} else if (cc.equals("//")) {
do ++j; while (j < l && "\r\n".indexOf(s.charAt(j)) < 0);
} else
break;
}
if (n < nExisting && javaTok_isCopyable(existing.get(n), s, i, j))
tok.add(existing.get(n));
else
tok.add(quickSubstring(s, i, j));
++n;
i = j;
if (i >= l) break;
c = s.charAt(i); // cc is not needed in rest of loop body
cc = s.substring(i, Math.min(i+2, l));
// scan for non-whitespace
if (c == '\'' || c == '"') {
char opener = c;
++j;
while (j < l) {
if (s.charAt(j) == opener || s.charAt(j) == '\n') { // end at \n to not propagate unclosed string literal errors
++j;
break;
} else if (s.charAt(j) == '\\' && j+1 < l)
j += 2;
else
++j;
}
} else if (Character.isJavaIdentifierStart(c))
do ++j; while (j < l && (Character.isJavaIdentifierPart(s.charAt(j)) || "'".indexOf(s.charAt(j)) >= 0)); // for stuff like "don't"
else if (Character.isDigit(c)) {
do ++j; while (j < l && Character.isDigit(s.charAt(j)));
if (j < l && s.charAt(j) == 'L') ++j; // Long constants like 1L
} else if (cc.equals("[[")) {
do ++j; while (j+1 < l && !s.substring(j, j+2).equals("]]"));
j = Math.min(j+2, l);
} else if (cc.equals("[=") && i+2 < l && s.charAt(i+2) == '[') {
do ++j; while (j+2 < l && !s.substring(j, j+3).equals("]=]"));
j = Math.min(j+3, l);
} else
++j;
if (n < nExisting && javaTok_isCopyable(existing.get(n), s, i, j))
tok.add(existing.get(n));
else
tok.add(quickSubstring(s, i, j));
++n;
i = j;
}
if ((tok.size() % 2) == 0) tok.add("");
javaTok_elements += tok.size();
return tok;
}
static List<String> javaTok(List<String> tok) {
return javaTok(join(tok), tok);
}
static boolean javaTok_isCopyable(String t, String s, int i, int j) {
return t.length() == j-i
&& s.regionMatches(i, t, 0, j-i); // << could be left out, but that's brave
}
// patterns last so we can use var args
static boolean matchOneOf(String s, Matches m, String... pats) {
for (String pat : pats)
if (match(pat, s, m)) return true; return false;
}
static boolean matchOneOf(String s, String... pats) {
return matchOneOf(s, null, pats);
}
static Object newObject(Class c, Object... args) {
return nuObject(c, args);
}
static Object newObject(String className, Object... args) {
return nuObject(className, args);
}
// We'd be really fancy if we filtered out return statements in
// inner blocks.
static boolean containsReturnWithArgument(String code) {
List<String> tok = javaTok(code);
for (int i = 1; i+2 < l(tok); i += 2)
if (eqOneOf(tok.get(i), "ret", "return") && neq(tok.get(i+2), ";")) return true; return false;
}
static String onlyAfter(String s, char c) {
int i = s.indexOf(c);
return i >= 0 ? s.substring(i+1) : "";
}
static Class __javax;
static Class getJavaX() {
return __javax;
}
static void set(Object o, String field, Object value) {
if (o instanceof Class) set((Class) o, field, value);
else try {
Field f = set_findField(o.getClass(), field);
smartSet(f, o, value);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
static void set(Class c, String field, Object value) {
try {
Field f = set_findStaticField(c, field);
smartSet(f, null, value);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
static Field set_findField(Class<?> c, String field) {
for (Field f : c.getDeclaredFields())
if (f.getName().equals(field))
return f;
throw new RuntimeException("Field '" + field + "' not found in " + c.getName());
}
static Field set_findStaticField(Class<?> c, String field) {
for (Field f : c.getDeclaredFields())
if (f.getName().equals(field) && (f.getModifiers() & Modifier.STATIC) != 0)
return f;
throw new RuntimeException("Static field '" + field + "' not found in " + c.getName());
}
static List collectField(Collection c, String field) {
new List l;
for (Object a : c)
l.add(getOpt(a, field));
return l;
}
static Throwable getInnerException(Throwable e) {
while (e.getCause() != null)
e = e.getCause();
return e;
}
static Object call(Object o) {
return callFunction(o);
}
// varargs assignment fixer for a single string array argument
static Object call(Object o, String method, String[] arg) {
return call(o, method, new Object[] {arg});
}
static Object call(Object o, String method, Object... args) {
try {
if (o instanceof Class) {
Method m = call_findStaticMethod((Class) o, method, args, false);
m.setAccessible(true);
return m.invoke(null, args);
} else {
Method m = call_findMethod(o, method, args, false);
m.setAccessible(true);
return m.invoke(o, args);
}
} catch (Exception e) {
throw e instanceof RuntimeException ? (RuntimeException) e : new RuntimeException(e);
}
}
static Method call_findStaticMethod(Class c, String method, Object[] args, boolean debug) {
Class _c = c;
while (c != null) {
for (Method m : c.getDeclaredMethods()) {
if (debug)
System.out.println("Checking method " + m.getName() + " with " + m.getParameterTypes().length + " parameters");;
if (!m.getName().equals(method)) {
if (debug) System.out.println("Method name mismatch: " + method);
continue;
}
if ((m.getModifiers() & Modifier.STATIC) == 0 || !call_checkArgs(m, args, debug))
continue;
return m;
}
c = c.getSuperclass();
}
throw new RuntimeException("Method '" + method + "' (static) with " + args.length + " parameter(s) not found in " + _c.getName());
}
static Method call_findMethod(Object o, String method, Object[] args, boolean debug) {
Class c = o.getClass();
while (c != null) {
for (Method m : c.getDeclaredMethods()) {
if (debug)
System.out.println("Checking method " + m.getName() + " with " + m.getParameterTypes().length + " parameters");;
if (m.getName().equals(method) && call_checkArgs(m, args, debug))
return m;
}
c = c.getSuperclass();
}
throw new RuntimeException("Method '" + method + "' (non-static) with " + args.length + " parameter(s) not found in " + o.getClass().getName());
}
private static boolean call_checkArgs(Method m, Object[] args, boolean debug) {
Class<?>[] types = m.getParameterTypes();
if (types.length != args.length) {
if (debug)
System.out.println("Bad parameter length: " + args.length + " vs " + types.length);
return false;
}
for (int i = 0; i < types.length; i++)
if (!(args[i] == null || isInstanceX(types[i], args[i]))) {
if (debug)
System.out.println("Bad parameter " + i + ": " + args[i] + " vs " + types[i]);
return false;
}
return true;
}
static boolean isTrue(Object o) {
return booleanValue(o);
}
static int days() {
return Calendar.getInstance().get(Calendar.DAY_OF_MONTH);
}
// c = Component or something implementing swing()
static Component wrap(Object swingable) {
Component c = (Component) ( swingable instanceof Component ? swingable : call(swingable, "swing"));
if (c instanceof JTable || c instanceof JList || c instanceof JTextArea)
return new JScrollPane(c);
return c;
}
static Object callCalc(Object o) {
return call(o, "calc");
}
static boolean startsWithIgnoreCase(String a, String b) {
return a != null && a.regionMatches(true, 0, b, 0, b.length());
}
static <A> A nextToLast(List<A> l) {
return get(l, l(l)-2);
}
// class Matches is added by #752
static boolean match3(String pat, String s) {
return match3(pat, s, null);
}
static boolean match3(String pat, String s, Matches matches) {
if (s == null) return false;
return match3(pat, parse3(s), matches);
}
static boolean match3(String pat, List<String> toks, Matches matches) {
List<String> tokpat = parse3(pat);
return match3(tokpat,toks,matches);
}
static boolean match3(List<String> tokpat, List<String> toks, Matches matches) {
String[] m = match2(tokpat, toks);
//print(structure(tokpat) + " on " + structure(toks) + " => " + structure(m));
if (m == null)
return false;
else {
if (matches != null) matches.m = m;
return true;
}
}
static Class run(String progID, String... args) {
Class main = hotwire(progID);
callMain(main, args);
return main;
}
static boolean isInteger(String s) {
return s != null && Pattern.matches("\\-?\\d+", s);
}
static String getStackTrace(Throwable throwable) {
StringWriter writer = new StringWriter();
throwable.printStackTrace(new PrintWriter(writer));
return writer.toString();
}
static void makeTableUneditable(JTable table) {
for (int c = 0; c < table.getColumnCount(); c++) {
Class<?> col_class = table.getColumnClass(c);
table.setDefaultEditor(col_class, null); // remove editor
}
}
static File programDir() {
return programDir(getProgramID());
}
static File programDir(String snippetID) {
return new File(javaxDataDir(), formatSnippetID(snippetID));
}
static String formatSnippetID(String id) {
return "#" + parseSnippetID(id);
}
static String formatSnippetID(long id) {
return "#" + id;
}
// returns true if a translator had been loaded
static synchronized boolean veryQuickJava_refresh() {
if (getOpt(mc(), "transpileRaw_trans") == null) return false;
setOpt(mc(), "transpileRaw_trans", null); return true;
}
static int month() {
return Calendar.getInstance().get(Calendar.MONTH)+1;
}
// optionally convert expression to return statement
static String tok_addReturn(List<String> tok) {
String lastToken = get(tok, l(tok)-2);
//print("addReturn: " + structure(tok) + ", lastToken: " + quote(lastToken));
if (eq(lastToken, "}") || eq(lastToken, ";")) return join(tok);
return "ret " + join(tok) + ";";
}
static String tok_addReturn(String s) {
return tok_addReturn(javaTok(s));
}
public static File mkdirsForFile(File file) {
File dir = file.getParentFile();
if (dir != null) // is null if file is in current dir
dir.mkdirs();
return file;
}
static void substanceLAF() {
substanceLAF(null);
}
static void substanceLAF(String skinName) {
try {
if (!substanceLookAndFeelEnabled()) {
Object x = hotwire("#1003448");
if (skinName != null)
set(x, "skinName", skinName);
runMain(x);
JFrame.setDefaultLookAndFeelDecorated(substanceLookAndFeelEnabled());
}
} catch (Throwable __e) { printStackTrace(__e); }
}
static List emptyList() {
return new ArrayList;
//ret Collections.emptyList();
}
static File fileFromDir(File f, String name) {
return f.isDirectory() ? new File(f, name) : f;
}
// first delay = delay
static void installTimer(JComponent component, Runnable r, int delay) {
installTimer(component, r, delay, delay);
}
// first delay = delay
static void installTimer(JFrame frame, int delay, Runnable r) {
installTimer(frame.getRootPane(), r, delay, delay);
}
// first delay = delay
static void installTimer(JComponent component, int delay, Runnable r) {
installTimer(component, r, delay, delay);
}
static void installTimer(final JComponent component, final Runnable r, final int delay, final int firstDelay) {
installTimer(component, r, delay, firstDelay, true);
}
static void installTimer(final JComponent component, final Runnable r, final int delay, final int firstDelay, final boolean repeats) {
swingLater(new Runnable() { public void run() { try {
final Timer timer = new Timer(delay, new java.awt.event.ActionListener() { public void actionPerformed(java.awt.event.ActionEvent _evt) {
r.run();
}});
timer.setInitialDelay(firstDelay);
timer.setRepeats(repeats);
if (component.isShowing())
timer.start();
component.addAncestorListener(new AncestorListener() {
public void ancestorAdded(AncestorEvent event) {
timer.start();
}
public void ancestorRemoved(AncestorEvent event) {
timer.stop();
}
public void ancestorMoved(AncestorEvent event) {
}
});
} catch (Exception __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}});
}
public static String unquote(String s) {
if (s == null) return null;
if (s.startsWith("[")) {
int i = 1;
while (i < s.length() && s.charAt(i) == '=') ++i;
if (i < s.length() && s.charAt(i) == '[') {
String m = s.substring(1, i);
if (s.endsWith("]" + m + "]"))
return s.substring(i+1, s.length()-i-1);
}
}
if (s.startsWith("\"") /*&& s.endsWith("\"")*/ && s.length() > 1) {
String st = s.substring(1, s.endsWith("\"") ? s.length()-1 : s.length());
StringBuilder sb = new StringBuilder(st.length());
for (int i = 0; i < st.length(); i++) {
char ch = st.charAt(i);
if (ch == '\\') {
char nextChar = (i == st.length() - 1) ? '\\' : st
.charAt(i + 1);
// Octal escape?
if (nextChar >= '0' && nextChar <= '7') {
String code = "" + nextChar;
i++;
if ((i < st.length() - 1) && st.charAt(i + 1) >= '0'
&& st.charAt(i + 1) <= '7') {
code += st.charAt(i + 1);
i++;
if ((i < st.length() - 1) && st.charAt(i + 1) >= '0'
&& st.charAt(i + 1) <= '7') {
code += st.charAt(i + 1);
i++;
}
}
sb.append((char) Integer.parseInt(code, 8));
continue;
}
switch (nextChar) {
case '\\':
ch = '\\';
break;
case 'b':
ch = '\b';
break;
case 'f':
ch = '\f';
break;
case 'n':
ch = '\n';
break;
case 'r':
ch = '\r';
break;
case 't':
ch = '\t';
break;
case '\"':
ch = '\"';
break;
case '\'':
ch = '\'';
break;
// Hex Unicode: u????
case 'u':
if (i >= st.length() - 5) {
ch = 'u';
break;
}
int code = Integer.parseInt(
"" + st.charAt(i + 2) + st.charAt(i + 3)
+ st.charAt(i + 4) + st.charAt(i + 5), 16);
sb.append(Character.toChars(code));
i += 5;
continue;
default:
ch = nextChar; // added by Stefan
}
i++;
}
sb.append(ch);
}
return sb.toString();
} else
return s; // return original
}
static String programID() {
return getProgramID();
}
static int hours() {
return Calendar.getInstance().get(Calendar.HOUR_OF_DAY);
}
static boolean isEmpty(Collection c) {
return c == null || c.isEmpty();
}
static boolean isEmpty(CharSequence s) {
return s == null || s.length() == 0;
}
static boolean isEmpty(Object[] a) {
return a == null || a.length == 0;
}
static boolean isEmpty(Map map) {
return map == null || map.isEmpty();
}
static String makeRandomID(int length) {
Random random = new Random();
char[] id = new char[length];
for (int i = 0; i < id.length; i++)
id[i] = (char) ((int) 'a' + random.nextInt(26));
return new String(id);
}
static char unquoteCharacter(String s) {
assertTrue(s.startsWith("'") && s.length() > 1);
return unquote("\"" + s.substring(1, s.endsWith("'") ? s.length()-1 : s.length()) + "\"").charAt(0);
}
static int parseInt(String s) {
return empty(s) ? 0 : Integer.parseInt(s);
}
static String structureOrText(Object o) {
return o instanceof String ? (String) o : structure(o);
}
static void setOpt(Object o, String field, Object value) {
if (o instanceof Class) setOpt((Class) o, field, value);
else try {
Field f = setOpt_findField(o.getClass(), field);
if (f != null)
smartSet(f, o, value);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
static void setOpt(Class c, String field, Object value) {
try {
Field f = setOpt_findStaticField(c, field);
if (f != null)
smartSet(f, null, value);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
static Field setOpt_findField(Class<?> c, String field) {
for (Field f : c.getDeclaredFields())
if (f.getName().equals(field))
return f;
return null;
}
static Field setOpt_findStaticField(Class<?> c, String field) {
for (Field f : c.getDeclaredFields())
if (f.getName().equals(field) && (f.getModifiers() & Modifier.STATIC) != 0)
return f;
return null;
}
static Object getOpt(Object o, String field) {
if (o instanceof String) o = getBot ((String) o);
if (o == null) return null;
if (o instanceof Class) return getOpt((Class) o, field);
if (o.getClass().getName().equals("main$DynamicObject"))
return ((Map) getOpt_raw(o, "fieldValues")).get(field);
if (o instanceof Map) return ((Map) o).get(field);
return getOpt_raw(o, field);
}
static Object getOpt_raw(Object o, String field) {
try {
Field f = getOpt_findField(o.getClass(), field);
if (f == null) return null;
f.setAccessible(true);
return f.get(o);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
static Object getOpt(Class c, String field) {
try {
if (c == null) return null;
Field f = getOpt_findStaticField(c, field);
if (f == null) return null;
f.setAccessible(true);
return f.get(null);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
static Field getOpt_findStaticField(Class<?> c, String field) {
Class _c = c;
do {
for (Field f : _c.getDeclaredFields())
if (f.getName().equals(field) && (f.getModifiers() & Modifier.STATIC) != 0)
return f;
_c = _c.getSuperclass();
} while (_c != null);
return null;
}
static Field getOpt_findField(Class<?> c, String field) {
Class _c = c;
do {
for (Field f : _c.getDeclaredFields())
if (f.getName().equals(field))
return f;
_c = _c.getSuperclass();
} while (_c != null);
return null;
}
// hopefully covers all cases :)
static String safeSubstring(String s, int x, int y) {
if (s == null) return null;
if (x < 0) x = 0;
if (x > s.length()) return "";
if (y < x) y = x;
if (y > s.length()) y = s.length();
return s.substring(x, y);
}
static String safeSubstring(String s, int x) {
return safeSubstring(s, x, l(s));
}
static int seconds() {
return Calendar.getInstance().get(Calendar.SECOND);
}
static String shorten(String s, int max) {
if (s == null) return "";
return s.length() <= max ? s : s.substring(0, Math.min(s.length(), max)) + "...";
}
public static String join(String glue, Iterable<String> strings) {
StringBuilder buf = new StringBuilder();
Iterator<String> i = strings.iterator();
if (i.hasNext()) {
buf.append(i.next());
while (i.hasNext())
buf.append(glue).append(i.next());
}
return buf.toString();
}
public static String join(String glue, String[] strings) {
return join(glue, Arrays.asList(strings));
}
public static String join(Iterable<String> strings) {
return join("", strings);
}
public static String join(String[] strings) {
return join("", strings);
}
static String dropPrefix(String prefix, String s) {
return s.startsWith(prefix) ? s.substring(l(prefix)) : s;
}
static List<String> codeTokensOnly(List<String> tok) {
new List<String> l;
for (int i = 1; i < tok.size(); i += 2)
l.add(tok.get(i));
return l;
}
// currently finds only inner classes of class "main"
// returns null on not found
// this is the simple version that is not case-tolerant
static Class findClass(String name) {
try {
return Class.forName("main$" + name);
} catch (ClassNotFoundException e) {
return null;
}
}
static Object safeUnstructure(String s) {
return unstructure(s, true);
}
static boolean isJavaIdentifier(String s) {
if (s.length() == 0 || !Character.isJavaIdentifierStart(s.charAt(0)))
return false;
for (int i = 1; i < s.length(); i++)
if (!Character.isJavaIdentifierPart(s.charAt(i)))
return false;
return true;
}
static boolean _inCore() {
return false;
}
static JTable dataToTable(Object data) {
return dataToTable(showTable(), data);
}
static JTable dataToTable(Object data, String title) {
return dataToTable(showTable(title), data);
}
static JTable dataToTable(JTable table, Object data) {
return dataToTable(table, data, false);
}
static JTable dataToTable(JTable table, Object data, boolean now) {
new List<List<String>> rows;
new List<String> cols;
if (data instanceof List) {
for (Object x : (List) data) try {
rows.add(dataToTable_makeRow(x, cols));
} catch (Throwable __e) { printStackTrace(__e); }
} else if (data instanceof Map) {
Map map = (Map) ( data);
for (Object key : map.keySet()) {
Object value = map.get(key);
rows.add(litlist(structureOrText(key), structureOrText(value)));
}
} else
print("Unknown data type: " + data);
if (now)
table.setModel(fillTableWithStrings_makeModel(rows, toStringArray(cols)));
else
fillTableWithStrings(table, rows, cols);
return table;
}
static Rectangle boundsOnScreen(Component c) {
if (c.getParent() instanceof JViewport
&& c.getParent().getParent() instanceof JScrollPane)
c = c.getParent().getParent();
return new Rectangle(c.getLocationOnScreen(), c.getSize());
}
static <A> ArrayList<A> litlist(A... a) {
return new ArrayList<A>(Arrays.asList(a));
}
static boolean isLongConstant(String s) {
if (!s.endsWith("L")) return false;
s = s.substring(0, l(s)-1);
return isInteger(s);
}
static List<String> toLines(File f) {
return toLines(loadTextFile(f));
}
public static List<String> toLines(String s) {
List<String> lines = new ArrayList<String>();
if (s == null) return lines;
int start = 0;
while (true) {
int i = toLines_nextLineBreak(s, start);
if (i < 0) {
if (s.length() > start) lines.add(s.substring(start));
break;
}
lines.add(s.substring(start, i));
if (s.charAt(i) == '\r' && i+1 < s.length() && s.charAt(i+1) == '\n')
i += 2;
else
++i;
start = i;
}
return lines;
}
private static int toLines_nextLineBreak(String s, int start) {
for (int i = start; i < s.length(); i++) {
char c = s.charAt(i);
if (c == '\r' || c == '\n')
return i;
}
return -1;
}
static void nohupJavax(String javaxargs) {
nohupJavax(javaxargs, "");
}
// vm args are ignored if pre-spun VM found...
static void nohupJavax(String javaxargs, String vmArgs) {
javaxargs = javaxargs.trim();
if (javaxargs.startsWith("#")) javaxargs = javaxargs.substring(1);
String snippetID = javaTok(javaxargs).get(1);
int idx = javaxargs.indexOf(' ');
String args = idx < 0 ? "" : javaxargs.substring(idx+1).trim();
String line;
if (args.length() != 0)
line = format3("please start program * with arguments *", snippetID, args);
else
line = format3("please start program *", snippetID);
String answer = sendToLocalBotOpt("A pre-spun VM.", line);
if (match3("ok", answer)) {
print("OK, used pre-spun VM.");
} else {
if (answer != null)
print("> " + answer);
print("Using standard nohup.");
classicNohupJavax(javaxargs, vmArgs);
}
}
static String autoFrameTitle() {
return getProgramTitle();
}
static List map(Object f, List l) {
new List x;
Object mc = mc();
for (Object o : unnull(l))
x.add(callFunction(f, o));
return x;
}
static WeakReference<Class> creator_class;
static Class creator() {
return creator_class == null ? null : creator_class.get();
}
static void fillJMenu(JMenu m, Object... x) {
if (x == null) return;
for (int i = 0; i < l(x); i++) {
Object o = x[i], y = get(x, i+1);
if (eqOneOf(o, "***", "---", "===", ""))
m.addSeparator();
else if (o instanceof String && y instanceof Runnable) {
m.add(jmenuItem((String) o, (Runnable) y));
++i;
} else if (o instanceof JMenuItem)
m.add((JMenuItem) o); // "call" might use wrong method
else if (o instanceof String || o instanceof Action || o instanceof Component)
call(m, "add", o);
else
print("Unknown menu item: " + o);
}
}
static int max(int a, int b) {
return Math.max(a, b);
}
static long max(int a, long b) {
return Math.max((long) a, b);
}
static long max(long a, long b) {
return Math.max(a, b);
}
static double max(int a, double b) {
return Math.max((double) a, b);
}
static int max(Collection<Integer> c) {
int x = Integer.MIN_VALUE;
for (int i : c) x = max(x, i);
return x;
}
static double max(double[] c) {
if (c.length == 0) return Double.MIN_VALUE;
double x = c[0];
for (int i = 1; i < c.length; i++) x = Math.max(x, c[i]);
return x;
}
static byte max(byte[] c) {
byte x = -128;
for (byte d : c) if (d > x) x = d;
return x;
}
static void restart() {
nohupJavax(programID());
System.exit(0);
}
static File getProgramDir() {
return programDir();
}
static File getProgramDir(String snippetID) {
return programDir(snippetID);
}
static Object quickExport(Object o, Object dest) { try {
return quickExport_impl(o, dest, new IdentityHashMap);
} catch (Throwable __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}
static Object quickExport_impl(Object o, Object dest, IdentityHashMap seen) { try {
if (o == null || o instanceof String || o instanceof Number) return o;
Object oo = seen.get(o);
if (oo != null) return oo;
if (o instanceof List) {
List l = (List) ( o);
List destO = new ArrayList(l.size());
seen.put(o, destO);
for (int i = 0; i < l.size(); i++)
destO.add(quickExport_impl(l.get(i), dest, seen));
return destO;
}
if (o instanceof Map) {
Map m = (Map) ( o);
Map destO = new HashMap();
seen.put(o, destO);
for (Object e : ((Map) o).entrySet())
destO.put(
quickExport_impl(((Map.Entry) e).getKey(), dest, seen),
quickExport_impl(((Map.Entry) e).getValue(), dest, seen));
return destO;
}
String className = o.getClass().getName();
if (className.startsWith("main$") && !isAnonymousClassName(className)) {
Class destClass = getClass(dest, className);
//print(o.getClass() + " => " + destClass);
if (o.getClass() == destClass)
return o; // no export necessary
// actually make a new object, copy fields
Object destO = nuObject(destClass);
seen.put(o, destO);
// TODO: superclasses
Field[] fields = o.getClass().getDeclaredFields();
for (Field field : fields) {
if ((field.getModifiers() & Modifier.STATIC) != 0)
continue;
field.setAccessible(true);
Object value = field.get(o);
setOpt(destO, field.getName(), quickExport_impl(value, dest, seen));
}
return destO;
}
// assume it's a shared library object
return o;
} catch (Throwable __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}
static long parseLong(String s) {
if (s == null) return 0;
return Long.parseLong(dropSuffix("L", s));
}
static long parseLong(Object s) {
return Long.parseLong((String) s);
}
static JTextArea newTypeWriterTextArea() {
new JTextArea textArea;
textArea.setFont(typeWriterFont());
return textArea;
}
static JTextArea newTypeWriterTextArea(String text) {
JTextArea textArea = newTypeWriterTextArea();
textArea.setText(text);
return textArea;
}
static String getSnippetTitle(String id) { try {
if (!isSnippetID(id)) return "?";
return loadPageSilently(new URL("http://tinybrain.de:8080/tb-int/getfield.php?id=" + parseSnippetID(id) + "&field=title"));
} catch (Throwable __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}
static String formatInt(int i, int digits) {
return padLeft(str(i), '0', digits);
}
static void hotwire_copyOver(Class c) {
synchronized(StringBuffer.class) {
for (String field : litlist("print_log", "print_silent")) {
Object o = get(mc(), field);
if (o != null)
setOpt(c, field, o);
}
Object mainBot = getMainBot();
if (mainBot != null)
setOpt(c, "mainBot", mainBot);
setOpt(c, "creator_class", new WeakReference(mc()));
}
}
static Class mc() {
return getMainClass();
}
// extended over Class.isInstance() to handle primitive types
static boolean isInstanceX(Class type, Object arg) {
if (type == boolean.class) return arg instanceof Boolean;
if (type == int.class) return arg instanceof Integer;
if (type == long.class) return arg instanceof Long;
if (type == float.class) return arg instanceof Float;
if (type == short.class) return arg instanceof Short;
if (type == char.class) return arg instanceof Character;
if (type == byte.class) return arg instanceof Byte;
if (type == double.class) return arg instanceof Double;
return type.isInstance(arg);
}
static int minutes() {
return Calendar.getInstance().get(Calendar.MINUTE);
}
static <A> List<A> concatLists(List<A>... lists) {
new List<A> l;
for (List<A> list : lists)
if (list != null)
l.addAll(list);
return l;
}
static <A> List<A> concatLists(Collection<List<A>> lists) {
new List<A> l;
for (List<A> list : lists)
if (list != null)
l.addAll(list);
return l;
}
static Object nuObject(String className, Object... args) { try {
return nuObject(Class.forName(className), args);
} catch (Throwable __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}
static Object nuObject(Object realm, String className, Object... args) {
return nuObject(_getClass(realm, className), args);
}
static <A> A nuObject(Class<A> c, Object... args) { try {
Constructor m = nuObject_findConstructor(c, args);
m.setAccessible(true);
return (A) m.newInstance(args);
} catch (Throwable __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}
static Constructor nuObject_findConstructor(Class c, Object... args) {
for (Constructor m : c.getDeclaredConstructors()) {
if (!nuObject_checkArgs(m.getParameterTypes(), args, false))
continue;
return m;
}
throw new RuntimeException("Constructor with " + args.length + " matching parameter(s) not found in " + c.getName());
}
static boolean nuObject_checkArgs(Class[] types, Object[] args, boolean debug) {
if (types.length != args.length) {
if (debug)
System.out.println("Bad parameter length: " + args.length + " vs " + types.length);
return false;
}
for (int i = 0; i < types.length; i++)
if (!(args[i] == null || isInstanceX(types[i], args[i]))) {
if (debug)
System.out.println("Bad parameter " + i + ": " + args[i] + " vs " + types[i]);
return false;
}
return true;
}
static String getClassName(Object o) {
return o == null ? "null" : o.getClass().getName();
}
static boolean confirmOKCancel(final Component owner, final String msg) {
return isTrue(swingAndWait(new Object { Object get() { return
JOptionPane.showConfirmDialog(owner,
msg, "JavaX", JOptionPane.OK_CANCEL_OPTION) == JOptionPane.OK_OPTION
; }
public String toString() { return "JOptionPane.showConfirmDialog(owner,\r\n msg, \"JavaX\", JOptionPane.OK_CANCEL_OPTION) == JOptionPane.OK_OPTION"; }}));
}
static AbstractAction abstractAction(String name, final Runnable r) {
return new AbstractAction(name) {
public void actionPerformed(ActionEvent evt) {
r.run();
}
};
}
static boolean inRange(int x, int n) {
return x >= 0 && x < n;
}
static double parseDouble(String s) {
return Double.parseDouble(s);
}
public static long parseSnippetID(String snippetID) {
long id = Long.parseLong(shortenSnippetID(snippetID));
if (id == 0) fail("0 is not a snippet ID");
return id;
}
static <A, B> Map<A, B> cloneTreeMap(Map<A, B> map) {
// assume mutex is equal to collection, which will be true unless you explicitly pass a mutex to synchronizedList() which no one ever does.
if (map == null) return new TreeMap;
else synchronized(map) {
return new TreeMap(map);
}
}
static ImageIcon imageIcon(String imageID) { try {
return new ImageIcon(loadLibrary(imageID).toURI().toURL());
} catch (Throwable __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}
static int toInt(Object o) {
if (o == null) return 0;
if (o instanceof Number)
return ((Number) o).intValue();
if (o instanceof String)
return parseInt((String) o);
throw fail("woot not int: " + getClassName(o));
}
public static String loadTextFile(String fileName) {
try {
return loadTextFile(fileName, null);
} catch (IOException e) {
throw new RuntimeException(e);
}
}
public static String loadTextFile(String fileName, String defaultContents) throws IOException {
if (!new File(fileName).exists())
return defaultContents;
FileInputStream fileInputStream = new FileInputStream(fileName);
InputStreamReader inputStreamReader = new InputStreamReader(fileInputStream, "UTF-8");
return loadTextFile(inputStreamReader);
}
public static String loadTextFile(File fileName) {
try {
return loadTextFile(fileName, null);
} catch (IOException e) {
throw new RuntimeException(e);
}
}
public static String loadTextFile(File fileName, String defaultContents) throws IOException {
try {
return loadTextFile(fileName.getPath(), defaultContents);
} catch (IOException e) {
throw new RuntimeException(e);
}
}
public static String loadTextFile(Reader reader) throws IOException {
StringBuilder builder = new StringBuilder();
try {
char[] buffer = new char[1024];
int n;
while (-1 != (n = reader.read(buffer)))
builder.append(buffer, 0, n);
} finally {
reader.close();
}
return builder.toString();
}
// mainJava is a complete program, but without the !752/!759 at the top
// returns link to main class
static Class veryQuickJava(String mainJava) {
return veryQuickJava2(mainJava); // It's just better.
}
static boolean startsWith(String a, String b) {
return a != null && a.startsWith(b);
}
static boolean startsWith(List a, List b) {
if (a == null || l(b) > l(a)) return false;
for (int i = 0; i < l(b); i++)
if (neq(a.get(i), b.get(i)))
return false;
return true;
}
static void onTitleRightClick(final JFrame frame, final Runnable r) {
swingLater(new Runnable() { public void run() { try {
if (!isSubstanceLAF())
print("Can't add title right click!");
else {
JComponent titleBar = getTitlePaneComponent(frame);
titleBar.addMouseListener(new MouseAdapter() {
public void mousePressed(MouseEvent evt) {
if (evt.getButton() != MouseEvent.BUTTON1)
r.run();
}
});
}
} catch (Exception __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}});
}
static Font typeWriterFont() {
return new Font("Courier", Font.PLAIN, 14);
}
static String shortenSnippetID(String snippetID) {
if (snippetID.startsWith("#"))
snippetID = snippetID.substring(1);
String httpBlaBla = "http://tinybrain.de/";
if (snippetID.startsWith(httpBlaBla))
snippetID = snippetID.substring(httpBlaBla.length());
return "" + parseLong(snippetID);
}
static String quickSubstring(String s, int i, int j) {
if (i == j) return "";
return s.substring(i, j);
}
static void showConsole() {
JFrame frame = consoleFrame();
if (frame != null)
frame.setVisible(true);
}
static Object mainBot;
static Object getMainBot() {
return mainBot;
}
static Class getMainClass() { try {
return Class.forName("main");
} catch (Throwable __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}
static Class getMainClass(Object o) { try {
return (o instanceof Class ? (Class) o : o.getClass()).getClassLoader().loadClass("main");
} catch (Throwable __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}
static String[] toStringArray(List<String> list) {
return list.toArray(new String[list.size()]);
}
static String[] toStringArray(Object o) {
if (o instanceof String[])
return (String[]) o;
else if (o instanceof List)
return toStringArray((List<String>) o);
else
throw fail("Not a list or array: " + structure(o));
}
static boolean isAnonymousClassName(String s) {
for (int i = 0; i < l(s)-1; i++)
if (s.charAt(i) == '$' && Character.isDigit(s.charAt(i+1))) return true; return false;
}
// match2 matches multiple "*" (matches a single token) wildcards and zero or one "..." wildcards (matches multiple tokens)
static String[] match2(List<String> pat, List<String> tok) {
// standard case (no ...)
int i = pat.indexOf("...");
if (i < 0) return match2_match(pat, tok);
pat = new ArrayList<String>(pat); // We're modifying it, so copy first
pat.set(i, "*");
while (pat.size() < tok.size()) {
pat.add(i, "*");
pat.add(i+1, ""); // doesn't matter
}
return match2_match(pat, tok);
}
static String[] match2_match(List<String> pat, List<String> tok) {
List<String> result = new ArrayList<String>();
if (pat.size() != tok.size()) {
/*if (debug)
print("Size mismatch: " + structure(pat) + " vs " + structure(tok));*/
return null;
}
for (int i = 1; i < pat.size(); i += 2) {
String p = pat.get(i), t = tok.get(i);
/*if (debug)
print("Checking " + p + " against " + t);*/
if (eq(p, "*"))
result.add(t);
else if (!equalsIgnoreCase(unquote(p), unquote(t))) // bold change - match quoted and unquoted now
return null;
}
return result.toArray(new String[result.size()]);
}
static String format3(String pat, Object... args) {
if (args.length == 0) return pat;
List<String> tok = javaTokPlusPeriod(pat);
int argidx = 0;
for (int i = 1; i < tok.size(); i += 2)
if (tok.get(i).equals("*"))
tok.set(i, format3_formatArg(argidx < args.length ? args[argidx++] : "null"));
return join(tok);
}
static String format3_formatArg(Object arg) {
if (arg == null) return "null";
if (arg instanceof String) {
String s = (String) arg;
return isIdentifier(s) || isNonNegativeInteger(s) ? s : quote(s);
}
if (arg instanceof Integer || arg instanceof Long) return String.valueOf(arg);
return quote(structure(arg));
}
static void callMain(Object c, String... args) {
callOpt(c, "main", new Object[] {args});
}
static Class<?> _getClass(String name) {
try {
return Class.forName(name);
} catch (ClassNotFoundException e) {
return null;
}
}
static Class _getClass(Object o) {
return o instanceof Class ? (Class) o : o.getClass();
}
static Class _getClass(Object realm, String name) { try {
return getClass(realm).getClassLoader().loadClass(classNameToVM(name));
} catch (Throwable __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}
static void dataToTable_dynSet(List<String> l, int i, String s) {
while (i >= l.size()) l.add("");
l.set(i, s);
}
static List<String> dataToTable_makeRow(Object x, List<String> cols) {
if (instanceOf(x, "DynamicObject"))
x = get_raw(x, "fieldValues");
if (x instanceof Map) {
Map m = (Map) ( x);
new List<String> row;
for (Object _field : m.keySet()) {
String field = (String) ( _field);
Object value = m.get(field);
int col = cols.indexOf(field);
if (col < 0) {
cols.add(field);
col = cols.size()-1;
}
dataToTable_dynSet(row, col, structureOrText(value));
}
return row;
}
return litlist(structureOrText(x));
}
static String getProgramTitle() {
return getProgramName();
}
static void runMain(Object c, String... args) {
callMain(c, args);
}
static String padLeft(String s, char c, int n) {
return rep(c, n-l(s)) + s;
}
static boolean veryQuickJava_silent = true;
// mainJava is a complete program, but without the !752/!759 at the top
// returns link to main class
static Class veryQuickJava2(String mainJava) {
transpileRaw_silent = veryQuickJava_silent;
String src = transpileRaw(mainJava); // transpiled, with lib references
new List<String> libs;
src = findTranslators2(src, libs);
//print("Libs found: " + struct(libs));
return hotwireCore(concatLists(ll(javaCompile(src, join(" ", libs))), loadLibraries(libs)));
}
static void fillTableWithStrings(final JTable table, List<List<String>> rows, List<String> colNames) {
fillTableWithStrings(table, rows, toStringArray(colNames));
}
// thread-safe
static void fillTableWithStrings(final JTable table, List<List<String>> rows, String... colNames) {
final DefaultTableModel model = fillTableWithStrings_makeModel(rows, colNames);
swingNowOrLater(r {
setTableModel(table, model);
});
}
static DefaultTableModel fillTableWithStrings_makeModel(List<List<String>> rows, String... colNames) {
Object[][] data = new Object[rows.size()][];
int w = 0;
for (int i = 0; i < rows.size(); i++) {
List<String> l = rows.get(i);
Object[] r = new Object[l.size()];
for (int j = 0; j < l.size(); j++)
r[j] = l.get(j);
data[i] = r;
w = Math.max(w, l.size());
}
Object[] columnNames = new Object[w];
for (int i = 0; i < w; i++)
columnNames[i] = i < l(colNames) ? colNames[i] : "?";
return new DefaultTableModel(data, columnNames);
}
static void classicNohupJavax(String javaxargs) {
classicNohupJavax(javaxargs, "");
}
static void classicNohupJavax(String javaxargs, String vmArgs) { try {
int x = latestInstalledJavaX();
File xfile = new File(userHome(), ".javax/x" + Math.max(x, 30) + ".jar");
if (!xfile.isFile()) {
String url = "http://tinybrain.de/x30.jar";
byte[] data = loadBinaryPage(url);
if (data.length < 1000000)
fail("Could not load " + url);
saveBinaryFile(xfile.getPath(), data);
}
String jarPath = xfile.getPath();
if (javaxargs.startsWith("#")) javaxargs = javaxargs.substring(1);
nohup("java " + vmArgs + " -jar " + (isWindows() ? winQuote(jarPath) : bashQuote(jarPath)) + " " + javaxargs);
} catch (Throwable __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}
static Object getBot(String botID) {
return callOpt(getMainBot(), "getBot", botID);
}
static boolean isSubstanceLAF() {
return substanceLookAndFeelEnabled();
}
static boolean substanceLookAndFeelEnabled() {
return startsWith(getLookAndFeel(), "org.pushingpixels.");
}
static JMenuItem jmenuItem(String text, final Runnable r) {
JMenuItem mi = new JMenuItem(text);
mi.addActionListener(new java.awt.event.ActionListener() { public void actionPerformed(java.awt.event.ActionEvent _evt) { r.run(); }});
return mi;
}
static JTable showTable(Object data) {
return dataToTable(data);
}
static JTable showTable(Object data, String title) {
return dataToTable(data, title);
}
static JTable showTable() {
return showTable(new ArrayList<List<String>>(), new ArrayList<String>());
}
static JTable showTable(String title) {
return showTable(new ArrayList<List<String>>(), new ArrayList<String>(), title);
}
static JTable showTable(List<List<String>> rows, List<String> cols) {
return showTable(rows, cols, autoFrameTitle());
}
static JTable showTable(List<List<String>> rows, List<String> cols, String title) {
JFrame frame = new JFrame(title);
frame.setBounds(10, 10, 500, 400);
centerFrame(frame);
JTable tbl = tableWithToolTips();
fillTableWithStrings(tbl, rows, cols);
frame.getContentPane().add(new JScrollPane(tbl));
frame.setVisible(true);
return tbl;
}
static List<String> parse3(String s) {
return dropPunctuation(javaTokPlusPeriod(s));
}
static new ThreadLocal<String> loadPage_charset;
static boolean loadPage_allowGzip = true, loadPage_debug;
static boolean loadPage_anonymous; // don't send computer ID
static int loadPage_verboseness = 100000;
public static String loadPageSilently(String url) {
try {
return loadPageSilently(new URL(loadPage_preprocess(url)));
} catch (IOException e) { throw new RuntimeException(e); }
}
public static String loadPageSilently(URL url) {
try {
IOException e = null;
for (int tries = 0; tries < 60; tries++)
try {
URLConnection con = url.openConnection();
return loadPage(con, url);
} catch (IOException _e) {
e = _e;
print("Retrying because of: " + e);
sleepSeconds(1);
}
throw e;
} catch (IOException e) { throw new RuntimeException(e); }
}
static String loadPage_preprocess(String url) {
if (url.startsWith("tb/"))
url = "tinybrain.de:8080/" + url;
if (url.indexOf("://") < 0)
url = "http://" + url;
return url;
}
public static String loadPage(String url) {
try {
return loadPage(new URL(loadPage_preprocess(url)));
} catch (IOException e) { throw new RuntimeException(e); }
}
public static String loadPage(URL url) {
print("Loading: " + url.toExternalForm());
return loadPageSilently(url);
}
public static String loadPage(URLConnection con, URL url) throws IOException {
try {
if (!loadPage_anonymous) {
String computerID = getComputerID();
if (computerID != null)
con.setRequestProperty("X-ComputerID", computerID);
}
if (loadPage_allowGzip)
con.setRequestProperty("Accept-Encoding", "gzip");
} catch (Throwable e) {} // fails if within doPost
String contentType = con.getContentType();
if (contentType == null)
throw new IOException("Page could not be read: " + url);
//print("Content-Type: " + contentType);
String charset = loadPage_charset == null ? null : loadPage_charset.get();
if (charset == null) charset = loadPage_guessCharset(contentType);
InputStream in = con.getInputStream();
if ("gzip".equals(con.getContentEncoding())) {
if (loadPage_debug)
print("loadPage: Using gzip.");
in = new GZIPInputStream(in);
}
Reader r = new InputStreamReader(in, charset);
StringBuilder buf = new StringBuilder();
int n = 0;
while (true) {
int ch = r.read();
if (ch < 0)
break;
buf.append((char) ch);
++n;
if ((n % loadPage_verboseness) == 0) print(" " + n + " chars read");
}
return buf.toString();
}
static String loadPage_guessCharset(String contentType) {
Pattern p = Pattern.compile("text/[a-z]+;\\s+charset=([^\\s]+)\\s*");
Matcher m = p.matcher(contentType);
/* If Content-Type doesn't match this pre-conception, choose default and hope for the best. */
return m.matches() ? m.group(1) : "ISO-8859-1";
}
static void assertTrue(Object o) {
assertEquals(true, o);
}
static boolean assertTrue(String msg, boolean b) {
if (!b)
fail(msg);
return b;
}
static boolean assertTrue(boolean b) {
if (!b)
fail("oops");
return b;
}
static String programTitle() {
return getProgramName();
}
static Class<?> getClass(String name) {
try {
return Class.forName(name);
} catch (ClassNotFoundException e) {
return null;
}
}
static Class getClass(Object o) {
return o instanceof Class ? (Class) o : o.getClass();
}
static Class getClass(Object realm, String name) { try {
return getClass(realm).getClassLoader().loadClass(classNameToVM(name));
} catch (Throwable __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}
static File loadLibrary(String snippetID) {
return loadBinarySnippet(snippetID);
}
static boolean eqOneOf(Object o, Object... l) {
for (Object x : l) if (eq(o, x)) return true; return false;
}
static boolean booleanValue(Object o) {
return eq(true, o);
}
static File javaxDataDir_dir; // can be set to work on different base dir
static File javaxDataDir() {
return javaxDataDir_dir != null ? javaxDataDir_dir : new File(userHome(), "JavaX-Data");
}
static Object[] toObjectArray(List list) {
return list.toArray(new Object[list.size()]);
}
static String dropSuffix(String suffix, String s) {
return s.endsWith(suffix) ? s.substring(0, l(s)-l(suffix)) : s;
}
static void smartSet(Field f, Object o, Object value) throws Exception {
f.setAccessible(true);
// take care of common case (long to int)
if (f.getType() == int.class && value instanceof Long)
value = ((Long) value).intValue();
f.set(o, value);
}
static String sendToLocalBotOpt(String bot, String text) {
if (bot == null) return null;
DialogIO channel = findBot(bot);
if (channel == null) {
print(quote(bot) + " not found, skipping send: " + quote(text));
return null;
}
try {
channel.readLine();
print(bot + "> " + text);
channel.sendLine(text);
String s = channel.readLine();
print(bot + "< " + s);
return s;
} catch (Throwable e) {
e.printStackTrace();
return null;
} finally {
channel.close();
}
}
public static boolean isWindows() {
return System.getProperty("os.name").contains("Windows");
}
static boolean equalsIgnoreCase(String a, String b) {
return a == null ? b == null : a.equalsIgnoreCase(b);
}
/** possibly improvable */
public static String bashQuote(String text) {
if (text == null) return null;
return "\"" + text
.replace("\\", "\\\\")
.replace("\"", "\\\"")
.replace("\n", "\\n")
.replace("\r", "\\r") + "\"";
}
static Object transpileRaw_trans;
static Object transpileRaw_silent = true;
static synchronized String transpileRaw(String mainJava) {
if (transpileRaw_trans == null)
// Note: we sync the whole main class on this
transpileRaw_trans = hotwire("#759");
setOpt(transpileRaw_trans, "print_silent", transpileRaw_silent);
set(transpileRaw_trans, "mainJava", mainJava);
callMain(transpileRaw_trans);
return (String) get(transpileRaw_trans, "mainJava");
}
static File loadBinarySnippet(String snippetID) { try {
long id = parseSnippetID(snippetID);
File f = DiskSnippetCache_getLibrary(id);
if (f == null) {
byte[] data = loadDataSnippetImpl(snippetID);
DiskSnippetCache_putLibrary(id, data);
f = DiskSnippetCache_getLibrary(id);
}
return f;
} catch (Throwable __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}
static JComponent getTitlePaneComponent(Window window) {
if (!substanceLookAndFeelEnabled()) return null;
JRootPane rootPane = null;
if (window instanceof JFrame) {
JFrame f = (JFrame) window;
rootPane = f.getRootPane();
}
if (window instanceof JDialog) {
JDialog d = (JDialog) window;
rootPane = d.getRootPane();
}
if (rootPane != null) {
Object /*SubstanceRootPaneUI*/ ui = rootPane.getUI();
return (JComponent) call(ui, "getTitlePane");
}
return null;
}
static void setTableModel(JTable table, TableModel model) {
int i = table.getSelectedRow();
table.setModel(model);
if (i >= 0 && i < model.getRowCount())
table.setRowSelectionInterval(i, i);
}
static String findTranslators2(String src, List<String> libsOut) {
List<String> tok = javaTok(src);
int i;
while ((i = jfind(tok, "!<int>")) >= 0) {
setAdd(libsOut, tok.get(i+2));
clearTokens(tok, i, i+3);
}
return join(tok);
}
static void centerFrame(JFrame frame) {
frame.setLocationRelativeTo(null); // magic trick
}
static new Map<String, Integer> findBot_cache;
static int findBot_timeout = 5000;
static DialogIO findBot(String searchPattern) {
// first split off sub-bot suffix
String subBot = null;
int i = searchPattern.indexOf('/');
if (i >= 0 && (isJavaIdentifier(searchPattern.substring(0, i)) || isInteger(searchPattern.substring(0, i)))) {
subBot = searchPattern.substring(i+1);
searchPattern = searchPattern.substring(0, i);
if (!isInteger(searchPattern))
searchPattern = "Multi-Port at " + searchPattern + ".";
}
// assume it's a port if it's an integer
if (isInteger(searchPattern))
return talkToSubBot(subBot, talkTo(parseInt(searchPattern)));
if (eq(searchPattern, "remote"))
return talkToSubBot(subBot, talkTo("second.tinybrain.de", 4999));
Integer port = findBot_cache.get(searchPattern);
if (port != null) try {
DialogIO io = talkTo("localhost", port);
io.waitForLine(/*findBot_timeout*/); // TODO: implement
String line = io.readLineNoBlock();
if (indexOfIgnoreCase(line, searchPattern) == 0) {
call(io, "pushback", line); // put hello string back in
return talkToSubBot(subBot, io);
}
} catch (Exception e) {
e.printStackTrace();
}
List<ProgramScan.Program> bots = quickBotScan();
// find top-level bots
for (ProgramScan.Program p : bots) {
if (indexOfIgnoreCase(p.helloString, searchPattern) == 0) { // strict matching - start of hello string only, but case-insensitive
findBot_cache.put(searchPattern, p.port);
return talkToSubBot(subBot, talkTo("localhost", p.port));
}
}
// find sub-bots
for (ProgramScan.Program p : bots) {
String botName = firstPartOfHelloString(p.helloString);
boolean isVM = startsWithIgnoreCase(p.helloString, "This is a JavaX VM.");
boolean shouldRecurse = startsWithIgnoreCase(botName, "Multi-Port") || isVM;
if (shouldRecurse) try {
Map<Number, String> subBots = (Map) unstructure(sendToLocalBot(p.port, "list bots"));
for (Number vport : subBots.keySet()) {
String name = subBots.get(vport);
if (startsWithIgnoreCase(name, searchPattern))
return talkToSubBot(vport.longValue(), talkTo("localhost", p.port));
}
} catch (Exception e) { e.printStackTrace(); }
}
return null;
}
/** possibly improvable */
public static String winQuote(String text) {
if (text == null) return null;
return "\"" + text
.replace("\\", "\\\\")
.replace("\"", "\\\"")
.replace("\n", "\\n")
.replace("\r", "\\r") + "\"";
}
static boolean instanceOf(Object o, String className) {
if (o == null) return false;
String c = o.getClass().getName();
return eq(c, className) || eq(c, "main$" + className);
}
static String rep(int n, char c) {
return repeat(c, n);
}
static String rep(char c, int n) {
return repeat(c, n);
}
static <A> List<A> rep(A a, int n) {
return repeat(a, n);
}
static boolean isNonNegativeInteger(String s) {
return s != null && Pattern.matches("\\d+", s);
}
static String classNameToVM(String name) {
return name.replace(".", "$");
}
// This is made for NL parsing.
// It's javaTok extended with "..." token, "$n" and "#n" and
// special quotes (which are converted to normal ones).
static List<String> javaTokPlusPeriod(String s) {
List<String> tok = new ArrayList<String>();
int l = s.length();
int i = 0;
while (i < l) {
int j = i;
char c; String cc;
// scan for whitespace
while (j < l) {
c = s.charAt(j);
cc = s.substring(j, Math.min(j+2, l));
if (c == ' ' || c == '\t' || c == '\r' || c == '\n')
++j;
else if (cc.equals("/*")) {
do ++j; while (j < l && !s.substring(j, Math.min(j+2, l)).equals("*/"));
j = Math.min(j+2, l);
} else if (cc.equals("//")) {
do ++j; while (j < l && "\r\n".indexOf(s.charAt(j)) < 0);
} else
break;
}
tok.add(s.substring(i, j));
i = j;
if (i >= l) break;
c = s.charAt(i);
cc = s.substring(i, Math.min(i+2, l));
// scan for non-whitespace
if (c == '\u201C' || c == '\u201D') c = '"'; // normalize quotes
if (c == '\'' || c == '"') {
char opener = c;
++j;
while (j < l) {
char _c = s.charAt(j);
if (_c == '\u201C' || _c == '\u201D') _c = '"'; // normalize quotes
if (_c == opener) {
++j;
break;
} else if (s.charAt(j) == '\\' && j+1 < l)
j += 2;
else
++j;
}
if (j-1 >= i+1) {
tok.add(opener + s.substring(i+1, j-1) + opener);
i = j;
continue;
}
} else if (Character.isJavaIdentifierStart(c))
do ++j; while (j < l && (Character.isJavaIdentifierPart(s.charAt(j)) || s.charAt(j) == '\'')); // for things like "this one's"
else if (Character.isDigit(c))
do ++j; while (j < l && Character.isDigit(s.charAt(j)));
else if (cc.equals("[[")) {
do ++j; while (j+1 < l && !s.substring(j, j+2).equals("]]"));
j = Math.min(j+2, l);
} else if (cc.equals("[=") && i+2 < l && s.charAt(i+2) == '[') {
do ++j; while (j+2 < l && !s.substring(j, j+3).equals("]=]"));
j = Math.min(j+3, l);
} else if (s.substring(j, Math.min(j+3, l)).equals("..."))
j += 3;
else if (c == '$' || c == '#')
do ++j; while (j < l && Character.isDigit(s.charAt(j)));
else
++j;
tok.add(s.substring(i, j));
i = j;
}
if ((tok.size() % 2) == 0) tok.add("");
return tok;
}
/** writes safely (to temp file, then rename) */
public static void saveBinaryFile(String fileName, byte[] contents) throws IOException {
File file = new File(fileName);
File parentFile = file.getParentFile();
if (parentFile != null)
parentFile.mkdirs();
String tempFileName = fileName + "_temp";
FileOutputStream fileOutputStream = new FileOutputStream(tempFileName);
fileOutputStream.write(contents);
fileOutputStream.close();
if (file.exists() && !file.delete())
throw new IOException("Can't delete " + fileName);
if (!new File(tempFileName).renameTo(file))
throw new IOException("Can't rename " + tempFileName + " to " + fileName);
}
static void saveBinaryFile(File fileName, byte[] contents) {
try {
saveBinaryFile(fileName.getPath(), contents);
} catch (IOException e) {
throw new RuntimeException(e);
}
}
static List<File> loadLibraries(List<String> snippetIDs) {
return map("loadLibrary", snippetIDs);
}
static JFrame consoleFrame() {
return (JFrame) getOpt(get(getJavaX(), "console"), "frame");
}
static Class hotwireCore(List urlsOrFiles) {
List<URL> urls = map("toURL", urlsOrFiles);
return hotwireCore((URL[]) asArray(URL.class, urls));
}
static Class hotwireCore(URL... urls) { try {
// make class loader
URLClassLoader classLoader = new URLClassLoader(urls);
// load & return main class
Class<?> theClass = classLoader.loadClass("main");
if (!_inCore())
hotwire_copyOver(theClass);
return theClass;
} catch (Throwable __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}
static TableWithTooltips tableWithToolTips() {
return tableWithTooltips();
}
static String getComputerID() { try {
return computerID();
} catch (Throwable __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}
static String _userHome;
static String userHome() {
if (_userHome == null) {
if (isAndroid())
_userHome = "/storage/sdcard0/";
else
_userHome = System.getProperty("user.home");
//System.out.println("userHome: " + _userHome);
}
return _userHome;
}
static File userHome(String path) {
return new File(userDir(), path);
}
static <A> A assertEquals(Object x, A y) {
return assertEquals(null, x, y);
}
static <A> A assertEquals(String msg, Object x, A y) {
if (!(x == null ? y == null : x.equals(y)))
fail((msg != null ? msg + ": " : "") + structure(x) + " != " + structure(y));
return y;
}
static boolean isIdentifier(String s) {
return isJavaIdentifier(s);
}
static String getLookAndFeel() {
return getClassName(UIManager.getLookAndFeel());
}
static void sleepSeconds(double s) {
if (s > 0) sleep(round(s*1000));
}
static int latestInstalledJavaX() {
File[] files = new File(userHome(), ".javax").listFiles();
int v = 0;
if (files != null) for (File f : files) {
Matcher m = Pattern.compile("x(\\d\\d\\d?)\\.jar").matcher(f.getName());
if (m.matches())
v = Math.max(v, Integer.parseInt(m.group(1)));
}
return v;
}
public static File nohup(String cmd) throws IOException {
File outFile = File.createTempFile("nohup_" + nohup_sanitize(cmd), ".out");
nohup(cmd, outFile, false);
return outFile;
}
static String nohup_sanitize(String s) {
return s.replaceAll("[^a-zA-Z0-9\\-_]", "");
}
/** outFile takes stdout and stderr. */
public static void nohup(String cmd, File outFile, boolean append) throws IOException {
String command = nohup_makeNohupCommand(cmd, outFile, append);
File scriptFile = File.createTempFile("_realnohup", isWindows() ? ".bat" : "");
System.out.println("[Nohup] " + command);
try {
//System.out.println("[RealNohup] Script file: " + scriptFile.getPath());
saveTextFile(scriptFile.getPath(), command);
String[] command2;
if (isWindows())
command2 = new String[] {"cmd", "/c", "start", "/b", scriptFile.getPath() };
else
command2 = new String[] {"/bin/bash", scriptFile.getPath() };
Process process = Runtime.getRuntime().exec(command2);
try {
process.waitFor();
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
int value = process.exitValue();
//System.out.println("exit value: " + value);
} finally {
if (!isWindows())
scriptFile.delete();
}
}
public static String nohup_makeNohupCommand(String cmd, File outFile, boolean append) {
mkdirsForFile(outFile);
String command;
if (isWindows())
command = cmd + (append ? " >>" : " >") + winQuote(outFile.getPath()) + " 2>&1";
else
command = "nohup " + cmd + (append ? " >>" : " >") + bashQuote(outFile.getPath()) + " 2>&1 &";
return command;
}
static List<String> dropPunctuation_keep = litlist("*", "<", ">");
static List<String> dropPunctuation(List<String> tok) {
tok = new ArrayList<String>(tok);
for (int i = 1; i < tok.size(); i += 2) {
String t = tok.get(i);
if (t.length() == 1 && !Character.isLetter(t.charAt(0)) && !Character.isDigit(t.charAt(0)) && !dropPunctuation_keep.contains(t)) {
tok.set(i-1, tok.get(i-1) + tok.get(i+1));
tok.remove(i);
tok.remove(i);
i -= 2;
}
}
return tok;
}
static String dropPunctuation(String s) {
return join(dropPunctuation(nlTok(s)));
}
static byte[] loadBinaryPage(String url) throws IOException {
return loadBinaryPage(new URL(url).openConnection());
}
public static byte[] loadBinaryPage(URLConnection con) throws IOException {
//setHeaders(con);
ByteArrayOutputStream buf = new ByteArrayOutputStream();
InputStream inputStream = con.getInputStream();
int n = 0;
while (true) {
int ch = inputStream.read();
if (ch < 0)
break;
buf.write(ch);
if (++n % 100000 == 0)
System.err.println(" " + n + " bytes loaded.");
}
inputStream.close();
return buf.toByteArray();
}
static File javaCompile(String src) {
return javaCompile(src, "");
}
// returns path to classes dir
static synchronized File javaCompile(String src, String dehlibs) {
String javaTarget = null; // use default target
//print("Compiling " + l(src) + " chars");
Class j = getJavaX();
if (javaTarget != null)
setOpt(j, "javaTarget", javaTarget);
//setOpt(j, "verbose", true);
File srcDir = (File) ( call(j, "TempDirMaker_make"));
String className = getNameOfPublicClass(javaTok(src));
String fileName = className + ".java";
File mainJava = new File(srcDir, fileName);
//print("main java: " + mainJava.getAbsolutePath());
saveTextFile(mainJava, src);
File classesDir = (File) call(j, "TempDirMaker_make");
new List<File> libraries;
Matcher m = Pattern.compile("\\d+").matcher(dehlibs);
while (m.find()) {
String libID = m.group();
print("libID=" + quote(libID));
assertTrue(isSnippetID(libID));
libraries.add(loadLibrary(libID));
}
try {
// This seems to be empty in case of success with Eclipse compiler.
String compilerOutput = (String) ( call(j, "compileJava", srcDir, libraries, classesDir));
if (nempty(compilerOutput)) print("Compiler said: " + quote(compilerOutput));
// sanity test
if (!new File(classesDir, className + ".class").exists())
fail("No class generated (" + className + ")");
} catch (Exception e) {
//e.printStackTrace();
fail("Compile Error\n" + getOpt(j, "javaCompilerOutput"));
}
return classesDir;
}
static String getProgramName_cache;
static synchronized String getProgramName() {
if (getProgramName_cache == null)
getProgramName_cache = getSnippetTitle(getProgramID());
return getProgramName_cache;
}
static DialogIO talkToSubBot(final long vport, final DialogIO io) {
return talkToSubBot(String.valueOf(vport), io);
}
static DialogIO talkToSubBot(final String subBot, final DialogIO io) {
if (subBot == null) return io;
return new DialogIO() {
// delegate all but sendLine
boolean isStillConnected() { return io.isStillConnected(); }
String readLineImpl() { return io.readLineImpl(); }
boolean isLocalConnection() { return io.isLocalConnection(); }
Socket getSocket() { return io.getSocket(); }
void close() { io.close(); }
void sendLine(String line) {
io.sendLine(format3("please forward to bot *: *", subBot, line));
}
};
}
static void sleep(long ms) {
try {
Thread.sleep(ms);
} catch (Exception e) { throw new RuntimeException(e); }
}
static void sleep() { try {
print("Sleeping.");
synchronized(main.class) { main.class.wait(); }
} catch (Throwable __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}
// Data files are immutable, use centralized cache
public static File DiskSnippetCache_getLibrary(long snippetID) throws IOException {
File file = new File(getGlobalCache(), "data_" + snippetID + ".jar");
return file.exists() ? file : null;
}
public static void DiskSnippetCache_putLibrary(long snippetID, byte[] data) throws IOException {
saveBinaryFile(new File(getGlobalCache(), "data_" + snippetID).getPath() + ".jar", data);
}
static byte[] loadDataSnippetImpl(String snippetID) throws IOException {
byte[] data;
try {
URL url = new URL("http://eyeocr.sourceforge.net/filestore/filestore.php?cmd=serve&file=blob_"
+ parseSnippetID(snippetID) + "&contentType=application/binary");
System.err.println("Loading library: " + url);
try {
data = loadBinaryPage(url.openConnection());
} catch (IOException e) {
data = null;
}
if (data == null || data.length == 0) {
url = new URL("http://data.tinybrain.de/blobs/"
+ parseSnippetID(snippetID));
System.err.println("Loading library: " + url);
data = loadBinaryPage(url.openConnection());
}
System.err.println("Bytes loaded: " + data.length);
} catch (FileNotFoundException e) {
throw new IOException("Binary snippet #" + snippetID + " not found or not public");
}
return data;
}
static URL toURL(Object o) { try {
if (o instanceof URL) return (URL) o;
if (o instanceof String) return new URL((String) o);
if (o instanceof File) return fileToURL((File) o);
fail("Can't convert to URL: " + o);
} catch (Throwable __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}
static String _computerID;
public static String computerID() { try {
if (_computerID == null) {
File file = new File(userHome(), ".tinybrain/computer-id");
_computerID = loadTextFile(file.getPath(), null);
if (_computerID == null) {
_computerID = makeRandomID(12);
saveTextFile(file.getPath(), _computerID);
}
}
return _computerID;
} catch (Throwable __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}
static String firstPartOfHelloString(String s) {
int i = s.lastIndexOf('/');
return i < 0 ? s : rtrim(s.substring(0, i));
}
static String getNameOfPublicClass(List<String> tok) {
for (List<String> c : allClasses(tok))
if (hasModifier(c, "public"))
return getClassDeclarationName(c);
return null;
}
static void clearTokens(List<String> tok) {
clearAllTokens(tok);
}
static void clearTokens(List<String> tok, int i, int j) {
clearAllTokens(tok, i, j);
}
static List<ProgramScan.Program> quickBotScan() {
return ProgramScan.quickBotScan();
}
static List<ProgramScan.Program> quickBotScan(int[] preferredPorts) {
return ProgramScan.quickBotScan(preferredPorts);
}
static List<ProgramScan.Program> quickBotScan(String searchPattern) {
List<ProgramScan.Program> l = new ArrayList<ProgramScan.Program>();
for (ProgramScan.Program p : ProgramScan.quickBotScan())
if (indexOfIgnoreCase(p.helloString, searchPattern) == 0)
l.add(p);
return l;
}
static List<String> nlTok(String s) {
return javaTokPlusPeriod(s);
}
static int jfind(List<String> tok, String in) {
List<String> tokin = javaTok(in);
jfind_preprocess(tokin);
return findCodeTokens(tok, false, toStringArray(codeTokensOnly(tokin)));
}
static void jfind_preprocess(List<String> tok) {
for (String type : litlist("quoted", "id", "int"))
replaceSublist(tok, litlist("<", "", type, "", ">"), litlist("<" + type + ">"));
}
static DialogIO talkTo(int port) {
return talkTo("localhost", port);
}
static DialogIO talkTo(String ip, int port) { try {
final Socket s = new Socket(ip, port);
//print("Talking to " + ip + ":" + port);
final Writer w = new OutputStreamWriter(s.getOutputStream(), "UTF-8");
final BufferedReader in = new BufferedReader(new InputStreamReader(s.getInputStream(), "UTF-8"));
return new DialogIO() {
boolean isLocalConnection() {
return s.getInetAddress().isLoopbackAddress();
}
boolean isStillConnected() {
return !(eos || s.isClosed());
}
void sendLine(String line) { try {
w.write(line + "\n");
w.flush();
} catch (Throwable __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}
String readLineImpl() { try {
return in.readLine();
} catch (Throwable __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}
void close() {
try {
s.close();
} catch (IOException e) {
// whatever
}
}
Socket getSocket() {
return s;
}
};
} catch (Throwable __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}
static String sendToLocalBot(String bot, String text, Object... args) {
text = format3(text, args);
DialogIO channel = findBot(bot);
if (channel == null)
fail(quote(bot) + " not found");
try {
channel.readLine();
print(bot + "> " + shorten(text, 80));
channel.sendLine(text);
String s = channel.readLine();
print(bot + "< " + shorten(s, 80));
return s;
} catch (Throwable e) {
e.printStackTrace();
return null;
} finally {
channel.close();
}
}
static String sendToLocalBot(int port, String text, Object... args) {
text = format3(text, args);
DialogIO channel = talkTo(port);
try {
channel.readLine();
print(port + "> " + shorten(text, 80));
channel.sendLine(text);
String s = channel.readLine();
print(port + "< " + shorten(s, 80));
return s;
} catch (Throwable e) {
e.printStackTrace();
return null;
} finally {
if (channel != null)
channel.close();
}
}
// works on lists and strings and null
static int indexOfIgnoreCase(Object a, Object b) {
if (a == null) return -1;
if (a instanceof String) {
Matcher m = Pattern.compile((String) b, Pattern.CASE_INSENSITIVE + Pattern.LITERAL).matcher((String) a);
if (m.find()) return m.start(); else return -1;
}
if (a instanceof List) {
for (int i = 0; i < ((List) a).size(); i++) {
Object o = ((List) a).get(i);
if (o != null && ((String) o).equalsIgnoreCase((String) b))
return i;
}
return -1;
}
throw fail("Unknown type: " + a);
}
static String repeat(char c, int n) {
n = max(n, 0);
char[] chars = new char[n];
for (int i = 0; i < n; i++)
chars[i] = c;
return new String(chars);
}
static <A> List<A> repeat(A a, int n) {
new List<A> l;
for (int i = 0; i < n; i++)
l.add(a);
return l;
}
static long round(double d) {
return Math.round(d);
}
static File userDir() {
return new File(userHome());
}
static File userDir(String path) {
return new File(userHome(), path);
}
static boolean isAndroid() { return System.getProperty("java.vendor").toLowerCase().indexOf("android") >= 0; }
static String getClassDeclarationName(List<String> c) {
for (int i = 1; i+2 < c.size(); i += 2)
if (c.get(i).equals("class"))
return c.get(i+2);
return null;
}
static URL fileToURL(File f) { try {
return f.toURI().toURL();
} catch (Throwable __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}
static File getGlobalCache() {
File file = new File(userHome(), ".tinybrain/snippet-cache");
file.mkdirs();
return file;
}
// lists returned are actual CNC (N/C/N/.../C/N) - and connected to
// original list
static List<List<String>> allClasses(List<String> tok) {
List<List<String>> l = new ArrayList();
for (int i = 1; i < tok.size(); i += 2) {
if (tok.get(i).equals("class") && (i == 1 || !tok.get(i-2).equals("."))) {
int j = i;
while (j < tok.size() && !tok.get(j).equals("{"))
j += 2;
j = findEndOfBlock(tok, j)+1;
i = leftScanModifiers(tok, i);
l.add(tok.subList(i-1, Math.min(tok.size(), j)));
i = j-2;
}
}
return l;
}
static List<List<String>> allClasses(String text) {
return allClasses(javaTok(text));
}
static List<String> replaceSublist(List<String> l, List<String> x, List<String> y) {
if (x == null) return l;
int i = 0;
while (true) {
i = indexOfSubList(l, x, i);
if (i < 0) break;
// It's inefficient :D
for (int j = 0; j < l(x); j++) l.remove(i);
l.addAll(i, y);
i += l(y);
}
return l;
}
// scans a Java construct (class, method) and checks its modifiers
static boolean hasModifier(List<String> tok, String modifier) {
for (int i = 1; i < tok.size() && getJavaModifiers().contains(tok.get(i)); i += 2)
if (tok.get(i).equals(modifier))
return true;
return false;
}
static void clearAllTokens(List<String> tok) {
for (int i = 0; i < tok.size(); i++)
tok.set(i, "");
}
static void clearAllTokens(List<String> tok, int i, int j) {
for (; i < j; i++)
tok.set(i, "");
}
static int findCodeTokens(List<String> tok, String... tokens) {
return findCodeTokens(tok, 1, false, tokens);
}
static int findCodeTokens(List<String> tok, boolean ignoreCase, String... tokens) {
return findCodeTokens(tok, 1, ignoreCase, tokens);
}
static int findCodeTokens(List<String> tok, int startIdx, boolean ignoreCase, String... tokens) {
return findCodeTokens(tok, startIdx, ignoreCase, tokens, null);
}
static List<String> findCodeTokens_specials = litlist("*", "<quoted>", "<id>", "<int>", "\\*");
static boolean findCodeTokens_debug;
static int findCodeTokens_indexed, findCodeTokens_unindexed;
static int findCodeTokens(List<String> tok, int startIdx, boolean ignoreCase, String[] tokens, Object condition) {
if (findCodeTokens_debug) {
if (eq(getClassName(tok), "main$IndexedList2"))
findCodeTokens_indexed++;
else
findCodeTokens_unindexed++;
}
// bail out early if first token not found (works great with IndexedList)
if (!findCodeTokens_specials.contains(tokens[0])
&& !tok.contains(tokens[0] /*, startIdx << no signature in List for this, unfortunately */)) return -1;
outer: for (int i = startIdx | 1; i+tokens.length*2-2 < tok.size(); i += 2) {
for (int j = 0; j < tokens.length; j++) {
String p = tokens[j], t = tok.get(i+j*2);
boolean match;
if (eq(p, "*")) match = true;
else if (eq(p, "<quoted>")) match = isQuoted(t);
else if (eq(p, "<id>")) match = isIdentifier(t);
else if (eq(p, "<int>")) match = isInteger(t);
else if (eq(p, "\\*")) match = eq("*", t);
else match = ignoreCase ? eqic(p, t) : eq(p, t);
if (!match)
continue outer;
}
if (condition == null || checkCondition(condition, tok, i-1)) // pass N index
return i;
}
return -1;
}
public static String rtrim(String s) {
int i = s.length();
while (i > 0 && " \t\r\n".indexOf(s.charAt(i-1)) >= 0)
--i;
return i < s.length() ? s.substring(0, i) : s;
}
static <A> int indexOfSubList(List<A> x, List<A> y, int i) {
outer: for (; i+l(y) <= l(x); i++) {
for (int j = 0; j < l(y); j++)
if (neq(x.get(i+j), y.get(j)))
continue outer;
return i;
}
return -1;
}
// supports the usual quotings (', ", variable length double brackets)
static boolean isQuoted(String s) {
if (s.startsWith("'") || s.startsWith("\"")) return true;
if (!s.startsWith("[")) return false;
int i = 1;
while (i < s.length() && s.charAt(i) == '=') ++i;
return i < s.length() && s.charAt(i) == '[';
//return Pattern.compile("^\\[=*\\[").matcher(s).find();
}
static boolean checkCondition(Object condition, Object... args) {
return isTrue(call(condition, "check", args));
}
static int leftScanModifiers(List<String> tok, int i) {
List<String> mod = getJavaModifiers();
while (i > 1 && mod.contains(tok.get(i-2)))
i -= 2;
return i;
}
static List<String> getJavaModifiers_list = litlist("static", "abstract", "public", "private", "protected", "final", "native", "volatile", "synchronized", "transient");
static List<String> getJavaModifiers() {
return getJavaModifiers_list;
}
// i must point at the opening bracket ("{")
// index returned is index of closing bracket + 1
static int findEndOfBlock(List<String> cnc, int i) {
int j = i+2, level = 1;
while (j < cnc.size()) {
if (cnc.get(j).equals("{")) ++level;
else if (cnc.get(j).equals("}")) --level;
if (level == 0)
return j+1;
++j;
}
return cnc.size();
}
static class Gen {
String name;
Object func;
*() {}
*(String *name, Object *func) {}
public String toString() {
return name;
}
}
static class Var<A> {
A v;
*() {}
*(A *v) {}
synchronized void set(A a) { v = a; }
synchronized A get() { return v; }
}
static class ProgramScan {
static int threads = isWindows() ? 500 : 10;
static int timeout = 5000; // hmm...
static String ip = "127.0.0.1";
static int quickScanFrom = 10000, quickScanTo = 10999;
static int maxNumberOfBotPorts = 100;
static boolean verbose;
static class Program {
int port;
String helloString;
*(int *port, String *helloString) {}
}
static List<Program> scan() { try {
return scan(1, 65535);
} catch (Throwable __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}
static List<Program> scan(int fromPort, int toPort) {
return scan(fromPort, toPort, new int[0]);
}
static List<Program> scan(int fromPort, int toPort, int[] preferredPorts) { try {
Set<Integer> preferredPortsSet = new HashSet<Integer>(asList(preferredPorts));
String name = toPort < 10000 ? "bot" : "program";
final ExecutorService es = Executors.newFixedThreadPool(threads);
if (verbose) print(firstToUpper(name) + "-scanning " + ip + " with timeout " + timeout + " ms in " + threads + " threads.");
startTiming();
new List<Future<Program>> futures;
for (int port : preferredPorts)
futures.add(checkPort(es, ip, port, timeout));
for (int port = fromPort; port <= toPort; port++)
if (!preferredPortsSet.contains(port))
futures.add(checkPort(es, ip, port, timeout));
es.shutdown();
new List<Program> programs;
for (final Future<Program> f : futures) {
Program p = f.get();
if (p != null)
programs.add(p);
}
stopTiming();
if (verbose) print("Found " + programs.size() + " " + name + "(s) on " + ip);
return programs;
} catch (Throwable __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}
static Future<Program> checkPort(final ExecutorService es, final String ip, final int port, final int timeout) {
return es.submit(new Callable<Program>() {
@Override public Program call() {
try {
Socket socket = new Socket();
socket.setSoTimeout(timeout);
socket.connect(new InetSocketAddress(ip, port), timeout);
if (verbose) print("Connected to " + ip + ":" + port);
BufferedReader in = new BufferedReader(
new InputStreamReader(socket.getInputStream(), "UTF-8"));
String hello = or(in.readLine(), "?");
socket.close();
return new Program(port, hello);
} catch (Exception ex) {
return null;
}
}
});
}
static List<Program> quickScan() {
return scan(quickScanFrom, quickScanTo);
}
static List<Program> quickBotScan() {
return quickBotScan(new int[0]);
}
static List<Program> quickBotScan(int[] preferredPorts) {
return scan(4990, 5000+maxNumberOfBotPorts-1, preferredPorts);
}
}
static abstract class DialogIO {
String line;
boolean eos;
abstract String readLineImpl();
abstract boolean isStillConnected();
abstract void sendLine(String line);
abstract boolean isLocalConnection();
abstract Socket getSocket();
abstract void close();
int getPort() { return getSocket().getPort(); }
boolean helloRead;
String readLineNoBlock() {
String l = line;
line = null;
return l;
}
boolean waitForLine() { try {
if (line != null) return true;
//print("Readline");
line = readLineImpl();
//print("Readline done: " + line);
if (line == null) eos = true;
return line != null;
} catch (Throwable __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}
String readLine() {
waitForLine();
helloRead = true;
return readLineNoBlock();
}
String ask(String s, Object... args) {
if (!helloRead) readLine();
if (args.length != 0) s = format3(s, args);
sendLine(s);
return readLine();
}
String askLoudly(String s, Object... args) {
if (!helloRead) readLine();
if (args.length != 0) s = format3(s, args);
print("> " + s);
sendLine(s);
String answer = readLine();
print("< " + answer);
return answer;
}
void pushback(String l) {
if (line != null)
fail();
line = l;
helloRead = false;
}
}
static abstract class DialogHandler {
abstract void run(DialogIO io);
}
static class Matches {
String[] m;
String get(int i) { return i < m.length ? m[i] : null; }
String unq(int i) { return unquote(get(i)); }
String fsi(int i) { return formatSnippetID(unq(i)); }
String fsi() { return fsi(0); }
String tlc(int i) { return unq(i).toLowerCase(); }
boolean bool(int i) { return "true".equals(unq(i)); }
String rest() { return m[m.length-1]; } // for matchStart
int psi(int i) { return Integer.parseInt(unq(i)); }
}
// Now uses TreeMap for nicer sorting (i.e., A must be a orderable type)
static class MultiSet<A> {
Map<A, Integer> map = new TreeMap<A, Integer>();
public MultiSet(boolean useTreeMap) {
if (!useTreeMap)
map = new HashMap;
}
public MultiSet() {
}
public MultiSet(Collection<A> c) {
addAll(c);
}
public void add(A key) {
add(key, 1);
}
public void addAll(Collection<A> c) {
if (c != null) for (A a : c)
add(a);
}
public void add(A key, int count) {
if (map.containsKey(key))
map.put(key, map.get(key)+count);
else
map.put(key, count);
}
public int get(A key) {
return key != null && map.containsKey(key) ? map.get(key) : 0;
}
public boolean contains(A key) {
return map.containsKey(key);
}
public void remove(A key) {
Integer i = map.get(key);
if (i != null && i > 1)
map.put(key, i - 1);
else
map.remove(key);
}
public List<A> getTopTen() {
return getTopTen(10);
}
public List<A> getTopTen(int maxSize) {
List<A> list = getSortedListDescending();
return list.size() > maxSize ? list.subList(0, maxSize) : list;
}
public List<A> getSortedListDescending() {
List<A> list = new ArrayList<A>(map.keySet());
Collections.sort(list, new Comparator<A>() {
public int compare(A a, A b) {
return map.get(b).compareTo(map.get(a));
}
});
return list;
}
public int getNumberOfUniqueElements() {
return map.size();
}
public Set<A> asSet() {
return map.keySet();
}
public A getMostPopularEntry() {
int max = 0;
A a = null;
for (Map.Entry<A,Integer> entry : map.entrySet()) {
if (entry.getValue() > max) {
max = entry.getValue();
a = entry.getKey();
}
}
return a;
}
public void removeAll(A key) {
map.remove(key);
}
public int size() {
int size = 0;
for (int i : map.values())
size += i;
return size;
}
public MultiSet<A> mergeWith(MultiSet<A> set) {
MultiSet<A> result = new MultiSet<A>();
for (A a : set.asSet()) {
result.add(a, set.get(a));
}
return result;
}
public boolean isEmpty() {
return map.isEmpty();
}
public String toString() {
return structure(this);
}
public void clear() {
map.clear();
}
}
static long startTiming_startTime;
static void startTiming() {
startTiming_startTime = now();
}
static void stopTiming() {
long end = now();
print("Time: " + (end-startTiming_startTime) + " ms");
}
static JWindow showLoadingAnimation() {
ret showAnimationInTopRightCorner("#1003543", "Hold on user...");
}
static BufferedReader readLine_reader;
static String readLine() {
ret (String) call(getJavaX(), "readLine");
}
static void swingLater(int delay, final Runnable r) {
javax.swing.Timer timer = new javax.swing.Timer(delay, actionListener {
r.run();
});
timer.setRepeats(false);
timer.start();
}
static void swingLater(Runnable r) {
SwingUtilities.invokeLater(r);
}
static void swingNowOrLater(Runnable r) {
if (isAWTThread())
r.run();
else
swingLater(r);
}
static Set asSet(O[] array) {
new HashSet set;
for (O o : array)
if (o != null)
set.add(o);
ret set;
}
static Set<S> asSet(S[] array) {
new TreeSet<S> set;
for (S o : array)
if (o != null)
set.add(o);
ret set;
}
static Set<S> asSet(Collection<S> l) {
new TreeSet<S> set;
for (S o : l)
if (o != null)
set.add(o);
ret set;
}
static <A> A or(A a, A b) {
return a != null ? a : b;
}
static void disposeWindow(final Window window) {
awt {
window.dispose();
}
}
static String firstToUpper(String s) {
if (s.length() == 0) return s;
return Character.toUpperCase(s.charAt(0)) + s.substring(1);
}
}
Travelled to 13 computer(s): aoiabmzegqzx, bhatertpkbcr, cbybwowwnfue, ddnzoavkxhuk, gwrvuhgaqvyk, ishqpsrjomds, lpdgvwnxivlt, mqqgnosmbjvj, pyentgdyhuwx, pzhvpgtvlbxg, tslmcundralx, tvejysmllsmz, vouqrxazstgt
No comments. add comment
| Snippet ID: | #1004053 |
| Snippet name: | Bug |
| Eternal ID of this version: | #1004053/1 |
| Text MD5: | 23e79db20826ee367ee750471d6824b3 |
| Author: | stefan |
| Category: | |
| Type: | Document |
| Public (visible to everyone): | Yes |
| Archived (hidden from active list): | No |
| Created/modified: | 2016-08-05 02:21:09 |
| Source code size: | 168409 bytes / 5529 lines |
| Pitched / IR pitched: | No / No |
| Views / Downloads: | 618 / 331 |
| Referenced in: | [show references] |