import java.math.*;
import javax.imageio.*;
import java.awt.image.*;
import java.awt.event.*;
import java.awt.*;
import java.security.spec.*;
import java.security.*;
import java.lang.management.*;
import java.lang.ref.*;
import java.lang.reflect.*;
import java.net.*;
import java.io.*;
import javax.swing.table.*;
import javax.swing.text.*;
import javax.swing.event.*;
import javax.swing.*;
import java.util.concurrent.atomic.*;
import java.util.concurrent.*;
import java.util.regex.*;
import java.util.List;
import java.util.zip.*;
import java.util.*;
public class main {
static String formatSnippetID(String id) {
return "#" + parseSnippetID(id);
}
static String formatSnippetID(long id) {
return "#" + id;
}
static class MultiMap {
Map> data = new HashMap>();
MultiMap() {}
MultiMap(MultiMap map) { putAll(map); }
public void put(A key, B value) {
List list = data.get(key);
if (list == null)
data.put(key, list = new ArrayList());
list.add(value);
}
public void addAll(A key, Collection values) {
putAll(key, values);
}
public void addAllIfNotThere(A key, Collection values) {
for (B value : values)
setPut(key, value);
}
void setPut(A key, B value) {
if (!containsPair(key, value))
put(key, value);
}
boolean containsPair(A key, B value) {
return get(key).contains(value);
}
public void putAll(A key, Collection values) {
for (B value : values)
put(key, value);
}
void removeAll(A key, Collection values) {
for (B value : values)
remove(key, value);
}
public List get(A key) {
List list = data.get(key);
return list == null ? Collections. emptyList() : list;
}
// returns actual mutable live list
// creates the list if not there
public List getActual(A key) {
List list = data.get(key);
if (list == null)
data.put(key, list = litlist());
return list;
}
void clean(A key) {
List list = data.get(key);
if (list != null && list.isEmpty())
data.remove(key);
}
public Set keySet() {
return data.keySet();
}
public Set keys() {
return data.keySet();
}
public void remove(A key) {
data.remove(key);
}
public void remove(A key, B value) {
List list = data.get(key);
if (list != null) {
list.remove(value);
if (list.isEmpty())
data.remove(key);
}
}
public void clear() {
data.clear();
}
public boolean containsKey(A key) {
return data.containsKey(key);
}
public B getFirst(A key) {
List list = get(key);
return list.isEmpty() ? null : list.get(0);
}
public void putAll(MultiMap map) {
for (A key : map.keySet())
putAll(key, map.get(key));
}
// note: expensive operation
int size() {
int n = 0;
for (List l : data.values())
n += l(l);
return n;
}
}
static class Matches {
String[] m;
String get(int i) { return m[i]; }
String unq(int i) { return unquote(m[i]); }
String fsi(int i) { return formatSnippetID(unq(i)); }
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)); }
}
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);
}
// Idea: For every position, store the productions recognized to start there, then infer up to higher classes
// a recognition is identified by (startPos, className, endPos)
// key 1 = start position, key 2 = class name, value = end position
static Map> recog;
static List tok;
static MultiMap> productionMap;
static boolean caseSensitive = false;
static boolean debug = false;
static long timing;
static int iterations;
static Map> dicts = new TreeMap(); // dictionaries - class name to lowercase examples
static String defaultParserRules = "#1002281"; // NL
static String javaRules = "#1002329";
static boolean keepRules = false;
static class ParseResult {
List tok;
Map> recog;
List fullMatchClasses() {
List l = new ArrayList();
MultiMap rr = recog.get(1);
for (String className : rr.keys())
if (rr.get(className).contains(l(tok)))
l.add(className);
return l;
}
List explainLongestMatch() {
String c = findLongestMatch(1);
if (c == null) return null;
int n = max(recog.get(1).get(c));
if (n == 1) return null;
List l = (List) ( explainMatch(new Pos(tok), n, c).get(0));
return shortenExplanation(l);
}
String findLongestMatch(int i) {
MultiMap rr = recog.get(i);
Map map = new TreeMap();
for (String c : rr.keys())
map.put(c, max(rr.get(c)));
return keyWithBiggestValue(map);
}
List explain(String className) {
return explain(1, l(tok), className);
}
List explainFull(String className) {
return explainFull(1, l(tok), className);
}
// full = not shortened (include all subclassings)
List explainFull(int fromToken, int toToken, String className) {
List matches = explainMatch(new Pos(tok, fromToken), toToken, className);
return get(matches, 0);
}
List explain(int fromToken, int toToken, String className) {
List l = explainFull(fromToken, toToken, className);
if (debug)
print("Full explanation: " + structure(l));
return shortenExplanation(l);
}
// Example: [[1, 11, "exp", "", [1, 11, "exp1", 11, "exp1", " + ", ...]]]
List shortenExplanation(List m) {
if (m == null) return null;
if (l(m) == 5) {
int ii = (Integer) m.get(0), jj = (Integer) m.get(1);
List sub = (List) m.get(4);
int II = (Integer) sub.get(0), JJ = (Integer) sub.get(1);
if (ii == II && jj == JJ)
return shortenExplanation(sub); // it's a subclassing - just drop the outer match
}
for (int i = 4; i < l(m); i++)
m.set(i, shortenExplanation((List) m.get(i)));
return m;
}
// assumes that there is a match (pos, class, endPos)
// and gives explanations of how it was probably matched.
// result list format: [className, prodText, [i1, i2], [i3, i4], ...]
List explainMatch(Pos pos, int endPos, String forClass) {
List> prods = productionMap.get(forClass);
List out = new ArrayList();
for (List prod : prods) {
List match = litlist(pos.i, endPos, forClass, join(prod));
if (debug)
print("Starting match: " + structure(match));
explainMatch2(pos, new Pos(prod), endPos, forClass, match, out);
}
return out;
}
// same, but with fixed production
void explainMatch2(Pos pos, Pos prod, int endPos, String forClass, List match, List out) {
if (prod.end()) {
if (pos.i == endPos) {
// match done! add sub-explanations.
match = cloneList(match);
if (debug)
print("Match done! " + structure(match));
for (int i = 4; i < l(match); i++) {
List m = cloneList((List) match.get(i));
//print("m=" + structure(m));
int ii = (Integer) m.get(0), jj = (Integer) m.get(1);
String className = (String) ( m.get(2));
List subExplanation = explainMatch(new Pos(pos.tok, ii), jj, className);
//print(format("Recursed: * * * => ", ii, jj, className) + structure(subExplanation));
if (empty(subExplanation)) {
// weird
} else
m.addAll(subList((List) subExplanation.get(0), 3));
match.set(i, m);
}
if (debug)
print("Match completed: " + structure(match));
out.add(match);
}
} else if (pos.end())
return;
else {
String p = prod.get();
if (isBracketedID(p)) {
String className = unbracket(p);
List r = recog.get(pos.i).get(className);
// keep parsing for every option
for (int i : cloneList(r)) {
match.add(litlist(pos.i, i, className));
explainMatch2(new Pos(pos.tok, i), prod.plus(2), endPos, forClass, match, out);
removeLast(match);
}
} else if (!pos.end()) {
// it's a literal
String t = pos.get();
if (!matchToken(p, t))
return;
//match.add(litlist(pos.i, pos.i+2, p));
explainMatch2(pos.plus(2), prod.plus(2), endPos, forClass, match, out);
//removeLast(match);
}
}
}
String prettierAnalysis() {
List l = new ArrayList();
TreeSet emptyClasses = new TreeSet();
for (int i = 1; i < l(tok); i += 2) {
MultiMap rr = recog.get(i);
List bla = new ArrayList();
for (String className : rr.keys()) {
List is = rr.get(className);
if (is.contains(i))
emptyClasses.add(className);
int n = (max(is)-i)/2;
if (n > 0)
bla.add(className + " " + n);
}
l.add(tok.get(i) + " : " + structure(bla));
}
if (!empty(emptyClasses))
l.add(" with empty classes " + structure(asList(emptyClasses)));
return fromLines(l);
}
}
public static void main(String[] args) throws Exception {
startBot("Snippet Text Bot", "#1002084");
}
static ParseResult parse(String inputText) {
return parse(inputText, defaultParserRules);
}
static ParseResult jparse(String inputText) {
return parse(inputText, javaRules);
}
static String keptRulesID;
static String keptRulesText;
static synchronized ParseResult parse(String inputText, String parserRules) {
String rulesText;
if (!isSnippetID(parserRules))
rulesText = parserRules;
else {
if (keepRules && sameSnippetID(parserRules, keptRulesID))
rulesText = keptRulesText;
else {
rulesText = loadSnippetThroughBot(parserRules);
if (keepRules) {
keptRulesID = parserRules;
keptRulesText = rulesText;
}
}
}
productionMap = new MultiMap();
caseSensitive = false;
for (String rule : toLinesFullTrim(rulesText)) try {
if (l(javaTok(rule)) == 1) continue; // just a comment
if (debug)
printF("Processing rule: *", rule);
if (rule.contains("=")) {
List lr = splitAtJavaToken(rule, "=");
String l, r;
if (l(lr) == 1) {
l = "";
r = lr.get(0);
} else if (l(lr) >= 2) {
l = join(" = ", lr.subList(0, l(lr)-1));
r = last(lr);
} else {
print("Weird rule: " + rule);
continue;
}
List tokr = mergeBracketThingies(javaTok(r));
assertEquals(structure(tokr), 3, l(tokr));
String className = assertIdentifier(unbracket(get(tokr, 1)));
List tok = javaTok(l);
tok = mergeBracketThingies(tok);
//printStructure(tok);
productionMap.put(className, tok);
} else if (match("case-sensitive", rule)) {
//print("Now case sensitive.");
caseSensitive = true;
} else if (match("case-insensitive", rule)) {
caseSensitive = false;
} else
print("Weird rule: " + rule);
} catch (Throwable __e) { printStackTrace(__e); }
if (debug) {
print(n(productionMap.size(), "production") + ".");
print();
}
timing = now();
tok = javaTok(inputText);
Pos pos = new Pos(tok);
parseTop(pos);
timing = now()-timing;
int numTok = l(tok)/2;
print("Iterations required for " + numTok + " tokens: " + iterations*numTok*productionMap.size() + ", time: " + timing + " ms");
ParseResult res = new ParseResult();
res.tok = tok;
res.recog = recog;
return res;
}
static void parseTop(Pos pos) {
// init structures
recog = new TreeMap();
for (int i = pos.i; i <= l(pos.tok); i += 2) // contains one more element for empty classes at the end
recog.put(i, new MultiMap());
//print("parser: recog inited " + pos.i + " to " + l(pos.tok));
// process dicts
for (String className : dicts.keySet()) {
Set values = dicts.get(className);
for (int i = pos.i; i < l(pos.tok); i += 2) {
String t = pos.tok.get(i);
if (values.contains(t.toLowerCase()))
recog.get(i).setPut(className, i+2);
}
}
matchSpecials();
boolean anyChange;
iterations = 0;
MultiMap> fullProductionMap = new MultiMap(productionMap);
while (iter(pos)) {}
iter(pos); // XX - one more - fixes anything?
productionMap = fullProductionMap; // restore ground productions
}
static boolean iter(Pos pos) {
boolean anyChange = false;
++iterations;
if (iterations == 2) removeGroundProductions();
if (debug) print("Iteration " + iterations);
for (int i = pos.i; i <= l(pos.tok); i += 2) {
Pos pos2 = new Pos(pos.tok, i);
for (String className : productionMap.keySet()) {
MultiMap rr = recog.get(i);
List recs = rr.getActual(className);
List> prods = productionMap.get(className);
for (List prod : prods) {
int n = l(recs);
matchProd(pos2, new Pos(prod), className, recs);
anyChange = anyChange || l(recs) > n;
}
rr.clean(className);
}
}
return anyChange;
}
static class Pos {
List tok;
int i = 1;
Pos() {}
Pos(List tok) {
this.tok = tok;}
Pos(List tok, int i) {
this.i = i;
this.tok = tok;}
boolean end() { return i >= l(tok)-1; }
String get() { return tok.get(i); }
public Pos clone() { return new Pos(tok, i); }
public boolean equals(Object o) {
if (!(o instanceof Pos)) return false;
Pos pos = (Pos) ( o);
return tok == pos.tok && i == pos.i;
}
String rest() {
return join(subList(tok, i));
}
Pos plus(int x) { return new Pos(tok, i + x); }
}
static void copy(Pos a, Pos b) {
b.tok = a.tok;
b.i = a.i;
}
static void debug(String bla, Pos pos) {
if (debug)
print(bla + " on " + quote(pos.rest()));
}
static void matchProd(Pos pos, Pos prod, String forClass, List out) {
if (prod.end())
setAdd(out, pos.i);
else if (pos.end())
return;
else {
String p = prod.get();
if (isBracketedID(p)/* && !specials.contains(p)*/) {
MultiMap rr = recog.get(pos.i);
if (rr == null)
fail("parser: recog null at " + pos.i);
List r = rr.get(unbracket(p));
// keep parsing for every option
for (int i : cloneList(r))
matchProd(new Pos(pos.tok, i), prod.plus(2), forClass, out);
} else {
// it's a literal
String t = pos.get();
if (!matchToken(p, t))
return;
matchProd(pos.plus(2), prod.plus(2), forClass, out);
}
}
}
static List specials = litlist("", "", "", "");
static boolean matchToken(String p, String t) {
if (eq(p, "")) {
if (!isQuoted(t)) return false;
} else if (eq(p, "")) {
if (!isInteger(t)) return false;
} else if (eq(p, "")) {
if (!isIdentifier(t)) return false;
} else if (!(eq(p, "") || (caseSensitive ? eq(p, t) : eqic(p, t))))
return false; // token mismatch
return true;
}
static String loadSnippetThroughBot(String snippetID) {
print("Loading parser rules.");
{ long __time_startTime = now(); try {
String answer = sendToLocalBot_cached("Snippet Text Bot", "what is the text of snippet *", snippetID);
Matches m = new Matches();
assertTrue(match("the text of snippet * is *", answer, m));
return m.unq(1);
} finally { __time_startTime = now()-__time_startTime; saveTiming(__time_startTime); } }
}
// Non-recursing productions don't need to be repeatedly executed
static void removeGroundProductions() {
int n = productionMap.size();
for (String className : new HashSet(productionMap.keySet())) {
List> prods = productionMap.getActual(className);
for (int i = 0; i < l(prods); )
if (isGroundProduction(prods.get(i))) {
if (debug)
print("Ground production: " + className + " = " + join(prods.get(i)));
prods.remove(i);
} else
++i;
productionMap.clean(className);
}
n -= productionMap.size();
if (debug && n != 0)
print(n + " ground productions removed.");
}
static boolean isGroundProduction(List prod) {
for (int i = 1; i < l(prod); i += 2) {
String t = prod.get(i);
if (isBracketedID(t) && !specials.contains(t))
return false;
}
return true;
}
static void addDict(String className, Collection entries) {
dicts.put(className, entries instanceof Set ? (Set) entries : new TreeSet(entries));
}
static void matchSpecials() {
for (int i = 1; i < l(tok); i += 2) {
MultiMap rr = recog.get(i);
for (String s : specials)
if (matchToken(s, tok.get(i)))
rr.put(unbracket(s), i+2);
}
}
static boolean isIdentifier(String s) {
return isJavaIdentifier(s);
}
static boolean isBracketedID(String s) {
return s.startsWith("<") && s.endsWith(">");
}
// replacement for class JavaTok
// maybe incomplete, might want to add floating point numbers
// todo also: extended multi-line strings
static List javaTok(String s) {
List tok = new ArrayList();
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 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
++j;
tok.add(s.substring(i, j));
i = j;
}
if ((tok.size() % 2) == 0) tok.add("");
return tok;
}
static List javaTok(List tok) {
return javaTok(join(tok));
}
static String sendToLocalBot_cached(String botName, String s, Object... args) {
DialogIO io = newFindBot(botName);
if (io == null)
fail("Bot not found: " + botName);
try {
return io.ask(s, args);
} finally {
io.close();
}
}
public static String fromLines(List lines) {
StringBuilder buf = new StringBuilder();
if (lines != null)
for (String line : lines)
buf.append(line).append('\n');
return buf.toString();
}
// properly post-parse angle bracket things like ""
// now also allows a space, like "" or ""
static List mergeBracketThingies(List tok) {
tok = cloneList(tok);
for (int i = 1; i+4 < l(tok); i += 2) {
// short case
if (eq(get(tok, i), "<") && eq(get(tok, i+1), "") && isIdentifier(get(tok, i+2)) && eq(get(tok, i+3), "") && eq(get(tok, i+4), ">")) {
tok.set(i, "<" + tok.get(i+2) + ">");
tok.remove(i+4);
tok.remove(i+3);
tok.remove(i+2);
tok.remove(i+1);
}
// longer case
if (eq(get(tok, i), "<")
&& eq(get(tok, i+1), "")
&& isIdentifier(get(tok, i+2))
&& (isIdentifier(get(tok, i+4)) || isInteger(get(tok, i+4)))
&& eq(get(tok, i+5), "")
&& eq(get(tok, i+6), ">")) {
tok.set(i, "<" + tok.get(i+2) + " " + tok.get(i+4) + ">");
tok.remove(i+6);
tok.remove(i+5);
tok.remove(i+4);
tok.remove(i+3);
tok.remove(i+2);
tok.remove(i+1);
}
}
return tok;
}
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 ArrayList asList(A[] a) {
return new ArrayList(Arrays.asList(a));
}
static ArrayList asList(int[] a) {
ArrayList l = new ArrayList();
for (int i : a) l.add(i);
return l;
}
static ArrayList asList(Set s) {
return new ArrayList(s);
}
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 String assertIdentifier(String s) {
return assertIsIdentifier(s);
}
static boolean isInteger(String s) {
return s != null && Pattern.matches("\\-?\\d+", 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 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 ArrayList litlist(A... a) {
return new ArrayList(Arrays.asList(a));
}
// get purpose 1: access a list/array (safer version of x.get(y))
static A get(List l, int idx) {
return idx >= 0 && idx < l(l) ? l.get(idx) : null;
}
static A get(A[] l, int idx) {
return idx >= 0 && idx < l(l) ? l[idx] : null;
}
// get purpose 2: access a field by reflection
static Object get(Object o, String field) {
if (o instanceof Class) return get((Class) o, 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 String unbracket(String s) {
return isBracketedID(s) ? s.substring(1, l(s)-1) : s;
}
static long now_virtualTime;
static long now() {
return now_virtualTime != 0 ? now_virtualTime : System.currentTimeMillis();
}
// 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();
}
public static String join(String glue, Iterable strings) {
StringBuilder buf = new StringBuilder();
Iterator 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 strings) {
return join("", strings);
}
public static String join(String[] strings) {
return join("", strings);
}
static void setAdd(Collection c, A a) {
if (!c.contains(a))
c.add(a);
}
static List subList(List l, int startIndex) {
return subList(l, startIndex, l(l));
}
static List subList(List 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 last(List l) {
return l.isEmpty() ? null : l.get(l.size()-1);
}
static int max(int a, int b) {
return Math.max(a, b);
}
static int max(Collection c) {
int x = Integer.MIN_VALUE;
for (int i : c) x = max(x, i);
return x;
}
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 List cloneList(List l) {
//O mutex = getOpt(l, "mutex");
/*if (mutex != null)
synchronized(mutex) {
ret new ArrayList(l);
}
else
ret new ArrayList(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(l);
}
}
static boolean eqic(String a, String b) {
if ((a == null) != (b == null)) return false;
if (a == null) return true;
return a.equalsIgnoreCase(b);
}
static void assertEquals(Object x, Object y) {
assertEquals(null, x, y);
}
static void assertEquals(String msg, Object x, Object y) {
if (!(x == null ? y == null : x.equals(y)))
fail((msg != null ? msg + ": " : "") + structure(x) + " != " + structure(y));
}
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 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 String structure(Object o) {
return structure(o, 0);
}
// leave to false, unless unstructure() breaks
static boolean structure_allowShortening = false;
static String structure(Object o, int stringSizeLimit) {
if (o == null) return "null";
String name = o.getClass().getName();
StringBuilder buf = new StringBuilder();
if (o instanceof Collection) { // TODO: store the type (e.g. HashSet/TreeSet)
for (Object x : (Collection) o) {
if (buf.length() != 0) buf.append(", ");
buf.append(structure(x, stringSizeLimit));
}
return "[" + buf + "]";
}
if (o instanceof Map) {
for (Object e : ((Map) o).entrySet()) {
if (buf.length() != 0) buf.append(", ");
buf.append(structure(((Map.Entry) e).getKey(), stringSizeLimit));
buf.append("=");
buf.append(structure(((Map.Entry) e).getValue(), stringSizeLimit));
}
return (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(Array.get(o, i), stringSizeLimit));
}
return "array{" + buf + "}";
}
if (o instanceof String)
return quote(stringSizeLimit != 0 ? shorten((String) o, stringSizeLimit) : (String) o);
if (o instanceof Class)
return "class(" + quote(((Class) o).getName()) + ")";
if (o instanceof Throwable)
return "exception(" + quote(((Throwable) o).getMessage()) + ")";
if (o instanceof BigInteger)
return "bigint(" + o + ")";
if (o instanceof Double)
return "d(" + quote(str(o)) + ")";
// Need more cases? This should cover all library classes...
if (name.startsWith("java.") || name.startsWith("javax."))
return String.valueOf(o);
String shortName = o.getClass().getName().replaceAll("^main\\$", "");
int numFields = 0;
String fieldName = "";
if (shortName.equals("DynamicObject")) {
shortName = (String) get(o, "className");
Map 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(value, stringSizeLimit));
}
++numFields;
}
} else {
// regular class
// TODO: go to superclasses too
Field[] fields = o.getClass().getDeclaredFields();
for (Field field : fields) {
if ((field.getModifiers() & Modifier.STATIC) != 0)
continue;
Object value;
try {
field.setAccessible(true);
value = field.get(o);
} catch (Exception e) {
value = "?";
}
fieldName = field.getName();
// put special cases here...
if (value != null) {
if (buf.length() != 0) buf.append(", ");
buf.append(fieldName + "=" + structure(value, stringSizeLimit));
}
++numFields;
}
}
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 s;
}
static String n(long l, String name) {
return l + " " + (l == 1 ? name : getPlural(name));
}
static boolean sameSnippetID(String a, String b) {
return a != null && b != null && parseSnippetID(a) == parseSnippetID(b);
}
static void printF(String s, Object... args) {
printFormat(s, args);
}
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));
}
static RuntimeException fail(String msg, Object... args) {
throw new RuntimeException(format(msg, args));
}
static StringBuffer print_log;
static void print() {
print("");
}
static void print(Object o) {
String s = String.valueOf(o) + "\n";
synchronized(StringBuffer.class) {
if (print_log == null) print_log = new StringBuffer();
}
print_log.append(s);
System.out.print(s);
}
static void print(long l) {
print(String.valueOf(l));
}
static List toLinesFullTrim(String s) {
List l = toLines(s);
for (ListIterator i = l.listIterator(); i.hasNext(); ) {
String line = i.next().trim();
if (line.length() == 0)
i.remove();
else
i.set(line);
}
return l;
}
static List splitAtJavaToken(String s, String splitToken) {
return splitByJavaToken(s, splitToken);
}
static boolean equals(Object a, Object b) {
return a == null ? b == null : a.equals(b);
}
static Object clone(Object o) {
ArrayDeque q = new ArrayDeque();
Object x = clone_impl(o, new IdentityHashMap(), q);
while (!q.isEmpty())
q.poll().run();
return x;
}
static Object clone_impl(Object o, final IdentityHashMap seen, final ArrayDeque q) { try {
if (o == null)
return o;
Object y = seen.get(o);
if (y != null) return y;
if (o instanceof List) {
//print("Cloning list: " + o);
final List l = new ArrayList();
seen.put(o, l);
for (final Object x : (List) o)
q.add(new Runnable() {
public void run() { try {
l.add(clone_impl(x, seen, q));
} catch (Exception __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}});
return l;
}
if (o instanceof Map) {
final Map m = o instanceof TreeMap ? new TreeMap() : new HashMap();
seen.put(o, m);
for (Object entry : ((Map) o).entrySet()) {
final Map.Entry e = (Map.Entry) entry;
q.add(new Runnable() {
public void run() { try {
m.put(clone_impl(e.getKey(), seen, q), clone_impl(e.getValue(), seen, q));
} catch (Exception __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}});
}
return m;
}
if (o instanceof String || o instanceof Number || o instanceof Boolean)
return o;
if (o instanceof Object[]) {
final Object[] l = (Object[]) o;
final Object[] l2 = l.clone();
seen.put(o, l2);
for (int i = 0; i < l.length; i++) {
final int _i = i;
q.add(new Runnable() {
public void run() { try {
l2[_i] = clone_impl(l[_i], seen, q);
} catch (Exception __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}});
}
return l2;
}
// clone an arbitrary custom object
// TODO: use Constructor object and setAccessible
//print("Cloning custom: " + o);
final Object clone = o.getClass().newInstance();
seen.put(o, clone);
Class c = o.getClass();
while (c != Object.class) {
Field[] fields = c.getDeclaredFields();
for (final Field field : fields) {
if ((field.getModifiers() & Modifier.STATIC) != 0)
continue;
field.setAccessible(true);
final Object value = field.get(o);
q.add(new Runnable() {
public void run() { try {
field.set(clone, clone_impl(value, seen, q));
} catch (Exception __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}});
}
c = c.getSuperclass();
}
return clone;
} catch (Throwable __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}
static Map startBot_assignments = new TreeMap();
static void startBot(String botName, String botID) {
DialogIO bot = newFindBot(botName);
if (bot != null)
bot.close();
else {
print("Bot " + quote(botName) + " not found. Starting " + botID);
javaxBot(botID);
waitForBotStartUp(botName);
}
}
static void startBot(String botIDOrName) {
String botID = startBot_assignments.get(botIDOrName);
if (botID != null)
startBot(botIDOrName, botID);
else {
String botName = getBotNameFromSnippet(botIDOrName);
if (botName == null) fail("Bot name not found in source of " + botID);
startBot(botName, botIDOrName);
}
}
static A keyWithBiggestValue(Map map) {
A best = null;
Number bestScore = null;
for (A key : keys(map)) {
Number score = map.get(key);
if (best == null || cmp(score, bestScore) > 0) {
best = key;
bestScore = score;
}
}
return best;
}
// 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 toks, Matches matches) {
List tokpat = parse3(pat);
return match3(tokpat,toks,matches);
}
static boolean match3(List tokpat, List 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 String shorten(String s, int max) {
if (s == null) return "";
return s.length() <= max ? s : s.substring(0, Math.min(s.length(), max)) + "...";
}
static int newFindBot_botVM;
static synchronized DialogIO newFindBot(String name) {
if (newFindBot_botVM == 0) {
print("Looking for Bot VM.");
List botVMs = quickBotScan("This is a JavaX VM. Bot VM.");
if (!botVMs.isEmpty()) {
newFindBot_botVM = botVMs.get(0).port;
print("Bot VM is at port " + newFindBot_botVM + ".");
}
}
if (newFindBot_botVM != 0) {
DialogIO io = talkTo(newFindBot_botVM);
String q = format("has bot *", name);
String s = io.ask(q);
print(format("Answer of Bot VM to *: *", q, s));
if (match("yes", s)) {
io = talkToSubBot(name, io);
call(io, "pushback", "?"); // put some hello string in (yes, this should be improved.)
return io;
}
}
return findBot(name);
}
static String getPlural(String s) {
return s + "s";
}
static String format(String pat, Object... args) {
return format3(pat, args);
}
static void printFormat(String s, Object... args) {
print(format(s, args));
}
static String str(Object o) {
return String.valueOf(o);
}
static void javaxBot(String botID) {
startBotVM();
if (injectTo("Bot VM", botID) == null)
fail("Couldn't inject to Bot VM");
//nohupJavax(botID);
}
static long waitForBotStartUp_timeoutSeconds = 60;
// returns address or fails
static String waitForBotStartUp(String botName) {
for (int i = 0; i < waitForBotStartUp_timeoutSeconds; i++) {
sleepSeconds(i == 0 ? 0 : 1);
String addr = getBotAddress(botName);
if (addr != null)
return addr;
}
throw fail("Bot not found: " + quote(botName));
}
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 Set keys(Map map) {
return map.keySet();
}
static Set keys(Object map) {
return keys((Map) map);
}
static int cmp(Number a, Number b) {
return a == null ? b == null ? 0 : -1 : cmp(a.doubleValue(), b.doubleValue());
}
static int cmp(double a, double b) {
return a < b ? -1 : a == b ? 0 : 1;
}
static int cmp(String a, String b) {
return a == null ? b == null ? 0 : -1 : a.compareTo(b);
}
static int cmp(Object a, Object b) {
if (a == null) return b == null ? 0 : -1;
return ((Comparable) a).compareTo(b);
}
static String unnull(String s) {
return s == null ? "" : s;
}
static List unnull(List l) {
return l == null ? emptyList() : l;
}
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 int min(int a, int b) {
return Math.min(a, b);
}
static String assertIsIdentifier(String s) {
if (!isIdentifier(s))
fail("Not an identifier: *", s);
return s;
}
static List toLines(File f) {
return toLines(loadTextFile(f));
}
public static List toLines(String s) {
List lines = new ArrayList();
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 boolean isEmpty(Collection c) {
return c == null || c.isEmpty();
}
static boolean isEmpty(String s) {
return s == null || s.length() == 0;
}
// covers the common cases
static String getBotNameFromSnippet(String programID) { try {
String src = loadSnippet(programID);
List tok = javaTok(src);
String[] m;
for (String pat : litlist(
"new Android3(*",
"makeAndroid(*", "makeAndroid3(*", "makeSilentAndroid(*",
"addToMultiPort(*")) {
m = find2(javaTok(pat), tok);
if (m != null && isQuoted(m[0])) return unquote(m[0]);
}
return null;
} catch (Throwable __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}
// 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 List splitByJavaToken(String s, String splitToken) {
List tok = javaTok(s);
List l = new ArrayList();
int i = 1;
while (i < l(tok)) {
int j = i;
while (i < l(tok)) {
j = indexOf(tok, splitToken, i);
if (j == i) i += 2; else break;
}
if (i >= l(tok)) break;
if (j < 0) j = l(tok);
l.add(join(tok.subList(i, j-1)));
i = j+2;
}
return l;
}
// match2 matches multiple "*" (matches a single token) wildcards and zero or one "..." wildcards (matches multiple tokens)
static String[] match2(List pat, List tok) {
// standard case (no ...)
int i = pat.indexOf("...");
if (i < 0) return match2_match(pat, tok);
pat = new ArrayList(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 pat, List tok) {
List result = new ArrayList();
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 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 class Injection {
int vmPort;
String injectionID;
}
static Injection injectTo(int vmPort, String progID) {
return injectTo(String.valueOf(vmPort), progID);
}
static Injection injectTo(String vmName, String progID) {
String line = format3("Please inject program *.", progID);
DialogIO injectionPoint = findBot(isInteger(vmName) ? vmName : "This is a JavaX VM. " + vmName);
if (injectionPoint == null) return null;
try {
injectionPoint.readLine();
String answer = injectionPoint.askLoudly(line);
Matches m = new Matches();
if (match3("OK. Injection ID: *", answer, m)) {
Injection i = new Injection();
i.vmPort = injectionPoint.getSocket().getPort();
i.injectionID = m.unq(0);
return i;
}
throw fail(answer);
} finally {
injectionPoint.close();
}
}
static int indexOf(List l, A a, int startIndex) {
for (int i = startIndex; i < l(l); i++)
if (eq(l.get(i), a))
return i;
return -1;
}
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 snippetID;
}
// 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 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 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 int getBotAddress_timeout = 5000;
static String getBotAddress(String searchPattern) {
String subBot = "";
int i = searchPattern.indexOf('/');
if (i >= 0 && (isJavaIdentifier(searchPattern.substring(0, i)) || isInteger(searchPattern.substring(0, i)))) {
subBot = searchPattern.substring(i);
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 searchPattern + subBot;
Integer port = findBot_cache.get(searchPattern);
if (port != null) try {
DialogIO io = talkTo("localhost", port);
try {
io.waitForLine(/*getBotAddress_timeout*/); // TODO: implement
String line = io.readLineNoBlock();
if (startsWithIgnoreCase(line, searchPattern))
return port + subBot;
} finally {
io.close();
}
} catch (Exception e) {
e.printStackTrace();
}
List 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
return p.port + subBot;
}
}
// 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 subBots = (Map) unstructure(sendToLocalBot(p.port, "list bots"));
for (Number vport : subBots.keySet()) {
String name = subBots.get(vport);
if (startsWithIgnoreCase(name, searchPattern))
return p.port + "/" + vport;
}
} catch (Exception e) { e.printStackTrace(); }
}
return null;
}
static void sleepSeconds(long s) {
if (s > 0) sleep(s*1000);
}
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;
Program(int port, String helloString) {
this.helloString = helloString;
this.port = port;}
}
static List scan() { try {
return scan(1, 65535);
} catch (Throwable __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}
static List scan(int fromPort, int toPort) {
return scan(fromPort, toPort, new int[0]);
}
static List scan(int fromPort, int toPort, int[] preferredPorts) { try {
Set preferredPortsSet = new HashSet(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();
List> futures = new ArrayList>();
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();
List programs = new ArrayList();
for (final Future 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 checkPort(final ExecutorService es, final String ip, final int port, final int timeout) {
return es.submit(new Callable() {
@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 quickScan() {
return scan(quickScanFrom, quickScanTo);
}
static List quickBotScan() {
return quickBotScan(new int[0]);
}
static List quickBotScan(int[] preferredPorts) {
return scan(4990, 5000+maxNumberOfBotPorts-1, preferredPorts);
}
} // ProgramScan
static List quickBotScan() {
return ProgramScan.quickBotScan();
}
static List quickBotScan(int[] preferredPorts) {
return ProgramScan.quickBotScan(preferredPorts);
}
static List quickBotScan(String searchPattern) {
List l = new ArrayList();
for (ProgramScan.Program p : ProgramScan.quickBotScan())
if (indexOfIgnoreCase(p.helloString, searchPattern) == 0)
l.add(p);
return l;
}
static List parse3(String s) {
return dropPunctuation(javaTokPlusPeriod(s));
}
static List emptyList() {
return Collections.emptyList();
}
// We dropped the "***" support here (use match3 for that)
static String[] find2(List pat, List tok) {
for (int idx = 0; idx < tok.size(); idx += 2) {
String[] result = find2(pat, tok, idx);
if (result != null) return result;
}
return null;
}
static String[] find2(List pat, List tok, int idx) {
if (idx+pat.size() > tok.size())
return null;
List result = new ArrayList();
for (int i = 1; i < pat.size(); i += 2) {
String p = pat.get(i), t = tok.get(idx+i);
if (eq(p, "*"))
result.add(t);
else if (!p.equalsIgnoreCase(t))
return null;
}
return toStringArray(result);
}
static boolean preferCached = false;
public static String loadSnippet(String snippetID) {
try {
return loadSnippet(parseSnippetID(snippetID), preferCached);
} catch (IOException e) {
throw new RuntimeException(e);
}
}
public static String loadSnippet(String snippetID, boolean preferCached) throws IOException {
return loadSnippet(parseSnippetID(snippetID), preferCached);
}
public static String loadSnippet(long snippetID, boolean preferCached) throws IOException {
String text = getSnippetFromBossBot(snippetID);
if (text != null) return text;
initSnippetCache();
text = DiskSnippetCache_get(snippetID);
if (preferCached && text != null)
return text;
try {
if (text != null) System.err.println("md5: " + md5(text));
URL url = new URL("http://tinybrain.de:8080/getraw.php?id=" + snippetID + "&utf8=1");
text = loadPage(url);
} catch (RuntimeException e) {
e.printStackTrace();
throw new IOException("Snippet #" + snippetID + " not found or not public");
}
try {
initSnippetCache();
DiskSnippetCache_put(snippetID, text);
} catch (IOException e) {
System.err.println("Minor warning: Couldn't save snippet to cache (" + DiskSnippetCache_getDir() + ")");
}
return text;
}
static File DiskSnippetCache_dir;
public static void initDiskSnippetCache(File dir) {
DiskSnippetCache_dir = dir;
dir.mkdirs();
}
public static synchronized String DiskSnippetCache_get(long snippetID) throws IOException {
return loadTextFile(DiskSnippetCache_getFile(snippetID).getPath(), null);
}
private static File DiskSnippetCache_getFile(long snippetID) {
return new File(DiskSnippetCache_dir, "" + snippetID);
}
public static synchronized void DiskSnippetCache_put(long snippetID, String snippet) throws IOException {
saveTextFile(DiskSnippetCache_getFile(snippetID).getPath(), snippet);
}
public static File DiskSnippetCache_getDir() {
return DiskSnippetCache_dir;
}
public static void initSnippetCache() {
if (DiskSnippetCache_dir == null)
initDiskSnippetCache(new File(System.getProperty("user.home"), ".tinybrain/snippet-cache"));
}
static void startBotVM() {
startBotSeparateVM("This is a JavaX VM. Bot VM.", "#1001710");
}
public static String unquote(String s) {
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.length()-1);
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
}
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();
}
static Map findBot_cache = new TreeMap();
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 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 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;
}
static boolean equalsIgnoreCase(String a, String b) {
return a == null ? b == null : a.equalsIgnoreCase(b);
}
static class DynamicObject {
String className;
Map fieldValues = new TreeMap();
}
static Object unstructure(String text) {
return unstructure(text, false);
}
// actually it's now almost the same as jsonDecode :)
static Object unstructure(String text, final boolean allDynamic) {
final List tok = javaTok(text);
class X {
int i = 1;
Object parse() {
String t = tok.get(i);
if (t.startsWith("\"")) {
String s = unquote(tok.get(i));
i += 2;
return s;
}
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("bigint"))
return parseBigInt();
if (t.equals("d"))
return parseDouble();
if (t.equals("null")) {
i += 2; return null;
}
if (t.equals("false")) {
i += 2; return false;
}
if (t.equals("true")) {
i += 2; return true;
}
if (t.equals("-")) {
t = tok.get(i+2);
i += 4;
long l = -Long.parseLong(t);
return l == (int) l ? (int) l : l;
}
if (isInteger(t)) {
i += 2;
long l = Long.parseLong(t);
return l == (int) l ? (int) l : l;
}
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;
}
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 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;
DynamicObject dO = new DynamicObject();
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 parseMap() {
return parseMap(new TreeMap());
}
Object parseMap(Map map) {
consume("{");
while (!tok.get(i).equals("}")) {
Object key = unstructure(tok.get(i));
i += 2;
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 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); }}
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 {
String contentType = con.getContentType();
if (contentType == null)
throw new IOException("Page could not be read: " + url);
//Log.info("Content-Type: " + contentType);
String charset = loadPage_guessCharset(contentType);
Reader r = new InputStreamReader(con.getInputStream(), charset);
StringBuilder buf = new StringBuilder();
while (true) {
int ch = r.read();
if (ch < 0)
break;
//Log.info("Chars read: " + buf.length());
buf.append((char) ch);
}
return buf.toString();
}
static String loadPage_guessCharset(String contentType) {
Pattern p = Pattern.compile("text/html;\\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 String[] toStringArray(List 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) o);
else
throw fail("Not a list or array: " + structure(o));
}
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 boolean startsWithIgnoreCase(String a, String b) {
return a != null && a.regionMatches(true, 0, b, 0, b.length());
}
static String md5(String text) { try {
if (text == null) return "-";
return bytesToHex(md5_impl(text.getBytes("UTF-8"))); // maybe different than the way PHP does it...
} catch (Throwable __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}
static String md5(byte[] data) {
return bytesToHex(md5_impl(data));
}
static byte[] md5_impl(byte[] data) {
try {
return MessageDigest.getInstance("MD5").digest(data);
} catch (Exception e) { throw e instanceof RuntimeException ? (RuntimeException) e : new RuntimeException(e); }
}
static String md5(File file) { try {
return md5(loadBinaryFile(file));
} 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 boolean isNonNegativeInteger(String s) {
return s != null && Pattern.matches("\\d+", s);
}
static String getSnippetFromBossBot(long snippetID) {
return boss(format3("get text for *", snippetID));
}
/** 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);
}
}
// 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 javaTokPlusPeriod(String s) {
List tok = new ArrayList();
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 (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;
}
static List dropPunctuation_keep = litlist("*", "<", ">");
static List dropPunctuation(List tok) {
tok = new ArrayList(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 void startBotSeparateVM(String botName, String scriptID) {
DialogIO bot = findBot(botName);
if (bot != null)
bot.close();
else {
print("Bot " + quote(botName) + " not found. Starting separately: " + scriptID);
nohupJavax(scriptID);
waitForBotStartUp(botName);
}
}
static int parseInt(String s) {
return Integer.parseInt(s);
}
// 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 String boss(String line) {
try {
//S s = sendToLocalBotOpt("Boss Bot", line);
DialogIO io = talkTo(4990); // Boss Bot port
io.readLine();
io.sendLine(line);
String s = io.readLine();
Matches m = new Matches();
if (match3("text: *", s, m))
return unquote(m.m[0]);
return null;
} catch (Exception e) {
//e.printStackTrace();
return null;
}
}
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);
}
}
public static String bytesToHex(byte[] bytes) {
return bytesToHex(bytes, 0, bytes.length);
}
public static String bytesToHex(byte[] bytes, int ofs, int len) {
StringBuilder stringBuilder = new StringBuilder(len*2);
for (int i = 0; i < len; i++) {
String s = "0" + Integer.toHexString(bytes[ofs+i]);
stringBuilder.append(s.substring(s.length()-2, s.length()));
}
return stringBuilder.toString();
}
static Object nuObject(Class c, Object... args) { try {
Constructor m = nuObject_findConstructor(c, args);
m.setAccessible(true);
return 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 double parseDouble(String s) {
return Double.parseDouble(s);
}
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 List nlTok(String s) {
return javaTokPlusPeriod(s);
}
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;
}
public static byte[] loadBinaryFile(String fileName) throws IOException {
if (!new File(fileName).exists())
return null;
FileInputStream in = new FileInputStream(fileName);
byte buf[] = new byte[1024];
ByteArrayOutputStream out = new ByteArrayOutputStream();
int l;
while (true) {
l = in.read(buf);
if (l <= 0) break;
out.write(buf, 0, l);
}
in.close();
return out.toByteArray();
}
public static byte[] loadBinaryFile(File file) throws IOException {
return loadBinaryFile(file.getPath());
}
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 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");
}
/** possibly improvable */
public static String bashQuote(String text) {
if (text == null) return null;
return "\"" + text
.replace("\\", "\\\\")
.replace("\"", "\\\"")
.replace("\n", "\\n")
.replace("\r", "\\r") + "\"";
}
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;
}
/** possibly improvable */
public static String winQuote(String text) {
if (text == null) return null;
return "\"" + text
.replace("\\", "\\\\")
.replace("\"", "\\\"")
.replace("\n", "\\n")
.replace("\r", "\\r") + "\"";
}
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;
}
/** 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);
}
}
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 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();
}
public static void mkdirsForFile(File file) {
File dir = file.getParentFile();
if (dir != null) // is null if file is in current dir
dir.mkdirs();
}
static boolean isAndroid() { return System.getProperty("java.vendor").toLowerCase().indexOf("android") >= 0; }
static void printStackTrace(Throwable e) {
// we go to system.out now - system.err is nonsense
print(getStackTrace(e));
}
static Class run(String progID) {
Class main = hotwire(progID);
callMain(main);
return main;
}
static BufferedReader readLine_reader;
static String readLine() {
return (String) call(getJavaX(), "readLine");
}
static String unq(String s) {
return unquote(s);
}
static ThreadLocal saveTiming_last = new ThreadLocal();
static void saveTiming(long ms) {
print(ms + " ms");
saveTiming_last.set(ms);
}
static Class __javax;
static Class getJavaX() {
return __javax;
}
static void callMain(Object c, String... args) {
callOpt(c, "main", new Object[] {args});
}
static String getStackTrace(Throwable throwable) {
StringWriter writer = new StringWriter();
throwable.printStackTrace(new PrintWriter(writer));
return writer.toString();
}
// 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 libraries = new ArrayList();
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);
return theClass;
}
} catch (Exception e) {
throw e instanceof RuntimeException ? (RuntimeException) e : new RuntimeException(e);
}
}
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 long startTiming_startTime;
static void startTiming() {
startTiming_startTime = now();
}
static void stopTiming() {
long end = now();
print("Time: " + (end-startTiming_startTime) + " ms");
}
static A or(A a, A b) {
return a != null ? a : b;
}
static String firstToUpper(String s) {
if (s.length() == 0) return s;
return Character.toUpperCase(s.charAt(0)) + s.substring(1);
}
}