import java.util.*;
import java.util.zip.*;
import java.util.List;
import java.util.regex.*;
import java.util.concurrent.*;
import java.util.concurrent.atomic.*;
import java.util.concurrent.locks.*;
import javax.swing.*;
import javax.swing.event.*;
import javax.swing.text.*;
import javax.swing.table.*;
import java.io.*;
import java.net.*;
import java.lang.reflect.*;
import java.lang.ref.*;
import java.lang.management.*;
import java.security.*;
import java.security.spec.*;
import java.awt.*;
import java.awt.event.*;
import java.awt.image.*;
import javax.imageio.*;
import java.math.*;
import x30_pkg.x30_util;
import static x30_pkg.x30_util.VF1;
import static x30_pkg.x30_util.l;
import static x30_pkg.x30_util.fail;
import static x30_pkg.x30_util.indexOf;
import static x30_pkg.x30_util.getOpt;
import static x30_pkg.x30_util.setOpt;
import static x30_pkg.x30_util.callOpt;
import static x30_pkg.x30_util.newWeakHashMap;
import static x30_pkg.x30_util.newDangerousWeakHashMap;
import static x30_pkg.x30_util.get;
import static x30_pkg.x30_util.get_raw;
import static x30_pkg.x30_util.assertTrue;
import static x30_pkg.x30_util.isHeadless;
import static x30_pkg.x30_util.isAndroid;
import static x30_pkg.x30_util.isTrue;
import static x30_pkg.x30_util.asList;
import x30_pkg.x30_util.DynamicObject;
import loadableUtils.utils;
import static loadableUtils.utils._threadInfo;
import static loadableUtils.utils._threadInheritInfo;
import static loadableUtils.utils._threadInfo_addMakerAndRetriever;
import static loadableUtils.utils.dm_currentModule;
import static loadableUtils.utils.dm_current_mandatory;
import static loadableUtils.utils.match;
import static loadableUtils.utils.getOpt_raw;
import static loadableUtils.utils.setOpt_raw;
import static loadableUtils.utils.getField;
import static loadableUtils.utils.fieldType;
import static loadableUtils.utils.format3;
import static loadableUtils.utils.vm_generalIdentityHashSet;
import static loadableUtils.utils.vm_generalHashMap;
import static loadableUtils.utils.vm_generalWeakSubMap;
import static loadableUtils.utils.bindToComponent;
import static loadableUtils.utils.struct;
import static loadableUtils.utils.structure;
import static loadableUtils.utils.loadPage;
import static loadableUtils.utils.loadPage_utf8;
import static loadableUtils.utils.loadPageSilentlyWithTimeout;
import static loadableUtils.utils.loadPageSilently;
import static loadableUtils.utils.loadSnippet;
import static loadableUtils.utils.loadSnippetQuietly;
import static loadableUtils.utils.sendToLocalBot;
import static loadableUtils.utils.componentPopupMenu;
import static loadableUtils.utils.componentPopupMenu_top;
import static loadableUtils.utils.componentPopupMenu_getEvent;
import static loadableUtils.utils.componentPopupMenu_initForComponent;
import static loadableUtils.utils.listPopupMenu;
import static loadableUtils.utils.tablePopupMenu;
import static loadableUtils.utils.sexyTableWithoutDrag;
import static loadableUtils.utils.dm_current_generic;
import static loadableUtils.utils.dm_current_mandatory_generic;
import static loadableUtils.utils.cset;
import static loadableUtils.utils.DynamicObject_loading;
import static loadableUtils.utils.concepts_unlisted;
import static loadableUtils.utils.makePopupMenuConditional;
import static loadableUtils.utils.makeConceptsTable_idWidth;
import static loadableUtils.utils.showConceptsTable_afterUpdate;
import static loadableUtils.utils.dynamicObjectIsLoading;
import loadableUtils.utils.F0;
import loadableUtils.utils.F1;
import loadableUtils.utils.IF1;
import loadableUtils.utils.Matches;
import loadableUtils.utils.BetterLabel;
import loadableUtils.utils.SingleComponentPanel;
import loadableUtils.utils.Snippet;
import loadableUtils.utils.Q;
import loadableUtils.utils.ImageSurface;
import loadableUtils.utils.structure_Data;
import loadableUtils.utils.RGBImage;
import loadableUtils.utils.RGB;
import loadableUtils.utils.BWImage;
import loadableUtils.utils.MakesBufferedImage;
import loadableUtils.utils.Concept;
import loadableUtils.utils.Concepts;
import loadableUtils.utils.IConceptIndex;
import loadableUtils.utils.IFieldIndex;
import loadableUtils.utils.Derefable;
import loadableUtils.utils.ImageSurfaceSelector;
import loadableUtils.utils.SimpleCRUD;
import loadableUtils.utils.PersistableThrowable;
import loadableUtils.utils.DynModule;
import loadableUtils.utils.DynPrintLog;
import loadableUtils.utils.DynObjectTable;
import loadableUtils.utils.DynImageSurface;
import loadableUtils.utils.DynCalculatedList;
import loadableUtils.utils.Rect;
import loadableUtils.utils.Pt;
import java.text.NumberFormat;
import javax.net.ssl.*;
import java.security.SecureRandom;
import java.security.cert.X509Certificate;
import javax.imageio.metadata.*;
import javax.imageio.stream.*;
import java.text.SimpleDateFormat;
import java.nio.file.Files;
import java.nio.file.Path;
class main {
public static class IWantYouToBePrelude extends DynPrintLog {
public static String objectiveSpace = "objective", computerSpace = "computer", userSpace = "user";
public transient String userName = "usery", computerName = "computery";
public transient Set<String> facts = tlft_ciSet("\r\n Computery is usery's assistant\r\n It is impossible that {Computery is usery's mother}\r\n ");
public transient WordTokRule rule_iWantYouToBe = wordTokReplacerRule("I want you to be my assistant", "assistant", "I want that {you are my assistant}");
public transient WordTokRule rule_useryWants = new WordTokRule("Usery wants that X", "X") {
public void run() {
String x_simplified = simpleSpaces_nTok(getVar("X"));
if (contains(facts, x_simplified))
emit("But " + x_simplified + " already");
else if (contains(facts, "It is impossible that " + curly(x_simplified)))
emit("No way brother");
else if (debug)
print("Can't decide on: " + x_simplified);
}
};
public transient MultiMap<String, WordTokRule> rulesForSpace = litmultimap(userSpace, ll(rule_iWantYouToBe), objectiveSpace, ll(rule_useryWants));
public Set<String> rewriteInSpace(String space, Collection<String> inputs) {
return applyWordTokRules(rulesForSpace.get(space), inputs);
}
public void start() {
super.start();
startThread("Start", new Runnable() {
public void run() {
try {
for (String input : ll("I want you to be my mother", "I want you to be my assistant")) {
print_nlBefore(input);
Set<String> outputs = rewriteInSpace(userSpace, ll(input));
pnlIndent("User space > ", outputs);
List<String> outputs2 = ai_spaceToSpace(userSpace, objectiveSpace, outputs, "computerName", computerName, "userName", userName);
pnlIndent("Objective space > ", outputs2);
Set<String> outputs3 = rewriteInSpace(objectiveSpace, outputs2);
pnlIndent("Objective space > ", outputs3);
List<String> outputs4 = ai_spaceToSpace(objectiveSpace, computerSpace, outputs3, "computerName", computerName, "userName", userName);
pnlIndent("Bot space > ", outputs4);
}
printDone();
} catch (Exception __e) {
throw rethrow(__e);
}
}
public String toString() {
return "for (String input : ll(\"I want you to be my mother\", \"I want you to be my ass...";
}
});
}
}
public static boolean _moduleClass_IWantYouToBePrelude;
public static Object callF(Object f, Object... args) {
try {
if (f instanceof String)
return callMC((String) f, args);
return x30_util.callF(f, args);
} catch (Exception __e) {
throw rethrow(__e);
}
}
public static <A> A callF(F0<A> f) {
return f == null ? null : f.get();
}
public static <A> A callF(IF0<A> f) {
return f == null ? null : f.get();
}
public static <A, B> B callF(F1<A, B> f, A a) {
return f == null ? null : f.get(a);
}
public static <A, B> B callF(IF1<A, B> f, A a) {
return f == null ? null : f.get(a);
}
public static <A> void callF(VF1<A> f, A a) {
if (f != null)
f.get(a);
}
public static Object callMC(String method, Object... args) {
return call(mc(), method, args);
}
public static Object call(Object o) {
return callF(o);
}
public static Object call(Object o, String method, Object... args) {
return call_withVarargs(o, method, args);
}
public static void _onLoad_initUtils() {
utils.__javax = javax();
}
public static void _onLoad_defaultClassFinder() {
setDefaultClassFinder(new F1<String, Class>() {
public Class get(String name) {
try {
Class c = findClass_fullName(name);
if (c != null)
return c;
if (startsWith(name, "main$"))
return loadableUtils.utils.findClass_fullName("loadableUtils.utils" + substring(name, 4));
return null;
} catch (Exception __e) {
throw rethrow(__e);
}
}
public String toString() {
return "Class c = findClass_fullName(name);\r\n if (c != null) ret c;\r\n if (start...";
}
});
}
public static String programID() {
return getProgramID();
}
public static String programID(Object o) {
return getProgramID(o);
}
public static volatile StringBuffer local_log = new StringBuffer();
public static volatile Appendable print_log = local_log;
public static volatile int print_log_max = 1024 * 1024;
public static volatile int local_log_max = 100 * 1024;
public static boolean print_silent;
public static Object print_byThread_lock = new Object();
public static volatile ThreadLocal<Object> print_byThread;
public static volatile Object print_allThreads;
public static volatile Object print_preprocess;
public static void print() {
print("");
}
public static <A> A print(String s, A o) {
print((endsWithLetterOrDigit(s) ? s + ": " : s) + o);
return o;
}
public static <A> A print(A o) {
ping_okInCleanUp();
if (print_silent)
return o;
String s = String.valueOf(o) + "\n";
print_noNewLine(s);
return o;
}
public static void print_noNewLine(String s) {
Object f = getThreadLocal(print_byThread_dontCreate());
if (f == null)
f = print_allThreads;
if (f != null)
if (isFalse(f instanceof F1 ? ((F1) f).get(s) : callF(f, s)))
return;
print_raw(s);
}
public static void print_raw(String s) {
if (print_preprocess != null)
s = (String) callF(print_preprocess, s);
s = fixNewLines(s);
Appendable loc = local_log;
Appendable 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);
}
public static TreeSet<String> tlft_ciSet(String s) {
return asCISet(tlft(s));
}
public static WordTokRule wordTokReplacerRule(String sentence, String _vars, String replaced) {
List<String> tokReplaced = wordTok_noBrackets(replaced);
class WordTokReplacer extends WordTokRule {
public WordTokReplacer() {
super(sentence, asCISet(javaTokC(_vars)));
}
public void run() {
emit(join(replaceCodeTokensUsingMap(tokReplaced, map)));
}
}
return new WordTokReplacer();
}
public static String simpleSpaces_nTok(String s) {
return join(simpleSpaces(javaTokNPunctuation(s)));
}
public static <A> A getVar(IVar<A> v) {
return v == null ? null : v.get();
}
public static boolean contains(Collection c, Object o) {
return c != null && c.contains(o);
}
public static boolean contains(Object[] x, Object o) {
if (x != null)
for (Object a : x) if (eq(a, o))
return true;
return false;
}
public static boolean contains(String s, char c) {
return s != null && s.indexOf(c) >= 0;
}
public static boolean contains(String s, String b) {
return s != null && s.indexOf(b) >= 0;
}
public static boolean contains(BitSet bs, int i) {
return bs != null && bs.get(i);
}
public static ThreadLocal<List> emit_tl = new ThreadLocal();
public static boolean emit_print = true;
public static ThreadLocal<String> emit_print_prefix = new ThreadLocal();
public static ThreadLocal<List> emit_onEmit = new ThreadLocal();
public static void emit(Object o) {
List l = emit_tl.get();
if (l == null)
emit_tl.set(l = new ArrayList());
l.add(o);
if (emit_print)
print(optPar(emit_print_prefix, "> ") + o);
pcallFAll(emit_onEmit.get(), o);
}
public static String curly(String s) {
return optionalCurlyBrace(s);
}
public static MultiMap litmultimap(Object... x) {
MultiMap mm = new MultiMap();
litmultimap_impl(mm, x);
return mm;
}
public static void litmultimap_impl(MultiMap mm, Object... x) {
for (int i = 0; i < x.length - 1; i += 2) if (x[i + 1] != null)
mm.putAll(x[i], (List) x[i + 1]);
}
public static <A> List<A> ll(A... a) {
ArrayList l = new ArrayList(a.length);
for (A x : a) l.add(x);
return l;
}
public static Set<String> applyWordTokRules(List<WordTokRule> rules, String s) {
return concatListsToCISet(map(rules, rule -> rule.matches(s) ? getStringEmits(rule) : null));
}
public static Set<String> applyWordTokRules(List<WordTokRule> rules, Collection<String> inputs) {
Set<String> out = cloneLinkedCISet(inputs);
for (String input : unnull(inputs)) functionReturningList_transitiveHull_ciSet(new F1<String, Collection<String>>() {
public Collection<String> get(String s) {
try {
return applyWordTokRules(rules, s);
} catch (Exception __e) {
throw rethrow(__e);
}
}
public String toString() {
return "applyWordTokRules(rules, s)";
}
}, input, "seen", out);
return out;
}
public static Thread startThread(Object runnable) {
return startThread(defaultThreadName(), runnable);
}
public static Thread startThread(String name, Object runnable) {
runnable = wrapAsActivity(runnable);
return startThread(newThread(toRunnable(runnable), name));
}
public static Thread startThread(Thread t) {
_registerThread(t);
t.start();
return t;
}
public static void print_nlBefore(Object o) {
nlPrint(o);
}
public static <A> void pnlIndent(Collection<A> l) {
print_noNewLine(indentx(numberedLines(l)));
}
public static <A> void pnlIndent(String indent, Collection<A> l) {
print_noNewLine(indentx(indent, numberedLines(l)));
}
public static List<String> ai_spaceToSpace(String space1, String space2, Collection<String> inputs, Object... __) {
return map(s -> ai_spaceToSpace(space1, space2, s, __), inputs);
}
public static String ai_spaceToSpace(String space1, String space2, String input, Object... __) {
String userName = optPar("userName", __, "usery");
String computerName = optPar("computerName", __, "computery");
if (eq(space1, "user") && eq(space2, "objective"))
return switcheroo_youToName(computerName, switcheroo_iToName(userName, input));
if (eq(space1, "objective") && eq(space2, "computer"))
return switcheroo_nameToYou(userName, switcheroo_nameToI(computerName, input));
return input;
}
public static void printDone() {
print("[done]");
}
public static RuntimeException rethrow(Throwable t) {
if (t instanceof Error)
_handleError((Error) t);
throw t instanceof RuntimeException ? (RuntimeException) t : new RuntimeException(t);
}
public static RuntimeException rethrow(String msg, Throwable t) {
throw new RuntimeException(msg, t);
}
public static Class mc() {
return main.class;
}
public static Object call_withVarargs(Object o, String method, Object... args) {
try {
if (o == null)
return null;
if (o instanceof Class) {
Class c = (Class) o;
_MethodCache cache = callOpt_getCache(c);
Method me = cache.findStaticMethod(method, args);
if (me != null)
return invokeMethod(me, null, args);
List<Method> methods = cache.cache.get(method);
if (methods != null)
methodSearch: for (Method m : methods) {
{
if (!(m.isVarArgs()))
continue;
}
{
if (!(isStaticMethod(m)))
continue;
}
Object[] newArgs = massageArgsForVarArgsCall(m, args);
if (newArgs != null)
return invokeMethod(m, null, newArgs);
}
throw fail("Method " + c.getName() + "." + method + "(" + joinWithComma(classNames(args)) + ") not found");
} else {
Class c = o.getClass();
_MethodCache cache = callOpt_getCache(c);
Method me = cache.findMethod(method, args);
if (me != null)
return invokeMethod(me, o, args);
List<Method> methods = cache.cache.get(method);
if (methods != null)
methodSearch: for (Method m : methods) {
{
if (!(m.isVarArgs()))
continue;
}
Object[] newArgs = massageArgsForVarArgsCall(m, args);
if (newArgs != null)
return invokeMethod(m, o, newArgs);
}
throw fail("Method " + c.getName() + "." + method + "(" + joinWithComma(classNames(args)) + ") not found");
}
} catch (Exception __e) {
throw rethrow(__e);
}
}
public static Class javax() {
return getJavaX();
}
public static void setDefaultClassFinder(Object cf) {
_defaultClassFinder_value = cf;
}
public static HashMap<String, Class> findClass_fullName_cache = new HashMap();
public static Class findClass_fullName(String name) {
synchronized (findClass_fullName_cache) {
if (findClass_fullName_cache.containsKey(name))
return findClass_fullName_cache.get(name);
Class c;
try {
c = Class.forName(name);
} catch (ClassNotFoundException e) {
c = null;
}
findClass_fullName_cache.put(name, c);
return c;
}
}
public static boolean startsWith(String a, String b) {
return a != null && a.startsWith(b);
}
public static boolean startsWith(String a, char c) {
return nemptyString(a) && a.charAt(0) == c;
}
public static boolean startsWith(String a, String b, Matches m) {
if (!startsWith(a, b))
return false;
m.m = new String[] { substring(a, strL(b)) };
return true;
}
public static boolean startsWith(List a, List b) {
if (a == null || listL(b) > listL(a))
return false;
for (int i = 0; i < listL(b); i++) if (neq(a.get(i), b.get(i)))
return false;
return true;
}
public static String substring(String s, int x) {
return substring(s, x, strL(s));
}
public static String substring(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);
}
public static Object _defaultClassFinder_value = defaultDefaultClassFinder();
public static Object _defaultClassFinder() {
return _defaultClassFinder_value;
}
public static String programID;
public static String getProgramID() {
return nempty(programID) ? formatSnippetIDOpt(programID) : "?";
}
public static String getProgramID(Class c) {
String id = (String) getOpt(c, "programID");
if (nempty(id))
return formatSnippetID(id);
return "?";
}
public static String getProgramID(Object o) {
return getProgramID(getMainClass(o));
}
public static boolean endsWithLetterOrDigit(String s) {
return s != null && s.length() > 0 && Character.isLetterOrDigit(s.charAt(s.length() - 1));
}
public static void ping_okInCleanUp() {
if (ping_pauseAll || ping_anyActions)
ping_impl(true);
}
public static Object getThreadLocal(Object o, String name) {
ThreadLocal t = (ThreadLocal) (getOpt(o, name));
return t != null ? t.get() : null;
}
public static <A> A getThreadLocal(ThreadLocal<A> tl) {
return tl == null ? null : tl.get();
}
public static ThreadLocal<Object> print_byThread_dontCreate() {
return print_byThread;
}
public static boolean isFalse(Object o) {
return eq(false, o);
}
public static String fixNewLines(String s) {
int i = indexOf(s, '\r');
if (i < 0)
return s;
int l = s.length();
StringBuilder out = new StringBuilder(l);
out.append(s, 0, i);
for (; i < l; i++) {
char c = s.charAt(i);
if (c != '\r')
out.append(c);
else {
out.append('\n');
if (i + 1 < l && s.charAt(i + 1) == '\n')
++i;
}
}
return out.toString();
}
public static void print_append(Appendable _buf, String s, int max) {
try {
synchronized (_buf) {
_buf.append(s);
if (!(_buf instanceof StringBuilder))
return;
StringBuilder buf = (StringBuilder) _buf;
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);
}
}
} catch (Exception __e) {
throw rethrow(__e);
}
}
public static TreeSet<String> asCISet(Iterable<String> c) {
return toCaseInsensitiveSet(c);
}
public static TreeSet<String> asCISet(String... x) {
return toCaseInsensitiveSet(x);
}
public static List<String> tlft(String s) {
return toLinesFullTrim(s);
}
public static List<String> tlft(File f) {
return toLinesFullTrim(f);
}
public static List<String> wordTok_noBrackets(String s) {
return javaTokNPunctuation_cached(s);
}
public static List<String> javaTokC(String s) {
if (s == null)
return null;
int l = s.length();
ArrayList<String> tok = new ArrayList();
int i = 0;
while (i < l) {
int j = i;
char c, d;
while (j < l) {
c = s.charAt(j);
d = j + 1 >= l ? '\0' : s.charAt(j + 1);
if (c == ' ' || c == '\t' || c == '\r' || c == '\n')
++j;
else if (c == '/' && d == '*') {
do ++j; while (j < l && !s.substring(j, Math.min(j + 2, l)).equals("*/"));
j = Math.min(j + 2, l);
} else if (c == '/' && d == '/') {
do ++j; while (j < l && "\r\n".indexOf(s.charAt(j)) < 0);
} else
break;
}
i = j;
if (i >= l)
break;
c = s.charAt(i);
d = i + 1 >= l ? '\0' : s.charAt(i + 1);
if (c == '\'' || c == '"') {
char opener = c;
++j;
while (j < l) {
if (s.charAt(j) == opener || s.charAt(j) == '\n') {
++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));
else if (Character.isDigit(c)) {
do ++j; while (j < l && Character.isDigit(s.charAt(j)));
if (j < l && s.charAt(j) == 'L')
++j;
} else if (c == '[' && d == '[') {
do ++j; while (j + 1 < l && !s.substring(j, j + 2).equals("]]"));
j = Math.min(j + 2, l);
} else if (c == '[' && d == '=' && 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;
tok.add(javaTok_substringC(s, i, j));
i = j;
}
return tok;
}
public static <A> String join(String glue, Iterable<A> strings) {
if (strings == null)
return "";
if (strings instanceof Collection) {
if (((Collection) strings).size() == 1)
return str(first(((Collection) strings)));
}
StringBuilder buf = new StringBuilder();
Iterator<A> 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 <A> String join(Iterable<A> strings) {
return join("", strings);
}
public static <A> String join(Iterable<A> strings, String glue) {
return join(glue, strings);
}
public static String join(String[] strings) {
return join("", strings);
}
public static String join(String glue, Pair p) {
return p == null ? "" : str(p.a) + glue + str(p.b);
}
public static String replaceCodeTokensUsingMap(String s, Map<String, String> map) {
return join(replaceCodeTokensUsingMap(javaTok(s), map));
}
public static List<String> replaceCodeTokensUsingMap(List<String> tok, Map<String, String> map) {
List<String> out = emptyList(tok);
for (int i = 0; i < l(tok); i++) {
out.add(odd(i) ? lookupOrKeep(map, tok.get(i)) : tok.get(i));
}
return out;
}
public static String replaceCodeTokensUsingMap(Map<String, String> map, String s) {
return replaceCodeTokensUsingMap(s, map);
}
public static List<String> simpleSpaces(List<String> tok) {
tok = cloneList(tok);
for (int i = 0; i < l(tok); i += 2) tok.set(i, tok.get(i).equals("") ? "" : " ");
return tok;
}
public static String simpleSpaces(String s) {
return join(simpleSpaces(nlTok(s)));
}
public static List<String> javaTokNPunctuation(String s) {
List<String> tok = javaTok(s);
for (int i = 1; i < l(tok); i += 2) {
int j = i;
String t;
while (j < l(tok) && l(t = tok.get(j)) == 1 && !Character.isLetterOrDigit(t.charAt(0))) j += 2;
if (j > i)
replaceSubList(tok, i - 1, j, ll(joinSubList(tok, i - 1, j)));
}
return tok;
}
public static boolean eq(Object a, Object b) {
return a == null ? b == null : a == b || b != null && a.equals(b);
}
public static <A> A optPar(ThreadLocal<A> tl, A defaultValue) {
A a = tl.get();
if (a != null) {
tl.set(null);
return a;
}
return defaultValue;
}
public static <A> A optPar(ThreadLocal<A> tl) {
return optPar(tl, null);
}
public static Object optPar(Object[] params, String name) {
return optParam(params, name);
}
public static Object optPar(String name, Object[] params) {
return optParam(params, name);
}
public static Object optPar(String name, Map params) {
return optParam(name, params);
}
public static <A> A optPar(Object[] params, String name, A defaultValue) {
return optParam(params, name, defaultValue);
}
public static <A> A optPar(String name, Object[] params, A defaultValue) {
return optParam(params, name, defaultValue);
}
public static void pcallFAll(Collection l, Object... args) {
if (l != null)
for (Object f : cloneList(l)) pcallF(f, args);
}
public static void pcallFAll(Iterator it, Object... args) {
while (it.hasNext()) pcallF(it.next(), args);
}
public static String optionalCurlyBrace(String s) {
return isCurlyBraced(s) ? s : curlyBrace(s);
}
public static Set<String> concatListsToCISet(Collection<? extends Collection<String>> lists) {
Set<String> l = ciSet();
for (Collection<String> list : lists) if (list != null)
l.addAll(list);
return l;
}
public static List map(Iterable l, Object f) {
return map(f, l);
}
public static List map(Object f, Iterable l) {
List x = emptyList(l);
if (l != null)
for (Object o : l) x.add(callF(f, o));
return x;
}
public static <A, B> List<B> map(Iterable<A> l, F1<A, B> f) {
return map(f, l);
}
public static <A, B> List<B> map(F1<A, B> f, Iterable<A> l) {
List x = emptyList(l);
if (l != null)
for (A o : l) x.add(callF(f, o));
return x;
}
public static <A, B> List<B> map(IF1<A, B> f, Iterable<A> l) {
return map(l, f);
}
public static <A, B> List<B> map(Iterable<A> l, IF1<A, B> f) {
List x = emptyList(l);
if (l != null)
for (A o : l) x.add(f.get(o));
return x;
}
public static <A, B> List<B> map(IF1<A, B> f, A[] l) {
return map(l, f);
}
public static <A, B> List<B> map(A[] l, IF1<A, B> f) {
List x = emptyList(l);
if (l != null)
for (A o : l) x.add(f.get(o));
return x;
}
public static List map(Object f, Object[] l) {
return map(f, asList(l));
}
public static List map(Object[] l, Object f) {
return map(f, l);
}
public static List map(Object f, Map map) {
return map(map, f);
}
public static List map(Map map, Object f) {
List x = new ArrayList();
if (map != null)
for (Object _e : map.entrySet()) {
Map.Entry e = (Map.Entry) _e;
x.add(callF(f, e.getKey(), e.getValue()));
}
return x;
}
public static List<String> getStringEmits(Runnable r) {
return stringsOnly(getEmits(r));
}
public static Set<String> cloneLinkedCISet(Collection<String> l) {
Set<String> set = linkedCISet();
if (l != null)
synchronized (collectionMutex(l)) {
addAll(set, l);
}
return set;
}
public static String unnull(String s) {
return s == null ? "" : s;
}
public static <A> Collection<A> unnull(Collection<A> l) {
return l == null ? emptyList() : l;
}
public static <A> List<A> unnull(List<A> l) {
return l == null ? emptyList() : l;
}
public static <A, B> Map<A, B> unnull(Map<A, B> l) {
return l == null ? emptyMap() : l;
}
public static <A> Iterable<A> unnull(Iterable<A> i) {
return i == null ? emptyList() : i;
}
public static <A> A[] unnull(A[] a) {
return a == null ? (A[]) new Object[0] : a;
}
public static BitSet unnull(BitSet b) {
return b == null ? new BitSet() : b;
}
public static Pt unnull(Pt p) {
return p == null ? new Pt() : p;
}
public static <A, B> Pair<A, B> unnull(Pair<A, B> p) {
return p != null ? p : new Pair(null, null);
}
public static Set<String> functionReturningList_transitiveHull_ciSet(Object f, String input, Object... __) {
Set<String> seen = optPar("seen", __, linkedCISet());
exhaustIterator(repeatFunctionReturningList_iterator(f, input, paramsPlus(__, "seen", seen)));
return seen;
}
public static String defaultThreadName_name;
public static String defaultThreadName() {
if (defaultThreadName_name == null)
defaultThreadName_name = "A thread by " + programID();
return defaultThreadName_name;
}
public static Runnable wrapAsActivity(Object r) {
return toRunnable(r);
}
public static Thread newThread(Object runnable) {
return new Thread(_topLevelErrorHandling(toRunnable(runnable)));
}
public static Thread newThread(Object runnable, String name) {
if (name == null)
name = defaultThreadName();
return new Thread(_topLevelErrorHandling(toRunnable(runnable)), name);
}
public static Thread newThread(String name, Object runnable) {
return newThread(runnable, name);
}
public static Runnable toRunnable(final Object o) {
if (o instanceof Runnable)
return (Runnable) o;
return new Runnable() {
public void run() {
try {
callF(o);
} catch (Exception __e) {
throw rethrow(__e);
}
}
public String toString() {
return "callF(o)";
}
};
}
public static Map<Thread, Boolean> _registerThread_threads;
public static Object _onRegisterThread;
public static Thread _registerThread(Thread t) {
if (_registerThread_threads == null)
_registerThread_threads = newWeakHashMap();
_registerThread_threads.put(t, true);
vm_generalWeakSubMap("thread2mc").put(t, weakRef(mc()));
callF(_onRegisterThread, t);
return t;
}
public static void _registerThread() {
_registerThread(Thread.currentThread());
}
public static <A> A nlPrint(A o) {
return nlPrint("", o);
}
public static <A> A nlPrint(String prefix, A o) {
return print("\n" + unnull(prefix), o);
}
public static String indentx(String s) {
return indentx(indent_default, s);
}
public static String indentx(int n, String s) {
return dropSuffix(repeat(' ', n), indent(n, s));
}
public static String indentx(String indent, String s) {
return dropSuffix(indent, indent(indent, s));
}
public static String numberedLines(Map map) {
return numberedLines(mapToLines(map));
}
public static <A> String numberedLines(Collection<A> l) {
int i = 0;
List<String> lines = new ArrayList();
if (l != null)
for (A a : l) lines.add(((++i) + ". " + str(a)));
return lines(lines);
}
public static String switcheroo_youToName(String name, String s) {
Map<String, String> map = mechMap("Switcheroo you -> $name");
map = mapValues(map, x -> replaceIC(x, "$name", name));
return translateUsingWordTree(s, mapToWordTree(map));
}
public static String switcheroo_iToName(String name, String s) {
Map<String, String> map = mechMap("Switcheroo I -> $name");
map = mapValues(map, x -> replaceIC(x, "$name", name));
return translateUsingWordTree(s, mapToWordTree(map));
}
public static String switcheroo_nameToYou(String name, String s) {
Map<String, String> map = mechMapInOrder("Switcheroo you -> $name");
map = mapValues(map, x -> replaceIC(x, "$name", name));
return translateUsingWordTree(s, mapToWordTree(reverseCIMap_noOverwrite(map)));
}
public static String switcheroo_nameToI(String name, String s) {
Map<String, String> map = mechMapInOrder("Switcheroo I -> $name");
map = mapValues(map, x -> replaceIC(x, "$name", name));
return translateUsingWordTree(s, mapToWordTree(reverseCIMap_noOverwrite(map)));
}
public static void _handleError(Error e) {
call(javax(), "_handleError", e);
}
public static final Map<Class, _MethodCache> callOpt_cache = newDangerousWeakHashMap();
public static Object callOpt_cached(Object o, String methodName, Object... args) {
try {
if (o == null)
return null;
if (o instanceof Class) {
Class c = (Class) o;
_MethodCache cache = callOpt_getCache(c);
Method me = cache.findMethod(methodName, args);
if (me == null || (me.getModifiers() & Modifier.STATIC) == 0)
return null;
return invokeMethod(me, null, args);
} else {
Class c = o.getClass();
_MethodCache cache = callOpt_getCache(c);
Method me = cache.findMethod(methodName, args);
if (me == null)
return null;
return invokeMethod(me, o, args);
}
} catch (Exception __e) {
throw rethrow(__e);
}
}
public static _MethodCache callOpt_getCache(Class c) {
synchronized (callOpt_cache) {
_MethodCache cache = callOpt_cache.get(c);
if (cache == null)
callOpt_cache.put(c, cache = new _MethodCache(c));
return cache;
}
}
public static Object invokeMethod(Method m, Object o, Object... args) {
try {
try {
return m.invoke(o, args);
} catch (InvocationTargetException e) {
throw rethrow(getExceptionCause(e));
} catch (IllegalArgumentException e) {
throw new IllegalArgumentException(e.getMessage() + " - was calling: " + m + ", args: " + joinWithSpace(classNames(args)));
}
} catch (Exception __e) {
throw rethrow(__e);
}
}
public static boolean isStaticMethod(Method m) {
return methodIsStatic(m);
}
public static Object[] massageArgsForVarArgsCall(Method m, Object[] args) {
Class<?>[] types = m.getParameterTypes();
int n = types.length - 1, nArgs = args.length;
if (nArgs < n)
return null;
for (int i = 0; i < n; i++) if (!argumentCompatibleWithType(args[i], types[i]))
return null;
Class varArgType = types[n].getComponentType();
for (int i = n; i < nArgs; i++) if (!argumentCompatibleWithType(args[i], varArgType))
return null;
Object[] newArgs = new Object[n + 1];
arraycopy(args, 0, newArgs, 0, n);
Object[] varArgs = arrayOfType(varArgType, nArgs - n);
arraycopy(args, n, varArgs, 0, nArgs - n);
newArgs[n] = varArgs;
return newArgs;
}
public static <A> String joinWithComma(Collection<A> c) {
return join(", ", c);
}
public static String joinWithComma(String... c) {
return join(", ", c);
}
public static String joinWithComma(Pair p) {
return p == null ? "" : joinWithComma(str(p.a), str(p.b));
}
public static List<String> classNames(Collection l) {
return getClassNames(l);
}
public static List<String> classNames(Object[] l) {
return getClassNames(Arrays.asList(l));
}
public static Class __javax;
public static Class getJavaX() {
try {
return __javax;
} catch (Exception __e) {
throw rethrow(__e);
}
}
public static boolean nemptyString(String s) {
return s != null && s.length() > 0;
}
public static int strL(String s) {
return s == null ? 0 : s.length();
}
public static int listL(Collection l) {
return l == null ? 0 : l.size();
}
public static boolean neq(Object a, Object b) {
return !eq(a, b);
}
public static Object defaultDefaultClassFinder() {
return new F1<String, Class>() {
public Class get(String name) {
try {
Class c = findClass_fullName(name);
if (c != null)
return c;
if (startsWith(name, "loadableUtils.utils$"))
return findClass_fullName("main" + substring(name, 19));
return null;
} catch (Exception __e) {
throw rethrow(__e);
}
}
public String toString() {
return "Class c = findClass_fullName(name);\r\n if (c != null) ret c;\r\n if (start...";
}
};
}
public static boolean nempty(Collection c) {
return !empty(c);
}
public static boolean nempty(CharSequence s) {
return !empty(s);
}
public static boolean nempty(Object[] o) {
return !empty(o);
}
public static boolean nempty(byte[] o) {
return !empty(o);
}
public static boolean nempty(int[] o) {
return !empty(o);
}
public static boolean nempty(Map m) {
return !empty(m);
}
public static boolean nempty(Iterator i) {
return i != null && i.hasNext();
}
public static boolean nempty(Object o) {
return !empty(o);
}
public static String formatSnippetIDOpt(String s) {
return isSnippetID(s) ? formatSnippetID(s) : s;
}
public static String formatSnippetID(String id) {
return "#" + parseSnippetID(id);
}
public static String formatSnippetID(long id) {
return "#" + id;
}
public static Class getMainClass() {
return mc();
}
public static Class getMainClass(Object o) {
try {
if (o == null)
return null;
if (o instanceof Class && eq(((Class) o).getName(), "x30"))
return (Class) o;
return (o instanceof Class ? (Class) o : o.getClass()).getClassLoader().loadClass("main");
} catch (Exception __e) {
throw rethrow(__e);
}
}
public static volatile boolean ping_pauseAll;
public static int ping_sleep = 100;
public static volatile boolean ping_anyActions;
public static Map<Thread, Object> ping_actions = newWeakHashMap();
public static ThreadLocal<Boolean> ping_isCleanUpThread = new ThreadLocal();
public static boolean ping() {
if (ping_pauseAll || ping_anyActions)
ping_impl(true);
return true;
}
public static boolean ping_impl(boolean okInCleanUp) {
try {
if (ping_pauseAll && !isAWTThread()) {
do Thread.sleep(ping_sleep); while (ping_pauseAll);
return true;
}
if (ping_anyActions) {
if (!okInCleanUp && !isTrue(ping_isCleanUpThread.get()))
failIfUnlicensed();
Object action = null;
synchronized (ping_actions) {
if (!ping_actions.isEmpty()) {
action = ping_actions.get(currentThread());
if (action instanceof Runnable)
ping_actions.remove(currentThread());
if (ping_actions.isEmpty())
ping_anyActions = false;
}
}
if (action instanceof Runnable)
((Runnable) action).run();
else if (eq(action, "cancelled"))
throw fail("Thread cancelled.");
}
return false;
} catch (Exception __e) {
throw rethrow(__e);
}
}
public static TreeSet<String> toCaseInsensitiveSet(Iterable<String> c) {
if (isCISet(c))
return (TreeSet) c;
TreeSet<String> set = caseInsensitiveSet();
addAll(set, c);
return set;
}
public static TreeSet<String> toCaseInsensitiveSet(String... x) {
TreeSet<String> set = caseInsensitiveSet();
addAll(set, x);
return set;
}
public static List<String> toLinesFullTrim(String s) {
List<String> l = new ArrayList();
for (String line : toLines(s)) if (nempty(line = trim(line)))
l.add(line);
return l;
}
public static List<String> toLinesFullTrim(File f) {
List<String> l = new ArrayList();
for (String line : linesFromFile(f)) if (nempty(line = trim(line)))
l.add(line);
return l;
}
public static Map<String, List<String>> javaTokNPunctuation_cached_cache = synchronizedMRUCache(defaultTokenizerCacheSize());
public static List<String> javaTokNPunctuation_cached(String s) {
List<String> tok = javaTokNPunctuation_cached_cache.get(s);
if (tok == null)
javaTokNPunctuation_cached_cache.put(s, tok = javaTokNPunctuation(s));
return tok;
}
public static String javaTok_substringC(String s, int i, int j) {
return s.substring(i, j);
}
public static String str(Object o) {
return o == null ? "null" : o.toString();
}
public static String str(char[] c) {
return new String(c);
}
public static Object first(Object list) {
return first((Iterable) list);
}
public static <A> A first(List<A> list) {
return empty(list) ? null : list.get(0);
}
public static <A> A first(A[] bla) {
return bla == null || bla.length == 0 ? null : bla[0];
}
public static <A> A first(IterableIterator<A> i) {
return first((Iterator<A>) i);
}
public static <A> A first(Iterator<A> i) {
return i == null || !i.hasNext() ? null : i.next();
}
public static <A> A first(Iterable<A> i) {
if (i == null)
return null;
Iterator<A> it = i.iterator();
return it.hasNext() ? it.next() : null;
}
public static Character first(String s) {
return empty(s) ? null : s.charAt(0);
}
public static <A, B> A first(Pair<A, B> p) {
return p == null ? null : p.a;
}
public static int javaTok_n, javaTok_elements;
public static boolean javaTok_opt;
public static List<String> javaTok(String s) {
++javaTok_n;
ArrayList<String> tok = new ArrayList();
int l = s == null ? 0 : s.length();
int i = 0, n = 0;
while (i < l) {
int j = i;
char c, d;
while (j < l) {
c = s.charAt(j);
d = j + 1 >= l ? '\0' : s.charAt(j + 1);
if (c == ' ' || c == '\t' || c == '\r' || c == '\n')
++j;
else if (c == '/' && d == '*') {
do ++j; while (j < l && !s.substring(j, Math.min(j + 2, l)).equals("*/"));
j = Math.min(j + 2, l);
} else if (c == '/' && d == '/') {
do ++j; while (j < l && "\r\n".indexOf(s.charAt(j)) < 0);
} else
break;
}
tok.add(javaTok_substringN(s, i, j));
++n;
i = j;
if (i >= l)
break;
c = s.charAt(i);
d = i + 1 >= l ? '\0' : s.charAt(i + 1);
if (c == '\'' && Character.isJavaIdentifierStart(d) && i + 2 < l && "'\\".indexOf(s.charAt(i + 2)) < 0) {
j += 2;
while (j < l && Character.isJavaIdentifierPart(s.charAt(j))) ++j;
} else if (c == '\'' || c == '"') {
char opener = c;
++j;
while (j < l) {
int c2 = s.charAt(j);
if (c2 == opener || c2 == '\n' && opener == '\'') {
++j;
break;
} else if (c2 == '\\' && 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));
else if (Character.isDigit(c)) {
do ++j; while (j < l && Character.isDigit(s.charAt(j)));
if (j < l && s.charAt(j) == 'L')
++j;
} else if (c == '[' && d == '[') {
do ++j; while (j + 1 < l && !s.substring(j, j + 2).equals("]]"));
j = Math.min(j + 2, l);
} else if (c == '[' && d == '=' && 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;
tok.add(javaTok_substringC(s, i, j));
++n;
i = j;
}
if ((tok.size() % 2) == 0)
tok.add("");
javaTok_elements += tok.size();
return tok;
}
public static List<String> javaTok(List<String> tok) {
return javaTokWithExisting(join(tok), tok);
}
public static ArrayList emptyList() {
return new ArrayList();
}
public static ArrayList emptyList(int capacity) {
return new ArrayList(max(0, capacity));
}
public static ArrayList emptyList(Iterable l) {
return l instanceof Collection ? emptyList(((Collection) l).size()) : emptyList();
}
public static ArrayList emptyList(Object[] l) {
return emptyList(l(l));
}
public static <A> ArrayList<A> emptyList(Class<A> c) {
return new ArrayList();
}
public static boolean odd(int i) {
return (i & 1) != 0;
}
public static boolean odd(long i) {
return (i & 1) != 0;
}
public static boolean odd(BigInteger i) {
return odd(toInt(i));
}
public static <A> A lookupOrKeep(Map<A, A> map, A key) {
return map != null && map.containsKey(key) ? map.get(key) : key;
}
public static <A> ArrayList<A> cloneList(Iterable<A> l) {
return l instanceof Collection ? cloneList((Collection) l) : asList(l);
}
public static <A> ArrayList<A> cloneList(Collection<A> l) {
if (l == null)
return new ArrayList();
synchronized (collectionMutex(l)) {
return new ArrayList<A>(l);
}
}
public static List<String> nlTok(String s) {
return javaTokPlusPeriod(s);
}
public static List<String> replaceSubList(List<String> l, List<String> x, List<String> y) {
return replaceSublist(l, x, y);
}
public static <A> List<A> replaceSubList(List<A> l, int fromIndex, int toIndex, List<A> y) {
return replaceSublist(l, fromIndex, toIndex, y);
}
public static String joinSubList(List<String> l, int i, int j) {
return join(subList(l, i, j));
}
public static String joinSubList(List<String> l, int i) {
return join(subList(l, i));
}
public static <A> A optParam(ThreadLocal<A> tl, A defaultValue) {
return optPar(tl, defaultValue);
}
public static <A> A optParam(ThreadLocal<A> tl) {
return optPar(tl);
}
public static Object optParam(String name, Map params) {
return mapGet(params, name);
}
public static <A> A optParam(Object[] opt, String name, A defaultValue) {
int n = l(opt);
if (n == 1 && opt[0] instanceof Map) {
Map map = (Map) (opt[0]);
return map.containsKey(name) ? (A) map.get(name) : defaultValue;
}
if (!even(l(opt)))
throw fail("Odd parameter length");
for (int i = 0; i < l(opt); i += 2) if (eq(opt[i], name))
return (A) opt[i + 1];
return defaultValue;
}
public static Object optParam(Object[] opt, String name) {
return optParam(opt, name, null);
}
public static Object pcallF(Object f, Object... args) {
return pcallFunction(f, args);
}
public static <A> A pcallF(F0<A> f) {
try {
return f == null ? null : f.get();
} catch (Throwable __e) {
return null;
}
}
public static <A, B> B pcallF(F1<A, B> f, A a) {
try {
return f == null ? null : f.get(a);
} catch (Throwable __e) {
return null;
}
}
public static boolean isCurlyBraced(String s) {
List<String> tok = tok_combineCurlyBrackets_keep(javaTok(s));
return l(tok) == 3 && startsWithAndEndsWith(tok.get(1), "{", "}");
}
public static String curlyBrace(String s) {
return "{" + s + "}";
}
public static TreeSet<String> ciSet() {
return caseInsensitiveSet();
}
public static List<String> stringsOnly(Iterable it) {
List<String> out = new ArrayList();
for (Object o : unnull(it)) if (o instanceof String)
out.add(((String) o));
return out;
}
public static List getEmits(Runnable r) {
List l = new ArrayList();
AutoCloseable __10 = tempSetThreadLocal(emit_tl, l);
try {
AutoCloseable __11 = tempSetMCOpt("emit_print", false);
try {
callF(r);
return l;
} finally {
_close(__11);
}
} finally {
_close(__10);
}
}
public static Set<String> linkedCISet() {
return new LinkedTreeSet(ciSet());
}
public static Object collectionMutex(Object o) {
String c = className(o);
if (eq(c, "java.util.TreeMap$KeySet"))
c = className(o = getOpt(o, "m"));
else if (eq(c, "java.util.HashMap$KeySet"))
c = className(o = get_raw(o, "this$0"));
if (eqOneOf(c, "java.util.TreeMap$AscendingSubMap", "java.util.TreeMap$DescendingSubMap"))
c = className(o = get_raw(o, "m"));
return o;
}
public static <A, B extends A> void addAll(Collection<A> c, Iterable<B> b) {
if (c != null && b != null)
for (A a : b) c.add(a);
}
public static <A, B extends A> boolean addAll(Collection<A> c, Collection<B> b) {
return c != null && b != null && c.addAll(b);
}
public static <A, B extends A> boolean addAll(Collection<A> c, B... b) {
return c != null && c.addAll(Arrays.asList(b));
}
public static <A, B> Map<A, B> addAll(Map<A, B> a, Map<? extends A, ? extends B> b) {
if (a != null)
a.putAll(b);
return a;
}
public static Map emptyMap() {
return new HashMap();
}
public static <A> void exhaustIterator(Iterator<A> it) {
if (it != null)
while (it.hasNext()) it.next();
}
public static <A> IterableIterator<A> repeatFunctionReturningList_iterator(Object f, A input, Object... __) {
final Set<A> seen = optParOr("seen", __, () -> (Set) new HashSet());
seen.add(input);
final Integer max = (Integer) (optPar("max", __));
final LinkedList<Iterator<A>> pool = new LinkedList();
pool.add(iterator((Iterable<A>) callF(f, input)));
return iteratorFromFunction(new F0<A>() {
public int n = 0;
public A get() {
if (max != null && n >= max)
return null;
while (!empty(pool)) {
ping();
Iterator<A> it = first(pool);
if (!it.hasNext()) {
removeFirst(pool);
continue;
}
A entry = it.next();
if (!seen.add(entry))
continue;
Collection<A> newStuff = (Collection<A>) (callF(f, entry));
if (nempty(newStuff))
pool.add(iterator(newStuff));
++n;
return entry;
}
return null;
}
});
}
public static Object[] paramsPlus(Object[] a1, Object... a2) {
if (a2 == null)
return a1;
if (a1 == null)
return a2;
if (l(a1) == 1 && a1[0] instanceof Map)
return new Object[] { mapPlus((Map) a1[0], a2) };
assertEvenLength(a1);
assertEvenLength(a2);
Map map = paramsToOrderedMap(a1);
int n = l(a2);
for (int i = 0; i < n; i += 2) {
Object key = a2[i];
if (key != null)
map.put(key, a2[i + 1]);
}
return mapToParams(map);
}
public static Runnable _topLevelErrorHandling(final Runnable runnable) {
final Object info = _threadInfo();
return new Runnable() {
public void run() {
try {
try {
_threadInheritInfo(info);
runnable.run();
} catch (Throwable __e) {
_handleException(__e);
}
} catch (Exception __e) {
throw rethrow(__e);
}
}
public String toString() {
return "pcall {\r\n _threadInheritInfo(info);\r\n runnable.run();\r\n }";
}
};
}
public static <A> WeakReference<A> weakRef(A a) {
return newWeakReference(a);
}
public static String dropSuffix(String suffix, String s) {
return s.endsWith(suffix) ? s.substring(0, l(s) - l(suffix)) : s;
}
public static String repeat(char c, int n) {
n = Math.max(n, 0);
char[] chars = new char[n];
for (int i = 0; i < n; i++) chars[i] = c;
return new String(chars);
}
public static <A> List<A> repeat(A a, int n) {
n = Math.max(n, 0);
List<A> l = new ArrayList(n);
for (int i = 0; i < n; i++) l.add(a);
return l;
}
public static <A> List<A> repeat(int n, A a) {
return repeat(a, n);
}
public static int indent_default = 2;
public static String indent(int indent) {
return repeat(' ', indent);
}
public static String indent(int indent, String s) {
return indent(repeat(' ', indent), s);
}
public static String indent(String indent, String s) {
return indent + s.replace("\n", "\n" + indent);
}
public static String indent(String s) {
return indent(indent_default, s);
}
public static List<String> indent(String indent, List<String> lines) {
List<String> l = new ArrayList();
if (lines != null)
for (String s : lines) l.add(indent + s);
return l;
}
public static List<String> mapToLines(Map map) {
List<String> l = new ArrayList();
for (Object key : keys(map)) l.add(str(key) + " = " + str(map.get(key)));
return l;
}
public static String mapToLines(Map map, Object f) {
return lines(map(map, f));
}
public static String lines(Iterable lines) {
return fromLines(lines);
}
public static String lines(Object[] lines) {
return fromLines(asList(lines));
}
public static List<String> lines(String s) {
return toLines(s);
}
public static Map<String, String> mechMap(String listName) {
return mechMapCI(listName);
}
public static Map mapValues(Object func, Map map) {
Map m = similarEmptyMap(map);
for (Object key : keys(map)) m.put(key, callF(func, map.get(key)));
return m;
}
public static <A, B, C> Map<A, C> mapValues(Map<A, B> map, IF1<B, C> f) {
return mapValues(f, map);
}
public static Map mapValues(Map map, Object func) {
return mapValues(func, map);
}
public static List<String> replaceIC(List<String> l, String a, String b) {
List<String> l2 = new ArrayList();
for (int i = 0; i < l(l); i++) {
String s = l.get(i);
l2.add(eqic(s, a) ? b : s);
}
return l2;
}
public static String replaceIC(String s, String a, String b) {
return s.replaceAll("(?i)" + patternQuote(a), quoteReplacement(b));
}
public static boolean translateUsingWordTree_debug;
public static boolean translateUsingWordTree_printReplacements;
public static String translateUsingWordTree(String input, Map<String, Object> tree) {
return join(translateUsingWordTree(javaTok(input), tree));
}
public static List<String> translateUsingWordTree(List<String> tok, Map<String, Object> tree) {
for (int i = 1; i < l(tok); ) i = translateUsingWordTree_scanFrom(tok, i, tree);
return tok;
}
public static int translateUsingWordTree_scanFrom(List<String> tok, int i, Map<String, Object> tree) {
int j = i;
String best = null;
int bestIndex = 0;
while (true) {
if (j > i) {
String def = (String) (tree.get("<default>"));
if (def != null) {
best = def;
bestIndex = j;
}
}
if (j >= l(tok))
break;
Object t = tree.get(tok.get(j));
if (translateUsingWordTree_debug)
print(i + "-" + j + " / " + joinSubList(tok, i, j + 1) + " => " + sfu(t));
if (t == null)
break;
if (t instanceof String) {
int k = j + 2;
if (translateUsingWordTree_printReplacements)
print("translateUsingWordTree: replacing " + sfu(subList(tok, i, k - 1) + " with " + quote(t)));
replaceTokens(tok, i, k - 1, (String) t);
return k;
}
tree = (Map) t;
j += 2;
}
if (best != null) {
int k = bestIndex;
replaceTokens(tok, i, k - 1, best);
return k;
}
return i + 2;
}
public static Map<String, Object> mapToWordTree(Map<String, String> map) {
Map<String, Object> tree = ciMap();
{
final Map<String, String> __94 = unnull(map);
for (String key : keys(__94)) {
String value = __94.get(key);
wordTreeAdd(tree, javaTokC(key), value);
}
}
return simplifyWordTree(tree);
}
public static Map<String, String> mechMapInOrder(String listName) {
return parseDoubleArrowLinkedHashMap(mechList(listName));
}
public static <A> Map<String, A> reverseCIMap_noOverwrite(Map<A, String> map) {
Map<String, A> rmap = ciMap();
for (A key : keys(map)) putIfNotThere(rmap, map.get(key), key);
return rmap;
}
public static Throwable getExceptionCause(Throwable e) {
Throwable c = e.getCause();
return c != null ? c : e;
}
public static String joinWithSpace(Collection<String> c) {
return join(" ", c);
}
public static String joinWithSpace(String... c) {
return join(" ", c);
}
public static boolean methodIsStatic(Method m) {
return (m.getModifiers() & Modifier.STATIC) != 0;
}
public static boolean argumentCompatibleWithType(Object arg, Class type) {
return arg == null ? !type.isPrimitive() : isInstanceX(type, arg);
}
public static void arraycopy(Object[] a, Object[] b) {
if (a != null && b != null)
arraycopy(a, 0, b, 0, min(a.length, b.length));
}
public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int n) {
if (n != 0)
System.arraycopy(src, srcPos, dest, destPos, n);
}
public static <A> A[] arrayOfType(Class<A> type, int n) {
return makeArray(type, n);
}
public static <A> A[] arrayOfType(int n, Class<A> type) {
return arrayOfType(type, n);
}
public static List<String> getClassNames(Collection l) {
List<String> out = new ArrayList();
if (l != null)
for (Object o : l) out.add(o == null ? null : getClassName(o));
return out;
}
public static boolean empty(Collection c) {
return c == null || c.isEmpty();
}
public static boolean empty(CharSequence s) {
return s == null || s.length() == 0;
}
public static boolean empty(Map map) {
return map == null || map.isEmpty();
}
public static boolean empty(Object[] o) {
return o == null || o.length == 0;
}
public 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);
if (o instanceof Object[])
return empty((Object[]) o);
if (o instanceof byte[])
return empty((byte[]) o);
if (o == null)
return true;
throw fail("unknown type for 'empty': " + getType(o));
}
public static boolean empty(float[] a) {
return a == null || a.length == 0;
}
public static boolean empty(int[] a) {
return a == null || a.length == 0;
}
public static boolean empty(long[] a) {
return a == null || a.length == 0;
}
public static boolean empty(byte[] a) {
return a == null || a.length == 0;
}
public static boolean empty(File f) {
return getFileSize(f) == 0;
}
public static boolean isSnippetID(String s) {
try {
parseSnippetID(s);
return true;
} catch (RuntimeException e) {
return false;
}
}
public static long parseSnippetID(String snippetID) {
long id = Long.parseLong(shortenSnippetID(snippetID));
if (id == 0)
throw fail("0 is not a snippet ID");
return id;
}
public static boolean isAWTThread() {
if (isAndroid())
return false;
if (isHeadless())
return false;
return isAWTThread_awt();
}
public static boolean isAWTThread_awt() {
return SwingUtilities.isEventDispatchThread();
}
public static void failIfUnlicensed() {
assertTrue("license off", licensed());
}
public static Thread currentThread() {
return Thread.currentThread();
}
public static boolean isCISet(Iterable<String> l) {
return l instanceof TreeSet && ((TreeSet) l).comparator() == caseInsensitiveComparator();
}
public static TreeSet<String> caseInsensitiveSet() {
return caseInsensitiveSet_treeSet();
}
public static TreeSet<String> caseInsensitiveSet(Collection<String> c) {
return caseInsensitiveSet_treeSet(c);
}
public static IterableIterator<String> toLines(File f) {
return linesFromFile(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;
}
public 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;
}
public static String trim(String s) {
return s == null ? null : s.trim();
}
public static String trim(StringBuilder buf) {
return buf.toString().trim();
}
public static String trim(StringBuffer buf) {
return buf.toString().trim();
}
public static CloseableIterableIterator<String> linesFromFile(File f) {
try {
if (!f.exists())
return emptyCloseableIterableIterator();
if (ewic(f.getName(), ".gz"))
return linesFromReader(utf8bufferedReader(newGZIPInputStream(f)));
return linesFromReader(utf8bufferedReader(f));
} catch (Exception __e) {
throw rethrow(__e);
}
}
public static <A, B> Map<A, B> synchronizedMRUCache(int maxSize) {
return synchroMap(new MRUCache(maxSize));
}
public static int defaultTokenizerCacheSize() {
return 1000;
}
public static String javaTok_substringN(String s, int i, int j) {
if (i == j)
return "";
if (j == i + 1 && s.charAt(i) == ' ')
return " ";
return s.substring(i, j);
}
public static List<String> javaTokWithExisting(String s, List<String> existing) {
++javaTok_n;
int nExisting = javaTok_opt && existing != null ? existing.size() : 0;
ArrayList<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, d;
while (j < l) {
c = s.charAt(j);
d = j + 1 >= l ? '\0' : s.charAt(j + 1);
if (c == ' ' || c == '\t' || c == '\r' || c == '\n')
++j;
else if (c == '/' && d == '*') {
do ++j; while (j < l && !s.substring(j, Math.min(j + 2, l)).equals("*/"));
j = Math.min(j + 2, l);
} else if (c == '/' && d == '/') {
do ++j; while (j < l && "\r\n".indexOf(s.charAt(j)) < 0);
} else
break;
}
if (n < nExisting && javaTokWithExisting_isCopyable(existing.get(n), s, i, j))
tok.add(existing.get(n));
else
tok.add(javaTok_substringN(s, i, j));
++n;
i = j;
if (i >= l)
break;
c = s.charAt(i);
d = i + 1 >= l ? '\0' : s.charAt(i + 1);
if (c == '\'' && Character.isJavaIdentifierStart(d) && i + 2 < l && "'\\".indexOf(s.charAt(i + 2)) < 0) {
j += 2;
while (j < l && Character.isJavaIdentifierPart(s.charAt(j))) ++j;
} else if (c == '\'' || c == '"') {
char opener = c;
++j;
while (j < l) {
if (s.charAt(j) == opener) {
++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));
else if (Character.isDigit(c)) {
do ++j; while (j < l && Character.isDigit(s.charAt(j)));
if (j < l && s.charAt(j) == 'L')
++j;
} else if (c == '[' && d == '[') {
do ++j; while (j + 1 < l && !s.substring(j, j + 2).equals("]]"));
j = Math.min(j + 2, l);
} else if (c == '[' && d == '=' && 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 && javaTokWithExisting_isCopyable(existing.get(n), s, i, j))
tok.add(existing.get(n));
else
tok.add(javaTok_substringC(s, i, j));
++n;
i = j;
}
if ((tok.size() % 2) == 0)
tok.add("");
javaTok_elements += tok.size();
return tok;
}
public static boolean javaTokWithExisting_isCopyable(String t, String s, int i, int j) {
return t.length() == j - i && s.regionMatches(i, t, 0, j - i);
}
public static int max(int a, int b) {
return Math.max(a, b);
}
public static int max(int a, int b, int c) {
return max(max(a, b), c);
}
public static long max(int a, long b) {
return Math.max((long) a, b);
}
public static long max(long a, long b) {
return Math.max(a, b);
}
public static double max(int a, double b) {
return Math.max((double) a, b);
}
public static float max(float a, float b) {
return Math.max(a, b);
}
public static double max(double a, double b) {
return Math.max(a, b);
}
public static int max(Collection<Integer> c) {
int x = Integer.MIN_VALUE;
for (int i : c) x = max(x, i);
return x;
}
public 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;
}
public static float max(float[] c) {
if (c.length == 0)
return Float.MAX_VALUE;
float x = c[0];
for (int i = 1; i < c.length; i++) x = Math.max(x, c[i]);
return x;
}
public static byte max(byte[] c) {
byte x = -128;
for (byte d : c) if (d > x)
x = d;
return x;
}
public static short max(short[] c) {
short x = -0x8000;
for (short d : c) if (d > x)
x = d;
return x;
}
public static int max(int[] c) {
int x = Integer.MIN_VALUE;
for (int d : c) if (d > x)
x = d;
return x;
}
public 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 int toInt(long l) {
if (l != (int) l)
throw fail("Too large for int: " + l);
return (int) l;
}
public 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;
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));
if (c == (char) 0x201C || c == (char) 0x201D)
c = '"';
if (c == '\'' || c == '"') {
char opener = c;
++j;
while (j < l) {
char _c = s.charAt(j);
if (_c == (char) 0x201C || _c == (char) 0x201D)
_c = '"';
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) == '\''));
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;
}
public static <A> List<A> replaceSublist(List<A> l, List<A> x, List<A> y) {
if (x == null)
return l;
int i = 0;
while (true) {
i = indexOfSubList(l, x, i);
if (i < 0)
break;
removeSubList(l, i, i + l(x));
l.addAll(i, y);
i += l(y);
}
return l;
}
public static <A> List<A> replaceSublist(List<A> l, int fromIndex, int toIndex, List<A> y) {
removeSubList(l, fromIndex, toIndex);
l.addAll(fromIndex, y);
return l;
}
public static <A> List<A> subList(List<A> l, int startIndex) {
return subList(l, startIndex, l(l));
}
public static <A> List<A> subList(List<A> l, int startIndex, int endIndex) {
if (l == null)
return null;
int n = l(l);
startIndex = Math.max(0, startIndex);
endIndex = Math.min(n, endIndex);
if (startIndex >= endIndex)
return ll();
if (startIndex == 0 && endIndex == n)
return l;
return l.subList(startIndex, endIndex);
}
public static <A, B> B mapGet(Map<A, B> map, A a) {
return map == null || a == null ? null : map.get(a);
}
public static <A, B> B mapGet(A a, Map<A, B> map) {
return map == null || a == null ? null : map.get(a);
}
public static boolean even(int i) {
return (i & 1) == 0;
}
public static boolean even(long i) {
return (i & 1) == 0;
}
public static Object pcallFunction(Object f, Object... args) {
try {
return callFunction(f, args);
} catch (Throwable __e) {
_handleException(__e);
}
return null;
}
public static List<String> tok_combineCurlyBrackets_keep(List<String> tok) {
List<String> l = new ArrayList();
for (int i = 0; i < l(tok); i++) {
String t = tok.get(i);
if (odd(i) && eq(t, "{")) {
int j = findEndOfCurlyBracketPart(tok, i);
l.add(joinSubList(tok, i, j));
i = j - 1;
} else
l.add(t);
}
return l;
}
public static boolean startsWithAndEndsWith(String s, String prefix, String suffix) {
return startsWith(s, prefix) && endsWith(s, suffix);
}
public static <A> AutoCloseable tempSetThreadLocal(final ThreadLocal<A> tl, A a) {
if (tl == null)
return null;
final A prev = setThreadLocal(tl, a);
return new AutoCloseable() {
public String toString() {
return "tl.set(prev);";
}
public void close() throws Exception {
tl.set(prev);
}
};
}
public static AutoCloseable tempSetMCOpt(final String field, Object value) {
final Object oldValue = getMCOpt(field);
setMCOpt(field, value);
return new AutoCloseable() {
public String toString() {
return "setMCOpt(field, oldValue);";
}
public void close() throws Exception {
setMCOpt(field, oldValue);
}
};
}
public static void _close(AutoCloseable c) {
if (c != null)
try {
c.close();
} catch (Throwable e) {
if (c instanceof javax.imageio.stream.ImageOutputStream)
return;
else
throw rethrow(e);
}
}
public static String className(Object o) {
return getClassName(o);
}
public static boolean eqOneOf(Object o, Object... l) {
for (Object x : l) if (eq(o, x))
return true;
return false;
}
public static <A> A optParOr(String name, Object[] opt, IF0<A> defaultFunction) {
int n = l(opt);
if (n == 1 && opt[0] instanceof Map) {
Map map = (Map) (opt[0]);
return map.containsKey(name) ? (A) map.get(name) : callF(defaultFunction);
}
if (!even(l(opt)))
throw fail("Odd parameter length");
for (int i = 0; i < l(opt); i += 2) if (eq(opt[i], name))
return (A) opt[i + 1];
return callF(defaultFunction);
}
public static <A> Iterator<A> iterator(Iterable<A> c) {
return c == null ? emptyIterator() : c.iterator();
}
public static <A> IterableIterator<A> iteratorFromFunction(final Object f) {
class IFF extends IterableIterator<A> {
public A a;
public boolean done;
public boolean hasNext() {
getNext();
return !done;
}
public A next() {
getNext();
if (done)
throw fail();
A _a = a;
a = null;
return _a;
}
public void getNext() {
if (done || a != null)
return;
a = (A) callF(f);
done = a == null;
}
}
;
return new IFF();
}
public static <A> IterableIterator<A> iteratorFromFunction(final F0<A> f) {
return iteratorFromFunction_f0(f);
}
public static void removeFirst(List l) {
if (nempty(l))
l.remove(0);
}
public static <A, B> Map<A, B> mapPlus(Map<A, B> m, Object... data) {
m = cloneMap(m);
litmap_impl(m, data);
return m;
}
public static Object[] assertEvenLength(Object[] a) {
assertTrue(even(l(a)));
return a;
}
public static LinkedHashMap paramsToOrderedMap(Object... params) {
return asLinkedHashMap(paramsToMap(params));
}
public static Object[] mapToParams(Map map) {
return mapToObjectArray(map);
}
public static volatile PersistableThrowable _handleException_lastException;
public static List _handleException_onException = synchroList(ll("printStackTrace2"));
public static void _handleException(Throwable e) {
_handleException_lastException = persistableThrowable(e);
Throwable e2 = innerException(e);
if (e2.getClass() == RuntimeException.class && eq(e2.getMessage(), "Thread cancelled.") || e2 instanceof InterruptedException)
return;
for (Object f : cloneList(_handleException_onException)) try {
callF(f, e);
} catch (Throwable e3) {
printStackTrace2(e3);
}
}
public static <A> WeakReference<A> newWeakReference(A a) {
return a == null ? null : new WeakReference(a);
}
public static <A, B> Set<A> keys(Map<A, B> map) {
return map == null ? new HashSet() : map.keySet();
}
public static Set keys(Object map) {
return keys((Map) map);
}
public static <A, B> Set<A> keys(MultiMap<A, B> mm) {
return mm.keySet();
}
public static String fromLines(Iterable lines) {
StringBuilder buf = new StringBuilder();
if (lines != null)
for (Object line : lines) buf.append(str(line)).append('\n');
return buf.toString();
}
public static String fromLines(String... lines) {
return fromLines(asList(lines));
}
public static Map<String, Pair<String, Map<String, String>>> mechMapCI_cache = synchroMap();
public static Map<String, String> mechMapCI(String listName) {
Pair<String, Map<String, String>> p = mechMapCI_cache.get(listName);
String text = mechList_raw(listName);
if (p != null && eq(p.a, text))
return p.b;
String parsing = first(mechList_opt(listName + " | Parsing"));
Map<String, String> map;
if (parsing == null)
map = parseDoubleArrowMapCI(tlft(text));
else
map = asCIMap((Map<String, String>) callAndMake(parsing, text));
p = pair(text, map);
mechMapCI_cache.put(listName, p);
return p.b;
}
public static Map similarEmptyMap(Map m) {
if (m instanceof TreeMap)
return new TreeMap(((TreeMap) m).comparator());
if (m instanceof LinkedHashMap)
return new LinkedHashMap();
return new HashMap();
}
public static boolean eqic(String a, String b) {
if ((a == null) != (b == null))
return false;
if (a == null)
return true;
return a.equalsIgnoreCase(b);
}
public static boolean eqic(char a, char b) {
if (a == b)
return true;
char u1 = Character.toUpperCase(a);
char u2 = Character.toUpperCase(b);
if (u1 == u2)
return true;
return Character.toLowerCase(u1) == Character.toLowerCase(u2);
}
public static String patternQuote(String s) {
return s.length() == 0 ? "" : Pattern.quote(s);
}
public static String quoteReplacement(String s) {
return Matcher.quoteReplacement(s);
}
public static String sfu(Object o) {
return structureForUser(o);
}
public static String quote(Object o) {
if (o == null)
return "null";
return quote(str(o));
}
public static String quote(String s) {
if (s == null)
return "null";
StringBuilder out = new StringBuilder((int) (l(s) * 1.5 + 2));
quote_impl(s, out);
return out.toString();
}
public static void quote_impl(String s, StringBuilder out) {
out.append('"');
int l = s.length();
for (int i = 0; i < l; i++) {
char c = s.charAt(i);
if (c == '\\' || c == '"')
out.append('\\').append(c);
else if (c == '\r')
out.append("\\r");
else if (c == '\n')
out.append("\\n");
else if (c == '\0')
out.append("\\0");
else
out.append(c);
}
out.append('"');
}
public static void replaceTokens(List<String> tok, int i, int j, String s) {
clearAllTokens(subList(tok, i, j));
tok.set(i, s);
}
public static void replaceTokens(List<String> tok, String s) {
clearAllTokens(tok);
tok.set(0, s);
}
public static <A> TreeMap<String, A> ciMap() {
return caseInsensitiveMap();
}
public static void wordTreeAdd(Map<String, Object> tree, List<String> words, String value) {
for (String word : words) {
Object child = tree.get(word);
Map<String, Object> subTree;
if (child instanceof Map)
tree = (Map) child;
else {
tree.put(word, subTree = ciMap());
if (child != null)
subTree.put("<default>", child);
tree = subTree;
}
}
tree.put("<default>", value);
}
public static Map<String, Object> simplifyWordTree(Map<String, Object> tree) {
if (tree == null)
return null;
return (Map) simplifyWordTree_impl(tree, true);
}
public static Object simplifyWordTree_impl(Object tree, boolean keepAsMap) {
if (tree instanceof String)
return tree;
Map<String, Object> m = (Map<String, Object>) tree;
if (!keepAsMap && l(m) == 1 && eq(firstKey(m), "<default>"))
return (String) firstValue(m);
Map<String, Object> map = similarEmptyMap(m);
for (String key : keys(m)) {
Object value = m.get(key);
map.put(key, simplifyWordTree_impl(value, false));
}
return map;
}
public static Map<String, String> parseDoubleArrowLinkedHashMap(List<String> l) {
return parseDoubleArrowMap(new LinkedHashMap(), l);
}
public static Map<String, String> parseDoubleArrowLinkedHashMap(String s) {
return parseDoubleArrowLinkedHashMap(tlft(s));
}
public static List<String> mechList(String name) {
return mechList_tlft(name);
}
public static <A, B> void putIfNotThere(Map<A, B> map, A key, B value) {
if (map != null && key != null && value != null && !map.containsKey(key))
map.put(key, value);
}
public 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);
}
public static int min(int a, int b) {
return Math.min(a, b);
}
public static long min(long a, long b) {
return Math.min(a, b);
}
public static float min(float a, float b) {
return Math.min(a, b);
}
public static float min(float a, float b, float c) {
return min(min(a, b), c);
}
public static double min(double a, double b) {
return Math.min(a, b);
}
public static double min(double[] c) {
double x = Double.MAX_VALUE;
for (double d : c) x = Math.min(x, d);
return x;
}
public static float min(float[] c) {
float x = Float.MAX_VALUE;
for (float d : c) x = Math.min(x, d);
return x;
}
public static byte min(byte[] c) {
byte x = 127;
for (byte d : c) if (d < x)
x = d;
return x;
}
public static short min(short[] c) {
short x = 0x7FFF;
for (short d : c) if (d < x)
x = d;
return x;
}
public static int min(int[] c) {
int x = Integer.MAX_VALUE;
for (int d : c) if (d < x)
x = d;
return x;
}
public static <A> A[] makeArray(Class<A> type, int n) {
return (A[]) Array.newInstance(type, n);
}
public static String getClassName(Object o) {
return o == null ? "null" : o instanceof Class ? ((Class) o).getName() : o.getClass().getName();
}
public static Throwable printStackTrace2(Throwable e) {
print(getStackTrace2(e));
return e;
}
public static void printStackTrace2() {
printStackTrace2(new Throwable());
}
public static void printStackTrace2(String msg) {
printStackTrace2(new Throwable(msg));
}
public static Map<String, String> parseDoubleLeftArrowMapCI_tlft(String s) {
return parseDoubleLeftArrowMapCI(tlft(s));
}
public static String getType(Object o) {
return getClassName(o);
}
public static long getFileSize(String path) {
return path == null ? 0 : new File(path).length();
}
public static long getFileSize(File f) {
return f == null ? 0 : f.length();
}
public 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);
}
public static volatile boolean licensed_yes = true;
public static boolean licensed() {
if (!licensed_yes)
return false;
ping_okInCleanUp();
return true;
}
public static void licensed_off() {
licensed_yes = false;
}
public static Comparator<String> caseInsensitiveComparator() {
return betterCIComparator();
}
public static TreeSet<String> caseInsensitiveSet_treeSet() {
return new TreeSet(caseInsensitiveComparator());
}
public static TreeSet<String> caseInsensitiveSet_treeSet(Collection<String> c) {
return toCaseInsensitiveSet_treeSet(c);
}
public static CloseableIterableIterator emptyCloseableIterableIterator_instance = new CloseableIterableIterator() {
public Object next() {
throw fail();
}
public boolean hasNext() {
return false;
}
};
public static <A> CloseableIterableIterator<A> emptyCloseableIterableIterator() {
return emptyCloseableIterableIterator_instance;
}
public static boolean ewic(String a, String b) {
return endsWithIgnoreCase(a, b);
}
public static boolean ewic(String a, String b, Matches m) {
return endsWithIgnoreCase(a, b, m);
}
public static CloseableIterableIterator<String> linesFromReader(Reader r) {
final BufferedReader br = bufferedReader(r);
return iteratorFromFunction_f0_autoCloseable(new F0<String>() {
public String get() {
try {
return readLineFromReaderWithClose(br);
} catch (Exception __e) {
throw rethrow(__e);
}
}
public String toString() {
return "ret readLineFromReaderWithClose(br);";
}
}, _wrapIOCloseable(r));
}
public static BufferedReader utf8bufferedReader(InputStream in) {
try {
return bufferedReader(_registerIOWrap(new InputStreamReader(in, "UTF-8"), in));
} catch (Exception __e) {
throw rethrow(__e);
}
}
public static BufferedReader utf8bufferedReader(File f) {
try {
return utf8bufferedReader(newFileInputStream(f));
} catch (Exception __e) {
throw rethrow(__e);
}
}
public static GZIPInputStream newGZIPInputStream(File f) {
return gzInputStream(f);
}
public static GZIPInputStream newGZIPInputStream(InputStream in) {
return gzInputStream(in);
}
public static Map synchroMap() {
return synchroHashMap();
}
public static <A, B> Map<A, B> synchroMap(Map<A, B> map) {
return Collections.synchronizedMap(map);
}
public static int parseInt(String s) {
return empty(s) ? 0 : Integer.parseInt(s);
}
public static int parseInt(char c) {
return Integer.parseInt(str(c));
}
public static <A> int indexOfSubList(List<A> x, List<A> y) {
return indexOfSubList(x, y, 0);
}
public 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;
}
public static <A> int indexOfSubList(List<A> x, 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[j]))
continue outer;
return i;
}
return -1;
}
public static void removeSubList(List l, int from, int to) {
if (l != null)
subList(l, from, to).clear();
}
public static void removeSubList(List l, int from) {
if (l != null)
subList(l, from).clear();
}
public static Object callFunction(Object f, Object... args) {
return callF(f, args);
}
public static int findEndOfCurlyBracketPart(List<String> cnc, int i) {
int j = i + 2, level = 1;
while (j < cnc.size()) {
if (eq(cnc.get(j), "{"))
++level;
else if (eq(cnc.get(j), "}"))
--level;
if (level == 0)
return j + 1;
++j;
}
return cnc.size();
}
public static boolean endsWith(String a, String b) {
return a != null && a.endsWith(b);
}
public static boolean endsWith(String a, char c) {
return nempty(a) && lastChar(a) == c;
}
public static boolean endsWith(String a, String b, Matches m) {
if (!endsWith(a, b))
return false;
m.m = new String[] { dropLast(l(b), a) };
return true;
}
public static <A> A setThreadLocal(ThreadLocal<A> tl, A value) {
if (tl == null)
return null;
A old = tl.get();
tl.set(value);
return old;
}
public static Object getMCOpt(String field) {
return getOptMC(field);
}
public static void setMCOpt(String field, Object value) {
setOptMC(field, value);
}
public static Iterator emptyIterator() {
return Collections.emptyIterator();
}
public static <A> IterableIterator<A> iteratorFromFunction_f0(final F0<A> f) {
class IFF2 extends IterableIterator<A> {
public A a;
public boolean done;
public boolean hasNext() {
getNext();
return !done;
}
public A next() {
getNext();
if (done)
throw fail();
A _a = a;
a = null;
return _a;
}
public void getNext() {
if (done || a != null)
return;
a = f.get();
done = a == null;
}
}
;
return new IFF2();
}
public static <A, B> Map<A, B> cloneMap(Map<A, B> map) {
if (map == null)
return new HashMap();
synchronized (map) {
return map instanceof TreeMap ? new TreeMap((TreeMap) map) : map instanceof LinkedHashMap ? new LinkedHashMap(map) : new HashMap(map);
}
}
public static HashMap litmap(Object... x) {
HashMap map = new HashMap();
litmap_impl(map, x);
return map;
}
public 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]);
}
public static <A, B> LinkedHashMap<A, B> asLinkedHashMap(Map<A, B> map) {
if (map instanceof LinkedHashMap)
return (LinkedHashMap) map;
LinkedHashMap<A, B> m = new LinkedHashMap();
if (map != null)
synchronized (collectionMutex(map)) {
m.putAll(map);
}
return m;
}
public static Map paramsToMap(Object... params) {
int n = l(params);
if (l(params) == 1 && params[0] instanceof Map)
return (Map) params[0];
LinkedHashMap map = new LinkedHashMap();
for (int i = 0; i + 1 < n; i += 2) mapPut(map, params[i], params[i + 1]);
return map;
}
public static Object[] mapToObjectArray(Map map) {
List l = new ArrayList();
for (Object o : keys(map)) {
l.add(o);
l.add(map.get(o));
}
return toObjectArray(l);
}
public static <A> List<A> synchroList() {
return Collections.synchronizedList(new ArrayList<A>());
}
public static <A> List<A> synchroList(List<A> l) {
return Collections.synchronizedList(l);
}
public static PersistableThrowable persistableThrowable(Throwable e) {
return e == null ? null : new PersistableThrowable(e);
}
public static Throwable innerException(Throwable e) {
return getInnerException(e);
}
public static ExpiringMap2<String, String> mechList_raw_cache = new ExpiringMap2(10000).setMap(ciMap());
public static Lock mechList_raw_lock = lock();
public static int mechList_raw_timeout = 60000;
public static String mechList_raw(String name) {
try {
Lock __268 = mechList_raw_lock;
lock(__268);
try {
if (empty(name))
return "";
String src = mechList_raw_cache.get(name);
if (src != null)
return src;
src = mechList_raw_fresh(name);
if (src != null)
mechList_raw_cache.put(name, src);
return src;
} finally {
unlock(__268);
}
} catch (Exception __e) {
throw rethrow(__e);
}
}
public static VF2<String, Object> mechList_raw_listener = new VF2<String, Object>() {
public void get(String msg, Object arg) {
try {
if (eq(msg, "mechChange") && arg instanceof String) {
mechList_raw_cache.remove((String) arg);
}
} catch (Exception __e) {
throw rethrow(__e);
}
}
public String toString() {
return "if (eq(msg, 'mechChange) && arg instanceof S) {\r\n //print(\"Got change noti...";
}
};
public static void _onLoad_mechList_raw() {
add(vm_busListeners_live(), mechList_raw_listener);
}
public static void cleanMeUp_mechList_raw() {
remove(vm_busListeners_live(), mechList_raw_listener);
}
public static List<String> mechList_opt(String name) {
return mechList_opt_tlft(name);
}
public static Map<String, String> parseDoubleArrowMapCI(List<String> l) {
return parseDoubleArrowMap((Map) ciMap(), l);
}
public static <B> TreeMap<String, B> asCIMap(Map<String, B> map) {
return asCaseInsensitiveMap(map);
}
public static Object callAndMake(String functionName, Object... args) {
return callAndMake_orDirect(functionName, args);
}
public static <A, B> Pair<A, B> pair(A a, B b) {
return new Pair(a, b);
}
public static <A> Pair<A, A> pair(A a) {
return new Pair(a, a);
}
public static String asString(Object o) {
return o == null ? null : o.toString();
}
public static String structureForUser(Object o) {
return beautifyStructure(struct_noStringSharing(o));
}
public static void clearAllTokens(List<String> tok) {
for (int i = 0; i < tok.size(); i++) tok.set(i, "");
}
public static void clearAllTokens(List<String> tok, int i, int j) {
for (; i < j; i++) tok.set(i, "");
}
public static <A> TreeMap<String, A> caseInsensitiveMap() {
return new TreeMap(caseInsensitiveComparator());
}
public static <A, B> A firstKey(Map<A, B> map) {
return first(keys(map));
}
public static <A, B> B firstValue(Map<A, B> map) {
return first(values(map));
}
public static Map<String, String> parseDoubleArrowMap(Map<String, String> map, List<String> l) {
for (String s : l) {
List<String> x = splitAtDoubleArrow_bothDirections(s);
if (l(x) == 2)
map.put(first(x), second(x));
}
return map;
}
public static List<String> mechList_tlft(String name) {
return tlft(mechList_raw(name));
}
public static String getStackTrace2(Throwable e) {
return hideCredentials(getStackTrace(unwrapTrivialExceptionWraps(e)) + replacePrefix("java.lang.RuntimeException: ", "FAIL: ", hideCredentials(str(innerException2(e)))) + "\n");
}
public static Map<String, String> parseDoubleLeftArrowMapCI(List<String> l) {
return parseDoubleLeftArrowMap((Map) ciMap(), l);
}
public static long parseLong(String s) {
if (s == null)
return 0;
return Long.parseLong(dropSuffix("L", s));
}
public static long parseLong(Object s) {
return Long.parseLong((String) s);
}
public static betterCIComparator_C betterCIComparator_instance;
public static betterCIComparator_C betterCIComparator() {
if (betterCIComparator_instance == null)
betterCIComparator_instance = new betterCIComparator_C();
return betterCIComparator_instance;
}
public static class betterCIComparator_C implements Comparator<String> {
public int compare(String s1, String s2) {
if (s1 == null)
return s2 == null ? 0 : -1;
if (s2 == null)
return 1;
int n1 = s1.length();
int n2 = s2.length();
int min = Math.min(n1, n2);
for (int i = 0; i < min; i++) {
char c1 = s1.charAt(i);
char c2 = s2.charAt(i);
if (c1 != c2) {
c1 = Character.toUpperCase(c1);
c2 = Character.toUpperCase(c2);
if (c1 != c2) {
c1 = Character.toLowerCase(c1);
c2 = Character.toLowerCase(c2);
if (c1 != c2) {
return c1 - c2;
}
}
}
}
return n1 - n2;
}
}
public static TreeSet<String> toCaseInsensitiveSet_treeSet(Iterable<String> c) {
if (isCISet(c))
return (TreeSet) c;
TreeSet<String> set = caseInsensitiveSet_treeSet();
addAll(set, c);
return set;
}
public static TreeSet<String> toCaseInsensitiveSet_treeSet(String... x) {
TreeSet<String> set = caseInsensitiveSet_treeSet();
addAll(set, x);
return set;
}
public static boolean endsWithIgnoreCase(String a, String b) {
int la = l(a), lb = l(b);
return la >= lb && regionMatchesIC(a, la - lb, b, 0, lb);
}
public static boolean endsWithIgnoreCase(String a, String b, Matches m) {
if (!endsWithIgnoreCase(a, b))
return false;
m.m = new String[] { substring(a, 0, l(a) - l(b)) };
return true;
}
public static BufferedReader bufferedReader(Reader r) {
return r instanceof BufferedReader ? (BufferedReader) r : _registerIOWrap(new BufferedReader(r), r);
}
public static <A> CloseableIterableIterator<A> iteratorFromFunction_f0_autoCloseable(final F0<A> f, final AutoCloseable closeable) {
class IFF2 extends CloseableIterableIterator<A> {
public A a;
public boolean done;
public boolean hasNext() {
getNext();
return !done;
}
public A next() {
getNext();
if (done)
throw fail();
A _a = a;
a = null;
return _a;
}
public void getNext() {
if (done || a != null)
return;
a = f.get();
done = a == null;
}
public void close() throws Exception {
if (closeable != null)
closeable.close();
}
}
;
return new IFF2();
}
public static String readLineFromReaderWithClose(BufferedReader r) {
try {
String s = r.readLine();
if (s == null)
r.close();
return s;
} catch (Exception __e) {
throw rethrow(__e);
}
}
public static AutoCloseable _wrapIOCloseable(final AutoCloseable c) {
return c == null ? null : new AutoCloseable() {
public String toString() {
return "c.close();\r\n _registerIO(c, null, false);";
}
public void close() throws Exception {
c.close();
_registerIO(c, null, false);
}
};
}
public static <A> A _registerIOWrap(A wrapper, Object wrapped) {
return wrapper;
}
public static FileInputStream newFileInputStream(File path) throws IOException {
return newFileInputStream(path.getPath());
}
public static FileInputStream newFileInputStream(String path) throws IOException {
FileInputStream f = new FileInputStream(path);
_registerIO(f, path, true);
return f;
}
public static int gzInputStream_defaultBufferSize = 65536;
public static GZIPInputStream gzInputStream(File f) {
try {
return gzInputStream(new FileInputStream(f));
} catch (Exception __e) {
throw rethrow(__e);
}
}
public static GZIPInputStream gzInputStream(File f, int bufferSize) {
try {
return gzInputStream(new FileInputStream(f), bufferSize);
} catch (Exception __e) {
throw rethrow(__e);
}
}
public static GZIPInputStream gzInputStream(InputStream in) {
return gzInputStream(in, gzInputStream_defaultBufferSize);
}
public static GZIPInputStream gzInputStream(InputStream in, int bufferSize) {
try {
return _registerIOWrap(new GZIPInputStream(in, gzInputStream_defaultBufferSize), in);
} catch (Exception __e) {
throw rethrow(__e);
}
}
public static Map synchroHashMap() {
return Collections.synchronizedMap(new HashMap());
}
public static char lastChar(String s) {
return empty(s) ? '\0' : s.charAt(l(s) - 1);
}
public 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;
}
public static <A> List<A> dropLast(List<A> l) {
return subList(l, 0, l(l) - 1);
}
public static <A> List<A> dropLast(int n, List<A> l) {
return subList(l, 0, l(l) - n);
}
public static <A> List<A> dropLast(Iterable<A> l) {
return dropLast(asList(l));
}
public static String dropLast(String s) {
return substring(s, 0, l(s) - 1);
}
public static String dropLast(String s, int n) {
return substring(s, 0, l(s) - n);
}
public static String dropLast(int n, String s) {
return dropLast(s, n);
}
public static Object getOptMC(String field) {
return getOpt(mc(), field);
}
public static void setOptMC(String field, Object value) {
setOpt(mc(), field, value);
}
public static <A, B> void mapPut(Map<A, B> map, A key, B value) {
if (map != null && key != null && value != null)
map.put(key, value);
}
public static Object[] toObjectArray(Collection c) {
List l = asList(c);
return l.toArray(new Object[l.size()]);
}
public static Throwable getInnerException(Throwable e) {
if (e == null)
return null;
while (e.getCause() != null) e = e.getCause();
return e;
}
public static Throwable getInnerException(Runnable r) {
return getInnerException(getException(r));
}
public static void lock(Lock lock) {
try {
ping();
if (lock == null)
return;
try {
lock.lockInterruptibly();
} catch (InterruptedException e) {
print("Locking interrupted! I probably deadlocked, oops.");
printStackTrace(e);
rethrow(e);
}
ping();
} catch (Exception __e) {
throw rethrow(__e);
}
}
public static void lock(Lock lock, String msg) {
print("Locking: " + msg);
lock(lock);
}
public static void lock(Lock lock, String msg, long timeout) {
print("Locking: " + msg);
lockOrFail(lock, timeout);
}
public static ReentrantLock lock() {
return fairLock();
}
public static String mechList_raw_fresh(String name) {
return mechList_opt_raw_fresh(name);
}
public static void unlock(Lock lock, String msg) {
if (lock == null)
return;
print("Unlocking: " + msg);
lock.unlock();
}
public static void unlock(Lock lock) {
if (lock == null)
return;
lock.unlock();
}
public static void add(BitSet bs, int i) {
bs.set(i);
}
public static <A> boolean add(Collection<A> c, A a) {
return c != null && c.add(a);
}
public static void add(Container c, Component x) {
addToContainer(c, x);
}
public static Set vm_busListeners_live_cache;
public static Set vm_busListeners_live() {
if (vm_busListeners_live_cache == null)
vm_busListeners_live_cache = vm_busListeners_live_load();
return vm_busListeners_live_cache;
}
public static Set vm_busListeners_live_load() {
return vm_generalIdentityHashSet("busListeners");
}
public static <A> void remove(List<A> l, int i) {
if (l != null && i >= 0 && i < l(l))
l.remove(i);
}
public static <A> void remove(Collection<A> l, A a) {
if (l != null)
l.remove(a);
}
public static List<String> mechList_opt_tlft(String name) {
return mechList_opt_tlft_cached(name);
}
public static <B> TreeMap<String, B> asCaseInsensitiveMap(Map<String, B> map) {
if (isCIMap(map))
return (TreeMap) map;
TreeMap<String, B> m = ciMap();
m.putAll(map);
return m;
}
public static Object callAndMake_orDirect(String functionName, List args) {
return callAndMake_orDirect(functionName, toObjectArray(args));
}
public static Object callAndMake_orDirect(String functionName, Object... args) {
if (functionName == null)
return null;
if (hasMethod(mc(), functionName, args))
return callMC(functionName, args);
else
return makeAndCall_cached(functionName, args);
}
public static String beautifyStructure(String s) {
List<String> tok = javaTok(s);
structure_addTokenMarkers(tok);
jreplace(tok, "lhm", "");
return join(tok);
}
public static String struct_noStringSharing(Object o) {
structure_Data d = new structure_Data();
d.noStringSharing = true;
return structure(o, d);
}
public static <A, B> Collection<B> values(Map<A, B> map) {
return map == null ? emptyList() : map.values();
}
public static <A, B> Collection<B> values(MultiMap<A, B> mm) {
return mm == null ? emptyList() : concatLists(values(mm.data));
}
public static List<String> splitAtDoubleArrow_bothDirections(String s) {
return splitAtDoubleArrow_bothDirections(javaTok(s));
}
public static List<String> splitAtDoubleArrow_bothDirections(List<String> tok) {
List<String> l = splitAtDoubleArrow(tok);
if (l(l) != 2)
l = reversedList(splitAtDoubleLeftArrow(tok));
return l;
}
public static <A> A second(List<A> l) {
return get(l, 1);
}
public static <A> A second(Iterable<A> l) {
if (l == null)
return null;
Iterator<A> it = iterator(l);
if (!it.hasNext())
return null;
it.next();
return it.hasNext() ? it.next() : null;
}
public static <A> A second(A[] bla) {
return bla == null || bla.length <= 1 ? null : bla[1];
}
public static <A, B> B second(Pair<A, B> p) {
return p == null ? null : p.b;
}
public static String hideCredentials(URL url) {
return url == null ? null : hideCredentials(str(url));
}
public static String hideCredentials(String url) {
return url.replaceAll("([&?])(_pass|key)=[^&\\s\"]*", "$1$2=<hidden>");
}
public static String hideCredentials(Object o) {
return hideCredentials(str(o));
}
public static String getStackTrace(Throwable throwable) {
lastException(throwable);
return getStackTrace_noRecord(throwable);
}
public static String getStackTrace_noRecord(Throwable throwable) {
StringWriter writer = new StringWriter();
throwable.printStackTrace(new PrintWriter(writer));
return hideCredentials(writer.toString());
}
public static String getStackTrace() {
return getStackTrace_noRecord(new Throwable());
}
public static Throwable unwrapTrivialExceptionWraps(Throwable e) {
if (e == null)
return e;
while (e.getClass() == RuntimeException.class && e.getCause() != null && eq(e.getMessage(), str(e.getCause()))) e = e.getCause();
return e;
}
public static String replacePrefix(String prefix, String replacement, String s) {
if (!startsWith(s, prefix))
return s;
return replacement + substring(s, l(prefix));
}
public static Throwable innerException2(Throwable e) {
if (e == null)
return null;
while (empty(e.getMessage()) && e.getCause() != null) e = e.getCause();
return e;
}
public static Map<String, String> parseDoubleLeftArrowMap(Map<String, String> map, List<String> l) {
for (String s : l) {
List<String> x = splitAtDoubleLeftArrow(s);
if (l(x) == 2)
map.put(second(x), first(x));
}
return map;
}
public static boolean regionMatchesIC(String a, int offsetA, String b, int offsetB, int len) {
return a != null && a.regionMatches(true, offsetA, b, offsetB, len);
}
public static void _registerIO(Object object, String path, boolean opened) {
}
public static Throwable getException(Runnable r) {
try {
callF(r);
return null;
} catch (Throwable e) {
return e;
}
}
public static Throwable printStackTrace(Throwable e) {
print(getStackTrace(e));
return e;
}
public static void printStackTrace() {
printStackTrace(new Throwable());
}
public static void printStackTrace(String msg) {
printStackTrace(new Throwable(msg));
}
public static void printStackTrace(String msg, Throwable e) {
printStackTrace(new Throwable(msg, e));
}
public static void lockOrFail(Lock lock, long timeout) {
try {
ping();
if (!lock.tryLock(timeout, TimeUnit.MILLISECONDS)) {
String s = "Couldn't acquire lock after " + timeout + " ms.";
if (lock instanceof ReentrantLock) {
ReentrantLock l = (ReentrantLock) lock;
s += " Hold count: " + l.getHoldCount() + ", owner: " + call(l, "getOwner");
}
throw fail(s);
}
ping();
} catch (Exception __e) {
throw rethrow(__e);
}
}
public static ReentrantLock fairLock() {
return new ReentrantLock(true);
}
public static String mechList_opt_raw_fresh(String name) {
Object readMode = mechMode().readMode;
if (readMode instanceof File) {
String md5Name = uniqueFileNameUsingMD5_80_v2(upper(name));
return loadTextFileFromZipFile((File) readMode, md5Name);
}
boolean useLocal = false, useRemote = true;
if (eq(readMode, "mergeLocalAndRemote"))
useLocal = true;
else if (eq(readMode, "local")) {
useLocal = true;
useRemote = false;
}
String s = "";
if (useRemote) {
if (eq(mechMode().readMode, "localCopies"))
s = unnull(loadTextFile(remoteMechListMirrorFile(name)));
else
s = serverMechList_raw_fresh(name, true);
}
if (useLocal)
s = appendNewLineIfNempty(s) + localMechList_opt_raw_fresh(name);
return s;
}
public static void addToContainer(final Container a, final Component b) {
if (a != null && b != null) {
swing(new Runnable() {
public void run() {
try {
a.add(b);
} catch (Exception __e) {
throw rethrow(__e);
}
}
public String toString() {
return "a.add(b);";
}
});
}
}
public static Map<String, MechListDependentCache<List<String>>> mechList_opt_tlft_cached_cache = ciMap();
public static Lock mechList_opt_tlft_cached_lock = lock();
public static List<String> mechList_opt_tlft_cached(String name) {
MechListDependentCache<List<String>> listCache;
{
Lock __459 = mechList_opt_tlft_cached_lock;
lock(__459);
try {
listCache = mechList_opt_tlft_cached_cache.get(name);
if (listCache == null)
mechList_opt_tlft_cached_cache.put(name, listCache = new MechListDependentCache(name, new F1<String, List<String>>() {
public List<String> get(String x) {
try {
return tlft(x);
} catch (Exception __e) {
throw rethrow(__e);
}
}
public String toString() {
return "tlft(x)";
}
}));
} finally {
unlock(__459);
}
}
return listCache.get();
}
public static boolean isCIMap(Map m) {
return m instanceof TreeMap && ((TreeMap) m).comparator() == caseInsensitiveComparator();
}
public static boolean hasMethod(Object o, String method, Object... args) {
return findMethod_cached(o, method, args) != null;
}
public static ThreadLocal makeAndCall_initChild = new ThreadLocal();
public static Object makeAndCall_cached(String functionName, Object... args) {
Class c = loadFunctions_cached(functionName);
AutoCloseable closer = (AutoCloseable) (callF(makeAndCall_initChild.get(), c));
AutoCloseable __463 = closer;
try {
return preciseCall(c, functionName, args);
} finally {
_close(__463);
}
}
public static String structure_addTokenMarkers(String s) {
return join(structure_addTokenMarkers(javaTok(s)));
}
public static List<String> structure_addTokenMarkers(List<String> tok) {
TreeSet<Integer> refs = new TreeSet();
for (int i = 1; i < l(tok); i += 2) {
String t = tok.get(i);
if (t.startsWith("t") && isInteger(t.substring(1)))
refs.add(parseInt(t.substring(1)));
}
if (empty(refs))
return tok;
for (int i : refs) {
int idx = i * 2 + 1;
String t = "";
if (endsWithLetterOrDigit(tok.get(idx - 1)))
t = " ";
tok.set(idx, t + "m" + i + " " + tok.get(idx));
}
return tok;
}
public static String jreplace(String s, String in, String out) {
return jreplace(s, in, out, null);
}
public static String jreplace(String s, String in, String out, Object condition) {
List<String> tok = javaTok(s);
return jreplace(tok, in, out, condition) ? join(tok) : s;
}
public static boolean jreplace(List<String> tok, String in, String out) {
return jreplace(tok, in, out, false, true, null);
}
public static boolean jreplace(List<String> tok, String in, String out, Object condition) {
return jreplace(tok, in, out, false, true, condition);
}
public static boolean jreplace(List<String> tok, String in, String out, boolean ignoreCase, boolean reTok, Object condition) {
String[] toks = javaTokForJFind_array(in);
int lTokin = toks.length * 2 + 1;
boolean anyChange = false;
int i = -1;
for (int n = 0; n < 10000; n++) {
i = findCodeTokens(tok, i + 1, ignoreCase, toks, condition);
if (i < 0)
return anyChange;
List<String> subList = tok.subList(i - 1, i + lTokin - 1);
String expansion = jreplaceExpandRefs(out, subList);
int end = i + lTokin - 2;
clearAllTokens(tok, i, end);
tok.set(i, expansion);
if (reTok)
reTok(tok, i, end);
i = end;
anyChange = true;
}
throw fail("woot? 10000! " + quote(in) + " => " + quote(out));
}
public static boolean jreplace_debug;
public static <A> List<A> concatLists(Collection<A>... lists) {
List<A> l = new ArrayList();
if (lists != null)
for (Collection<A> list : lists) if (list != null)
l.addAll(list);
return l;
}
public static <A> List<A> concatLists(Collection<? extends Collection<A>> lists) {
List<A> l = new ArrayList();
if (lists != null)
for (Collection<A> list : lists) if (list != null)
l.addAll(list);
return l;
}
public static List<String> splitAtDoubleArrow(String s) {
return splitAtDoubleArrow(javaTok(s));
}
public static List<String> splitAtDoubleArrow(List<String> tok) {
List<String> l = new ArrayList();
int i = 0;
while (i < l(tok)) {
int j = indexOfSubList(tok, splitAtDoubleArrow_tok(), i);
if (i >= l(tok))
break;
if (j < 0)
j = l(tok);
l.add(trimJoin(tok.subList(i, j)));
i = j + 3;
}
return l;
}
public static <A> List<A> reversedList(Collection<A> l) {
List<A> x = cloneList(l);
Collections.reverse(x);
return x;
}
public static List<String> splitAtDoubleLeftArrow(String s) {
return splitAtDoubleLeftArrow(javaTok(s));
}
public static List<String> splitAtDoubleLeftArrow(List<String> tok) {
List<String> l = new ArrayList();
int i = 0;
while (i < l(tok)) {
int j = indexOfSubList(tok, ll("<", "", "="), i);
if (i >= l(tok))
break;
if (j < 0)
j = l(tok);
l.add(trimJoin(tok.subList(i, j)));
i = j + 3;
}
return l;
}
public static volatile PersistableThrowable lastException_lastException;
public static PersistableThrowable lastException() {
return lastException_lastException;
}
public static void lastException(Throwable e) {
lastException_lastException = persistableThrowable(e);
}
public static MechMode mechMode_value = new MechMode();
public static MechMode mechMode() {
return mechMode_value;
}
public static String uniqueFileNameUsingMD5_80_v2(String fullName) {
return uniqueFileNameUsingMD5_80_v2(fullName, md5(fullName));
}
public static String uniqueFileNameUsingMD5_80_v2(String fullName, String md5) {
return takeFirst(80 - 33, fileNameEncode(fullName)) + " - " + md5;
}
public static String upper(String s) {
return s == null ? null : s.toUpperCase();
}
public static char upper(char c) {
return Character.toUpperCase(c);
}
public static String loadTextFileFromZipFile(File inZip, String fileName) {
try {
if (!fileExists(inZip))
return null;
try {
ZipFile zip = new ZipFile(inZip);
try {
return loadTextFileFromZipFile(zip, fileName);
} finally {
_close(zip);
}
} catch (Throwable e) {
throw fail(f2s(inZip), e);
}
} catch (Exception __e) {
throw rethrow(__e);
}
}
public static String loadTextFileFromZipFile(ZipFile zip, String fileName) {
try {
ZipEntry entry = zip.getEntry(fileName);
if (entry == null)
return null;
InputStream fin = zip.getInputStream(entry);
try {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
copyStream(fin, baos);
return fromUTF8(baos.toByteArray());
} finally {
_close(fin);
}
} catch (Exception __e) {
throw rethrow(__e);
}
}
public static String loadTextFile(String fileName) {
return loadTextFile(fileName, null);
}
public static String loadTextFile(File f, String defaultContents) {
try {
checkFileNotTooBigToRead(f);
if (f == null || !f.exists())
return defaultContents;
FileInputStream fileInputStream = new FileInputStream(f);
InputStreamReader inputStreamReader = new InputStreamReader(fileInputStream, "UTF-8");
return loadTextFile(inputStreamReader);
} catch (Exception __e) {
throw rethrow(__e);
}
}
public static String loadTextFile(File fileName) {
return loadTextFile(fileName, null);
}
public static String loadTextFile(String fileName, String defaultContents) {
return fileName == null ? defaultContents : loadTextFile(newFile(fileName), defaultContents);
}
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 str(builder);
}
public static File remoteMechListMirrorFile(String listName) {
return newFile(remoteMechListMirrorsDir(), uniqueFileNameUsingMD5_80_v2(upper(listName)));
}
public static boolean serverMechList_raw_fresh_verbose;
public static String serverMechList_raw_fresh(String name) {
return serverMechList_raw_fresh(name, false);
}
public static String serverMechList_raw_fresh(String name, boolean opt) {
Lock __514 = downloadLock();
lock(__514);
try {
String text = null;
try {
text = loadTextFile(remoteMechListMirrorFile(name));
} catch (Throwable __e) {
_handleException(__e);
}
Object[] params = muricaCredentialsPlus("md5", md5OrNull(text), "l", l(text), "opt", opt ? 1 : 0, "withStatus", 1);
String url = "http://butter.botcompany.de:8080/mech/raw/list-text/" + urlencode(name);
String page = postPageSilently(url, params);
Map map = jsonDecodeMap(page);
boolean same = eq(map.get("Same"), true);
boolean appended = eq(map.get("Appended"), true);
saveTextFile(remoteMechListMirrorMetaFile(name), struct(getMultipleKeys(map, "Name", "Status")));
if (!same) {
if (appended)
text += (String) map.get("Text");
else
text = (String) map.get("Text");
saveTextFile(remoteMechListMirrorFile(name), text);
File nameFile = remoteMechListMirrorNameFile(name);
if (!fileExists(nameFile)) {
String actualName = or((String) map.get("Name"), name);
saveTextFile(nameFile, actualName);
}
}
if (serverMechList_raw_fresh_verbose)
print("Mech list " + name + ": " + (appended ? "appended" : same ? "same" : "downloaded") + ": " + n2(countLines(text), "line"));
if (!same)
vmBus_send("remoteMechListMirrorChanged", name);
return text;
} finally {
unlock(__514);
}
}
public static String appendNewLineIfNempty(String s) {
return empty(s) ? "" : s + "\n";
}
public static String localMechList_opt_raw_fresh(String name) {
return unnull(loadTextFile(localMechListFile(name)));
}
public static Object swing(Object f) {
return swingAndWait(f);
}
public static <A> A swing(F0<A> f) {
return (A) swingAndWait(f);
}
public static Method findMethod_cached(Object o, String method, Object... args) {
try {
if (o == null)
return null;
if (o instanceof Class) {
_MethodCache cache = callOpt_getCache(((Class) o));
List<Method> methods = cache.cache.get(method);
if (methods != null)
for (Method m : methods) if (isStaticMethod(m) && findMethod_checkArgs(m, args, false))
return m;
return null;
} else {
_MethodCache cache = callOpt_getCache(o.getClass());
List<Method> methods = cache.cache.get(method);
if (methods != null)
for (Method m : methods) if (findMethod_checkArgs(m, args, false))
return m;
return null;
}
} catch (Exception __e) {
throw rethrow(__e);
}
}
public static HashMap<Set<String>, Class> loadFunctions_cache = new HashMap();
public static Lock loadFunctions_cached_lock = lock();
public static boolean loadFunctions_preferDiskCache;
public static Class loadFunctions_cached(String... functions) {
return loadFunctions_cached(asList(functions));
}
public static Class loadFunctions_cached(Collection<String> functions) {
TreeSet<String> functionSet = new TreeSet<String>(functions);
Lock __531 = loadFunctions_cached_lock;
lock(__531);
try {
Class c = loadFunctions_cache.get(functionSet);
if (c != null)
return c;
String cached = getTranspiledStandardFunctionsIfCached(functionSet);
String transpilation = null;
if (cached != null && (loadFunctions_preferDiskCache || standardFunctionsCacheUpToDate(functionSet)))
transpilation = cached;
if (transpilation != null) {
print("Loading " + joinWithPlus(functionSet));
c = veryQuickJava_finish(transpilation, emptyList());
}
if (c == null)
c = loadFunctions(functionSet);
loadFunctions_cache.put(functionSet, c);
assertNotNull(loadFunctions_cache.get(functionSet));
return c;
} finally {
unlock(__531);
}
}
public static void loadFunctions_cached_clearCache() {
Lock __532 = loadFunctions_cached_lock;
lock(__532);
try {
loadFunctions_cache.clear();
} finally {
unlock(__532);
}
}
public static void _onLoad_loadFunctions_cached() {
ownResource(vmBus_onMessage("refreshedTranspiler", new Runnable() {
public void run() {
try {
loadFunctions_clearCache();
} catch (Exception __e) {
throw rethrow(__e);
}
}
public String toString() {
return "loadFunctions_clearCache();";
}
}));
}
public static boolean preciseCall_debug;
public static Object preciseCall(Object o, String method, Object... args) {
try {
if (o instanceof Class) {
_MethodCache cache = callOpt_getCache(((Class) o));
List<Method> methods = cache.cache.get(method);
Lowest<Method> best = new Lowest();
if (methods != null)
for (Method m : methods) {
{
if (!(isStaticMethod(m)))
continue;
}
int score = methodApplicabilityScore(m, args);
if (score < Integer.MAX_VALUE) {
if (preciseCall_debug)
print("Method score: " + m + " " + score);
best.put(m, score);
}
}
Method m = best.get();
if (m != null)
return invokeMethod(m, null, args);
return call_withVarargs(((Class) o), method, args);
} else
throw todo();
} catch (Exception __e) {
throw rethrow(__e);
}
}
public static boolean isInteger(String s) {
int n = l(s);
if (n == 0)
return false;
int i = 0;
if (s.charAt(0) == '-')
if (++i >= n)
return false;
while (i < n) {
char c = s.charAt(i);
if (c < '0' || c > '9')
return false;
++i;
}
return true;
}
public static Map<String, String[]> javaTokForJFind_array_cache = synchronizedMRUCache(1000);
public static String[] javaTokForJFind_array(String s) {
String[] tok = javaTokForJFind_array_cache.get(s);
if (tok == null)
javaTokForJFind_array_cache.put(s, tok = codeTokensAsStringArray(jfind_preprocess(javaTok(s))));
return tok;
}
public static int findCodeTokens(List<String> tok, String... tokens) {
return findCodeTokens(tok, 1, false, tokens);
}
public static int findCodeTokens(List<String> tok, boolean ignoreCase, String... tokens) {
return findCodeTokens(tok, 1, ignoreCase, tokens);
}
public static int findCodeTokens(List<String> tok, int startIdx, boolean ignoreCase, String... tokens) {
return findCodeTokens(tok, startIdx, ignoreCase, tokens, null);
}
public static HashSet<String> findCodeTokens_specials = lithashset("*", "<quoted>", "<id>", "<int>", "\\*");
public static boolean findCodeTokens_debug;
public static int findCodeTokens_indexed, findCodeTokens_unindexed;
public static int findCodeTokens_bails, findCodeTokens_nonbails;
public 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++;
}
int end = tok.size() - tokens.length * 2 + 2, nTokens = tokens.length;
int i = startIdx | 1;
String firstToken = tokens[0];
if (!ignoreCase && !findCodeTokens_specials.contains(firstToken)) {
while (i < end && !firstToken.equals(tok.get(i))) i += 2;
}
outer: for (; i < end; i += 2) {
for (int j = 0; j < nTokens; 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 || checkTokCondition(condition, tok, i - 1))
return i;
}
return -1;
}
public static String jreplaceExpandRefs(String s, List<String> tokref) {
List<String> tok = javaTok(s);
for (int i = 1; i < l(tok); i += 2) {
if (tok.get(i).startsWith("$") && isInteger(tok.get(i).substring(1))) {
String x = tokref.get(-1 + parseInt(tok.get(i).substring(1)) * 2);
tok.set(i, x);
}
}
return join(tok);
}
public static List<String> reTok(List<String> tok) {
replaceCollection(tok, javaTok(tok));
return tok;
}
public static List<String> reTok(List<String> tok, int i) {
return reTok(tok, i, i + 1);
}
public static List<String> reTok(List<String> tok, int i, int j) {
i = i & ~1;
j = j | 1;
List<String> t = javaTok(join(subList(tok, i, j)));
replaceListPart(tok, i, j, t);
return tok;
}
public static List<String> splitAtDoubleArrow_tok;
public static List<String> splitAtDoubleArrow_tok() {
if (splitAtDoubleArrow_tok == null)
splitAtDoubleArrow_tok = ll("=", "", ">");
return splitAtDoubleArrow_tok;
}
public static String trimJoin(List<String> s) {
return trim(join(s));
}
public static String md5(String text) {
try {
if (text == null)
return "-";
return bytesToHex(md5_impl(toUtf8(text)));
} catch (Exception __e) {
throw rethrow(__e);
}
}
public static String md5(byte[] data) {
if (data == null)
return "-";
return bytesToHex(md5_impl(data));
}
public static MessageDigest md5_md;
public static byte[] md5_impl(byte[] data) {
try {
return MessageDigest.getInstance("MD5").digest(data);
} catch (Exception __e) {
throw rethrow(__e);
}
}
public static String md5(File file) {
return md5OfFile(file);
}
public static <A> List<A> takeFirst(List<A> l, int n) {
return l(l) <= n ? l : newSubListOrSame(l, 0, n);
}
public static <A> List<A> takeFirst(int n, List<A> l) {
return takeFirst(l, n);
}
public static String takeFirst(int n, String s) {
return substring(s, 0, n);
}
public static String takeFirst(String s, int n) {
return substring(s, 0, n);
}
public static <A> List<A> takeFirst(int n, Iterable<A> i) {
List l = new ArrayList();
Iterator<A> it = i.iterator();
for (int _repeat_601 = 0; _repeat_601 < n; _repeat_601++) {
if (it.hasNext())
l.add(it.next());
else
break;
}
return l;
}
public static String fileNameEncode_safeChars = " ()[]#,!";
public static String fileNameEncode(String s) {
StringBuilder buf = new StringBuilder();
int n = l(s);
for (int i = 0; i < n; i++) {
char c = s.charAt(i);
if (contains(fileNameEncode_safeChars, c))
buf.append(c);
else
buf.append(urlencode(str(c)));
}
return str(buf);
}
public static boolean fileExists(String path) {
return path != null && new File(path).exists();
}
public static boolean fileExists(File f) {
return f != null && f.exists();
}
public static String f2s(File f) {
return f == null ? null : f.getAbsolutePath();
}
public static String f2s(java.nio.file.Path p) {
return p == null ? null : f2s(p.toFile());
}
public static void copyStream(InputStream in, OutputStream out) {
try {
byte[] buf = new byte[65536];
while (true) {
int n = in.read(buf);
if (n <= 0)
return;
out.write(buf, 0, n);
}
} catch (Exception __e) {
throw rethrow(__e);
}
}
public static String fromUTF8(byte[] bytes) {
return fromUtf8(bytes);
}
public static ThreadLocal<VF1<File>> checkFileNotTooBigToRead_tl = new ThreadLocal();
public static void checkFileNotTooBigToRead(File f) {
callF(checkFileNotTooBigToRead_tl.get(), f);
}
public static File newFile(File base, String... names) {
for (String name : names) base = new File(base, name);
return base;
}
public static File newFile(String name) {
return name == null ? null : new File(name);
}
public static File remoteMechListMirrorsDir() {
return javaxDataDir("Remote Mech Lists");
}
public static Lock downloadLock_lock = fairLock();
public static Lock downloadLock() {
return downloadLock_lock;
}
public static Object[] muricaCredentialsPlus(Object... params) {
return concatArrays(muricaCredentials(), params);
}
public static String md5OrNull(String s) {
return s == null ? null : md5(s);
}
public static String urlencode(String x) {
try {
return URLEncoder.encode(unnull(x), "UTF-8");
} catch (UnsupportedEncodingException e) {
throw new RuntimeException(e);
}
}
public static String postPageSilently(String url, Object... params) {
return doPostSilently(litmap(params), url);
}
public static Map jsonDecodeMap(String s) {
Object o = jsonDecode(s);
if (o instanceof List && empty((List) o))
return new HashMap();
if (o instanceof Map)
return (Map) o;
else
throw fail("Not a JSON map: " + s);
}
public static File saveTextFile(String fileName, String contents) throws IOException {
CriticalAction action = beginCriticalAction("Saving file " + fileName + " (" + l(contents) + " chars)");
try {
File file = new File(fileName);
mkdirsForFile(file);
String tempFileName = fileName + "_temp";
File tempFile = new File(tempFileName);
if (contents != null) {
if (tempFile.exists())
try {
String saveName = tempFileName + ".saved." + now();
copyFile(tempFile, new File(saveName));
} catch (Throwable e) {
printStackTrace(e);
}
FileOutputStream fileOutputStream = newFileOutputStream(tempFile.getPath());
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 (!tempFile.renameTo(file))
throw new IOException("Can't rename " + tempFile + " to " + file);
vmBus_send("wroteFile", file);
return file;
} finally {
action.done();
}
}
public static File saveTextFile(File fileName, String contents) {
try {
saveTextFile(fileName.getPath(), contents);
return fileName;
} catch (Exception __e) {
throw rethrow(__e);
}
}
public static File remoteMechListMirrorMetaFile(String listName) {
return javaxDataDir("Remote Mech Lists/" + uniqueFileNameUsingMD5_80_v2(upper(listName)) + ".meta");
}
public static <A, B> Map<A, B> getMultipleKeys(Map<A, B> map, A... keys) {
Map<A, B> map2 = similarEmptyMap(map);
if (map != null)
for (A key : keys) map2.put(key, map.get(key));
return map2;
}
public static File remoteMechListMirrorNameFile(String listName) {
return javaxDataDir("Remote Mech Lists/" + uniqueFileNameUsingMD5_80_v2(upper(listName)) + ".name");
}
public static <A> A or(A a, A b) {
return a != null ? a : b;
}
public static String n2(long l) {
return formatWithThousands(l);
}
public static String n2(Collection l) {
return n2(l(l));
}
public static String n2(double l, String singular) {
return n2(l, singular, singular + "s");
}
public static String n2(double l, String singular, String plural) {
if (fraction(l) == 0)
return n2((long) l, singular, plural);
else
return l + " " + plural;
}
public static String n2(long l, String singular, String plural) {
return n_fancy2(l, singular, plural);
}
public static String n2(long l, String singular) {
return n_fancy2(l, singular, singular + "s");
}
public static String n2(Collection l, String singular) {
return n2(l(l), singular);
}
public static String n2(Collection l, String singular, String plural) {
return n_fancy2(l, singular, plural);
}
public static String n2(Map m, String singular, String plural) {
return n_fancy2(m, singular, plural);
}
public static String n2(Map m, String singular) {
return n2(l(m), singular);
}
public static String n2(Object[] a, String singular) {
return n2(l(a), singular);
}
public static String n2(Object[] a, String singular, String plural) {
return n_fancy2(a, singular, plural);
}
public static int countLines(String s) {
return l(toLines(s));
}
public static void vmBus_send(String msg, Object... args) {
Object arg = vmBus_wrapArgs(args);
pcallFAll(vm_busListeners_live(), msg, arg);
pcallFAll(vm_busListenersByMessage_live().get(msg), msg, arg);
}
public static void vmBus_send(String msg) {
vmBus_send(msg, (Object) null);
}
public static File localMechListFile(String listName) {
return newFile(localMechListsDir(), uniqueFileNameUsingMD5_80_v2(listName) + ".text");
}
public static void swingAndWait(Runnable r) {
try {
if (isAWTThread())
r.run();
else
EventQueue.invokeAndWait(addThreadInfoToRunnable(r));
} catch (Exception __e) {
throw rethrow(__e);
}
}
public static Object swingAndWait(final Object f) {
if (isAWTThread())
return callF(f);
else {
final Var result = new Var();
swingAndWait(new Runnable() {
public void run() {
try {
result.set(callF(f));
} catch (Exception __e) {
throw rethrow(__e);
}
}
public String toString() {
return "result.set(callF(f));";
}
});
return result.get();
}
}
public static Method findMethod(Object o, String method, Object... args) {
return findMethod_cached(o, method, args);
}
public static boolean findMethod_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;
}
public static String getTranspiledStandardFunctionsIfCached(TreeSet<String> functionSet) {
try {
File f = transpiledStandardFunctions_file(functionSet);
return loadTextFile(f);
} catch (Throwable __e) {
return null;
}
}
public static boolean standardFunctionsCacheUpToDate(TreeSet<String> functionSet) {
File f = transpiledStandardFunctions_file(functionSet);
long date = recommendedTranspilationDateForStandardFunctions(functionSet);
return date != 0 && f.lastModified() >= date;
}
public static String joinWithPlus(Collection<String> c) {
return join("+", c);
}
public static String joinWithPlus(String... c) {
return join("+", c);
}
public static Class veryQuickJava_finish(String src, List<String> libs) {
libs = cloneList(libs);
src = findTranslators2(src, libs);
String dehlibs = join(" ", libs);
File bytecode = null;
try {
bytecode = javaCompile_overInternalBot(src, dehlibs);
} catch (Throwable _e) {
print("Was compiling: " + src + "\n");
throw rethrow(_e);
}
return hotwireCore(concatLists(ll(bytecode), loadLibraries(libs)));
}
public static boolean loadFunctions_debug;
public static Object loadFunctions_veryQuickJava;
public static Class loadFunctions(String... functions) {
return loadFunctions(asList(functions));
}
public static Class loadFunctions(Collection<String> functions) {
print("Compiling " + joinWithPlus(functions));
TreeSet<String> functionSet = new TreeSet<String>(functions);
StringBuilder buf = new StringBuilder();
for (String s : functionSet) buf.append("please include function " + assertIdentifier(s) + ".\n");
long time = sysNow();
Class c;
if (loadFunctions_veryQuickJava != null)
c = (Class) callF(loadFunctions_veryQuickJava, str(buf));
else {
veryQuickJava_transpiled.set("");
c = veryQuickJava(str(buf));
saveTranspiledStandardFunctions(functionSet, getAndClearThreadLocal(veryQuickJava_transpiled));
}
if (loadFunctions_debug)
done2_always(time, "loadFunctions: " + join(" ", functions));
return c;
}
public static <A> A assertNotNull(A a) {
assertTrue(a != null);
return a;
}
public static <A> A assertNotNull(String msg, A a) {
assertTrue(msg, a != null);
return a;
}
public static void ownResource(AutoCloseable c) {
_registerAutoCloseable(c);
}
public static <A> AutoCloseable vmBus_onMessage(final String msg, final VF1<A> onMessage) {
Map<String, Set> map = vm_busListenersByMessage_live();
synchronized (map) {
Set listeners = map.get(msg);
if (listeners == null)
map.put(msg, listeners = syncIdentityHashSet());
return tempAdd(listeners, new VF2<String, Object>() {
public void get(String _msg, Object arg) {
try {
callF(onMessage, arg);
} catch (Exception __e) {
throw rethrow(__e);
}
}
public String toString() {
return "callF(onMessage, arg)";
}
});
}
}
public static <A, B> AutoCloseable vmBus_onMessage(String msg, final VF2<A, B> onMessage) {
return vmBus_onMessage(msg, new VF1<Object[]>() {
public void get(Object[] o) {
try {
callF(onMessage, first(o), second(o));
} catch (Exception __e) {
throw rethrow(__e);
}
}
public String toString() {
return "callF(onMessage, first(o), second(o));";
}
});
}
public static AutoCloseable vmBus_onMessage(String msg, Runnable onMessage) {
return vmBus_onMessage(msg, runnableToVF1(onMessage));
}
public static void loadFunctions_clearCache() {
callOptMC("loadFunctions_cached_clearCache");
}
public static int methodApplicabilityScore(Method m, Object[] args) {
Class<?>[] types = m.getParameterTypes();
if (types.length != args.length)
return Integer.MAX_VALUE;
int score = 0;
for (int i = 0; i < types.length; i++) {
Object a = args[i];
Class c = types[i];
if (a == null)
++score;
else if (c == a.getClass()) {
} else if (isInstanceX(c, a))
++score;
else
return Integer.MAX_VALUE;
}
return score;
}
public static RuntimeException todo() {
throw new RuntimeException("TODO");
}
public static RuntimeException todo(String msg) {
throw new RuntimeException("TODO: " + msg);
}
public static String[] codeTokensAsStringArray(List<String> tok) {
int n = max(0, (l(tok) - 1) / 2);
String[] out = new String[n];
for (int i = 0; i < n; i++) out[i] = tok.get(i * 2 + 1);
return out;
}
public static int jfind(String s, String in) {
return jfind(javaTok(s), in);
}
public static int jfind(List<String> tok, String in) {
return jfind(tok, 1, in);
}
public static int jfind(List<String> tok, int startIdx, String in) {
return jfind(tok, startIdx, in, null);
}
public static int jfind(List<String> tok, String in, Object condition) {
return jfind(tok, 1, in, condition);
}
public static int jfind(List<String> tok, int startIdx, String in, Object condition) {
return jfind(tok, startIdx, javaTokForJFind_array(in), condition);
}
public static int jfind(List<String> tok, List<String> tokin) {
return jfind(tok, 1, tokin);
}
public static int jfind(List<String> tok, int startIdx, List<String> tokin) {
return jfind(tok, startIdx, tokin, null);
}
public static int jfind(List<String> tok, int startIdx, String[] tokinC, Object condition) {
return findCodeTokens(tok, startIdx, false, tokinC, condition);
}
public static int jfind(List<String> tok, int startIdx, List<String> tokin, Object condition) {
return findCodeTokens(tok, startIdx, false, codeTokensAsStringArray(tokin), condition);
}
public static List<String> jfind_preprocess(List<String> tok) {
for (String type : litlist("quoted", "id", "int")) replaceSublist(tok, ll("<", "", type, "", ">"), ll("<" + type + ">"));
replaceSublist(tok, ll("\\", "", "*"), ll("\\*"));
return tok;
}
public static <A> HashSet<A> lithashset(A... items) {
HashSet<A> set = new HashSet();
for (A a : items) set.add(a);
return set;
}
public static boolean isQuoted(String s) {
if (isNormalQuoted(s))
return true;
return isMultilineQuoted(s);
}
public static boolean isIdentifier(String s) {
return isJavaIdentifier(s);
}
public static boolean checkTokCondition(Object condition, List<String> tok, int i) {
if (condition instanceof TokCondition)
return ((TokCondition) condition).get(tok, i);
return checkCondition(condition, tok, i);
}
public static <A> void replaceCollection(Collection<A> dest, Collection<A> src) {
dest.clear();
dest.addAll(src);
}
public static void replaceListPart(List l, int i, int j, List l2) {
int j2 = i + l(l2);
if (j2 == j) {
copyListPart(l2, 0, l, i, l(l2));
return;
}
l.subList(i, j).clear();
l.addAll(i, l2);
}
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();
}
public static byte[] toUtf8(String s) {
try {
return s.getBytes("UTF-8");
} catch (Exception __e) {
throw rethrow(__e);
}
}
public static boolean md5OfFile_verbose;
public static String md5OfFile(String path) {
return md5OfFile(newFile(path));
}
public static String md5OfFile(File f) {
try {
if (!f.exists())
return "-";
if (md5OfFile_verbose)
print("Getting MD5 of " + f);
MessageDigest md5 = MessageDigest.getInstance("MD5");
FileInputStream in = new FileInputStream(f);
try {
byte[] buf = new byte[65536];
int l;
while (true) {
l = in.read(buf);
if (l <= 0)
break;
md5.update(buf, 0, l);
}
return bytesToHex(md5.digest());
} finally {
_close(in);
}
} catch (Exception __e) {
throw rethrow(__e);
}
}
public static <A> List<A> newSubListOrSame(List<A> l, int startIndex) {
return newSubListOrSame(l, startIndex, l(l));
}
public static <A> List<A> newSubListOrSame(List<A> l, int startIndex, int endIndex) {
if (l == null)
return null;
int n = l(l);
startIndex = max(0, startIndex);
endIndex = min(n, endIndex);
if (startIndex >= endIndex)
return ll();
if (startIndex == 0 && endIndex == n)
return l;
return cloneList(l.subList(startIndex, endIndex));
}
public static String fromUtf8(byte[] bytes) {
try {
return bytes == null ? null : new String(bytes, "UTF-8");
} catch (Exception __e) {
throw rethrow(__e);
}
}
public static File javaxDataDir_dir;
public static File javaxDataDir() {
return javaxDataDir_dir != null ? javaxDataDir_dir : new File(userHome(), "JavaX-Data");
}
public static File javaxDataDir(String... subs) {
return newFile(javaxDataDir(), subs);
}
public static Object[] concatArrays(Object[]... arrays) {
int l = 0;
for (Object[] a : arrays) l += l(a);
Object[] x = new Object[l];
int i = 0;
for (Object[] a : arrays) if (a != null) {
System.arraycopy(a, 0, x, i, l(a));
i += l(a);
}
return x;
}
public static Object[] muricaCredentials() {
String pass = muricaPassword();
return nempty(pass) ? new Object[] { "_pass", pass } : new Object[0];
}
public static String doPostSilently(Map urlParameters, String url) {
return doPostSilently(makePostData(urlParameters), url);
}
public static String doPostSilently(String urlParameters, String url) {
doPost_silently.set(true);
return doPost(urlParameters, url);
}
public static boolean jsonDecode_useOrderedMaps = true;
public static Object jsonDecode(final String text) {
final List<String> tok = jsonTok(text);
if (l(tok) == 1)
return null;
class Y {
public int i = 1;
public Object parse() {
String t = tok.get(i);
if (t.startsWith("\"")) {
String s = unquote(tok.get(i));
i += 2;
return s;
}
if (t.equals("{"))
return parseMap();
if (t.equals("["))
return this.parseList();
if (t.equals("null")) {
i += 2;
return null;
}
if (t.equals("false")) {
i += 2;
return false;
}
if (t.equals("true")) {
i += 2;
return true;
}
boolean minus = false;
if (t.equals("-")) {
minus = true;
i += 2;
t = get(tok, i);
}
if (isInteger(t)) {
i += 2;
if (eq(get(tok, i), ".")) {
String x = t + "." + get(tok, i + 2);
i += 4;
double d = parseDouble(x);
if (minus)
d = -d;
return d;
} else {
long l = parseLong(t);
if (minus)
l = -l;
return l != (int) l ? new Long(l) : new Integer((int) l);
}
}
throw new RuntimeException("Unknown token " + (i + 1) + ": " + t + ": " + text);
}
public 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;
}
public Object parseMap() {
consume("{");
Map map = jsonDecode_useOrderedMaps ? new LinkedHashMap() : new TreeMap();
while (!tok.get(i).equals("}")) {
String key = unquote(tok.get(i));
i += 2;
consume(":");
Object value = parse();
map.put(key, value);
if (tok.get(i).equals(","))
i += 2;
}
consume("}");
return map;
}
public 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())));
throw fail(quote(s) + " expected: " + prevToken + " " + nextTokens + " (" + i + "/" + tok.size() + ")");
}
i += 2;
}
}
return new Y().parse();
}
public static List<CriticalAction> beginCriticalAction_inFlight = synchroList();
public static class CriticalAction {
public String description;
public CriticalAction() {
}
public CriticalAction(String description) {
this.description = description;
}
public void done() {
beginCriticalAction_inFlight.remove(this);
}
}
public static CriticalAction beginCriticalAction(String description) {
ping();
CriticalAction c = new CriticalAction(description);
beginCriticalAction_inFlight.add(c);
return c;
}
public static void cleanMeUp_beginCriticalAction() {
int n = 0;
while (nempty(beginCriticalAction_inFlight)) {
int m = l(beginCriticalAction_inFlight);
if (m != n) {
n = m;
try {
print("Waiting for " + n2(n, "critical actions") + ": " + join(", ", collect(beginCriticalAction_inFlight, "description")));
} catch (Throwable __e) {
_handleException(__e);
}
}
sleepInCleanUp(10);
}
}
public static File mkdirsForFile(File file) {
File dir = file.getParentFile();
if (dir != null) {
dir.mkdirs();
if (!dir.isDirectory())
if (dir.isFile())
throw fail("Please delete the file " + f2s(dir) + " - it is supposed to be a directory!");
else
throw fail("Unknown IO exception during mkdirs of " + f2s(file));
}
return file;
}
public static String mkdirsForFile(String path) {
mkdirsForFile(new File(path));
return path;
}
public static long now_virtualTime;
public static long now() {
return now_virtualTime != 0 ? now_virtualTime : System.currentTimeMillis();
}
public static void copyFile(File src, File dest) {
try {
FileInputStream inputStream = new FileInputStream(src.getPath());
FileOutputStream outputStream = newFileOutputStream(dest.getPath());
try {
copyStream(inputStream, outputStream);
inputStream.close();
} finally {
outputStream.close();
}
} catch (Exception __e) {
throw rethrow(__e);
}
}
public static FileOutputStream newFileOutputStream(File path) throws IOException {
return newFileOutputStream(path.getPath());
}
public static FileOutputStream newFileOutputStream(String path) throws IOException {
return newFileOutputStream(path, false);
}
public static FileOutputStream newFileOutputStream(File path, boolean append) throws IOException {
return newFileOutputStream(path.getPath(), append);
}
public static FileOutputStream newFileOutputStream(String path, boolean append) throws IOException {
mkdirsForFile(path);
FileOutputStream f = new FileOutputStream(path, append);
_registerIO(f, path, true);
return f;
}
public static String formatWithThousands(long l) {
return formatWithThousandsSeparator(l);
}
public static double fraction(double d) {
return d % 1;
}
public static String n_fancy2(long l, String singular, String plural) {
return formatWithThousandsSeparator(l) + " " + trim(l == 1 ? singular : plural);
}
public static String n_fancy2(Collection l, String singular, String plural) {
return n_fancy2(l(l), singular, plural);
}
public static String n_fancy2(Map m, String singular, String plural) {
return n_fancy2(l(m), singular, plural);
}
public static String n_fancy2(Object[] a, String singular, String plural) {
return n_fancy2(l(a), singular, plural);
}
public static Object vmBus_wrapArgs(Object... args) {
return empty(args) ? null : l(args) == 1 ? args[0] : args;
}
public static Map<String, Set> vm_busListenersByMessage_live_cache;
public static Map<String, Set> vm_busListenersByMessage_live() {
if (vm_busListenersByMessage_live_cache == null)
vm_busListenersByMessage_live_cache = vm_busListenersByMessage_live_load();
return vm_busListenersByMessage_live_cache;
}
public static Map<String, Set> vm_busListenersByMessage_live_load() {
return vm_generalHashMap("busListenersByMessage");
}
public static File localMechListsDir() {
return javaxDataDir("Mech Lists");
}
public static Runnable addThreadInfoToRunnable(final Object r) {
final Object info = _threadInfo();
return info == null ? asRunnable(r) : new Runnable() {
public void run() {
try {
_inheritThreadInfo(info);
callF(r);
} catch (Exception __e) {
throw rethrow(__e);
}
}
public String toString() {
return "_inheritThreadInfo(info); callF(r);";
}
};
}
public static File transpiledStandardFunctions_file(TreeSet<String> functionSet) {
String name = uniqueFileNameUsingMD5_80_v2(join("+", functionSet));
File dir = javaxCachesDir("Transpiled Standard Functions");
saveTextFileUnlessExists(newFile(dir, name + ".functions"), lines(functionSet));
return newFile(dir, name + ".java");
}
public static long recommendedTranspilationDateForStandardFunctions(Collection<String> sfNames) {
long date = 0;
for (String name : sfNames) {
long d = recommendedTranspilationDateForStandardFunction(name);
if (d == 0)
return 0;
date = max(date, d);
}
return date;
}
public static String findTranslators2(String src, List<String> libsOut) {
return join(findTranslators2(javaTok(src), libsOut));
}
public static List<String> findTranslators2(List<String> tok, List<String> libsOut) {
int i;
while ((i = jfind(tok, "!<int>")) >= 0) {
setAdd(libsOut, tok.get(i + 2));
clearTokens(tok, i, i + 3);
}
return tok;
}
public static File javaCompile_overInternalBot(String src) {
return javaCompile_overInternalBot(src, "");
}
public static synchronized File javaCompile_overInternalBot(String src, String dehlibs) {
return CompilerBot.compile(src, dehlibs);
}
public static Class hotwireCore(List<File> files) {
try {
JavaXClassLoader classLoader = hotwire_makeClassLoader(files);
Class<?> theClass = classLoader.loadClass("main");
setOpt(theClass, "__javax", getJavaX());
if (getOpt(theClass, "programID") == null)
setOpt(theClass, "programID", "#3999999");
if (!_inCore())
hotwire_copyOver(theClass);
return theClass;
} catch (Exception __e) {
throw rethrow(__e);
}
}
public static List<File> loadLibraries(List<String> snippetIDs) {
return map("loadLibrary", snippetIDs);
}
public static String assertIdentifier(String s) {
return assertIsIdentifier(s);
}
public static String assertIdentifier(String msg, String s) {
return assertIsIdentifier(msg, s);
}
public static long sysNow() {
ping();
return System.nanoTime() / 1000000;
}
public static Class veryQuickJava(CharSequence mainJava) {
return veryQuickJava3(str(mainJava));
}
public static void saveTranspiledStandardFunctions(TreeSet<String> functionSet, String transpiledSrc) {
try {
saveTextFile(transpiledStandardFunctions_file(functionSet), transpiledSrc);
} catch (Throwable __e) {
_handleException(__e);
}
}
public static <A> A getAndClearThreadLocal(ThreadLocal<A> tl) {
A a = tl.get();
tl.set(null);
return a;
}
public static long done2_always(long startTime, String desc) {
long time = sysNow() - startTime;
print(desc + " [" + time + " ms]");
return time;
}
public static long done2_always(String desc, long startTime) {
return done2_always(startTime, desc);
}
public static long done2_always(long startTime) {
return done2_always(startTime, "");
}
public static Set<AutoCloseable> _registerAutoCloseable_set = synchroHashSet();
public static void _registerAutoCloseable(AutoCloseable c) {
addIfNotNull(_registerAutoCloseable_set, c);
}
public static void cleanMeUp__registerAutoCloseable() {
closeAutoCloseables(getAndClearList(_registerAutoCloseable_set));
}
public static <A> Set<A> syncIdentityHashSet() {
return (Set) synchronizedSet(identityHashSet());
}
public static <A> AutoCloseable tempAdd(final Collection<A> l, final A a) {
if (l == null || l.contains(a))
return null;
l.add(a);
return new AutoCloseable() {
public String toString() {
return "l.remove(a);";
}
public void close() throws Exception {
l.remove(a);
}
};
}
public static <A> A third(List<A> l) {
return _get(l, 2);
}
public static <A> A third(Iterable<A> l) {
if (l == null)
return null;
Iterator<A> it = iterator(l);
for (int _repeat_815 = 0; _repeat_815 < 2; _repeat_815++) {
if (!it.hasNext())
return null;
it.next();
}
return it.hasNext() ? it.next() : null;
}
public static <A> A third(A[] bla) {
return bla == null || bla.length <= 2 ? null : bla[2];
}
public static <A> VF1<A> runnableToVF1(final Runnable r) {
return r == null ? null : new VF1<A>() {
public void get(A a) {
try {
r.run();
} catch (Exception __e) {
throw rethrow(__e);
}
}
public String toString() {
return "r.run()";
}
};
}
public static Object callOptMC(String method, Object... args) {
return callOpt(mc(), method, args);
}
public static <A> ArrayList<A> litlist(A... a) {
ArrayList l = new ArrayList(a.length);
for (A x : a) l.add(x);
return l;
}
public static boolean isNormalQuoted(String s) {
int l = l(s);
if (!(l >= 2 && s.charAt(0) == '"' && lastChar(s) == '"'))
return false;
int j = 1;
while (j < l) if (s.charAt(j) == '"')
return j == l - 1;
else if (s.charAt(j) == '\\' && j + 1 < l)
j += 2;
else
++j;
return false;
}
public static boolean isMultilineQuoted(String s) {
if (!startsWith(s, "["))
return false;
int i = 1;
while (i < s.length() && s.charAt(i) == '=') ++i;
return i < s.length() && s.charAt(i) == '[';
}
public static boolean isJavaIdentifier(String s) {
if (empty(s) || !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;
}
public static boolean checkCondition(Object condition, Object... args) {
return isTrue(callF(condition, args));
}
public static <A, B extends A> void copyListPart(List<B> a, int i1, List<A> b, int i2, int n) {
if (a == null || b == null)
return;
for (int i = 0; i < n; i++) b.set(i2 + i, a.get(i1 + i));
}
public static File loadLibrary(String snippetID) {
return loadBinarySnippet(snippetID);
}
public static String _userHome;
public static String userHome() {
if (_userHome == null)
return actualUserHome();
return _userHome;
}
public static File userHome(String path) {
return new File(userDir(), path);
}
public static volatile boolean muricaPassword_pretendNotAuthed;
public static String muricaPassword() {
if (muricaPassword_pretendNotAuthed)
return null;
return trim(loadTextFile(muricaPasswordFile()));
}
public static String makePostData(Map<Object, Object> map) {
List<String> l = new ArrayList();
for (Map.Entry<Object, Object> e : map.entrySet()) {
String key = (String) (e.getKey());
Object val = e.getValue();
if (val != null) {
String value = str(val);
l.add(urlencode(key) + "=" + urlencode((value)));
}
}
return join("&", l);
}
public static String makePostData(Object... params) {
return makePostData(litorderedmap(params));
}
public static ThreadLocal<Boolean> doPost_silently = new ThreadLocal();
public static ThreadLocal<Long> doPost_timeout = new ThreadLocal();
public static String doPost(Map urlParameters, String url) {
return doPost(makePostData(urlParameters), url);
}
public static String doPost(String urlParameters, String url) {
try {
URL _url = new URL(url);
ping();
return doPost(urlParameters, _url.openConnection(), _url);
} catch (Exception __e) {
throw rethrow(__e);
}
}
public static String doPost(String urlParameters, URLConnection conn, URL url) {
try {
boolean silently = isTrue(optParam(doPost_silently));
Long timeout = optParam(doPost_timeout);
setHeaders(conn);
int l = lUtf8(urlParameters);
if (!silently)
print("Sending POST request: " + hideCredentials(url) + " (" + l + " bytes)");
if (timeout != null)
setURLConnectionTimeouts(conn, timeout);
((HttpURLConnection) conn).setRequestMethod("POST");
conn.setDoOutput(true);
conn.setRequestProperty("Content-Length", str(l));
OutputStreamWriter writer = new OutputStreamWriter(conn.getOutputStream(), "UTF-8");
writer.write(urlParameters);
writer.flush();
String contents = loadPage_utf8(conn, url, false);
writer.close();
return contents;
} catch (Exception __e) {
throw rethrow(__e);
}
}
public static List<String> jsonTok(String s) {
List<String> tok = new ArrayList();
int l = l(s);
int i = 0;
while (i < l) {
int j = i;
char c;
String cc;
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);
if (c == '\'' || c == '"') {
char opener = c;
++j;
while (j < l) {
if (s.charAt(j) == opener) {
++j;
break;
} else if (s.charAt(j) == '\\' && j + 1 < l)
j += 2;
else
++j;
}
} else if (Character.isLetter(c))
do ++j; while (j < l && Character.isLetter(s.charAt(j)));
else if (Character.isDigit(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;
}
public static String unquote(String s) {
if (s == null)
return null;
if (startsWith(s, '[')) {
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.length() > 1) {
char c = s.charAt(0);
if (c == '\"' || c == '\'') {
int l = endsWith(s, c) ? s.length() - 1 : s.length();
StringBuilder sb = new StringBuilder(l - 1);
for (int i = 1; i < l; i++) {
char ch = s.charAt(i);
if (ch == '\\') {
char nextChar = (i == l - 1) ? '\\' : s.charAt(i + 1);
if (nextChar >= '0' && nextChar <= '7') {
String code = "" + nextChar;
i++;
if ((i < l - 1) && s.charAt(i + 1) >= '0' && s.charAt(i + 1) <= '7') {
code += s.charAt(i + 1);
i++;
if ((i < l - 1) && s.charAt(i + 1) >= '0' && s.charAt(i + 1) <= '7') {
code += s.charAt(i + 1);
i++;
}
}
sb.append((char) Integer.parseInt(code, 8));
continue;
}
switch(nextChar) {
case '\"':
ch = '\"';
break;
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 'u':
if (i >= l - 5) {
ch = 'u';
break;
}
int code = Integer.parseInt("" + s.charAt(i + 2) + s.charAt(i + 3) + s.charAt(i + 4) + s.charAt(i + 5), 16);
sb.append(Character.toChars(code));
i += 5;
continue;
default:
ch = nextChar;
}
i++;
}
sb.append(ch);
}
return sb.toString();
}
}
return s;
}
public static double parseDouble(String s) {
return Double.parseDouble(s);
}
public static List collect(Collection c, String field) {
return collectField(c, field);
}
public static List collect(String field, Collection c) {
return collectField(c, field);
}
public static void sleepInCleanUp(long ms) {
try {
if (ms < 0)
return;
Thread.sleep(ms);
} catch (Exception __e) {
throw rethrow(__e);
}
}
public static String formatWithThousandsSeparator(long l) {
return NumberFormat.getInstance(new Locale("en_US")).format(l);
}
public static Runnable asRunnable(Object o) {
return toRunnable(o);
}
public static void _inheritThreadInfo(Object info) {
_threadInheritInfo(info);
}
public static File javaxCachesDir_dir;
public static File javaxCachesDir() {
return javaxCachesDir_dir != null ? javaxCachesDir_dir : new File(userHome(), "JavaX-Caches");
}
public static File javaxCachesDir(String sub) {
return newFile(javaxCachesDir(), sub);
}
public static void saveTextFileUnlessExists(File f, String contents) {
if (f != null && !f.exists())
saveTextFile(f, contents);
}
public static long recommendedTranspilationDateForStandardFunction(String sfName) {
return toLong(mechMap("Recommended SF Transpilation Date").get(sfName));
}
public static <A> boolean setAdd(Collection<A> c, A a) {
if (c == null || c.contains(a))
return false;
c.add(a);
return true;
}
public static void clearTokens(List<String> tok) {
clearAllTokens(tok);
}
public static void clearTokens(List<String> tok, int i, int j) {
clearAllTokens(tok, i, j);
}
public static JavaXClassLoader hotwire_makeClassLoader(List<File> files) {
Collection<String> toShare = hotwire_classesToShare();
return nempty(toShare) ? new JavaXClassLoaderWithParent2(null, files, myClassLoader(), cloneList(toShare)) : new JavaXClassLoader(null, files);
}
public static boolean _inCore() {
return false;
}
public static List hotwire_copyOver_after = synchroList();
public static void hotwire_copyOver(Class c) {
for (String field : ll("print_log", "print_silent", "androidContext", "_userHome")) setOptIfNotNull(c, field, getOpt(mc(), field));
setOptIfNotNull(c, "mainBot", getMainBot());
setOpt(c, "creator_class", new WeakReference(mc()));
pcallFAll(hotwire_copyOver_after, c);
}
public static String assertIsIdentifier(String s) {
if (!isIdentifier(s))
throw fail("Not an identifier: " + quote(s));
return s;
}
public static String assertIsIdentifier(String msg, String s) {
if (!isIdentifier(s))
throw fail(msg + " - Not an identifier: " + quote(s));
return s;
}
public static boolean veryQuickJava_silent = true;
public static boolean veryQuickJava_useCompilerBot = true;
public static ThreadLocal<String> veryQuickJava_transpiled = new ThreadLocal();
public static Object veryQuickJava3_cacheFunction;
public static Class veryQuickJava3(String mainJava) {
return veryQuickJava3(mainJava, emptyList());
}
public static Class veryQuickJava3(String mainJava, List<String> libs) {
Class c = (Class) (callF(veryQuickJava3_cacheFunction, mainJava, libs));
if (c != null)
return c;
transpileRaw_silent = veryQuickJava_silent;
String src = transpileRaw(mainJava);
if (veryQuickJava_transpiled.get() != null)
veryQuickJava_transpiled.set(src);
return veryQuickJava_finish(src, libs);
}
public static <A> Set<A> synchroHashSet() {
return Collections.synchronizedSet(new HashSet<A>());
}
public static <A> void addIfNotNull(Collection<A> l, A a) {
if (a != null && l != null)
l.add(a);
}
public static void closeAutoCloseables(Collection<AutoCloseable> l) {
if (l != null)
for (AutoCloseable c : l) {
try {
c.close();
} catch (Throwable __e) {
_handleException(__e);
}
}
}
public static <A> List<A> getAndClearList(Collection<A> l) {
if (l == null)
return emptyList();
synchronized (collectionMutex(l)) {
List<A> out = cloneList(l);
l.clear();
return out;
}
}
public static <A> Set<A> synchronizedSet() {
return synchroHashSet();
}
public static <A> Set<A> synchronizedSet(Set<A> set) {
return Collections.synchronizedSet(set);
}
public static <A> Set<A> identityHashSet() {
return Collections.newSetFromMap(new IdentityHashMap());
}
public static <A> A _get(List<A> l, int idx) {
return l != null && idx >= 0 && idx < l(l) ? l.get(idx) : null;
}
public static Object _get(Object o, String field) {
return get(o, field);
}
public static Object _get(String field, Object o) {
return get(o, field);
}
public static <A> A _get(A[] l, int idx) {
return idx >= 0 && idx < l(l) ? l[idx] : null;
}
public static File loadBinarySnippet(String snippetID) {
try {
IResourceLoader rl = vm_getResourceLoader();
if (rl != null)
return rl.loadLibrary(snippetID);
long id = parseSnippetID(snippetID);
if (isImageServerSnippet(id))
return loadImageAsFile(snippetID);
File f = DiskSnippetCache_getLibrary(id);
if (fileSize(f) == 0)
f = loadDataSnippetToFile(snippetID);
return f;
} catch (Exception __e) {
throw rethrow(__e);
}
}
public static String actualUserHome_value;
public static String actualUserHome() {
if (actualUserHome_value == null) {
if (isAndroid())
actualUserHome_value = "/storage/emulated/0/";
else
actualUserHome_value = System.getProperty("user.home");
}
return actualUserHome_value;
}
public static File actualUserHome(String sub) {
return newFile(new File(actualUserHome()), sub);
}
public static File userDir() {
return new File(userHome());
}
public static File userDir(String path) {
return new File(userHome(), path);
}
public static File muricaPasswordFile() {
return new File(javaxSecretDir(), "murica/muricaPasswordFile");
}
public static LinkedHashMap litorderedmap(Object... x) {
LinkedHashMap map = new LinkedHashMap();
litmap_impl(map, x);
return map;
}
public static void setHeaders(URLConnection con) throws IOException {
String computerID = getComputerID_quick();
if (computerID != null)
try {
con.setRequestProperty("X-ComputerID", computerID);
con.setRequestProperty("X-OS", System.getProperty("os.name") + " " + System.getProperty("os.version"));
} catch (Throwable e) {
}
}
public static int lUtf8(String s) {
return l(utf8(s));
}
public static URLConnection setURLConnectionTimeouts(URLConnection con, long timeout) {
con.setConnectTimeout(toInt(timeout));
con.setReadTimeout(toInt(timeout));
if (con.getConnectTimeout() != timeout || con.getReadTimeout() != timeout)
print("Warning: Timeouts not set by JDK.");
return con;
}
public static List collectField(Collection c, String field) {
List l = new ArrayList();
if (c != null)
for (Object a : c) l.add(getOpt(a, field));
return l;
}
public static List collectField(String field, Collection c) {
return collectField(c, field);
}
public static long toLong(Object o) {
if (o instanceof Number)
return ((Number) o).longValue();
if (o instanceof String)
return parseLong((String) o);
return 0;
}
public static Set<String> hotwire_classesToShare = synchroSet();
public static Set<String> hotwire_classesToShare() {
return hotwire_classesToShare;
}
public static ClassLoader myClassLoader() {
return _getClass(mc()).getClassLoader();
}
public static void setOptIfNotNull(Object o, String field, Object value) {
if (value != null)
setOpt(o, field, value);
}
public static Object mainBot;
public static Object getMainBot() {
return mainBot;
}
public static boolean transpileRaw_silent = true;
public static boolean transpileRaw_useDiskCache;
public static Class transpileRaw_trans;
public static boolean transpileRaw_verySilent;
public static boolean transpileRaw_dontCopyFromCreator;
public static Lock transpileRaw_lock = lock();
public static String transpileRaw(String mainJava) {
return transpileRaw(mainJava, false, transpileRaw_useDiskCache);
}
public static String transpileRaw(String mainJava, boolean fragment) {
return transpileRaw(mainJava, fragment, transpileRaw_useDiskCache);
}
public static String transpileRaw(String mainJava, boolean fragment, boolean useDiskCache) {
mainJava = dropTranslators(mainJava);
if (!transpileRaw_dontCopyFromCreator)
transpileRaw_copyFromCreator();
Lock __939 = transpileRaw_lock;
lock(__939);
try {
File cacheFile = null;
if (useDiskCache) {
cacheFile = new File(javaxCodeDir(), "Transpilations/" + uniqueFileNameUsingMD5_80_v2(mainJava) + ".java");
{
String _a_943 = loadTextFile(cacheFile);
if (!empty(_a_943))
return _a_943;
}
}
{
JWindow _loading_window = showLoadingAnimation("Transpiling...");
try {
transpileRaw_translator();
setOpt(transpileRaw_trans, "localStuffOnly", fragment);
set(transpileRaw_trans, "mainJava", mainJava);
set(transpileRaw_trans, "print_byThread", print_byThread);
if (!transpileRaw_verySilent) {
print("Running translator " + getOpt(transpileRaw_trans, "programID"));
if (!transpileRaw_silent) {
print("Translator ID: " + systemHashCode(transpileRaw_trans) + ", print_byThread=" + getTL((ThreadLocal) getOpt(transpileRaw_trans, "print_byThread")));
call(transpileRaw_trans, "print", "test");
}
}
callMain(transpileRaw_trans);
String main = (String) (get(transpileRaw_trans, "mainJava"));
if (useDiskCache) {
saveTextFile(new File(cacheFile.getPath() + "x"), mainJava);
saveTextFile(cacheFile, main);
}
return main;
} finally {
disposeWindow(_loading_window);
}
}
} finally {
unlock(__939);
}
}
public static Class transpileRaw_translator() {
if (transpileRaw_trans == null) {
transpileRaw_trans = hotwireSharingLibraries_silently(defaultJavaXTranslatorID());
makeDependent(transpileRaw_trans);
}
setOpt(transpileRaw_trans, "print_silent", transpileRaw_silent);
return transpileRaw_trans;
}
public static void transpileRaw_copyFromCreator() {
Lock __940 = transpileRaw_lock;
lock(__940);
try {
if (transpileRaw_trans != null)
return;
Object c = creator();
if (c == null)
return;
Class trans = (Class) (getOpt(c, "transpileRaw_trans"));
Lock lock = (Lock) (getOpt(c, "transpileRaw_lock"));
if (trans != null && lock != null) {
print("Using creator's transpiler: " + getProgramID(c) + " => " + programID());
transpileRaw_lock = lock;
transpileRaw_trans = trans;
}
} finally {
unlock(__940);
}
}
public static void cleanMeUp_transpileRaw() {
transpileRaw_trans = null;
}
public static IResourceLoader vm_getResourceLoader() {
return proxy(IResourceLoader.class, vm_generalMap_get("_officialResourceLoader"));
}
public static boolean isImageServerSnippet(long id) {
return id >= 1100000 && id < 1200000;
}
public static File loadImageAsFile(String snippetIDOrURL) {
try {
if (isURL(snippetIDOrURL))
throw fail("not implemented");
if (!isSnippetID(snippetIDOrURL))
throw fail("Not a URL or snippet ID: " + snippetIDOrURL);
String snippetID = "" + parseSnippetID(snippetIDOrURL);
File dir = imageSnippetsCacheDir();
if (loadBufferedImage_useImageCache) {
dir.mkdirs();
File file = new File(dir, snippetID + ".png");
if (file.exists() && file.length() != 0)
return file;
}
String imageURL = snippetImageURL_noHttps(snippetID);
System.err.println("Loading image: " + imageURL);
byte[] data = loadBinaryPage(imageURL);
File file = new File(dir, snippetID + ".png");
saveBinaryFile(file, data);
return file;
} catch (Exception __e) {
throw rethrow(__e);
}
}
public static File DiskSnippetCache_file(long snippetID) {
return new File(getGlobalCache(), "data_" + snippetID + ".jar");
}
public static File DiskSnippetCache_getLibrary(long snippetID) throws IOException {
File file = DiskSnippetCache_file(snippetID);
return file.exists() ? file : null;
}
public static void DiskSnippetCache_putLibrary(long snippetID, byte[] data) throws IOException {
saveBinaryFile(DiskSnippetCache_file(snippetID), data);
}
public static byte[] loadDataSnippetImpl(String snippetID) throws IOException {
byte[] data;
try {
URL url = new URL(dataSnippetLink(snippetID));
print("Loading library: " + hideCredentials(url));
try {
data = loadBinaryPage(url.openConnection());
} catch (RuntimeException e) {
data = null;
}
if (data == null || data.length == 0) {
url = new URL("http://data.tinybrain.de/blobs/" + parseSnippetID(snippetID));
print("Loading library: " + hideCredentials(url));
data = loadBinaryPage(url.openConnection());
}
print("Bytes loaded: " + data.length);
} catch (FileNotFoundException e) {
throw new IOException("Binary snippet #" + snippetID + " not found or not public");
}
return data;
}
public static long fileSize(String path) {
return getFileSize(path);
}
public static long fileSize(File f) {
return getFileSize(f);
}
public static File loadDataSnippetToFile(String snippetID) {
try {
snippetID = fsI(snippetID);
IResourceLoader rl = vm_getResourceLoader();
if (rl != null)
return rl.loadLibrary(snippetID);
File f = DiskSnippetCache_file(parseSnippetID(snippetID));
List<URL> urlsTried = new ArrayList();
List<Throwable> errors = new ArrayList();
try {
URL url = addAndReturn(urlsTried, new URL(dataSnippetLink(snippetID)));
print("Loading library: " + hideCredentials(url));
try {
loadBinaryPageToFile(openConnection(url), f);
if (fileSize(f) == 0)
throw fail();
} catch (Throwable e) {
errors.add(e);
url = addAndReturn(urlsTried, new URL("http://data.tinybrain.de/blobs/" + psI(snippetID)));
print("Trying other server: " + hideCredentials(url));
loadBinaryPageToFile(openConnection(url), f);
print("Got bytes: " + fileSize(f));
}
if (fileSize(f) == 0)
throw fail();
System.err.println("Bytes loaded: " + fileSize(f));
} catch (Throwable e) {
printStackTrace(e);
errors.add(e);
throw fail("Binary snippet " + snippetID + " not found or not public. URLs tried: " + allToString(urlsTried) + ", errors: " + allToString(errors));
}
return f;
} catch (Exception __e) {
throw rethrow(__e);
}
}
public static File javaxSecretDir_dir;
public static File javaxSecretDir() {
return javaxSecretDir_dir != null ? javaxSecretDir_dir : new File(userHome(), "JavaX-Secret");
}
public static File javaxSecretDir(String sub) {
return newFile(javaxSecretDir(), sub);
}
public static String getComputerID_quick() {
return computerID();
}
public static byte[] utf8(String s) {
return toUtf8(s);
}
public static <A> Set<A> synchroSet() {
return synchroHashSet();
}
public static <A> Set<A> synchroSet(Set<A> set) {
return Collections.synchronizedSet(set);
}
public static Class<?> _getClass(String name) {
try {
return Class.forName(name);
} catch (ClassNotFoundException e) {
return null;
}
}
public static Class _getClass(Object o) {
return o == null ? null : o instanceof Class ? (Class) o : o.getClass();
}
public static Class _getClass(Object realm, String name) {
try {
return getClass(realm).getClassLoader().loadClass(classNameToVM(name));
} catch (ClassNotFoundException e) {
return null;
}
}
public static String dropTranslators(String src) {
return findTranslators2(src, null);
}
public static List<String> dropTranslators(List<String> tok) {
return findTranslators2(tok, null);
}
public static File javaxCodeDir_dir;
public static File javaxCodeDir() {
return javaxCodeDir_dir != null ? javaxCodeDir_dir : new File(userHome(), "JavaX-Code");
}
public static File javaxCodeDir(String sub) {
return newFile(javaxCodeDir(), sub);
}
public static JWindow showLoadingAnimation() {
return showLoadingAnimation("Hold on user...");
}
public static JWindow showLoadingAnimation(String text) {
try {
return showAnimationInTopRightCorner("#1003543", text);
} catch (Throwable __e) {
return null;
}
}
public static void set(Object o, String field, Object value) {
if (o == null)
return;
if (o instanceof Class)
set((Class) o, field, value);
else
try {
Field f = set_findField(o.getClass(), field);
f.setAccessible(true);
smartSet(f, o, value);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
public static void set(Class c, String field, Object value) {
if (c == null)
return;
try {
Field f = set_findStaticField(c, field);
f.setAccessible(true);
smartSet(f, null, value);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
public static Field set_findStaticField(Class<?> c, String field) {
Class _c = c;
do {
for (Field f : _c.getDeclaredFields()) if (f.getName().equals(field) && (f.getModifiers() & java.lang.reflect.Modifier.STATIC) != 0)
return f;
_c = _c.getSuperclass();
} while (_c != null);
throw new RuntimeException("Static field '" + field + "' not found in " + c.getName());
}
public static Field set_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());
}
public static int systemHashCode(Object o) {
return identityHashCode(o);
}
public static Object getTL(Object o, String name) {
return getThreadLocal(o, name);
}
public static <A> A getTL(ThreadLocal<A> tl) {
return getThreadLocal(tl);
}
public static <A> A callMain(A c, String... args) {
callOpt(c, "main", new Object[] { args });
return c;
}
public static void callMain() {
callMain(mc());
}
public static void disposeWindow(final Window window) {
if (window != null) {
swing(new Runnable() {
public void run() {
try {
window.dispatchEvent(new WindowEvent(window, WindowEvent.WINDOW_CLOSING));
myFrames_list.remove(window);
window.dispose();
} catch (Exception __e) {
throw rethrow(__e);
}
}
public String toString() {
return "window.dispatchEvent(new WindowEvent(window, WindowEvent.WINDOW_CLOSING)); //...";
}
});
}
}
public static void disposeWindow(final Component c) {
disposeWindow(getWindow(c));
}
public static void disposeWindow(Object o) {
if (o != null)
disposeWindow(((Component) o));
}
public static void disposeWindow() {
disposeWindow(heldInstance(Component.class));
}
public static Class<?> hotwireSharingLibraries_silently(String progID) {
AutoCloseable __995 = tempSetThreadLocal(loadPage_silent, true);
try {
return hotwireSharingLibraries(progID);
} finally {
_close(__995);
}
}
public static String defaultJavaXTranslatorID_value = "#759";
public static String defaultJavaXTranslatorID() {
return defaultJavaXTranslatorID_value;
}
public static Object makeDependent_postProcess;
public static void makeDependent(Object c) {
if (c == null)
return;
assertTrue("Not a class", c instanceof Class);
dependentClasses();
hotwire_classes.add(new WeakReference(c));
Object local_log = getOpt(mc(), "local_log");
if (local_log != null)
setOpt(c, "local_log", local_log);
Object print_byThread = getOpt(mc(), "print_byThread");
if (print_byThread != null)
setOpt(c, "print_byThread", print_byThread);
callF(makeDependent_postProcess, c);
}
public static WeakReference<Object> creator_class;
public static Object creator() {
return creator_class == null ? null : creator_class.get();
}
public static boolean loadBufferedImage_useImageCache = true;
public static BufferedImage loadBufferedImage(String snippetIDOrURLOrFile) {
try {
ping();
if (snippetIDOrURLOrFile == null)
return null;
if (isURL(snippetIDOrURLOrFile))
return imageIO_readURL(snippetIDOrURLOrFile);
if (isAbsolutePath(snippetIDOrURLOrFile))
return loadBufferedImage(new File(snippetIDOrURLOrFile));
if (!isSnippetID(snippetIDOrURLOrFile))
throw fail("Not a URL or snippet ID or file: " + snippetIDOrURLOrFile);
String snippetID = "" + parseSnippetID(snippetIDOrURLOrFile);
IResourceLoader rl = vm_getResourceLoader();
if (rl != null)
return loadBufferedImage(rl.loadLibrary(snippetID));
File dir = imageSnippetsCacheDir();
if (loadBufferedImage_useImageCache) {
dir.mkdirs();
File file = new File(dir, snippetID + ".png");
if (file.exists() && file.length() != 0)
try {
return ImageIO.read(file);
} catch (Throwable e) {
e.printStackTrace();
}
}
String imageURL = snippetImageURL_http(snippetID);
print("Loading image: " + imageURL);
BufferedImage image = imageIO_readURL(imageURL);
if (loadBufferedImage_useImageCache) {
File tempFile = new File(dir, snippetID + ".tmp." + System.currentTimeMillis());
ImageIO.write(image, "png", tempFile);
tempFile.renameTo(new File(dir, snippetID + ".png"));
}
return image;
} catch (Exception __e) {
throw rethrow(__e);
}
}
public static BufferedImage loadBufferedImage(File file) {
try {
return file.isFile() ? ImageIO.read(file) : null;
} catch (Exception __e) {
throw rethrow(__e);
}
}
public static Map<JFrame, Boolean> myFrames_list = weakHashMap();
public static List<JFrame> myFrames() {
return swing(new F0<List<JFrame>>() {
public List<JFrame> get() {
try {
return keysList(myFrames_list);
} catch (Exception __e) {
throw rethrow(__e);
}
}
public String toString() {
return "ret keysList(myFrames_list);";
}
});
}
public static <A> A proxy(Class<A> intrface, final Object target) {
if (target == null)
return null;
if (isInstance(intrface, target))
return (A) target;
return (A) java.lang.reflect.Proxy.newProxyInstance(intrface.getClassLoader(), new Class[] { intrface }, new InvocationHandler() {
public Object invoke(Object proxy, Method method, Object[] args) {
return call(target, method.getName(), unnull(args));
}
});
}
public static <A> A proxy(Object target, Class<A> intrface) {
return proxy(intrface, target);
}
public static Object vm_generalMap_get(Object key) {
return vm_generalMap().get(key);
}
public static boolean isURL(String s) {
return startsWithOneOf(s, "http://", "https://", "file:");
}
public static File imageSnippetsCacheDir() {
return javaxCachesDir("Image-Snippets");
}
public static String snippetImageURL_noHttps(String snippetID) {
return snippetImageURL_noHttps(snippetID, "png");
}
public static String snippetImageURL_noHttps(String snippetID, String contentType) {
return snippetImageURL(snippetID, contentType).replace("https://www.botcompany.de:8443/", "http://www.botcompany.de:8080/").replace("https://botcompany.de/", "http://botcompany.de/");
}
public static ThreadLocal<Map<String, List<String>>> loadBinaryPage_responseHeaders = new ThreadLocal();
public static ThreadLocal<Map<String, String>> loadBinaryPage_extraHeaders = new ThreadLocal();
public static byte[] loadBinaryPage(String url) {
try {
print("Loading " + url);
return loadBinaryPage(loadPage_openConnection(new URL(url)));
} catch (Exception __e) {
throw rethrow(__e);
}
}
public static byte[] loadBinaryPage(URLConnection con) {
try {
Map<String, String> extraHeaders = getAndClearThreadLocal(loadBinaryPage_extraHeaders);
setHeaders(con);
for (String key : keys(extraHeaders)) con.setRequestProperty(key, extraHeaders.get(key));
return loadBinaryPage_noHeaders(con);
} catch (Exception __e) {
throw rethrow(__e);
}
}
public static byte[] loadBinaryPage_noHeaders(URLConnection con) {
try {
ByteArrayOutputStream buf = new ByteArrayOutputStream();
InputStream inputStream = con.getInputStream();
loadBinaryPage_responseHeaders.set(con.getHeaderFields());
long len = 0;
try {
len = con.getContentLength();
} catch (Throwable e) {
printStackTrace(e);
}
int n = 0;
while (true) {
int ch = inputStream.read();
if (ch < 0)
break;
buf.write(ch);
if (++n % 100000 == 0)
println(" " + n + (len != 0 ? "/" + len : "") + " bytes loaded.");
}
inputStream.close();
return buf.toByteArray();
} catch (Exception __e) {
throw rethrow(__e);
}
}
public static byte[] saveBinaryFile(String fileName, byte[] contents) {
try {
File file = new File(fileName);
File parentFile = file.getParentFile();
if (parentFile != null)
parentFile.mkdirs();
String tempFileName = fileName + "_temp";
FileOutputStream fileOutputStream = newFileOutputStream(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);
vmBus_send("wroteFile", file);
return contents;
} catch (Exception __e) {
throw rethrow(__e);
}
}
public static byte[] saveBinaryFile(File fileName, byte[] contents) {
return saveBinaryFile(fileName.getPath(), contents);
}
public static File getGlobalCache() {
File file = new File(javaxCachesDir(), "Binary Snippets");
file.mkdirs();
return file;
}
public static String dataSnippetLink(String snippetID) {
long id = parseSnippetID(snippetID);
if (id >= 1100000 && id < 1200000)
return imageServerURL() + id;
if (id >= 1400000 && id < 1500000)
return "http://butter.botcompany.de:8080/files/" + id + "?_pass=" + muricaPassword();
if (id >= 1200000 && id < 1300000) {
String pw = muricaPassword();
if (empty(pw))
throw fail("Please set 'murica password by running #1008829");
return "http://butter.botcompany.de:8080/1008823/raw/" + id + "?_pass=" + pw;
} else
return "http://eyeocr.sourceforge.net/filestore/filestore.php?cmd=serve&file=blob_" + id + "&contentType=application/binary";
}
public static String fsI(String id) {
return formatSnippetID(id);
}
public static String fsI(long id) {
return formatSnippetID(id);
}
public static <B, A extends B> A addAndReturn(Collection<B> c, A a) {
if (c != null)
c.add(a);
return a;
}
public static void loadBinaryPageToFile(String url, File file) {
try {
print("Loading " + url);
loadBinaryPageToFile(openConnection(new URL(url)), file);
} catch (Exception __e) {
throw rethrow(__e);
}
}
public static void loadBinaryPageToFile(URLConnection con, File file) {
try {
setHeaders(con);
loadBinaryPageToFile_noHeaders(con, file);
} catch (Exception __e) {
throw rethrow(__e);
}
}
public static void loadBinaryPageToFile_noHeaders(URLConnection con, File file) {
try {
File ftemp = new File(f2s(file) + "_temp");
FileOutputStream buf = newFileOutputStream(mkdirsFor(ftemp));
try {
InputStream inputStream = con.getInputStream();
long len = 0;
try {
len = con.getContentLength();
} catch (Throwable e) {
printStackTrace(e);
}
String pat = " {*}" + (len != 0 ? "/" + len : "") + " bytes loaded.";
copyStreamWithPrints(inputStream, buf, pat);
inputStream.close();
buf.close();
file.delete();
renameFile_assertTrue(ftemp, file);
} finally {
if (buf != null)
buf.close();
}
} catch (Exception __e) {
throw rethrow(__e);
}
}
public static URLConnection openConnection(URL url) {
try {
ping();
callOpt(javax(), "recordOpenURLConnection", str(url));
return url.openConnection();
} catch (Exception __e) {
throw rethrow(__e);
}
}
public static long psI(String snippetID) {
return parseSnippetID(snippetID);
}
public static List<String> allToString(Collection c) {
List<String> l = new ArrayList();
for (Object o : unnull(c)) l.add(str(o));
return l;
}
public static List<String> allToString(Object[] c) {
List<String> l = new ArrayList();
for (Object o : unnull(c)) l.add(str(o));
return l;
}
public static String _computerID;
public static Lock computerID_lock = lock();
public static String computerID() {
if (_computerID == null) {
Lock __1041 = computerID_lock;
lock(__1041);
try {
if (_computerID != null)
return _computerID;
File file = computerIDFile();
_computerID = loadTextFile(file.getPath());
if (_computerID == null) {
_computerID = loadTextFile(userDir(".tinybrain/computer-id"));
if (_computerID == null)
_computerID = makeRandomID(12, new SecureRandom());
saveTextFile(file, _computerID);
}
} finally {
unlock(__1041);
}
}
return _computerID;
}
public static Class<?> getClass(String name) {
try {
return Class.forName(name);
} catch (ClassNotFoundException e) {
return null;
}
}
public static Class getClass(Object o) {
return o instanceof Class ? (Class) o : o.getClass();
}
public static Class getClass(Object realm, String name) {
try {
try {
return getClass(realm).getClassLoader().loadClass(classNameToVM(name));
} catch (ClassNotFoundException e) {
return null;
}
} catch (Exception __e) {
throw rethrow(__e);
}
}
public static String classNameToVM(String name) {
return name.replace(".", "$");
}
public static boolean showAnimationInTopRightCorner_alwaysOnTop = true;
public static boolean showAnimationInTopRightCorner_on = true;
public static JWindow showAnimationInTopRightCorner(String imageID, String text) {
if (isHeadless() || !showAnimationInTopRightCorner_on)
return null;
return showAnimationInTopRightCorner(imageIcon(imageID), text);
}
public static JWindow showAnimationInTopRightCorner(final Image image, final String text) {
if (image == null || isHeadless() || !showAnimationInTopRightCorner_on)
return null;
return showAnimationInTopRightCorner(imageIcon(image), text);
}
public static JWindow showAnimationInTopRightCorner(final ImageIcon imageIcon, final String text) {
if (isHeadless() || !showAnimationInTopRightCorner_on)
return null;
return (JWindow) swingAndWait(new F0<Object>() {
public Object get() {
try {
JLabel label = new JLabel(imageIcon);
if (nempty(text)) {
label.setText(text);
label.setVerticalTextPosition(SwingConstants.BOTTOM);
label.setHorizontalTextPosition(SwingConstants.CENTER);
}
final JWindow window = showInTopRightCorner(label);
onClick(label, new Runnable() {
public void run() {
try {
window.dispose();
} catch (Exception __e) {
throw rethrow(__e);
}
}
public String toString() {
return "window.dispose()";
}
});
if (showAnimationInTopRightCorner_alwaysOnTop)
window.setAlwaysOnTop(true);
return window;
} catch (Exception __e) {
throw rethrow(__e);
}
}
public String toString() {
return "JLabel label = new JLabel(imageIcon);\r\n if (nempty(text)) {\r\n label.s...";
}
});
}
public static JWindow showAnimationInTopRightCorner(final String imageID) {
return showAnimationInTopRightCorner(imageID, "");
}
public static JWindow showAnimationInTopRightCorner(String imageID, double seconds) {
return showAnimationInTopRightCorner(imageID, "", seconds);
}
public static JWindow showAnimationInTopRightCorner(String imageID, String text, double seconds) {
if (isHeadless())
return null;
return disposeWindowAfter(iround(seconds * 1000), showAnimationInTopRightCorner(imageID, text));
}
public static JWindow showAnimationInTopRightCorner(BufferedImage img, String text, double seconds) {
return disposeWindowAfter(iround(seconds * 1000), showAnimationInTopRightCorner(img, text));
}
public static void smartSet(Field f, Object o, Object value) throws Exception {
try {
f.set(o, value);
} catch (Exception e) {
Class type = f.getType();
if (type == int.class && value instanceof Long)
value = ((Long) value).intValue();
if (type == LinkedHashMap.class && value instanceof Map) {
f.set(o, asLinkedHashMap((Map) value));
return;
}
try {
if (f.getType() == Concept.Ref.class) {
f.set(o, ((Concept) o).new Ref((Concept) value));
return;
}
if (o instanceof Concept.Ref) {
f.set(o, ((Concept.Ref) o).get());
return;
}
} catch (Throwable _e) {
}
throw e;
}
}
public static int identityHashCode(Object o) {
return System.identityHashCode(o);
}
public static Window getWindow(Object o) {
if (!(o instanceof Component))
return null;
Component c = (Component) o;
while (c != null) {
if (c instanceof Window)
return (Window) c;
c = c.getParent();
}
return null;
}
public static <A> A heldInstance(Class<A> c) {
List<Object> l = holdInstance_l.get();
for (int i = l(l) - 1; i >= 0; i--) {
Object o = l.get(i);
if (isInstanceOf(o, c))
return (A) o;
}
throw fail("No instance of " + className(c) + " held");
}
public static Class<?> hotwireSharingLibraries(String progID) {
try {
Pair<File, String> p = CompilerBot.compileSnippet2(progID);
File jar = p.a;
assertTrue(f2s(jar), jar.isFile());
List<File> files = ll(jar);
String dehlibs = unnull(loadTextFileFromZip(jar, "libraries"));
List<File> myLibraries = myLibraryFiles();
Matcher matcher = Pattern.compile("\\d+").matcher(dehlibs);
while (matcher.find()) {
String libID = matcher.group();
File lib = loadLibrary(libID);
if (myLibraries.contains(lib)) {
} else {
files.add(lib);
}
}
JavaXClassLoaderWithParent classLoader = new JavaXClassLoaderWithParent(progID, files, myClassLoader());
return hotwire_finish(classLoader, progID, p.b);
} catch (Exception __e) {
throw rethrow(__e);
}
}
public static List<Class> dependentClasses() {
return cleanUpAndGetWeakReferencesList(hotwire_classes);
}
public static ThreadLocal<List<Object>> holdInstance_l = new ThreadLocal();
public static AutoCloseable holdInstance(Object o) {
if (o == null)
return null;
listThreadLocalAdd(holdInstance_l, o);
return new AutoCloseable() {
public void close() {
listThreadLocalPopLast(holdInstance_l);
}
};
}
public static List<WeakReference<Class>> hotwire_classes = synchroList();
public static Class<?> hotwireDependent(String src) {
Class c = hotwire(src);
makeDependent(c);
return c;
}
public static BufferedImage imageIO_readURL(String url) {
try {
if (startsWith(url, "https:"))
disableCertificateValidation();
return ImageIO.read(new URL(url));
} catch (Exception __e) {
throw rethrow(__e);
}
}
public static boolean isAbsolutePath(String s) {
return s != null && new File(s).isAbsolute();
}
public static boolean isAbsolutePath(File f) {
return f != null && f.isAbsolute();
}
public static String snippetImageURL_http(String snippetID) {
return snippetImageURL_http(snippetID, "png");
}
public static String snippetImageURL_http(String snippetID, String contentType) {
return replacePrefix("https://", "http://", snippetImageURL(snippetID, contentType)).replace(":8443", ":8080");
}
public static <A, B> Map<A, B> weakHashMap() {
return newWeakHashMap();
}
public static <A, B> List<A> keysList(Map<A, B> map) {
return cloneListSynchronizingOn(keys(map), map);
}
public static boolean isInstance(Class type, Object arg) {
return type.isInstance(arg);
}
public static Map vm_generalMap_map;
public static Map vm_generalMap() {
if (vm_generalMap_map == null)
vm_generalMap_map = (Map) get(javax(), "generalMap");
return vm_generalMap_map;
}
public static boolean startsWithOneOf(String s, String... l) {
for (String x : l) if (startsWith(s, x))
return true;
return false;
}
public static String snippetImageURL(String snippetID) {
return snippetImageURL(snippetID, "png");
}
public static String snippetImageURL(String snippetID, String contentType) {
if (isURL(snippetID))
return snippetID;
long id = parseSnippetID(snippetID);
String url;
if (id == 1000010 || id == 1000012)
url = "http://tinybrain.de:8080/tb/show-blobimage.php?id=" + id;
else if (isImageServerSnippet(id))
url = imageServerLink(id);
else
url = "https://www.botcompany.de:8443/img/" + id;
return url;
}
public static int loadPage_defaultTimeout = 60000;
public static ThreadLocal<String> loadPage_charset = new ThreadLocal();
public static boolean loadPage_allowGzip = true, loadPage_debug;
public static boolean loadPage_anonymous;
public static int loadPage_verboseness = 100000;
public static int loadPage_retries = 1;
public static ThreadLocal<Boolean> loadPage_silent = new ThreadLocal();
public static volatile int loadPage_forcedTimeout;
public static ThreadLocal<Integer> loadPage_forcedTimeout_byThread = new ThreadLocal();
public static ThreadLocal<Map<String, List<String>>> loadPage_responseHeaders = new ThreadLocal();
public static ThreadLocal<Map<String, String>> loadPage_extraHeaders = new ThreadLocal();
public static String loadPageSilently(String url) {
try {
return loadPageSilently(new URL(loadPage_preprocess(url)));
} catch (Exception __e) {
throw rethrow(__e);
}
}
public static String loadPageSilently(URL url) {
try {
if (url.getProtocol().equals("https"))
disableCertificateValidation();
if (!networkAllowanceTest(str(url)))
throw fail("Not allowed: " + url);
IOException e = null;
for (int tries = 0; tries < loadPage_retries; tries++) try {
URLConnection con = loadPage_openConnection(url);
return loadPage(con, url);
} catch (IOException _e) {
e = _e;
if (loadPageThroughProxy_enabled) {
print("Trying proxy because of: " + e);
try {
return loadPageThroughProxy(str(url));
} catch (Throwable e2) {
print(" " + exceptionToStringShort(e2));
}
} else if (loadPage_debug)
print(exceptionToStringShort(e));
if (tries < loadPage_retries - 1)
sleepSeconds(1);
}
throw e;
} catch (Exception __e) {
throw rethrow(__e);
}
}
public static String loadPage_preprocess(String url) {
if (url.startsWith("tb/"))
url = tb_mainServer() + "/" + url;
if (url.indexOf("://") < 0)
url = "http://" + url;
return url;
}
public static String loadPage(String url) {
try {
url = loadPage_preprocess(url);
if (!isTrue(loadPage_silent.get()))
printWithTime("Loading: " + hideCredentials(url));
return loadPageSilently(new URL(url));
} catch (Exception __e) {
throw rethrow(__e);
}
}
public static String loadPage(URL url) {
return loadPage(url.toExternalForm());
}
public static String loadPage(URLConnection con, URL url) throws IOException {
return loadPage(con, url, true);
}
public static String loadPage(URLConnection con, URL url, boolean addHeaders) throws IOException {
Map<String, String> extraHeaders = getAndClearThreadLocal(loadPage_extraHeaders);
if (addHeaders)
try {
if (!loadPage_anonymous)
setHeaders(con);
if (loadPage_allowGzip)
con.setRequestProperty("Accept-Encoding", "gzip");
con.setRequestProperty("X-No-Cookies", "1");
for (String key : keys(extraHeaders)) con.setRequestProperty(key, extraHeaders.get(key));
} catch (Throwable e) {
}
vm_generalSubMap("URLConnection per thread").put(currentThread(), con);
loadPage_responseHeaders.set(con.getHeaderFields());
InputStream in = null;
try {
in = urlConnection_getInputStream(con);
if (loadPage_debug)
print("Put stream in map: " + currentThread());
String contentType = con.getContentType();
if (contentType == null) {
throw new IOException("Page could not be read: " + hideCredentials(url));
}
String charset = loadPage_charset == null ? null : loadPage_charset.get();
if (charset == null)
charset = loadPage_guessCharset(contentType);
if ("gzip".equals(con.getContentEncoding())) {
if (loadPage_debug)
print("loadPage: Using gzip.");
in = newGZIPInputStream(in);
}
Reader r;
try {
r = new InputStreamReader(in, unquote(charset));
} catch (UnsupportedEncodingException e) {
print(toHex(utf8(charset)));
throw e;
}
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();
} finally {
if (loadPage_debug)
print("loadPage done");
vm_generalSubMap("URLConnection per thread").remove(currentThread());
if (in != null)
in.close();
}
}
public static String loadPage_guessCharset(String contentType) {
Matcher m = regexpMatcher("text/[a-z]+;\\s*charset=([^\\s]+)\\s*", contentType);
String match = m.matches() ? m.group(1) : null;
if (loadPage_debug)
print("loadPage: contentType=" + contentType + ", match: " + match);
return or(match, "UTF-8");
}
public static URLConnection loadPage_openConnection(URL url) {
URLConnection con = openConnection(url);
int timeout = toInt(loadPage_forcedTimeout_byThread.get());
if (timeout == 0)
timeout = loadPage_forcedTimeout;
if (timeout != 0)
setURLConnectionTimeouts(con, loadPage_forcedTimeout);
else
setURLConnectionDefaultTimeouts(con, loadPage_defaultTimeout);
return con;
}
public static <A> A println(A a) {
return print(a);
}
public static String imageServerURL() {
return or2(trim(loadTextFile(javaxDataDir("image-server-url.txt"))), "http://botcompany.de/images/raw/");
}
public static File mkdirsFor(File file) {
return mkdirsForFile(file);
}
public static void copyStreamWithPrints(InputStream in, OutputStream out, String pat) {
try {
byte[] buf = new byte[65536];
int total = 0;
while (true) {
int n = in.read(buf);
if (n <= 0)
return;
out.write(buf, 0, n);
if ((total + n) / 100000 > total / 100000)
print(pat.replace("{*}", str(roundDownTo(total, 100000))));
total += n;
}
} catch (Exception __e) {
throw rethrow(__e);
}
}
public static void renameFile_assertTrue(File a, File b) {
try {
if (!a.exists())
throw fail("Source file not found: " + f2s(a));
if (b.exists())
throw fail("Target file exists: " + f2s(b));
mkdirsForFile(b);
if (!a.renameTo(b))
throw fail("Can't rename " + f2s(a) + " to " + f2s(b));
} catch (Exception __e) {
throw rethrow(__e);
}
}
public static File computerIDFile() {
return javaxDataDir("Basic Info/computer-id.txt");
}
public static String makeRandomID(int length) {
return makeRandomID(length, defaultRandomGenerator());
}
public static String makeRandomID(int length, Random 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);
}
public static int imageIcon_cacheSize = 10;
public static boolean imageIcon_verbose;
public static Map<String, ImageIcon> imageIcon_cache;
public static Lock imageIcon_lock = lock();
public static ThreadLocal<Boolean> imageIcon_fixGIF = new ThreadLocal();
public static ImageIcon imageIcon(String imageID) {
try {
if (imageID == null)
return null;
Lock __1144 = imageIcon_lock;
lock(__1144);
try {
if (imageIcon_cache == null)
imageIcon_cache = new MRUCache(imageIcon_cacheSize);
imageID = fsI(imageID);
ImageIcon ii = imageIcon_cache.get(imageID);
if (ii == null) {
if (imageIcon_verbose)
print("Loading image icon: " + imageID);
File f = loadBinarySnippet(imageID);
Boolean b = imageIcon_fixGIF.get();
if (!isFalse(b))
ii = new ImageIcon(loadBufferedImageFixingGIFs(f));
else
ii = new ImageIcon(f.toURI().toURL());
} else
imageIcon_cache.remove(imageID);
imageIcon_cache.put(imageID, ii);
return ii;
} finally {
unlock(__1144);
}
} catch (Exception __e) {
throw rethrow(__e);
}
}
public static ImageIcon imageIcon(File f) {
try {
return new ImageIcon(f.toURI().toURL());
} catch (Exception __e) {
throw rethrow(__e);
}
}
public static ImageIcon imageIcon(Image img) {
return new ImageIcon(img);
}
public static ImageIcon imageIcon(RGBImage img) {
return imageIcon(img.getBufferedImage());
}
public static JWindow showInTopRightCorner(Component c) {
JWindow w = new JWindow();
w.add(c);
w.pack();
moveToTopRightCorner(w);
w.setVisible(true);
return w;
}
public static <A extends JComponent> A onClick(final A c, final Object runnable) {
if (c != null) {
swing(new Runnable() {
public void run() {
try {
c.addMouseListener(new MouseAdapter() {
public void mouseClicked(MouseEvent e) {
callF(runnable, e);
}
});
} catch (Exception __e) {
throw rethrow(__e);
}
}
public String toString() {
return "c.addMouseListener(new MouseAdapter {\r\n public void mouseClicked(MouseEv...";
}
});
}
return c;
}
public static void onClick(JButton btn, final Object runnable) {
onEnter(btn, runnable);
}
public static <A extends Window> A disposeWindowAfter(int delay, final A w) {
if (w != null)
swingLater(delay, new Runnable() {
public void run() {
try {
w.dispose();
} catch (Exception __e) {
throw rethrow(__e);
}
}
public String toString() {
return "w.dispose();";
}
});
return w;
}
public static <A extends Window> A disposeWindowAfter(A w, double seconds) {
return disposeWindowAfter(toMS_int(seconds), w);
}
public static <A extends Window> A disposeWindowAfter(double seconds, A w) {
return disposeWindowAfter(w, seconds);
}
public static int iround(double d) {
return (int) Math.round(d);
}
public static int iround(Number n) {
return iround(toDouble(n));
}
public static boolean isInstanceOf(Object o, Class type) {
return type.isInstance(o);
}
public static String loadTextFileFromZip(File inZip, String fileName) {
return loadTextFileFromZipFile(inZip, fileName);
}
public static List<File> myLibraryFiles() {
return (List<File>) get(myClassLoader(), "files");
}
public static Class hotwire_finish(ClassLoader classLoader, String progID, String javaSource) {
return hotwire_finish(classLoader, progID, javaSource, "main");
}
public static Class hotwire_finish(ClassLoader classLoader, String progID, String javaSource, String mainClass) {
try {
Class<?> theClass = classLoader.loadClass(mainClass);
Class j = getJavaX();
setOpt(theClass, "myJavaSource_code", javaSource);
synchronized (j) {
call(j, "setVars", theClass, progID);
callOpt(j, "addInstance", progID, theClass);
}
hotwire_copyOver(theClass);
return theClass;
} catch (Exception __e) {
throw rethrow(__e);
}
}
public static <A> List<A> cleanUpAndGetWeakReferencesList(List<WeakReference<A>> l) {
if (l == null)
return null;
synchronized (l) {
List<A> out = new ArrayList();
for (int i = 0; i < l(l); i++) {
A a = l.get(i).get();
if (a == null)
l.remove(i--);
else
out.add(a);
}
return out;
}
}
public static <A> void listThreadLocalAdd(ThreadLocal<List<A>> tl, A a) {
List<A> l = tl.get();
if (l == null)
tl.set(l = new ArrayList());
l.add(a);
}
public static <A> A listThreadLocalPopLast(ThreadLocal<List<A>> tl) {
List<A> l = tl.get();
if (l == null)
return null;
A a = popLast(l);
if (empty(l))
tl.set(null);
return a;
}
public static Class<?> hotwire(String src) {
assertFalse(_inCore());
Class j = getJavaX();
if (isAndroid()) {
synchronized (j) {
List<File> libraries = new ArrayList<File>();
File srcDir = (File) call(j, "transpileMain", src, libraries);
if (srcDir == null)
throw fail("transpileMain returned null (src=" + quote(src) + ")");
Object androidContext = get(j, "androidContext");
return (Class) call(j, "loadx2android", srcDir, src);
}
} else {
Class c = (Class) (call(j, "hotwire", src));
hotwire_copyOver(c);
return c;
}
}
public static volatile boolean disableCertificateValidation_attempted;
public static void disableCertificateValidation() {
try {
if (disableCertificateValidation_attempted)
return;
disableCertificateValidation_attempted = true;
try {
TrustManager[] trustAllCerts = new TrustManager[] { new X509TrustManager() {
public X509Certificate[] getAcceptedIssuers() {
return new X509Certificate[0];
}
public void checkClientTrusted(X509Certificate[] certs, String authType) {
}
public void checkServerTrusted(X509Certificate[] certs, String authType) {
}
} };
HostnameVerifier hv = new HostnameVerifier() {
public boolean verify(String hostname, SSLSession session) {
return true;
}
};
SSLContext sc = SSLContext.getInstance("SSL");
sc.init(null, trustAllCerts, new SecureRandom());
HttpsURLConnection.setDefaultSSLSocketFactory(sc.getSocketFactory());
HttpsURLConnection.setDefaultHostnameVerifier(hv);
} catch (Throwable __e) {
_handleException(__e);
}
} catch (Exception __e) {
throw rethrow(__e);
}
}
public static <A> ArrayList<A> cloneListSynchronizingOn(Collection<A> l, Object mutex) {
if (l == null)
return new ArrayList();
synchronized (mutex) {
return new ArrayList<A>(l);
}
}
public static String imageServerLink(String md5OrID) {
if (possibleMD5(md5OrID))
return "https://botcompany.de/images/md5/" + md5OrID;
return imageServerLink(parseSnippetID(md5OrID));
}
public static String imageServerLink(long id) {
return "https://botcompany.de/images/" + id;
}
public static boolean networkAllowanceTest(String url) {
return isAllowed("networkAllowanceTest", url);
}
public static final boolean loadPageThroughProxy_enabled = false;
public static String loadPageThroughProxy(String url) {
return null;
}
public static String exceptionToStringShort(Throwable e) {
lastException(e);
e = getInnerException(e);
String msg = hideCredentials(unnull(e.getMessage()));
if (msg.indexOf("Error") < 0 && msg.indexOf("Exception") < 0)
return baseClassName(e) + prependIfNempty(": ", msg);
else
return msg;
}
public static void sleepSeconds(double s) {
if (s > 0)
sleep(round(s * 1000));
}
public static String tb_mainServer_default = "http://tinybrain.de:8080";
public static Object tb_mainServer_override;
public static String tb_mainServer() {
if (tb_mainServer_override != null)
return (String) callF(tb_mainServer_override);
return trim(loadTextFile(tb_mainServer_file(), tb_mainServer_default));
}
public static File tb_mainServer_file() {
return getProgramFile("#1001638", "mainserver.txt");
}
public static boolean tb_mainServer_isDefault() {
return eq(tb_mainServer(), tb_mainServer_default);
}
public static <A> A printWithTime(A a) {
print(hmsWithColons() + ": " + a);
return a;
}
public static Map vm_generalSubMap(Object name) {
synchronized (get(javax(), "generalMap")) {
Map map = (Map) (vm_generalMap_get(name));
if (map == null)
vm_generalMap_put(name, map = synchroMap());
return map;
}
}
public static InputStream urlConnection_getInputStream(URLConnection con) throws IOException {
UnknownHostException lastException = null;
for (int _repeat_1058 = 0; _repeat_1058 < 2; _repeat_1058++) {
try {
return con.getInputStream();
} catch (UnknownHostException e) {
lastException = e;
print("Retrying because of: " + e);
continue;
}
}
throw lastException;
}
public static String toHex(byte[] bytes) {
return bytesToHex(bytes);
}
public static String toHex(byte[] bytes, int ofs, int len) {
return bytesToHex(bytes, ofs, len);
}
public static Matcher regexpMatcher(String pat, String s) {
return compileRegexp(pat).matcher(unnull(s));
}
public static URLConnection setURLConnectionDefaultTimeouts(URLConnection con, long timeout) {
if (con.getConnectTimeout() == 0) {
con.setConnectTimeout(toInt(timeout));
if (con.getConnectTimeout() != timeout)
print("Warning: URL connect timeout not set by JDK.");
}
if (con.getReadTimeout() == 0) {
con.setReadTimeout(toInt(timeout));
if (con.getReadTimeout() != timeout)
print("Warning: URL read timeout not set by JDK.");
}
return con;
}
public static String or2(String a, String b) {
return nempty(a) ? a : b;
}
public static String or2(String a, String b, String c) {
return or2(or2(a, b), c);
}
public static int roundDownTo(int x, int n) {
return x / n * n;
}
public static long roundDownTo(long x, long n) {
return x / n * n;
}
public static Random defaultRandomGenerator() {
return ThreadLocalRandom.current();
}
public static boolean loadBufferedImageFixingGIFs_debug;
public static ThreadLocal<Var<byte[]>> loadBufferedImageFixingGIFs_output = new ThreadLocal();
public static Image loadBufferedImageFixingGIFs(File file) {
try {
if (!file.exists())
return null;
if (!isGIF(file))
return ImageIO.read(file);
if (loadBufferedImageFixingGIFs_debug)
print("loadBufferedImageFixingGIFs" + ": checking gif");
ImageReader reader = ImageIO.getImageReadersByFormatName("gif").next();
reader.setInput(ImageIO.createImageInputStream(file));
int numImages = reader.getNumImages(true);
IIOMetadata imageMetaData = reader.getImageMetadata(0);
String metaFormatName = imageMetaData.getNativeMetadataFormatName();
boolean foundBug = false;
for (int i = 0; i < numImages && !foundBug; i++) {
IIOMetadataNode root = (IIOMetadataNode) reader.getImageMetadata(i).getAsTree(metaFormatName);
int nNodes = root.getLength();
for (int j = 0; j < nNodes; j++) {
org.w3c.dom.Node node = root.item(j);
if (node.getNodeName().equalsIgnoreCase("GraphicControlExtension")) {
String delay = ((IIOMetadataNode) node).getAttribute("delayTime");
if (Integer.parseInt(delay) == 0) {
foundBug = true;
}
break;
}
}
}
if (loadBufferedImageFixingGIFs_debug)
print("loadBufferedImageFixingGIFs" + ": " + f2s(file) + " foundBug=" + foundBug);
Image image;
if (!foundBug) {
image = Toolkit.getDefaultToolkit().createImage(f2s(file));
} else {
ByteArrayOutputStream baoStream = new ByteArrayOutputStream();
{
ImageOutputStream ios = ImageIO.createImageOutputStream(baoStream);
try {
ImageWriter writer = ImageIO.getImageWriter(reader);
writer.setOutput(ios);
writer.prepareWriteSequence(null);
for (int i = 0; i < numImages; i++) {
BufferedImage frameIn = reader.read(i);
IIOMetadataNode root = (IIOMetadataNode) reader.getImageMetadata(i).getAsTree(metaFormatName);
int nNodes = root.getLength();
for (int j = 0; j < nNodes; j++) {
org.w3c.dom.Node node = root.item(j);
if (node.getNodeName().equalsIgnoreCase("GraphicControlExtension")) {
String delay = ((IIOMetadataNode) node).getAttribute("delayTime");
if (Integer.parseInt(delay) == 0) {
((IIOMetadataNode) node).setAttribute("delayTime", "10");
}
break;
}
}
IIOMetadata metadata = writer.getDefaultImageMetadata(new ImageTypeSpecifier(frameIn), null);
metadata.setFromTree(metadata.getNativeMetadataFormatName(), root);
IIOImage frameOut = new IIOImage(frameIn, null, metadata);
writer.writeToSequence(frameOut, writer.getDefaultWriteParam());
}
writer.endWriteSequence();
} finally {
_close(ios);
}
}
byte[] data = baoStream.toByteArray();
setVar(loadBufferedImageFixingGIFs_output.get(), data);
if (loadBufferedImageFixingGIFs_debug)
print("Data size: " + l(data));
image = Toolkit.getDefaultToolkit().createImage(data);
}
return image;
} catch (Exception __e) {
throw rethrow(__e);
}
}
public static int moveToTopRightCorner_inset = 20;
public static <A extends Component> A moveToTopRightCorner(A a) {
return moveToTopRightCorner(moveToTopRightCorner_inset, moveToTopRightCorner_inset, a);
}
public static <A extends Component> A moveToTopRightCorner(int insetX, int insetY, A a) {
Window w = getWindow(a);
if (w != null)
w.setLocation(getScreenSize().width - w.getWidth() - insetX, insetY);
return a;
}
public static JTextField onEnter(final JTextField tf, final Object action) {
if (action == null || tf == null)
return tf;
tf.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent _evt) {
try {
tf.selectAll();
callF(action);
} catch (Throwable __e) {
messageBox(__e);
}
}
});
return tf;
}
public static JButton onEnter(JButton btn, final Object action) {
if (action == null || btn == null)
return btn;
btn.addActionListener(actionListener(action));
return btn;
}
public static JList onEnter(JList list, Object action) {
list.addKeyListener(enterKeyListener(rCallOnSelectedListItem(list, action)));
return list;
}
public static JComboBox onEnter(final JComboBox cb, final Object action) {
{
swing(new Runnable() {
public void run() {
try {
if (cb.isEditable()) {
JTextField text = (JTextField) cb.getEditor().getEditorComponent();
onEnter(text, action);
} else {
cb.getInputMap().put(KeyStroke.getKeyStroke("ENTER"), "enter");
cb.getActionMap().put("enter", abstractAction("", new Runnable() {
public void run() {
try {
cb.hidePopup();
callF(action);
} catch (Exception __e) {
throw rethrow(__e);
}
}
public String toString() {
return "cb.hidePopup(); callF(action);";
}
}));
}
} catch (Exception __e) {
throw rethrow(__e);
}
}
public String toString() {
return "if (cb.isEditable()) {\r\n JTextField text = (JTextField) cb.getEditor().g...";
}
});
}
return cb;
}
public static JTable onEnter(final JTable table, final Object action) {
table.getInputMap(JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT).put(KeyStroke.getKeyStroke(KeyEvent.VK_ENTER, 0), "Enter");
table.getActionMap().put("Enter", new AbstractAction() {
public void actionPerformed(ActionEvent e) {
callF(action, table.getSelectedRow());
}
});
return table;
}
public static JTextField onEnter(Object action, JTextField tf) {
return onEnter(tf, action);
}
public static void swingLater(long delay, final Object r) {
javax.swing.Timer timer = new javax.swing.Timer(toInt(delay), actionListener(wrapAsActivity(r)));
timer.setRepeats(false);
timer.start();
}
public static void swingLater(Object r) {
SwingUtilities.invokeLater(toRunnable(r));
}
public static int toMS_int(double seconds) {
return toInt_checked((long) (seconds * 1000));
}
public static double toDouble(Object o) {
if (o instanceof Number)
return ((Number) o).doubleValue();
if (o instanceof BigInteger)
return ((BigInteger) o).doubleValue();
if (o == null)
return 0.0;
throw fail(o);
}
public static <A> A popLast(List<A> l) {
return liftLast(l);
}
public static void assertFalse(Object o) {
if (!(eq(o, false)))
throw fail(str(o));
}
public static boolean assertFalse(boolean b) {
if (b)
throw fail("oops");
return b;
}
public static boolean assertFalse(String msg, boolean b) {
if (b)
throw fail(msg);
return b;
}
public static boolean possibleMD5(String s) {
return isMD5(s);
}
public static volatile Object isAllowed_function;
public static volatile boolean isAllowed_all = true;
public static boolean isAllowed(String askingMethod, Object... args) {
Object f = vm_generalMap_get("isAllowed_function");
if (f != null && !isTrue(callF(f, askingMethod, args)))
return false;
return isAllowed_all || isTrue(callF(isAllowed_function, askingMethod, args));
}
public static String baseClassName(String className) {
return substring(className, className.lastIndexOf('.') + 1);
}
public static String baseClassName(Object o) {
return baseClassName(getClassName(o));
}
public static String prependIfNempty(String prefix, String s) {
return empty(s) ? s : prefix + s;
}
public static volatile boolean sleep_noSleep;
public static void sleep(long ms) {
ping();
if (ms < 0)
return;
if (isAWTThread() && ms > 100)
throw fail("Should not sleep on AWT thread");
try {
Thread.sleep(ms);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
public static void sleep() {
try {
if (sleep_noSleep)
throw fail("nosleep");
print("Sleeping.");
sleepQuietly();
} catch (Exception __e) {
throw rethrow(__e);
}
}
public static long round(double d) {
return Math.round(d);
}
public static File getProgramFile(String progID, String fileName) {
if (new File(fileName).isAbsolute())
return new File(fileName);
return new File(getProgramDir(progID), fileName);
}
public static File getProgramFile(String fileName) {
return getProgramFile(getProgramID(), fileName);
}
public static String hmsWithColons() {
return hmsWithColons(now());
}
public static String hmsWithColons(long time) {
return new SimpleDateFormat("HH:mm:ss").format(time);
}
public static Object vm_generalMap_put(Object key, Object value) {
return mapPutOrRemove(vm_generalMap(), key, value);
}
public static Map<String, java.util.regex.Pattern> compileRegexp_cache = syncMRUCache(10);
public static java.util.regex.Pattern compileRegexp(String pat) {
java.util.regex.Pattern p = compileRegexp_cache.get(pat);
if (p == null) {
compileRegexp_cache.put(pat, p = java.util.regex.Pattern.compile(pat));
}
return p;
}
public static byte[] isGIF_magic = bytesFromHex("47494638");
public static boolean isGIF(byte[] data) {
return byteArrayStartsWith(data, isGIF_magic);
}
public static boolean isGIF(File f) {
return isGIF(loadBeginningOfBinaryFile(f, l(isGIF_magic)));
}
public static <A> void setVar(IVar<A> v, A value) {
if (v != null)
v.set(value);
}
public static Dimension getScreenSize() {
return Toolkit.getDefaultToolkit().getScreenSize();
}
public static void messageBox(final String msg) {
if (headless())
print(msg);
else {
swing(new Runnable() {
public void run() {
try {
JOptionPane.showMessageDialog(null, msg, "JavaX", JOptionPane.INFORMATION_MESSAGE);
} catch (Exception __e) {
throw rethrow(__e);
}
}
public String toString() {
return "JOptionPane.showMessageDialog(null, msg, \"JavaX\", JOptionPane.INFORMATION_MES...";
}
});
}
}
public static void messageBox(Throwable e) {
printStackTrace(e);
messageBox(hideCredentials(innerException2(e)));
}
public static ActionListener actionListener(final Object runnable) {
return actionListener(runnable, null);
}
public static ActionListener actionListener(final Object runnable, final Object instanceToHold) {
if (runnable instanceof ActionListener)
return (ActionListener) runnable;
final Object info = _threadInfo();
return new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent _evt) {
try {
_threadInheritInfo(info);
AutoCloseable __1210 = holdInstance(instanceToHold);
try {
callF(runnable);
} finally {
_close(__1210);
}
} catch (Throwable __e) {
messageBox(__e);
}
}
};
}
public static KeyListener enterKeyListener(final Object action) {
return new KeyAdapter() {
public void keyPressed(KeyEvent ke) {
if (ke.getKeyCode() == KeyEvent.VK_ENTER)
pcallF(action);
}
};
}
public static Runnable rCallOnSelectedListItem(final JList list, final Object action) {
return new Runnable() {
public void run() {
try {
pcallF(action, getSelectedItem(list));
} catch (Exception __e) {
throw rethrow(__e);
}
}
public String toString() {
return "pcallF(action, getSelectedItem(list))";
}
};
}
public static AbstractAction abstractAction(String name, final Object runnable) {
return new AbstractAction(name) {
public void actionPerformed(ActionEvent evt) {
pcallF(runnable);
}
};
}
public static int toInt_checked(long l) {
if (l != (int) l)
throw fail("Too large for int: " + l);
return (int) l;
}
public static <A> A liftLast(List<A> l) {
if (l.isEmpty())
return null;
int i = l(l) - 1;
A a = l.get(i);
l.remove(i);
return a;
}
public static boolean isMD5(String s) {
return l(s) == 32 && isLowerHexString(s);
}
public static Object sleepQuietly_monitor = new Object();
public static void sleepQuietly() {
try {
assertFalse(isAWTThread());
synchronized (sleepQuietly_monitor) {
sleepQuietly_monitor.wait();
}
} catch (Exception __e) {
throw rethrow(__e);
}
}
public static File getProgramDir() {
return programDir();
}
public static File getProgramDir(String snippetID) {
return programDir(snippetID);
}
public static <A, B> B mapPutOrRemove(Map<A, B> map, A key, B value) {
if (map != null && key != null)
if (value != null)
return map.put(key, value);
else
return map.remove(key);
return null;
}
public static <A, B> Map<A, B> syncMRUCache(int size) {
return synchroMap(new MRUCache(size));
}
public static byte[] bytesFromHex(String s) {
return hexToBytes(s);
}
public static boolean byteArrayStartsWith(byte[] a, byte[] b) {
if (a == null || b == null)
return false;
if (a.length < b.length)
return false;
for (int i = 0; i < b.length; i++) if (a[i] != b[i])
return false;
return true;
}
public static byte[] loadBeginningOfBinaryFile(File file, int maxBytes) {
return loadBinaryFilePart(file, 0, maxBytes);
}
public static boolean headless() {
return isHeadless();
}
public static String getSelectedItem(JList l) {
return (String) l.getSelectedValue();
}
public static String getSelectedItem(JComboBox cb) {
return strOrNull(cb.getSelectedItem());
}
public static boolean isLowerHexString(String s) {
for (int i = 0; i < l(s); i++) {
char c = s.charAt(i);
if (c >= '0' && c <= '9' || c >= 'a' && c <= 'f') {
} else
return false;
}
return true;
}
public static File programDir_mine;
public static File programDir() {
return programDir(getProgramID());
}
public static File programDir(String snippetID) {
boolean me = sameSnippetID(snippetID, programID());
if (programDir_mine != null && me)
return programDir_mine;
File dir = new File(javaxDataDir(), formatSnippetIDOpt(snippetID));
if (me) {
String c = caseID();
if (nempty(c))
dir = newFile(dir, c);
}
return dir;
}
public static File programDir(String snippetID, String subPath) {
return new File(programDir(snippetID), subPath);
}
public static byte[] hexToBytes(String s) {
if (odd(l(s)))
throw fail("Hex string has odd length: " + quote(shorten(10, s)));
int n = l(s) / 2;
byte[] bytes = new byte[n];
for (int i = 0; i < n; i++) {
int a = parseHexChar(s.charAt(i * 2));
int b = parseHexChar(s.charAt(i * 2 + 1));
if (a < 0 || b < 0)
throw fail("Bad hex byte: " + quote(substring(s, i * 2, i * 2 + 2)) + " at " + i * 2 + "/" + l(s));
bytes[i] = (byte) ((a << 4) | b);
}
return bytes;
}
public static byte[] loadBinaryFilePart(File file, long start, long end) {
try {
RandomAccessFile raf = new RandomAccessFile(file, "r");
int n = toInt(min(raf.length(), end - start));
byte[] buffer = new byte[n];
try {
raf.seek(start);
raf.readFully(buffer, 0, n);
return buffer;
} finally {
raf.close();
}
} catch (Exception __e) {
throw rethrow(__e);
}
}
public static String strOrNull(Object o) {
return o == null ? null : str(o);
}
public static boolean sameSnippetID(String a, String b) {
if (!isSnippetID(a) || !isSnippetID(b))
return false;
return parseSnippetID(a) == parseSnippetID(b);
}
public static volatile String caseID_caseID;
public static String caseID() {
return caseID_caseID;
}
public static void caseID(String id) {
caseID_caseID = id;
}
public static int shorten_default = 100;
public static String shorten(String s) {
return shorten(s, shorten_default);
}
public static String shorten(String s, int max) {
return shorten(s, max, "...");
}
public static String shorten(String s, int max, String shortener) {
if (s == null)
return "";
if (max < 0)
return s;
return s.length() <= max ? s : substring(s, 0, min(s.length(), max - l(shortener))) + shortener;
}
public static String shorten(int max, String s) {
return shorten(s, max);
}
public static int parseHexChar(char c) {
if (c >= '0' && c <= '9')
return charDiff(c, '0');
if (c >= 'a' && c <= 'f')
return charDiff(c, 'a') + 10;
if (c >= 'A' && c <= 'F')
return charDiff(c, 'A') + 10;
return -1;
}
public static int charDiff(char a, char b) {
return (int) a - (int) b;
}
public static int charDiff(String a, char b) {
return charDiff(stringToChar(a), b);
}
public static char stringToChar(String s) {
if (l(s) != 1)
throw fail("bad stringToChar: " + s);
return firstChar(s);
}
public static char firstChar(String s) {
return s.charAt(0);
}
public static final class _MethodCache {
public final Class c;
public final HashMap<String, List<Method>> cache = new HashMap();
public _MethodCache(Class c) {
this.c = c;
_init();
}
public void _init() {
Class _c = c;
while (_c != null) {
for (Method m : _c.getDeclaredMethods()) if (!reflection_isForbiddenMethod(m))
multiMapPut(cache, m.getName(), makeAccessible(m));
_c = _c.getSuperclass();
}
for (Class intf : allInterfacesImplementedBy(c)) for (Method m : intf.getDeclaredMethods()) if (m.isDefault() && !reflection_isForbiddenMethod(m))
multiMapPut(cache, m.getName(), makeAccessible(m));
}
public Method findMethod(String method, Object[] args) {
try {
List<Method> m = cache.get(method);
if (m == null)
return null;
int n = m.size();
for (int i = 0; i < n; i++) {
Method me = m.get(i);
if (call_checkArgs(me, args, false))
return me;
}
return null;
} catch (Exception __e) {
throw rethrow(__e);
}
}
public Method findStaticMethod(String method, Object[] args) {
try {
List<Method> m = cache.get(method);
if (m == null)
return null;
int n = m.size();
for (int i = 0; i < n; i++) {
Method me = m.get(i);
if (isStaticMethod(me) && call_checkArgs(me, args, false))
return me;
}
return null;
} catch (Exception __e) {
throw rethrow(__e);
}
}
}
public abstract static class VF2<A, B> {
public abstract void get(A a, B b);
}
public static class JavaXClassLoader extends URLClassLoader {
public String progID;
public List<File> files;
public Set<String> triedToLoad = synchroSet();
public Set<Class> loadedClasses = synchroSet();
public boolean retired;
public Object retiredMarker;
public JavaXClassLoader(String progID, List<File> files) {
this(progID, files, getSystemClassLoader());
}
public JavaXClassLoader(String progID, List<File> files, ClassLoader parent) {
super(new URL[0], parent);
this.progID = progID;
this.files = files;
{
try {
for (File f : files) addURL(f.toURI().toURL());
} catch (Exception __e) {
throw rethrow(__e);
}
}
fixACCInClassLoader(this);
}
public Class<?> findClass(String name) throws ClassNotFoundException {
boolean triedBefore = !triedToLoad.add(name);
try {
Class<?> c = super.findClass(name);
loadedClasses.add(c);
if (eq(name, "main"))
callOpt(javax(), "registerAMainClass", c);
return c;
} catch (ClassNotFoundException e) {
throw new ClassNotFoundException("Class " + name + " not found in " + joinWithComma(map("f2s", files)) + " (progID=" + progID + ")" + (triedBefore ? ", tried to load before" : ""), e);
}
}
public String toString() {
return "JavaXClassLoader[" + systemHashCodeHex(this) + "] - " + progID;
}
}
public static class Var<A> implements IVar<A> {
public Var() {
}
public Var(A v) {
this.v = v;
}
public A v;
public synchronized void set(A a) {
if (v != a) {
v = a;
notifyAll();
}
}
public synchronized A get() {
return v;
}
public synchronized boolean has() {
return v != null;
}
public synchronized void clear() {
v = null;
}
public String toString() {
return str(get());
}
}
public static class MechListDependentCache<A> extends Cache<A> {
public String listName, lastListContents;
public MechListDependentCache() {
}
public MechListDependentCache(String listName, Object maker) {
this.maker = maker;
this.listName = listName;
}
public A make() {
return (A) callF(maker, lastListContents);
}
public A get() {
if (hasLock(lock))
return value;
{
String listContents = mL_raw(listName);
Lock __1270 = lock;
lock(__1270);
try {
if (!eqOrSame(listContents, lastListContents))
clear();
lastListContents = listContents;
} finally {
unlock(__1270);
}
}
return super.get();
}
}
public static class JavaXClassLoaderWithParent extends JavaXClassLoader {
public ClassLoader virtualParent;
public JavaXClassLoaderWithParent(String progID, List<File> files, ClassLoader virtualParent) {
super(progID, files);
this.virtualParent = virtualParent;
}
public Class<?> findClass(String name) throws ClassNotFoundException {
if (virtualParent != null && !eq(name, "main") && !name.startsWith("main$")) {
try {
return virtualParent.loadClass(name);
} catch (ClassNotFoundException e) {
}
}
return super.findClass(name);
}
}
public static class LinkedTreeSet<A> extends AbstractSet<A> {
public Set<A> set;
public LinkedList<A> list = new LinkedList();
public LinkedTreeSet() {
set = new TreeSet();
}
public LinkedTreeSet(Set<A> set) {
this.set = set;
}
public int size() {
return list.size();
}
public Iterator<A> iterator() {
return list.iterator();
}
public boolean contains(Object o) {
return set.contains(o);
}
public boolean add(A a) {
if (!set.add(a))
return false;
{
list.add(a);
return true;
}
}
public boolean remove(Object o) {
if (!set.remove(o))
return false;
{
list.remove(o);
return true;
}
}
}
public abstract static class TokCondition {
public abstract boolean get(List<String> tok, int i);
}
public abstract static class IterableIterator<A> implements Iterator<A>, Iterable<A> {
public Iterator<A> iterator() {
return this;
}
public void remove() {
unsupportedOperation();
}
}
public static class MRUCache<A, B> extends LinkedHashMap<A, B> {
public int maxSize = 10;
public MRUCache() {
}
public MRUCache(int maxSize) {
this.maxSize = maxSize;
}
public boolean removeEldestEntry(Map.Entry eldest) {
return size() > maxSize;
}
}
public static class MultiMap<A, B> {
public Map<A, List<B>> data = new HashMap<A, List<B>>();
public MultiMap() {
}
public MultiMap(boolean useTreeMap) {
if (useTreeMap)
data = new TreeMap();
}
public MultiMap(MultiMap<A, B> map) {
putAll(map);
}
public MultiMap(Map<A, List<B>> data) {
this.data = data;
}
public void put(A key, B value) {
synchronized (data) {
List<B> list = data.get(key);
if (list == null)
data.put(key, list = _makeEmptyList());
list.add(value);
}
}
public void addAll(A key, Collection<B> values) {
synchronized (data) {
putAll(key, values);
}
}
public void addAllIfNotThere(A key, Collection<B> values) {
synchronized (data) {
for (B value : values) setPut(key, value);
}
}
public void setPut(A key, B value) {
synchronized (data) {
if (!containsPair(key, value))
put(key, value);
}
}
public boolean containsPair(A key, B value) {
synchronized (data) {
return get(key).contains(value);
}
}
public void putAll(A key, Collection<B> values) {
synchronized (data) {
for (B value : values) put(key, value);
}
}
public void removeAll(A key, Collection<B> values) {
synchronized (data) {
for (B value : values) remove(key, value);
}
}
public List<B> get(A key) {
synchronized (data) {
List<B> list = data.get(key);
return list == null ? Collections.<B>emptyList() : list;
}
}
public List<B> getActual(A key) {
synchronized (data) {
List<B> list = data.get(key);
if (list == null)
data.put(key, list = _makeEmptyList());
return list;
}
}
public void clean(A key) {
synchronized (data) {
List<B> list = data.get(key);
if (list != null && list.isEmpty())
data.remove(key);
}
}
public Set<A> keySet() {
synchronized (data) {
return data.keySet();
}
}
public Set<A> keys() {
synchronized (data) {
return data.keySet();
}
}
public void remove(A key) {
synchronized (data) {
data.remove(key);
}
}
public void remove(A key, B value) {
synchronized (data) {
List<B> list = data.get(key);
if (list != null) {
list.remove(value);
if (list.isEmpty())
data.remove(key);
}
}
}
public void clear() {
synchronized (data) {
data.clear();
}
}
public boolean containsKey(A key) {
synchronized (data) {
return data.containsKey(key);
}
}
public B getFirst(A key) {
synchronized (data) {
List<B> list = get(key);
return list.isEmpty() ? null : list.get(0);
}
}
public void addAll(MultiMap<A, B> map) {
putAll(map);
}
public void putAll(MultiMap<A, B> map) {
synchronized (data) {
for (A key : map.keySet()) putAll(key, map.get(key));
}
}
public int keysSize() {
synchronized (data) {
return l(data);
}
}
public int size() {
synchronized (data) {
int n = 0;
for (List l : data.values()) n += l(l);
return n;
}
}
public List<A> reverseGet(B b) {
synchronized (data) {
List<A> l = new ArrayList();
for (A key : data.keySet()) if (data.get(key).contains(b))
l.add(key);
return l;
}
}
public Map<A, List<B>> asMap() {
synchronized (data) {
return cloneMap(data);
}
}
public boolean isEmpty() {
synchronized (data) {
return data.isEmpty();
}
}
public List<B> _makeEmptyList() {
return new ArrayList();
}
public Collection<List<B>> allLists() {
synchronized (data) {
return new ArrayList(data.values());
}
}
public List<B> allValues() {
return concatLists(values(data));
}
public Object mutex() {
return data;
}
public String toString() {
return "mm" + str(data);
}
}
public static interface IF0<A> {
public A get();
}
public abstract static class CloseableIterableIterator<A> extends IterableIterator<A> implements AutoCloseable {
public void close() throws Exception {
}
}
public static class ExpiringMap2<A, B> extends AbstractMap<A, B> {
public Map<A, Pair<Long, B>> byKey = new HashMap();
public PriorityBlockingQueue<Pair<Long, A>> queue = new PriorityBlockingQueue();
public long standardExpiryTime;
public boolean renewOnOverwrite = true, renewOnGet;
public Object onChange;
public ExpiringMap2() {
}
public ExpiringMap2(long standardExpiryTime) {
this.standardExpiryTime = standardExpiryTime;
}
public ExpiringMap2(long standardExpiryTime, Object onChange) {
this.onChange = onChange;
this.standardExpiryTime = standardExpiryTime;
}
public synchronized boolean clean() {
boolean changes = false;
Pair<Long, A> p;
while ((p = queue.peek()) != null && sysTime() >= p.a) {
p = queue.poll();
Pair<Long, B> v = byKey.get(p.b);
if (v != null) {
byKey.remove(p.b);
changes = true;
change();
}
}
return changes;
}
public void change() {
callF(onChange);
}
public synchronized B put(A a, B b) {
clean();
long timeout = sysTime() + standardExpiryTime;
Pair<Long, B> p = byKey.get(a);
if (p != null && renewOnOverwrite)
queue.remove(new Pair(p.a, a));
byKey.put(a, pair(timeout, b));
change();
if (p == null || renewOnOverwrite)
queue.add(new Pair(timeout, a));
return pairB(p);
}
public synchronized B remove(Object a) {
clean();
Pair<Long, B> p = byKey.get(a);
if (p == null)
return null;
queue.remove(new Pair(p.a, a));
byKey.remove(a);
change();
return p.b;
}
public synchronized B get(Object a) {
clean();
Pair<Long, B> p = byKey.get(a);
if (renewOnGet && p != null) {
queue.remove(new Pair(p.a, a));
long timeout = sysTime() + standardExpiryTime;
byKey.put((A) a, pair(timeout, p.b));
queue.add(new Pair(timeout, a));
}
return pairB(p);
}
public synchronized Set<Map.Entry<A, B>> entrySet() {
clean();
return synchronizedSet(mapValues("pairB", byKey).entrySet());
}
public synchronized Set<A> keySet() {
clean();
return synchronizedSet(byKey.keySet());
}
public synchronized int size() {
clean();
return byKey.size();
}
public void setStandardExpiryTime(long ms) {
standardExpiryTime = ms;
}
public synchronized ExpiringMap2<A, B> setMap(Map innerMap) {
byKey = innerMap;
return this;
}
}
public static class JavaXClassLoaderWithParent2 extends JavaXClassLoader {
public ClassLoader virtualParent;
public List<String> classesToSkip;
public JavaXClassLoaderWithParent2(String progID, List<File> files, ClassLoader virtualParent, List<String> classesToSkip) {
super(progID, files);
this.virtualParent = virtualParent;
this.classesToSkip = classesToSkip;
}
public Class<?> findClass(String name) throws ClassNotFoundException {
if (shouldDelegate(name)) {
Class<?> c = virtualParent.loadClass(name);
if (c != null)
return c;
}
return super.findClass(name);
}
public boolean shouldDelegate(String name) {
for (String s : classesToSkip) if (eq(name, s) || startsWith(name, s + "$"))
return true;
return false;
}
}
public static class Lowest<A> {
public A best;
public double score;
public transient Object onChange;
public synchronized boolean isNewBest(double score) {
return best == null || score < this.score;
}
public synchronized double bestScore() {
return best == null ? Double.NaN : score;
}
public double score() {
return bestScore();
}
public synchronized float floatScore() {
return best == null ? Float.NaN : (float) score;
}
public synchronized float floatScoreOr(float defaultValue) {
return best == null ? defaultValue : (float) score;
}
public boolean put(A a, double score) {
boolean change = false;
synchronized (this) {
if (a != null && isNewBest(score)) {
best = a;
this.score = score;
change = true;
}
}
if (change)
pcallF(onChange);
return change;
}
public synchronized A get() {
return best;
}
public synchronized boolean has() {
return best != null;
}
}
public static interface IResourceLoader {
public String loadSnippet(String snippetID);
public String getTranspiled(String snippetID);
public int getSnippetType(String snippetID);
public String getSnippetTitle(String snippetID);
public File loadLibrary(String snippetID);
public File pathToJavaXJar();
public File getSnippetJar(String snippetID, String transpiledSrc);
}
public static interface IVar<A> {
public void set(A a);
public A get();
public boolean has();
public void clear();
}
public abstract static class WordTokRule extends Attractor implements RuleOnTok, RuleOnString {
public String pattern;
public Set<String> vars;
public boolean debug;
public transient List<String> tokPat;
public transient Map<String, String> map;
public WordTokRule() {
}
public WordTokRule(String pattern, String... vars) {
this.pattern = pattern;
this.vars = litciset(vars);
}
public WordTokRule(String pattern, Set<String> vars) {
this.vars = vars;
this.pattern = pattern;
}
public List<String> tokPat() {
if (tokPat == null)
tokPat = wordTok(pattern);
return tokPat;
}
public boolean validate() {
return true;
}
public boolean matches(String s) {
process(s);
if (map != null && !validate())
map = null;
return matched();
}
public void process(String s) {
process(wordTok(s));
}
public void process(List<String> tok) {
map = nullIfContainsKeysOtherThan(gazelle_zipTwoTokenizationsToMap(tokPat(), tok), vars);
if (debug)
print(pattern + " + " + join(tok) + " => " + map);
}
public boolean matched() {
return map != null;
}
public String getVar(String name) {
return getOrKeep(map, name);
}
}
public static class MechMode {
public Object readMode;
public Object writeMode;
public MechMode() {
}
public MechMode(Object readMode, Object writeMode) {
this.writeMode = writeMode;
this.readMode = readMode;
}
public String toString() {
return "MechMode(" + readMode + ", " + writeMode + ")";
}
public boolean equals(Object o) {
if (!(o instanceof MechMode))
return false;
MechMode x = (MechMode) o;
return eq(readMode, x.readMode) && eq(writeMode, x.writeMode);
}
public int hashCode() {
int h = -866263200;
h = h * 2 + _hashCode(readMode);
h = h * 2 + _hashCode(writeMode);
return h;
}
}
public static class CompilerBot {
public static boolean verbose;
public static File compileSnippet(String snippetID) {
return compileSnippet(snippetID, "");
}
public static Pair<File, String> compileSnippet2(String snippetID) {
return compileSnippet2(snippetID, "");
}
public static File compileSnippet(String snippetID, String javaTarget) {
return compileSnippet2(snippetID, javaTarget).a;
}
public static Pair<File, String> compileSnippet2(String snippetID, String javaTarget) {
String transpiledSrc = getServerTranspiled2(snippetID);
int i = transpiledSrc.indexOf('\n');
String libs = transpiledSrc.substring(0, Math.max(0, i));
if (verbose)
print("Compiling snippet: " + snippetID + ". Libs: " + libs);
transpiledSrc = transpiledSrc.substring(i + 1);
return pair(compile(transpiledSrc, libs, javaTarget, snippetID), transpiledSrc);
}
public static File compile(String src) {
return compile(src, "");
}
public static File compile(String src, String libs) {
return compile(src, libs, null);
}
public static File compile(String src, String dehlibs, String javaTarget) {
return compile(src, dehlibs, javaTarget, null);
}
public static File compile(String src, String dehlibs, String javaTarget, String progID) {
if (verbose)
print("Compiling " + l(src) + " chars");
String md5 = md5(dehlibs + "\n" + src + "\n" + progID);
File jar = getJarFile(md5);
if (jar == null || jar.length() <= 22) {
List<String> mainClass = findMainClass(javaTok(src));
boolean canRename = mainClass != null && useDummyMainClasses() && isSnippetID(progID) && !tok_classHasModifier(mainClass, "public");
if (verbose)
print("useRenaming: " + useDummyMainClasses() + ", canRename: " + canRename + ", progID: " + progID);
javaCompileToJar_optionalRename(src, dehlibs, jar, canRename ? progID : null, progID);
} else {
if (verbose)
print("Getting classes from cache (" + jar.getAbsolutePath() + ", " + jar.length() + " bytes)");
touchFile(jar);
}
return jar;
}
public static File getJarFile(String md5) {
assertTrue(isMD5(md5));
return new File(getCacheProgramDir("#1002203"), md5 + ".jar");
}
}
public static class Pair<A, B> implements Comparable<Pair<A, B>> {
public A a;
public B b;
public Pair() {
}
public Pair(A a, B b) {
this.b = b;
this.a = a;
}
public int hashCode() {
return hashCodeFor(a) + 2 * hashCodeFor(b);
}
public boolean equals(Object o) {
if (o == this)
return true;
if (!(o instanceof Pair))
return false;
Pair t = (Pair) o;
return eq(a, t.a) && eq(b, t.b);
}
public String toString() {
return "<" + a + ", " + b + ">";
}
public int compareTo(Pair<A, B> p) {
if (p == null)
return 1;
int i = ((Comparable<A>) a).compareTo(p.a);
if (i != 0)
return i;
return ((Comparable<B>) b).compareTo(p.b);
}
}
public static interface RuleOnString {
public void process(String input);
}
public static interface RuleOnTok {
public void process(List<String> tok);
}
public static class Attractor implements IAttractor, Runnable {
public F1<String, Boolean> tester;
public Runnable action;
public String input;
public Attractor() {
}
public Attractor(F1<String, Boolean> tester, Runnable action) {
this.action = action;
this.tester = tester;
}
public Attractor(Runnable action) {
this.action = action;
}
public boolean matches(String s) {
return isTrue(callF(tester, s));
}
public void run() {
callF(action);
}
public String toString() {
return standard_toString(this);
}
}
public static class DefaultAttractor extends Attractor {
public DefaultAttractor() {
this(null);
}
public DefaultAttractor(Runnable action) {
this.action = action;
tester = f1_true();
}
}
public static class MatchAttractor extends Attractor {
public String pattern;
public MatchAttractor(String pattern) {
this.pattern = pattern;
}
public MatchAttractor(String pattern, Runnable action) {
this.action = action;
this.pattern = pattern;
}
public boolean matches(String s) {
return matchX2(pattern, s);
}
}
public static class YesAttractor extends Attractor {
public YesAttractor() {
tester = new F1<String, Boolean>() {
public Boolean get(String x) {
try {
return isYes_1(x);
} catch (Exception __e) {
throw rethrow(__e);
}
}
public String toString() {
return "isYes_1(x)";
}
};
}
public YesAttractor(Runnable action) {
this();
this.action = action;
}
}
public static class Cache<A> {
public Object maker;
public A value;
public long loaded;
public static boolean debug;
public long changeCount;
public Lock lock = lock();
public Cache() {
}
public Cache(Object maker) {
this.maker = maker;
}
public A get() {
if (hasLock(lock))
return value;
Lock __1325 = lock;
lock(__1325);
try {
if (loaded == 0) {
value = make();
changeCount++;
loaded = sysNow();
}
return value;
} finally {
unlock(__1325);
}
}
public void clear() {
Lock __1326 = lock;
lock(__1326);
try {
if (debug && loaded != 0)
print("Clearing cache");
value = null;
changeCount++;
loaded = 0;
} finally {
unlock(__1326);
}
}
public void clear(double seconds) {
Lock __1327 = lock;
lock(__1327);
try {
if (seconds != 0 && loaded != 0 && sysNow() >= loaded + seconds * 1000)
clear();
} finally {
unlock(__1327);
}
}
public void set(A a) {
Lock __1328 = lock;
lock(__1328);
try {
value = a;
++changeCount;
loaded = sysNow();
} finally {
unlock(__1328);
}
}
public A make() {
return (A) callF(maker);
}
}
public static interface IAttractor extends Runnable {
public boolean matches(String s);
}
public static <A, B> B pairB(Pair<A, B> p) {
return p == null ? null : p.b;
}
public static boolean reflection_isForbiddenMethod(Method m) {
return m.getDeclaringClass() == Object.class && eqOneOf(m.getName(), "finalize", "clone", "registerNatives");
}
public static <A, B> void multiMapPut(Map<A, List<B>> map, A a, B b) {
List<B> l = map.get(a);
if (l == null)
map.put(a, l = new ArrayList());
l.add(b);
}
public static <A, B> void multiMapPut(MultiMap<A, B> mm, A key, B value) {
if (mm != null && key != null && value != null)
mm.put(key, value);
}
public static Field makeAccessible(Field f) {
f.setAccessible(true);
return f;
}
public static Method makeAccessible(Method m) {
m.setAccessible(true);
return m;
}
public static Set<Class> allInterfacesImplementedBy(Class c) {
if (c == null)
return null;
HashSet<Class> set = new HashSet();
allInterfacesImplementedBy_find(c, set);
return set;
}
public static void allInterfacesImplementedBy_find(Class c, Set<Class> set) {
if (c.isInterface() && !set.add(c))
return;
do {
for (Class intf : c.getInterfaces()) allInterfacesImplementedBy_find(intf, set);
} while ((c = c.getSuperclass()) != null);
}
public static boolean call_checkArgs(Method m, Object[] args, boolean debug) {
Class<?>[] types = m.getParameterTypes();
if (types.length != args.length) {
if (debug)
print("Bad parameter length: " + args.length + " vs " + types.length);
return false;
}
for (int i = 0; i < types.length; i++) {
Object arg = args[i];
if (!(arg == null ? !types[i].isPrimitive() : isInstanceX(types[i], arg))) {
if (debug)
print("Bad parameter " + i + ": " + arg + " vs " + types[i]);
return false;
}
}
return true;
}
public static Method findStaticMethod(Class c, String method, Object... args) {
Class _c = c;
while (c != null) {
for (Method m : c.getDeclaredMethods()) {
if (!m.getName().equals(method))
continue;
if ((m.getModifiers() & Modifier.STATIC) == 0 || !findStaticMethod_checkArgs(m, args))
continue;
return m;
}
c = c.getSuperclass();
}
return null;
}
public static boolean findStaticMethod_checkArgs(Method m, Object[] args) {
Class<?>[] types = m.getParameterTypes();
if (types.length != args.length)
return false;
for (int i = 0; i < types.length; i++) if (!(args[i] == null || isInstanceX(types[i], args[i])))
return false;
return true;
}
public static void fixACCInClassLoader(Object o) {
try {
AccessControlContext acc = vm_globalACC();
if (acc != null)
replaceACCInClassLoader(o, acc);
} catch (Throwable __e) {
_handleException(__e);
}
}
public static HashMap<String, Class> findClass_cache = new HashMap();
public static Class findClass(String name) {
synchronized (findClass_cache) {
if (findClass_cache.containsKey(name))
return findClass_cache.get(name);
if (!isJavaIdentifier(name))
return null;
Class c;
try {
c = Class.forName("main$" + name);
} catch (ClassNotFoundException e) {
c = null;
}
findClass_cache.put(name, c);
return c;
}
}
public static String systemHashCodeHex(Object o) {
return intToHex(identityHashCode(o));
}
public static boolean hasLock(Lock lock) {
return ((ReentrantLock) lock).isHeldByCurrentThread();
}
public static String mL_raw(String name) {
return mechList_raw(name);
}
public static boolean eqOrSame(Object a, Object b) {
return a == null ? b == null : a == b || b != null && a.equals(b);
}
public static void clear(Collection c) {
if (c != null)
c.clear();
}
public static UnsupportedOperationException unsupportedOperation() {
throw new UnsupportedOperationException();
}
public static <A, B> Map<A, B> putAll(Map<A, B> a, Map<? extends A, ? extends B> b) {
if (a != null)
a.putAll(b);
return a;
}
public static <A, B> void put(Map<A, B> map, A a, B b) {
if (map != null)
map.put(a, b);
}
public static <A> void put(List<A> l, int i, A a) {
if (l != null && i >= 0 && i < l(l))
l.set(i, a);
}
public static <A, B> Set<A> keySet(Map<A, B> map) {
return map == null ? new HashSet() : map.keySet();
}
public static Set keySet(Object map) {
return keys((Map) map);
}
public static <A, B> Set<A> keySet(MultiMap<A, B> mm) {
return mm.keySet();
}
public static <A> A reverseGet(List<A> l, int idx) {
if (l == null || idx < 0)
return null;
int n = l(l);
return idx < n ? l.get(n - 1 - idx) : null;
}
public static long sysTime() {
return sysNow();
}
public static void change() {
callOpt(getOptMC("mainConcepts"), "allChanged");
}
public static TreeSet<String> litciset(String... items) {
TreeSet<String> set = caseInsensitiveSet();
for (String a : items) set.add(a);
return set;
}
public static List<String> wordTok(String s) {
return javaTokNPunctuationWithBrackets_cached(s);
}
public static Object process(String processorID, Object in) {
return process(processorID, in, "in");
}
public static Object process(String processorID, Object in, String outVar) {
try {
Class processor = hotwire(processorID);
set(processor, "in", in);
call(processor, "main", new Object[] { new String[0] });
return get(processor, outVar);
} catch (Exception e) {
throw new RuntimeException("Error in #" + parseSnippetID(processorID), e);
}
}
public static <A, B> Map<A, B> nullIfContainsKeysOtherThan(Map<A, B> map, Set<A> allowedKeys) {
return containsAnyKeyExcept(map, allowedKeys) ? null : map;
}
public static Map<String, String> gazelle_zipTwoTokenizationsToMap(List<String> tokA, List<String> tokB) {
return ciMapWithoutKeysEqualToValues(zipTwoListsToCIMap_strict(codeTokens_lazy_uncurly(tokA), codeTokens_lazy_uncurly(tokB)));
}
public static <A> A getOrKeep(Map<A, ? extends A> map, A a) {
if (map == null)
return a;
A v = map.get(a);
return v != null ? v : a;
}
public static int _hashCode(Object a) {
return a == null ? 0 : a.hashCode();
}
public static boolean getServerTranspiled2_allowLocalFallback = true, getServerTranspiled2_localFallbackVerbose = true;
public static String getServerTranspiled2(String id) {
IResourceLoader rl = vm_getResourceLoader();
if (rl != null)
return rl.getTranspiled(id);
String transpiled = loadCachedTranspilation(id);
String md5 = null;
if (machineIsOffline() || isOfflineMode() || isLocalSnippet(id))
return transpiled;
if (transpiled != null)
md5 = md5(transpiled);
String transpiledSrc;
try {
transpiledSrc = getServerTranspiled(formatSnippetID(id), md5);
} catch (Throwable e) {
if (!getServerTranspiled2_allowLocalFallback)
rethrow(e);
printExceptionShort(e);
if (getServerTranspiled2_localFallbackVerbose)
print("Fallback to local code");
return transpiled;
}
if (eq(transpiledSrc, "SAME")) {
if (!isTrue(loadPage_silent.get()))
print("SAME");
return transpiled;
}
return transpiledSrc;
}
public static List<String> findMainClass(List<String> tok) {
for (List<String> c : reversedList(allClasses(tok))) {
String name = getClassDeclarationName(c);
if (eq(name, "main") || name.startsWith("x"))
return c;
}
return findBlock("m {", tok);
}
public static boolean useDummyMainClasses() {
return true;
}
public static boolean tok_classHasModifier(List<String> classDecl, String modifier) {
if (classDecl == null)
return false;
int i = classDecl.indexOf("class");
return subList(classDecl, 0, i).contains(modifier);
}
public static boolean javaCompileToJar_useRAMDisk;
public static File javaCompileToJar_optionalRename(String src, File destJar, String progIDForRename) {
return javaCompileToJar_optionalRename(src, "", destJar, progIDForRename);
}
public static synchronized File javaCompileToJar_optionalRename(String src, String dehlibs, File destJar, String progIDForRename) {
return javaCompileToJar_optionalRename(src, dehlibs, destJar, progIDForRename, null);
}
public static synchronized File javaCompileToJar_optionalRename(String src, String dehlibs, File destJar, String progIDForRename, String progID) {
String javaTarget = null;
String dummyClass = "main";
if (progIDForRename != null) {
dummyClass = dummyMainClassName(progIDForRename);
src += "\nclass " + dummyClass + "{}";
}
String md5 = md5(src);
File jar = destJar;
Class j = getJavaX();
if (javaTarget != null)
setOpt(j, "javaTarget", javaTarget);
File srcDir = tempDir();
String className = "main";
String fileName = dummyClass + ".java";
List<String> tok = javaTok(src);
String packageName = tok_packageName(tok);
if (packageName != null)
fileName = packageName.replace(".", "/") + "/" + tok_firstClassName(tok) + ".java";
File mainJava = new File(srcDir, fileName);
saveTextFile(mainJava, src);
File classesDir = javaCompileToJar_useRAMDisk ? tempDirPossiblyInRAMDisk() : tempDir();
try {
List<File> libraries = new ArrayList();
Matcher m = Pattern.compile("\\d+").matcher(dehlibs);
while (m.find()) {
String libID = m.group();
assertTrue(isSnippetID(libID));
libraries.add(loadLibraryOrSrcLib(libID));
}
libraries.add(pathToJavaxJar());
String compilerOutput;
try {
compilerOutput = (String) call(j, "compileJava", srcDir, libraries, classesDir);
} catch (Throwable e) {
compilerOutput = (String) get(getJavaX(), "javaCompilerOutput");
String msg = cleanJavaCompilerOutput(compilerOutput);
if (neqic(e.getMessage(), "Java compiler returned errors.") || empty(msg))
msg = appendWithNewLine(msg, str(e));
printStackTrace(e);
throw fail(msg);
}
compilerOutput = cleanJavaCompilerOutput("Annotation processing got disabled, since it requires a 1.6 compliant JVM");
if (nempty(compilerOutput)) {
print("Compiler said: " + compilerOutput);
}
if (!anyFileWithExtensionInDir(classesDir, ".class"))
throw fail("No classes generated");
saveTextFile(new File(classesDir, "main.java"), src);
if (nempty(dehlibs))
saveTextFile(new File(classesDir, "libraries"), dehlibs);
saveTextFile(new File(classesDir, "progID"), progID);
dir2zip_recurse_verbose = false;
int n = dir2zip_recurse(classesDir, jar);
return jar;
} finally {
if (isInRAMDisk(classesDir))
deleteDirectory(classesDir);
}
}
public static void touchFile(File file) {
try {
closeRandomAccessFile(newRandomAccessFile(mkdirsForFile(file), "rw"));
} catch (Exception __e) {
throw rethrow(__e);
}
}
public static File getCacheProgramDir() {
return getCacheProgramDir(getProgramID());
}
public static File getCacheProgramDir(String snippetID) {
return new File(userHome(), "JavaX-Caches/" + formatSnippetIDOpt(snippetID));
}
public static int hashCodeFor(Object a) {
return a == null ? 0 : a.hashCode();
}
public static String standard_toString(Object o) {
if (o == null)
return "null";
String name = shortClassName(o);
Set<String> fields = fieldNames(o);
if (empty(fields))
return name;
return name + "(" + joinWithComma(mapNonNulls(fields, field -> {
Object value = get(o, field);
if (value == null)
return null;
return field + "=" + str(value);
})) + ")";
}
public static <A> F1<A, Boolean> f1_true() {
return f1_const(true);
}
public static boolean matchX2(String pat, String s) {
return matchX_vbar(pat, s);
}
public static boolean matchX2(String pat, String s, Matches matches) {
return matchX_vbar(pat, s, matches);
}
public static boolean isYes_1(String s) {
return match_vbar("accept|except|save|definitely|and if it is|is if it is right|is this|right|enter|submit|send|you got it|close enough|that it is|bingo|confirm|confirming|confirmed|i said yes|it is|surely|is this the man|guess my man|just|sieve|yesterday's", s) || matchStart_vbar("yes|yeah|yep|yup|yo|yay|absolutely|correct|you can say that|chore|shore|shorts|sure|is yes|okay|ok|that's correct|you are right|you're right|you're correct|you just said it", s) || matchEnd_vbar("that's right|got it|could say that|could say so|that's it|couldn't be anything else", s);
}
public static AccessControlContext vm_globalACC() {
return (AccessControlContext) vm_generalMap_get("Global ACC");
}
public static void replaceACCInClassLoader(Object o, AccessControlContext newACC) {
ClassLoader cl = getClassLoaderOrSame(o);
if (cl instanceof URLClassLoader) {
try {
setOpt(cl, "acc", newACC);
try {
setOpt((Object) getOpt(cl, "ucp"), "acc", newACC);
} catch (Throwable e) {
printShortException("replaceACCInClassLoader: ", e);
if (java10OrHigher())
if (addDefaultVMOption("--add-opens java.base/jdk.internal.loader=ALL-UNNAMED"))
print("Please restart the OS");
}
} catch (Throwable __e) {
_handleException(__e);
}
}
}
public static String intToHex(int i) {
return bytesToHex(intToBytes(i));
}
public static <A> TreeSet<A> treeSet() {
return new TreeSet();
}
public static Map<String, List<String>> javaTokNPunctuationWithBrackets_cached_cache = synchronizedMRUCache(100);
public static synchronized List<String> javaTokNPunctuationWithBrackets_cached(String s) {
List<String> tok = javaTokNPunctuationWithBrackets_cached_cache.get(s);
if (tok == null)
javaTokNPunctuationWithBrackets_cached_cache.put(s, tok = javaTokNPunctuationWithBrackets(s));
return tok;
}
public static <A, B> boolean containsAnyKeyExcept(Map<A, B> map, Set<A> allowedKeys) {
if (map != null)
for (A x : keys(map)) if (!contains(allowedKeys, x))
return true;
return false;
}
public static Map<String, String> ciMapWithoutKeysEqualToValues(Map<String, String> map) {
if (map == null)
return null;
Map<String, String> map2 = ciMap();
for (String key : keys(map)) {
String value = map.get(key);
if (!eqic(key, value))
map2.put(key, value);
}
return map2;
}
public static Map<String, String> zipTwoListsToCIMap_strict(List<String> l1, List<String> l2) {
int n = l(l1);
if (n != l(l2))
return null;
Map<String, String> map = ciMap();
for (int i = 0; i < n; i++) if (!strictPutIC(map, l1.get(i), l2.get(i)))
return null;
return map;
}
public static List<String> codeTokens_lazy_uncurly(List<String> tok) {
return lazilyMap("uncurly", codeTokens_lazy(tok));
}
public static String loadCachedTranspilation(String id) {
try {
return loadTextFilePossiblyGZipped(getCachedTranspilationFile(id));
} catch (Throwable __e) {
return null;
}
}
public static boolean machineIsOffline() {
return isFalse(callF(vmGeneralMap_get("areWeOnline")));
}
public static boolean isOfflineMode() {
return eq("1", trim(loadProgramTextFile("#1005806", "offline-mode")));
}
public static boolean isLocalSnippet(String snippetID) {
return isLocalSnippetID(snippetID);
}
public static boolean isLocalSnippet(long snippetID) {
return isLocalSnippetID(snippetID);
}
public static String getServerTranspiled(String snippetID) {
return getServerTranspiled(snippetID, null);
}
public static String getServerTranspiled(String snippetID, String expectedMD5) {
try {
long id = parseSnippetID(snippetID);
String text = loadPage_utf8(tb_mainServer() + "/tb-int/get-transpiled.php?raw=1&withlibs=1&id=" + id + "&utf8=1" + (l(expectedMD5) > 1 ? "&md5=" + urlencode(expectedMD5) : "") + standardCredentials());
if (nempty(text) && neq(text, "SAME"))
saveTranspiledCode(snippetID, text);
return text;
} catch (Exception __e) {
throw rethrow(__e);
}
}
public static void printExceptionShort(Throwable e) {
print(exceptionToStringShort(e));
}
public static HashSet<String> allClasses_keywords = lithashset("class", "interface", "enum", "sclass", "sinterface", "record", "srecord");
public static List<List<String>> allClasses(List<String> tok) {
List<List<String>> l = new ArrayList();
int n = tok.size();
HashSet<String> _allClasses_keywords = allClasses_keywords;
for (int i = 1; i < n; i += 2) {
String t = tok.get(i);
if ("{".equals(t))
i = findEndOfBlock(tok, i) - 1;
else if (_allClasses_keywords.contains(t) && (i == 1 || !eqGetOneOf(tok, i - 2, ".", "include"))) {
int j = i;
while (j < n && !tok.get(j).equals("{")) j += 2;
j = findEndOfBlock(tok, j) + 1;
i = leftScanModifiers(tok, i);
l.add(tok.subList(i - 1, Math.min(n, j)));
i = j - 2;
}
}
return l;
}
public static List<List<String>> allClasses(String text) {
return allClasses(javaTok(text));
}
public static String getClassDeclarationName(List<String> tok) {
if (tok != null)
for (int i = 1; i + 2 < tok.size(); i += 2) if (allClasses_keywords.contains(tok.get(i)) && isIdentifier(tok.get(i + 2)))
return tok.get(i + 2);
return null;
}
public static List<String> findBlock(String pat, List<String> tok) {
List<String> tokpat = javaTok(pat);
int i = findCodeTokens(tok, toStringArray(codeTokensOnly(tokpat)));
if (i < 0)
return null;
int bracketIdx = i + tokpat.size() - 3;
assertEquals("{", tok.get(bracketIdx));
int endIdx = findEndOfBlock(tok, bracketIdx);
return subList(tok, i - 1, endIdx + 1);
}
public static String dummyMainClassName(String progID) {
return "m" + psI(progID);
}
public static File tempDir() {
return makeTempDir();
}
public static String tok_packageName(List<String> tok) {
int i = jfind(tok, "package");
if (i < 0)
return "";
i += 2;
int j = jfind(tok, i, ";");
if (j < 0)
return "";
return join(codeTokensOnly(subList(tok, i - 1, j)));
}
public static String tok_firstClassName(List<String> tok) {
int i = jfind(tok, "class <id>");
return i < 0 ? null : tok.get(i + 2);
}
public static File tempDirPossiblyInRAMDisk() {
File f = linux_fileInRamDisk(aGlobalID());
if (f != null) {
f.mkdirs();
return f;
}
return makeTempDir();
}
public static boolean loadLibraryOrSrcLib_srcLibsEnabled = true;
public static File loadLibraryOrSrcLib(String snippetID) {
try {
long id = parseSnippetID(snippetID);
boolean srcLib = loadLibraryOrSrcLib_srcLibsEnabled && isMarkedAsSrcLib(snippetID);
if (srcLib)
return pairA(hotwire_compile(snippetID));
File f = DiskSnippetCache_getLibrary(id);
if (fileSize(f) != 0)
return f;
try {
return loadDataSnippetToFile(snippetID);
} catch (Throwable e) {
if (loadLibraryOrSrcLib_srcLibsEnabled && nempty(loadSnippet(snippetID))) {
markAsSrcLib(snippetID);
return pairA(hotwire_compile(snippetID));
}
throw rethrow(e);
}
} catch (Exception __e) {
throw rethrow(__e);
}
}
public static File pathToJavaxJar() {
try {
IResourceLoader rl = vm_getResourceLoader();
if (rl != null)
return rl.pathToJavaXJar();
int x = latestInstalledJavaX();
File xfile = new File(userHome(), ".javax/x" + Math.max(x, 30) + ".jar");
if (!xfile.isFile()) {
print("Saving " + f2s(xfile));
String url = "http://tinybrain.de/x30.jar";
byte[] data = loadBinaryPage(url);
if (data.length < 1000000)
throw fail("Could not load " + url);
saveBinaryFile(xfile.getPath(), data);
}
return xfile;
} catch (Exception __e) {
throw rethrow(__e);
}
}
public static String cleanJavaCompilerOutput(String s) {
return dropPrefixTrim("Annotation processing got disabled, since it requires a 1.6 compliant JVM", s);
}
public static boolean neqic(String a, String b) {
return !eqic(a, b);
}
public static String appendWithNewLine(String a, String b) {
if (empty(b))
return a;
if (empty(a))
return b;
return addSuffix(a, "\n") + b;
}
public static boolean anyFileWithExtensionInDir(File dir, String ext) {
return nempty(filesWithExtension(ext, findAllFiles_noDirs(dir)));
}
public static boolean dir2zip_recurse_verbose;
public static int dir2zip_recurse(File inDir, File zip) {
return dir2zip_recurse(inDir, zip, "");
}
public static int dir2zip_recurse(File inDir, File zip, String outPrefix) {
try {
mkdirsForFile(zip);
FileOutputStream fout = newFileOutputStream(zip);
ZipOutputStream outZip = new ZipOutputStream(fout);
try {
return dir2zip_recurse(inDir, outZip, outPrefix, 0);
} finally {
outZip.close();
}
} catch (Exception __e) {
throw rethrow(__e);
}
}
public static int dir2zip_recurse(File inDir, ZipOutputStream outZip) {
return dir2zip_recurse(inDir, outZip, "", 0);
}
public static int dir2zip_recurse(File inDir, ZipOutputStream outZip, String outPrefix, int level) {
try {
if (++level >= 20)
throw fail("woot? 20 levels in zip?");
List<File> files = new ArrayList();
for (File f : listFiles(inDir)) files.add(f);
int n = 0;
sortFilesByName(files);
for (File f : files) {
if (f.isDirectory()) {
print("dir2zip_recurse: Scanning " + f.getAbsolutePath());
n += dir2zip_recurse(f, outZip, outPrefix + f.getName() + "/", level);
} else {
if (dir2zip_recurse_verbose)
print("Copying " + f.getName());
outZip.putNextEntry(new ZipEntry(outPrefix + f.getName()));
InputStream fin = new FileInputStream(f);
copyStream(fin, outZip);
fin.close();
++n;
}
}
return n;
} catch (Exception __e) {
throw rethrow(__e);
}
}
public static boolean isInRAMDisk(File f) {
return startsWith(f2s(f), "/dev/shm");
}
public static void deleteDirectory(File dir) {
deleteDirectory(dir, false, false);
}
public static void deleteDirectory(File dir, boolean verbose, boolean testRun) {
deleteAllFilesInDirectory(dir, verbose, testRun);
if (verbose)
print((testRun ? "Would delete " : "Deleting ") + dir.getAbsolutePath());
if (!testRun)
dir.delete();
}
public static void closeRandomAccessFile(RandomAccessFile f) {
if (f != null)
try {
f.close();
callJavaX("dropIO", f);
} catch (Throwable e) {
printStackTrace(e);
}
}
public static RandomAccessFile newRandomAccessFile(File path, String mode) throws IOException {
boolean forWrite = mode.indexOf('w') >= 0;
if (forWrite)
mkdirsForFile(path);
RandomAccessFile f = new RandomAccessFile(path, mode);
callJavaX("registerIO", f, path, forWrite);
return f;
}
public static String shortClassName(Object o) {
if (o == null)
return null;
Class c = o instanceof Class ? (Class) o : o.getClass();
String name = c.getName();
return shortenClassName(name);
}
public static Set<String> fieldNames(Object o) {
return allFields(o);
}
public static List mapNonNulls(Iterable l, Object f) {
return mapNonNulls(f, l);
}
public static List mapNonNulls(Object f, Iterable l) {
List x = new ArrayList();
if (l != null)
for (Object o : l) addIfNotNull(x, callF(f, o));
return x;
}
public static List mapNonNulls(Object f, Object[] l) {
List x = new ArrayList();
if (l != null)
for (Object o : l) addIfNotNull(x, callF(f, o));
return x;
}
public static <A, B> List<B> mapNonNulls(Iterable<A> l, F1<A, B> f) {
return mapNonNulls(f, l);
}
public static <A, B> List<B> mapNonNulls(F1<A, B> f, Iterable<A> l) {
List x = new ArrayList();
if (l != null)
for (Object o : l) addIfNotNull(x, callF(f, o));
return x;
}
public static <A, B> List<B> mapNonNulls(Iterable<A> l, IF1<A, B> f) {
List x = emptyList(l);
if (l != null)
for (A o : l) addIfNotNull(x, f.get(o));
return x;
}
public static <A, B> F1<A, B> f1_const(final B b) {
return new F1<A, B>() {
public B get(A a) {
return b;
}
};
}
public static boolean matchX_vbar(String pat, String s) {
return matchX_vbar(pat, s, null);
}
public static boolean matchX_vbar(String pat, String s, Matches matches) {
for (String pat2 : tok_splitAtVerticalBar(pat)) if (matchX(pat2, s, matches))
return true;
return false;
}
public static boolean match_vbar(String pat, String s) {
return match_vbar(pat, s, null);
}
public static boolean match_vbar(String pat, String s, Matches matches) {
for (String pat2 : tok_splitAtVerticalBar(pat)) if (match3(pat2, s, matches))
return true;
return false;
}
public static boolean matchStart_vbar(String pat, String s) {
return matchStart_vbar(pat, s, null);
}
public static boolean matchStart_vbar(String pat, String s, Matches matches) {
for (String pat2 : splitAtTokens(pat, ll("|"))) if (matchStart(pat2, s, matches))
return true;
return false;
}
public static boolean matchEnd_vbar(String pat, String s) {
return matchEnd_vbar(pat, s, null);
}
public static boolean matchEnd_vbar(String pat, String s, Matches matches) {
for (String pat2 : splitAtTokens(pat, ll("|"))) if (matchEnd(pat2, s, matches))
return true;
return false;
}
public static ClassLoader getClassLoaderOrSame(Object o) {
return o instanceof ClassLoader ? (ClassLoader) o : getClassLoader(o);
}
public static void printShortException(Throwable e) {
print(exceptionToStringShort(e));
}
public static void printShortException(String s, Throwable e) {
print(s, exceptionToStringShort(e));
}
public static boolean java10OrHigher() {
return parseFirstInt(javaVersion()) >= 10;
}
public static boolean addDefaultVMOption(String option) {
String s = defaultVMArgs(), old = s;
if (!s.contains(option))
s = trim(s + " " + option);
if (eq(old, s))
return false;
{
setDefaultVMArgs(s);
return true;
}
}
public static byte[] intToBytes(int i) {
return new byte[] { (byte) (i >>> 24), (byte) (i >>> 16), (byte) (i >>> 8), (byte) i };
}
public static Map<String, List<String>> javaTokNPunctuationWithBrackets_cache = synchronizedMRUCache(1000);
public static List<String> javaTokNPunctuationWithBrackets(String s) {
List<String> tok = javaTokNPunctuationWithBrackets_cache.get(s);
if (tok == null)
javaTokNPunctuationWithBrackets_cache.put(s, tok = javaTokNPunctuationWithBrackets_uncached(s));
return tok;
}
public static List<String> javaTokNPunctuationWithBrackets_uncached(String s) {
return tok_combineRoundOrCurlyBrackets_keep(javaTokNPunctuation_bracketsInC(s));
}
public static <A> boolean strictPutIC(Map<A, String> map, A key, String value) {
if (!(map != null && key != null && value != null))
return true;
String old = map.get(key);
if (old == null) {
map.put(key, value);
return true;
}
return eqic(old, value);
}
public static List lazilyMap(final Object f, final List l) {
return new RandomAccessAbstractList() {
public final int size = l(l);
public HashMap<Integer, Object> data = new HashMap();
public int size() {
return size;
}
public Object get(int i) {
if (data.containsKey(i))
return data.get(i);
Object o = callF(f, l.get(i));
data.put(i, o);
return o;
}
};
}
public static String uncurly(String s) {
return tok_unCurlyBracket(s);
}
public static List<String> codeTokens_lazy(final List<String> tok) {
return new RandomAccessAbstractList<String>() {
public final int size = l(tok) / 2;
public int size() {
return size;
}
public String get(int i) {
return tok.get(i * 2 + 1);
}
};
}
public static String loadTextFilePossiblyGZipped(String fileName) {
return loadTextFilePossiblyGZipped(fileName, null);
}
public static String loadTextFilePossiblyGZipped(String fileName, String defaultContents) {
File gz = new File(fileName + ".gz");
return gz.exists() ? loadGZTextFile(gz) : loadTextFile(fileName, defaultContents);
}
public static String loadTextFilePossiblyGZipped(File fileName) {
return loadTextFilePossiblyGZipped(fileName, null);
}
public static String loadTextFilePossiblyGZipped(File fileName, String defaultContents) {
return loadTextFilePossiblyGZipped(fileName.getPath(), defaultContents);
}
public static File getCachedTranspilationFile(String id) {
return newFile(getCodeProgramDir(id), "Transpilation");
}
public static Object vmGeneralMap_get(Object key) {
return vm_generalMap_get(key);
}
public static String loadProgramTextFile(String name) {
return loadTextFile(getProgramFile(name));
}
public static String loadProgramTextFile(String progID, String name) {
return loadTextFile(getProgramFile(progID, name));
}
public static String loadProgramTextFile(String progID, String name, String defaultText) {
return loadTextFile(getProgramFile(progID, name), defaultText);
}
public static boolean isLocalSnippetID(String snippetID) {
return isSnippetID(snippetID) && isLocalSnippetID(psI(snippetID));
}
public static boolean isLocalSnippetID(long snippetID) {
return snippetID >= 1000 && snippetID <= 9999;
}
public static String standardCredentials() {
String user = standardCredentialsUser();
String pass = standardCredentialsPass();
if (nempty(user) && nempty(pass))
return "&_user=" + urlencode(user) + "&_pass=" + urlencode(pass);
return "";
}
public static void saveTranspiledCode(String progID, String code) {
File dir = getCodeProgramDir(progID);
new File(dir, "Transpilation").delete();
saveGZTextFile(new File(dir, "Transpilation.gz"), code);
}
public static int findEndOfBlock(List<String> cnc, int i) {
int j = i + 2, level = 1, n = cnc.size();
while (j < n) {
String t = cnc.get(j);
if ("{".equals(t))
++level;
else if ("}".equals(t))
--level;
if (level == 0)
return j + 1;
j += 2;
}
return n;
}
public static <A> boolean eqGetOneOf(List<A> l, int i, A... options) {
return eqOneOf(get(l, i), options);
}
public 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;
}
public static String[] toStringArray(Collection<String> c) {
String[] a = new String[l(c)];
Iterator<String> it = c.iterator();
for (int i = 0; i < l(a); i++) a[i] = it.next();
return a;
}
public static String[] toStringArray(Object o) {
if (o instanceof String[])
return (String[]) o;
else if (o instanceof Collection)
return toStringArray((Collection<String>) o);
else
throw fail("Not a collection or array: " + getClassName(o));
}
public static List<String> codeTokensOnly(List<String> tok) {
int n = tok.size();
List<String> l = emptyList(n / 2);
for (int i = 1; i < n; i += 2) l.add(tok.get(i));
return l;
}
public static <A> A assertEquals(Object x, A y) {
return assertEquals(null, x, y);
}
public static <A> A assertEquals(String msg, Object x, A y) {
if (assertVerbose())
return assertEqualsVerbose(msg, x, y);
if (!(x == null ? y == null : x.equals(y)))
throw fail((msg != null ? msg + ": " : "") + y + " != " + x);
return y;
}
public static File makeTempDir() {
return (File) call(getJavaX(), "TempDirMaker_make");
}
public static File linux_fileInRamDisk(String name) {
if (!isLinux())
return null;
File dir = newFile("/dev/shm");
if (dir.isDirectory())
return newFile(dir, name);
return null;
}
public static String aGlobalID() {
return randomID(globalIDLength());
}
public static boolean isMarkedAsSrcLib(String snippetID) {
if (snippetID == null)
return false;
IResourceLoader rl = vm_getResourceLoader();
if (rl != null)
return isJavaxCompilableSnippetType(rl.getSnippetType(snippetID));
return fileExists(javaxCodeDir("srclibs/" + psI(snippetID)));
}
public static <A, B> A pairA(Pair<A, B> p) {
return p == null ? null : p.a;
}
public static Object hotwire_onCompile;
public static boolean hotwire_serially;
public static Lock hotwire_overInternalBot_lock = lock();
public static boolean hotwire_compileOnServer;
public static Class<?> hotwire_overInternalBot(String progID) {
return hotwire_overInternalBot(progID, "main");
}
public static Class<?> hotwire_overInternalBot(String progID, String mainClass) {
try {
Pair<File, String> p;
try {
p = hotwire_compile(progID);
} catch (Throwable e) {
throw rethrow("Error hotwiring " + progID, e);
}
File jar = p.a;
assertTrue(jar.getAbsolutePath(), jar.isFile());
List<File> files = hotwire_collectJars(jar);
JavaXClassLoader classLoader = hotwire_makeClassLoader(files);
classLoader.progID = progID;
return hotwire_finish(classLoader, progID, p.b, mainClass);
} catch (Exception __e) {
throw rethrow(__e);
}
}
public static Pair<File, String> hotwire_compile(String progID) {
Pair<File, String> p = hotwire_compileOnServer && !isLocalSnippetID(progID) ? compileSnippetThroughServer(progID) : CompilerBot.compileSnippet2(progID);
Lock __1520 = hotwire_serially ? hotwire_overInternalBot_lock : null;
lock(__1520);
try {
callF(hotwire_onCompile, p);
return p;
} finally {
unlock(__1520);
}
}
public static void markAsSrcLib(String snippetID) {
saveTextFile(javaxCodeDir("srclibs/" + psI(snippetID)), "");
}
public 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 String dropPrefixTrim(String prefix, String s) {
return trim(dropPrefix(prefix, s));
}
public static String addSuffix(String s, String suffix) {
return s == null || s.endsWith(suffix) ? s : s + suffix;
}
public static List<File> filesWithExtension(String ext, List<File> files) {
return filesEndingWith(files, addPrefixIfNotEmpty2(".", ext));
}
public static List<File> findAllFiles_noDirs(List dirs) {
return findAllFiles_noDirs(asObjectArray(dirs));
}
public static List<File> findAllFiles_noDirs(Object... dirs) {
List<File> l = new ArrayList();
for (Object dir : dirs) {
if (dir instanceof String && ((String) dir).endsWith("/.")) {
for (File f : listFiles(dropSuffix("/.", (String) dir))) if (f.isFile())
l.add(f);
} else
findAllFiles_noDirs_impl(toFile(dir), l);
}
return l;
}
public static void findAllFiles_noDirs_impl(File dir, List<File> l) {
for (File f : listFiles(dir)) {
if (f.isDirectory())
findAllFiles_noDirs_impl(f, l);
else
l.add(f);
}
}
public static File[] listFiles(File dir) {
File[] files = dir.listFiles();
return files == null ? new File[0] : files;
}
public static File[] listFiles(String dir) {
return listFiles(new File(dir));
}
public static List<File> sortFilesByName(List<File> l) {
sort(l, new Comparator<File>() {
public int compare(File a, File b) {
return stdcompare(a.getName(), b.getName());
}
});
return l;
}
public static int deleteAllFilesInDirectory_minPathLength = 10;
public static void deleteAllFilesInDirectory(File dir) {
deleteAllFilesInDirectory(dir, false, false);
}
public static void deleteAllFilesInDirectory(File dir, boolean verbose, boolean testRun) {
dir = getCanonicalFile(dir);
assertTrue(f2s(dir), l(f2s(dir)) >= deleteAllFilesInDirectory_minPathLength);
File[] files = dir.listFiles();
if (files == null)
return;
for (File f : files) {
if (!isSymLink(f) && f.isDirectory())
deleteDirectory(f, verbose, testRun);
else {
if (verbose)
print((testRun ? "Would delete " : "Deleting ") + f.getAbsolutePath());
if (!testRun)
f.delete();
}
}
}
public static Object callJavaX(String method, Object... args) {
return callOpt(getJavaX(), method, args);
}
public static String shortenClassName(String name) {
if (name == null)
return null;
int i = lastIndexOf(name, "$");
if (i < 0)
i = lastIndexOf(name, ".");
return i < 0 ? name : substring(name, i + 1);
}
public static Set<String> allFields(Object o) {
TreeSet<String> fields = new TreeSet();
Class _c = _getClass(o);
do {
for (Field f : _c.getDeclaredFields()) fields.add(f.getName());
_c = _c.getSuperclass();
} while (_c != null);
return fields;
}
public static List<String> tok_splitAtVerticalBar(String s) {
if (!contains(s, '|'))
return ll(s);
return splitAtTokens(javaTokPlusBrackets2(s), tok_splitAtVerticalBar_list);
}
public static List<String> tok_splitAtVerticalBar_list = ll("|");
public static boolean matchX(String pat, String s) {
return matchX(pat, s, null);
}
public static boolean matchX(String pat, String s, Matches m) {
if (endsWith(pat, "...")) {
pat = dropSuffixTrim("...", pat);
if (startsWith(pat, "..."))
return find3(dropPrefixTrim("...", pat), s, m);
else
return matchStart(pat, s, m);
}
if (startsWith(pat, "..."))
return matchEndX(pat, s, m);
return match(pat, s, m);
}
public static boolean match3(String pat, String s) {
return match3(pat, s, null);
}
public static boolean match3(String pat, String s, Matches matches) {
if (pat == null || s == null)
return false;
return match3(pat, parse3_cachedInput(s), matches);
}
public static boolean match3(String pat, List<String> toks, Matches matches) {
List<String> tokpat = parse3_cachedPattern(pat);
return match3(tokpat, toks, matches);
}
public static boolean match3(List<String> tokpat, List<String> toks, Matches matches) {
String[] m = match2(tokpat, toks);
if (m == null)
return false;
if (matches != null)
matches.m = m;
return true;
}
public static List<String> splitAtTokens(String s, List<String> tokens) {
return splitAtTokens(javaTok(s), tokens);
}
public static List<String> splitAtTokens(List<String> tok, List<String> tokens) {
List<String> l = new ArrayList();
int i = 0;
while (i < l(tok)) {
int j = indexOfSubList(tok, tokens, i);
if (i >= l(tok))
break;
if (j < 0)
j = l(tok);
l.add(trimJoin(tok.subList(i, j)));
i = j + l(tokens);
}
return l;
}
public static List<String> splitAtTokens(List<String> tok, String... tokens) {
List<String> l = new ArrayList();
int i = 0;
while (i < l(tok)) {
int j = indexOfSubList(tok, tokens, i);
if (i >= l(tok))
break;
if (j < 0)
j = l(tok);
l.add(trimJoin(tok.subList(i, j)));
i = j + l(tokens);
}
return l;
}
public static boolean matchStart(String pat, String s) {
return matchStart(pat, s, null);
}
public static boolean matchStart(String pat, String s, Matches matches) {
if (s == null)
return false;
return matchStart(pat, parse3_cachedInput(s), matches);
}
public static boolean matchStart(String pat, List<String> toks, Matches matches) {
if (toks == null)
return false;
List<String> tokpat = parse3_cachedPattern(pat);
if (toks.size() < tokpat.size())
return false;
String[] m = match2(tokpat, toks.subList(0, tokpat.size()));
if (m == null)
return false;
if (matches != null) {
matches.m = new String[m.length + 1];
arraycopy(m, matches.m);
matches.m[m.length] = joinSubList(toks, tokpat.size(), toks.size());
}
return true;
}
public static boolean matchEnd(String pat, String s) {
return matchEnd(pat, s, null);
}
public static boolean matchEnd(String pat, String s, Matches matches) {
if (s == null)
return false;
List<String> tokpat = parse3(pat), toks = parse3(s);
if (toks.size() < tokpat.size())
return false;
String[] m = match2(tokpat, takeLast(l(tokpat), toks));
if (m == null)
return false;
if (matches != null) {
matches.m = new String[m.length + 1];
arraycopy(m, matches.m);
matches.m[m.length] = join(dropLast(l(tokpat), toks));
}
return true;
}
public static ClassLoader getClassLoader(Object o) {
return o == null ? null : _getClass(o).getClassLoader();
}
public static int parseFirstInt(String s) {
return parseInt(jextract("<int>", s));
}
public static String javaVersion() {
return System.getProperty("java.version");
}
public static String defaultVMArgs() {
return javaxDefaultVMArgs();
}
public static void setDefaultVMArgs(String args) {
String oldArgs = javaxDefaultVMArgs();
args = trim(args);
if (neq(unnull(oldArgs), unnull(args))) {
print();
print("Changing default VM arguments from");
print(" " + oldArgs);
print("to");
print(" " + args);
print();
saveTextFile(javaxDataDir("default-vm-args"), nullIfEmpty(args));
}
}
public static List<String> tok_combineRoundOrCurlyBrackets_keep(List<String> tok) {
List<String> l = new ArrayList();
for (int i = 0; i < l(tok); i++) {
String t = tok.get(i);
if (odd(i) && eqOneOf(t, "{", "(")) {
int j = findEndOfBracketPart(tok, i);
l.add(joinSubList(tok, i, j));
i = j - 1;
} else
l.add(t);
}
return l;
}
public static List<String> javaTokNPunctuation_bracketsInC(String s) {
List<String> tok = javaTok(s);
for (int i = 1; i < l(tok); i += 2) {
int j = i;
String t;
char c;
while (j < l(tok) && l(t = tok.get(j)) == 1 && !Character.isLetterOrDigit(c = t.charAt(0)) && "{}()".indexOf(c) < 0) j += 2;
if (j > i)
replaceSubList(tok, i - 1, j, ll(joinSubList(tok, i - 1, j)));
}
return tok;
}
public static String tok_unCurlyBracket(String s) {
return isCurlyBraced(s) ? join(dropFirstThreeAndLastThree(javaTok(s))) : s;
}
public static String loadGZTextFile(File file) {
try {
if (!file.isFile())
return null;
ByteArrayOutputStream baos = new ByteArrayOutputStream();
InputStream fis = new FileInputStream(file);
GZIPInputStream gis = newGZIPInputStream(fis);
try {
byte[] buffer = new byte[1024];
int len;
while ((len = gis.read(buffer)) != -1) {
baos.write(buffer, 0, len);
}
} finally {
fis.close();
}
baos.close();
return fromUtf8(baos.toByteArray());
} catch (Exception __e) {
throw rethrow(__e);
}
}
public static File getCodeProgramDir() {
return getCodeProgramDir(getProgramID());
}
public static File getCodeProgramDir(String snippetID) {
return new File(javaxCodeDir(), formatSnippetID(snippetID));
}
public static File getCodeProgramDir(long snippetID) {
return getCodeProgramDir(formatSnippetID(snippetID));
}
public static String standardCredentialsUser() {
return trim(loadTextFile(oneOfTheFiles(javaxSecretDir("tinybrain-username"), userDir(".tinybrain/username"))));
}
public static String standardCredentialsPass() {
return trim(loadTextFile(oneOfTheFiles(javaxSecretDir("tinybrain-userpass"), userDir(".tinybrain/userpass"))));
}
public static void saveGZTextFile(File file, String contents) {
try {
File parentFile = file.getParentFile();
if (parentFile != null)
parentFile.mkdirs();
String tempFileName = file.getPath() + "_temp";
File tempFile = new File(tempFileName);
if (contents != null) {
if (tempFile.exists())
try {
String saveName = tempFileName + ".saved." + now();
copyFile(tempFile, new File(saveName));
} catch (Throwable e) {
printStackTrace(e);
}
FileOutputStream fileOutputStream = newFileOutputStream(tempFile.getPath());
GZIPOutputStream gos = new GZIPOutputStream(fileOutputStream);
OutputStreamWriter outputStreamWriter = new OutputStreamWriter(gos, "UTF-8");
PrintWriter printWriter = new PrintWriter(outputStreamWriter);
printWriter.print(contents);
printWriter.close();
gos.close();
fileOutputStream.close();
}
if (file.exists() && !file.delete())
throw new IOException("Can't delete " + file.getPath());
if (contents != null)
if (!tempFile.renameTo(file))
throw new IOException("Can't rename " + tempFile + " to " + file);
} catch (Exception __e) {
throw rethrow(__e);
}
}
public static List<String> getJavaModifiers_list = litlist("static", "abstract", "public", "private", "protected", "final", "native", "volatile", "synchronized", "transient");
public static List<String> getJavaModifiers() {
return getJavaModifiers_list;
}
public static ThreadLocal<Boolean> assertVerbose_value = new ThreadLocal();
public static void assertVerbose(boolean b) {
assertVerbose_value.set(b);
}
public static boolean assertVerbose() {
return isTrue(assertVerbose_value.get());
}
public static <A> A assertEqualsVerbose(Object x, A y) {
assertEqualsVerbose((String) null, x, y);
return y;
}
public static <A> A assertEqualsVerbose(String msg, Object x, A y) {
if (!eq(x, y)) {
throw fail((msg != null ? msg + ": " : "") + (y) + " != " + (x));
} else
print("OK: " + (x));
return y;
}
public static Cache<Boolean> isLinux_cache = new Cache("isLinux_load");
public static boolean isLinux() {
return isLinux_cache.get();
}
public static Boolean isLinux_load() {
return !isWindows() && !isMac() && !isAndroid();
}
public static int randomID_defaultLength = 12;
public static String randomID(int length) {
return makeRandomID(length);
}
public static String randomID() {
return randomID(randomID_defaultLength);
}
public static int globalIDLength() {
return 16;
}
public static boolean isJavaxCompilableSnippetType(int type) {
return isJavaxCompilableSnippetTypeExceptInclude(type) || type == javaxIncludeSnippetType();
}
public static List<File> hotwire_collectJars(File jar) {
List<String> libIDs = hotwire_libraryIDsFromJar_deleteJarOnFail(jar);
List<File> files = ll(jar);
for (String libID : libIDs) files.add(loadLibraryOrSrcLib(libID));
return files;
}
public static Pair<File, String> compileSnippetThroughServer(String progID) {
String transpiledSrc = getServerTranspiled2(progID);
String md5 = md5(transpiledSrc + "\n" + progID);
File jar = CompilerBot.getJarFile(md5);
if (jar == null || jar.length() <= 22) {
byte[] jarData = null;
boolean dontLoad = false;
IResourceLoader rl = vm_getResourceLoader();
if (rl != null) {
dontLoad = true;
File jar2 = rl.getSnippetJar(progID, transpiledSrc);
if (jar2 != null)
return pair(jar2, transpiledSrc);
}
if (!dontLoad) {
try {
jarData = loadBinaryPage("http://www.botcompany.de/jar/" + psI(progID) + "?md5=" + md5(transpiledSrc));
} catch (Throwable __e) {
_handleException(__e);
}
}
if (!isJAR(jarData)) {
if (jarData != null) {
print(bytesToHex(takeFirstOfByteArray(8, jarData)));
print("fallback to CompilerBot: " + fromUtf8(takeFirstOfByteArray(80, jarData)));
}
return CompilerBot.compileSnippet2(progID);
}
saveBinaryFile(jar, jarData);
}
return pair(jar, transpiledSrc);
}
public static String dropPrefix(String prefix, String s) {
return s == null ? null : s.startsWith(prefix) ? s.substring(l(prefix)) : s;
}
public static List<File> filesEndingWith(File dir, String suffix) {
return listFilesWithSuffix(dir, suffix);
}
public static List<File> filesEndingWith(List<File> l, String suffix) {
List<File> out = new ArrayList();
for (File f : unnull(l)) if (!f.isDirectory() && (empty(suffix) || endsWithIgnoreCase(f.getName(), suffix)))
out.add(f);
return out;
}
public static String addPrefixIfNotEmpty2(String prefix, String s) {
return empty(s) ? "" : addPrefix(prefix, s);
}
public static Object[] asObjectArray(List l) {
return toObjectArray(l);
}
public static File toFile(Object o) {
if (o instanceof File)
return (File) o;
if (o instanceof String)
return new File((String) o);
throw fail("Not a file: " + o);
}
public static <T> void sort(T[] a, Comparator<? super T> c) {
Arrays.sort(a, c);
}
public static <T> void sort(T[] a) {
Arrays.sort(a);
}
public static <T> void sort(List<T> a, Comparator<? super T> c) {
Collections.sort(a, c);
}
public static void sort(List a) {
Collections.sort(a);
}
public static int stdcompare(Number a, Number b) {
return cmp(a, b);
}
public static int stdcompare(String a, String b) {
return cmp(a, b);
}
public static int stdcompare(long a, long b) {
return a < b ? -1 : a > b ? 1 : 0;
}
public static int stdcompare(Object a, Object b) {
return cmp(a, b);
}
public static File getCanonicalFile(File f) {
try {
return f == null ? null : f.getCanonicalFile();
} catch (Exception __e) {
throw rethrow(__e);
}
}
public static boolean isSymLink(File f) {
return f != null && Files.isSymbolicLink(toPath(f));
}
public static int lastIndexOf(String a, String b) {
return a == null || b == null ? -1 : a.lastIndexOf(b);
}
public static int lastIndexOf(String a, char b) {
return a == null ? -1 : a.lastIndexOf(b);
}
public static List<String> javaTokPlusBrackets2(String s) {
return tok_combineRoundCurlySquareBrackets_keep(javaTok(s));
}
public static String dropSuffixTrim(String suffix, String s) {
return dropSuffixAndTrim(suffix, s);
}
public static boolean dropSuffixTrim(String suffix, String s, Matches m) {
if (!endsWith(s, suffix))
return false;
m.m = new String[] { dropLast(l(suffix), s) };
return true;
}
public static boolean find3(String pat, String s) {
return find3(pat, s, null);
}
public static boolean find3(String pat, String s, Matches matches) {
return find3(pat, parse3(s), matches);
}
public static boolean find3(String pat, List<String> toks, Matches matches) {
List<String> tokpat = parse3(pat);
String[] m = find2(tokpat, toks);
if (m == null)
return false;
if (matches != null)
matches.m = m;
return true;
}
public static boolean matchEndX(String pat, String s, Matches matches) {
return matchEnd(dropPrefix("...", pat), s, matches);
}
public static Map<String, List<String>> parse3_cachedInput_cache = synchronizedMRUCache(1000);
public static List<String> parse3_cachedInput(String s) {
List<String> tok = parse3_cachedInput_cache.get(s);
if (tok == null)
parse3_cachedInput_cache.put(s, tok = parse3(s));
return tok;
}
public static Map<String, List<String>> parse3_cachedPattern_cache = synchronizedMRUCache(1000);
public static synchronized List<String> parse3_cachedPattern(String s) {
List<String> tok = parse3_cachedPattern_cache.get(s);
if (tok == null)
parse3_cachedPattern_cache.put(s, tok = parse3(s));
return tok;
}
public static String[] match2(List<String> pat, List<String> tok) {
int i = pat.indexOf("...");
if (i < 0)
return match2_match(pat, tok);
pat = new ArrayList<String>(pat);
pat.set(i, "*");
while (pat.size() < tok.size()) {
pat.add(i, "*");
pat.add(i + 1, "");
}
return match2_match(pat, tok);
}
public static String[] match2_match(List<String> pat, List<String> tok) {
List<String> result = new ArrayList<String>();
if (pat.size() != tok.size()) {
return null;
}
for (int i = 1; i < pat.size(); i += 2) {
String p = pat.get(i), t = tok.get(i);
if (eq(p, "*"))
result.add(t);
else if (!equalsIgnoreCase(unquote(p), unquote(t)))
return null;
}
return result.toArray(new String[result.size()]);
}
public static List<String> parse3(String s) {
return dropPunctuation(javaTokPlusPeriod(s));
}
public static <A> List<A> takeLast(List<A> l, int n) {
return newSubList(l, l(l) - n);
}
public static <A> List<A> takeLast(int n, List<A> l) {
return takeLast(l, n);
}
public static String takeLast(int n, String s) {
return substring(s, l(s) - n);
}
public static String takeLast(String s, int n) {
return substring(s, l(s) - n);
}
public static String jextract(String pat, String s) {
return jextract(pat, javaTok(s));
}
public static String jextract(String pat, List<String> tok) {
List<String> tokpat = javaTok(pat);
jfind_preprocess(tokpat);
int i = jfind(tok, tokpat);
if (i < 0)
return null;
int j = i + l(tokpat) - 2;
return joinSubList(tok, i, j);
}
public static String javaxDefaultVMArgs() {
File fileNew, fileOld;
String text = loadTextFile(fileNew = javaxDataDir("default-vm-args"));
if (text == null) {
text = loadTextFile(fileOld = programFile("#1005850", "default-vm-args"));
if (text != null)
moveFile(fileOld, fileNew);
}
return trim(unnull(text));
}
public static String nullIfEmpty(String s) {
return isEmpty(s) ? null : s;
}
public static <A, B> Map<A, B> nullIfEmpty(Map<A, B> map) {
return isEmpty(map) ? null : map;
}
public static <A> List<A> nullIfEmpty(List<A> l) {
return isEmpty(l) ? null : l;
}
public static int findEndOfBracketPart(List<String> cnc, int i) {
int j = i + 2, level = 1;
while (j < cnc.size()) {
if (eqOneOf(cnc.get(j), "{", "("))
++level;
else if (eqOneOf(cnc.get(j), "}", ")"))
--level;
if (level == 0)
return j + 1;
++j;
}
return cnc.size();
}
public static <A> List<A> dropFirstThreeAndLastThree(List<A> l) {
return dropFirstAndLast(3, l);
}
public static File oneOfTheFiles(String... paths) {
if (paths != null)
for (String path : paths) if (fileExists(path))
return newFile(path);
return null;
}
public static File oneOfTheFiles(File... files) {
if (files != null)
for (File f : files) if (fileExists(f))
return f;
return null;
}
public static boolean isWindows() {
return System.getProperty("os.name").contains("Windows");
}
public static boolean isMac() {
return System.getProperty("os.name").toLowerCase().contains("mac");
}
public static boolean isJavaxCompilableSnippetTypeExceptInclude(int type) {
return isJavaxApplicationSnippetType(type) || isJavaxModuleSnippetType(type) || type == snippetType_dynModule();
}
public static int javaxIncludeSnippetType() {
return 42;
}
public static List<String> hotwire_libraryIDsFromJar_deleteJarOnFail(File jar) {
try {
return hotwire_libraryIDsFromJar(jar);
} catch (Throwable _e) {
jar.delete();
throw rethrow(_e);
}
}
public static byte[] isJAR_magic = bytesFromHex("504B0304");
public static boolean isJAR(byte[] data) {
return byteArrayStartsWith(data, isJAR_magic);
}
public static boolean isJAR(File f) {
return isJAR(loadBeginningOfBinaryFile(f, l(isJAR_magic)));
}
public static byte[] takeFirstOfByteArray(byte[] b, int n) {
return subByteArray(b, 0, n);
}
public static byte[] takeFirstOfByteArray(int n, byte[] b) {
return takeFirstOfByteArray(b, n);
}
public static List<File> listFilesWithSuffix(File dir, String suffix) {
List<File> l = new ArrayList();
for (File f : listFiles(dir)) if (!f.isDirectory() && (empty(suffix) || endsWithIgnoreCase(f.getName(), suffix)))
l.add(f);
return l;
}
public static String addPrefix(String prefix, String s) {
return s.startsWith(prefix) ? s : prefix + s;
}
public static int cmp(Number a, Number b) {
return a == null ? b == null ? 0 : -1 : cmp(a.doubleValue(), b.doubleValue());
}
public static int cmp(double a, double b) {
return a < b ? -1 : a == b ? 0 : 1;
}
public static int cmp(Object a, Object b) {
if (a == null)
return b == null ? 0 : -1;
if (b == null)
return 1;
return ((Comparable) a).compareTo(b);
}
public static Path toPath(File f) {
return f == null ? null : f.toPath();
}
public static List<String> tok_combineRoundCurlySquareBrackets_keep(List<String> tok) {
List<String> l = new ArrayList();
for (int i = 0; i < l(tok); i++) {
String t = tok.get(i);
if (odd(i) && eqOneOf(t, "{", "(", "[")) {
int j = findEndOfBracketPart2(tok, i);
l.add(joinSubList(tok, i, j));
i = j - 1;
} else
l.add(t);
}
return l;
}
public static String dropSuffixAndTrim(String suffix, String s) {
return trim(dropSuffix(suffix, s));
}
public static String[] find2(List<String> pat, List<String> tok) {
for (int idx = 0; idx < tok.size(); idx += 2) {
String[] result = find2(pat, tok, idx);
if (result != null)
return result;
}
return null;
}
public static String[] find2(List<String> pat, List<String> tok, int idx) {
if (idx + pat.size() > tok.size())
return null;
List<String> 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);
}
public static boolean equalsIgnoreCase(String a, String b) {
return eqic(a, b);
}
public static boolean equalsIgnoreCase(char a, char b) {
return eqic(a, b);
}
public static List<String> dropPunctuation_keep = ll("*", "<", ">");
public 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;
}
public static String dropPunctuation(String s) {
return join(dropPunctuation(nlTok(s)));
}
public static <A> List<A> newSubList(List<A> l, int startIndex, int endIndex) {
return cloneList(subList(l, startIndex, endIndex));
}
public static <A> List<A> newSubList(List<A> l, int startIndex) {
return cloneList(subList(l, startIndex));
}
public static File programFile(String name) {
return prepareProgramFile(name);
}
public static File programFile(String progID, String name) {
return prepareProgramFile(progID, name);
}
public static void moveFile(File a, File b) {
if (!renameFile(a, b))
throw fail("File move failed: " + a + " to " + b);
}
public static boolean isEmpty(Collection c) {
return c == null || c.isEmpty();
}
public static boolean isEmpty(CharSequence s) {
return s == null || s.length() == 0;
}
public static boolean isEmpty(Object[] a) {
return a == null || a.length == 0;
}
public static boolean isEmpty(byte[] a) {
return a == null || a.length == 0;
}
public static boolean isEmpty(Map map) {
return map == null || map.isEmpty();
}
public static <A> List<A> dropFirstAndLast(int n, List<A> l) {
return new ArrayList(subList(l, n, l(l) - n));
}
public static <A> List<A> dropFirstAndLast(List<A> l) {
return dropFirstAndLast(1, l);
}
public static String dropFirstAndLast(String s) {
return substring(s, 1, l(s) - 1);
}
public static boolean isJavaxApplicationSnippetType(int type) {
return type == snippetType_javaxSource() || type == snippetType_JavaXDesktop();
}
public static boolean isJavaxModuleSnippetType(int type) {
return type == snippetType_javaxModule() || type == snippetType_javaxDesktopModule();
}
public static int snippetType_dynModule() {
return 57;
}
public static List<String> hotwire_libraryIDsFromJar(File jar) {
String dehlibs = unnull(loadTextFileFromZip(jar, "libraries"));
return regexpExtractAll("\\d+", dehlibs);
}
public static byte[] subByteArray(byte[] b, int start) {
return subByteArray(b, start, l(b));
}
public static byte[] subByteArray(byte[] b, int start, int end) {
start = max(start, 0);
end = min(end, l(b));
if (start == 0 && end == l(b))
return b;
if (start >= end)
return new byte[0];
byte[] x = new byte[end - start];
System.arraycopy(b, start, x, 0, end - start);
return x;
}
public static int findEndOfBracketPart2(List<String> cnc, int i) {
int j = i + 2, level = 1;
while (j < cnc.size()) {
if (eqOneOf(cnc.get(j), "{", "(", "["))
++level;
else if (eqOneOf(cnc.get(j), "}", ")", "]"))
--level;
if (level == 0)
return j + 1;
++j;
}
return cnc.size();
}
public static File prepareProgramFile(String name) {
return mkdirsForFile(getProgramFile(name));
}
public static File prepareProgramFile(String progID, String name) {
return mkdirsForFile(getProgramFile(progID, name));
}
public static boolean renameFile(File a, File b) {
mkdirsForFile(b);
return a.renameTo(b);
}
public static boolean renameFile(File a, String newName) {
return renameFile(a, fileInSameDir(a, newName));
}
public static int snippetType_javaxSource() {
return 34;
}
public static int snippetType_JavaXDesktop() {
return 55;
}
public static int snippetType_javaxModule() {
return 54;
}
public static int snippetType_javaxDesktopModule() {
return 58;
}
public static List<String> regexpExtractAll(String pat, String s) {
if (s == null)
return null;
Matcher m = regexpMatcher(pat, s);
List<String> out = new ArrayList();
while (m.find()) out.add(m.group());
return out;
}
public static File fileInSameDir(File f, String newName) {
return newFile(parentFile(f), newName);
}
public static File parentFile(File f) {
return dirOfFile(f);
}
public static File dirOfFile(File f) {
return f == null ? null : f.getParentFile();
}
public abstract static class RandomAccessAbstractList<A> extends AbstractList<A> implements RandomAccess {
}
}