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_initForComponent; import static loadableUtils.utils.componentPopupMenu_getEvent; import static loadableUtils.utils.listPopupMenu; import static loadableUtils.utils.tablePopupMenu; import static loadableUtils.utils.rowSorter_setComparators; 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.structure_ClassInfo; import loadableUtils.utils.RGBImage; import loadableUtils.utils.RGB; import loadableUtils.utils.BWImage; import loadableUtils.utils.MakesBufferedImage; import loadableUtils.utils.MultiSet; 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; class main { static public String rules = "\r\n keyword greeting => say \"Hello, welcome to Manisha Mozumder (Business Consulting Services)!\\nHow can I help you?\"\r\n \r\n keyword location => say \"We are located in Germany. But we are a global company. So, we serve all over the world.\"\r\n \r\n keyword services => say [[Our Specializations are: \r\n a. 4 Phases consulting services \r\n b. Business Plan \r\n c. Business Problem Solving]]\r\n \r\n keyword phases => say [[We consult in four phases like: \r\n a. Incubator \r\n b. Planning \r\n c. Implementation & Market Entry \r\n d. Evaluation\r\n \r\n Our main purpose of four phases consulting services is to support the business from the route level to market entry. We also provide services after that if our customers demand that.]]\r\n \r\n keyword quote => say [[Please email at manisha@mmozumder.com to get a quote for your expected service or click on \"ask for quote\" on our website.]]\r\n \r\n // How long it takes to finish a business plan?\r\n \r\n keyword \"how long, duration\" => say \"7?15 working days depending on the business/products/services\"\r\n \r\n // 7. How can I contact with you? Or Can I have an appointment? \r\n \r\n keyword \"contact, appointment\" => say \"Please give us your expected date, time and mode of communication (Phone Number/Whatsapp/Skype address/Email Address). Someone from our office will contact with you on that time.\"\r\n \r\n // 8. Can you tell me about the sections of Business Plan? Or What are the parts which would be added in a business plan? \r\n \r\n keyword \"sections, parts\" => say [[There would be 4?5 parts in general. Those are:\r\n \r\n Core Planning, Marketing Plan, Strategies for Personnel Planning and Financials. \r\n \r\n Please ask for quote to know more details.]]\r\n \r\n don't know => say \"Please ask for quote to know about it.\"\r\n don't know => say [[Please give us your expected date, time and mode of communication (Phone Number/Whatsapp/Skype address/Email Address). Someone from our office will contact with you soon.]]\r\n \r\n theory test {\r\n on \"fjdiojgogfdo\" expect (don't know)\r\n }\r\n \r\n afterwards => proc {\r\n unless (say $x):\r\n don't know\r\n }\r\n"; static public class MMORules extends DynPrintLog { public void start() { super.start(); startThread("Start", new Runnable() { public void run() { try { AutoCloseable __8 = enter(); try { try { PhilosophyBot1 bot = new PhilosophyBot1(rules); bot.run(); bot.openTheory("test"); for (Map map : bot.matchFacts("on $a expect $b")) { PhilosophyBot1 bot2 = new PhilosophyBot1(rules); bot.run(); bot.addFact(bot.format("input $a", map)); bot.addFact(bot.format("expect $b", map)); bot.run(); bot.addFact("afterwards"); bot.run(); bot.checkExpectations(); } } catch (Throwable __e) { _handleException(__e); } } finally { _close(__8); } } catch (Exception __e) { throw rethrow(__e); } } public String toString() { return "AutoCloseable __8 = enter(); try { try {\r\n PhilosophyBot1 bot = new Philos..."; } }); } } static public boolean _moduleClass_MMORules = true; static public 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); } } static public A callF(F0 f) { return f == null ? null : f.get(); } static public A callF(IF0 f) { return f == null ? null : f.get(); } static public B callF(F1 f, A a) { return f == null ? null : f.get(a); } static public B callF(IF1 f, A a) { return f == null ? null : f.get(a); } static public C callF(F2 f, A a, B b) { return f == null ? null : f.get(a, b); } static public void callF(VF1 f, A a) { if (f != null) f.get(a); } static public Object callMC(String method, Object... args) { return call(mc(), method, args); } static public Object call(Object o) { return callF(o); } static public Object call(Object o, String method, Object... args) { return call_withVarargs(o, method, args); } static public void _onLoad_initUtils() { utils.__javax = javax(); } static public void _onLoad_defaultClassFinder() { setDefaultClassFinder(new F1() { 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..."; } }); } static public String programID() { return getProgramID(); } static public String programID(Object o) { return getProgramID(o); } static volatile public StringBuffer local_log = new StringBuffer(); static volatile public Appendable print_log = local_log; static volatile public int print_log_max = 1024 * 1024; static volatile public int local_log_max = 100 * 1024; static public boolean print_silent = false; static public Object print_byThread_lock = new Object(); static volatile public ThreadLocal print_byThread; static volatile public Object print_allThreads; static volatile public Object print_preprocess; static public void print() { print(""); } static public A print(String s, A o) { print((endsWithLetterOrDigit(s) ? s + ": " : s) + o); return o; } static public A print(A o) { ping_okInCleanUp(); if (print_silent) return o; String s = String.valueOf(o) + "\n"; print_noNewLine(s); return o; } static public 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); } static public 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); } static public void print_autoRotate() { } static public AutoCloseable tempInterceptPrintIfNotIntercepted(F1 f) { return print_byThread().get() == null ? tempInterceptPrint(f) : null; } static public Thread startThread(Object runnable) { return startThread(defaultThreadName(), runnable); } static public Thread startThread(String name, Object runnable) { runnable = wrapAsActivity(runnable); return startThread(newThread(toRunnable(runnable), name)); } static public Thread startThread(Thread t) { _registerThread(t); t.start(); return t; } static volatile public PersistableThrowable _handleException_lastException; static public List _handleException_onException = synchroList(ll("printStackTrace2")); static public 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); } } static public 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); } } static public RuntimeException rethrow(Throwable t) { if (t instanceof Error) _handleError((Error) t); throw t instanceof RuntimeException ? (RuntimeException) t : new RuntimeException(t); } static public RuntimeException rethrow(String msg, Throwable t) { throw new RuntimeException(msg, t); } static public Class mc() { return main.class; } static public 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 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 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 in " + c); } } catch (Exception __e) { throw rethrow(__e); } } static public Class javax() { return getJavaX(); } static public void setDefaultClassFinder(Object cf) { _defaultClassFinder_value = cf; } static public HashMap findClass_fullName_cache = new HashMap(); static public 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; } } static public boolean startsWith(String a, String b) { return a != null && a.startsWith(b); } static public boolean startsWith(String a, char c) { return nemptyString(a) && a.charAt(0) == c; } static public boolean startsWith(String a, String b, Matches m) { if (!startsWith(a, b)) return false; m.m = new String[] { substring(a, strL(b)) }; return true; } static public 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; } static public String substring(String s, int x) { return substring(s, x, strL(s)); } static public 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); } static public String substring(String s, IntRange r) { return r == null ? null : substring(s, r.start, r.end); } static public Throwable printStackTrace2(Throwable e) { print(getStackTrace2(e)); return e; } static public void printStackTrace2() { printStackTrace2(new Throwable()); } static public void printStackTrace2(String msg) { printStackTrace2(new Throwable(msg)); } static public Object _defaultClassFinder_value = defaultDefaultClassFinder(); static public Object _defaultClassFinder() { return _defaultClassFinder_value; } static public String programID; static public String getProgramID() { return nempty(programID) ? formatSnippetIDOpt(programID) : "?"; } static public String getProgramID(Class c) { String id = (String) getOpt(c, "programID"); if (nempty(id)) return formatSnippetID(id); return "?"; } static public String getProgramID(Object o) { return getProgramID(getMainClass(o)); } static public boolean endsWithLetterOrDigit(String s) { return s != null && s.length() > 0 && Character.isLetterOrDigit(s.charAt(s.length() - 1)); } static public void ping_okInCleanUp() { if (ping_pauseAll || ping_anyActions) ping_impl(true); } static public Object getThreadLocal(Object o, String name) { ThreadLocal t = (ThreadLocal) (getOpt(o, name)); return t != null ? t.get() : null; } static public A getThreadLocal(ThreadLocal tl) { return tl == null ? null : tl.get(); } static public A getThreadLocal(ThreadLocal tl, A defaultValue) { return or(getThreadLocal(tl), defaultValue); } static public ThreadLocal print_byThread_dontCreate() { return print_byThread; } static public boolean isFalse(Object o) { return eq(false, o); } static public 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(); } static public void print_append(Appendable buf, String s, int max) { try { synchronized (buf) { buf.append(s); if (buf instanceof StringBuffer) rotateStringBuffer(((StringBuffer) buf), max); else if (buf instanceof StringBuilder) rotateStringBuilder(((StringBuilder) buf), max); } } catch (Exception __e) { throw rethrow(__e); } } static public ThreadLocal print_byThread() { synchronized (print_byThread_lock) { if (print_byThread == null) print_byThread = new ThreadLocal(); } return print_byThread; } static public AutoCloseable tempInterceptPrint(F1 f) { return tempSetThreadLocal(print_byThread(), f); } static public String defaultThreadName_name; static public String defaultThreadName() { if (defaultThreadName_name == null) defaultThreadName_name = "A thread by " + programID(); return defaultThreadName_name; } static public Runnable wrapAsActivity(Object r) { return toRunnable(r); } static public Thread newThread(Object runnable) { return new Thread(_topLevelErrorHandling(toRunnable(runnable))); } static public Thread newThread(Object runnable, String name) { if (name == null) name = defaultThreadName(); return new Thread(_topLevelErrorHandling(toRunnable(runnable)), name); } static public Thread newThread(String name, Object runnable) { return newThread(runnable, name); } static public 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)"; } }; } static public Map _registerThread_threads; static public Object _onRegisterThread; static public 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; } static public void _registerThread() { _registerThread(Thread.currentThread()); } static public List synchroList() { return Collections.synchronizedList(new ArrayList()); } static public List synchroList(List l) { return Collections.synchronizedList(l); } static public List ll(A... a) { ArrayList l = new ArrayList(a.length); if (a != null) for (A x : a) l.add(x); return l; } static public PersistableThrowable persistableThrowable(Throwable e) { return e == null ? null : new PersistableThrowable(e); } static public Throwable innerException(Throwable e) { return getInnerException(e); } static public boolean eq(Object a, Object b) { return a == b || (a == null ? b == null : b != null && a.equals(b)); } static public ArrayList cloneList(Iterable l) { return l instanceof Collection ? cloneList((Collection) l) : asList(l); } static public ArrayList cloneList(Collection l) { if (l == null) return new ArrayList(); synchronized (collectionMutex(l)) { return new ArrayList(l); } } static public void _handleError(Error e) { call(javax(), "_handleError", e); } static final public Map callOpt_cache = newDangerousWeakHashMap(); static public 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); } } static public _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; } } static public 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); } } static public boolean isStaticMethod(Method m) { return methodIsStatic(m); } static public 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; } static public String joinWithComma(Collection c) { return join(", ", c); } static public String joinWithComma(String... c) { return join(", ", c); } static public String joinWithComma(Pair p) { return p == null ? "" : joinWithComma(str(p.a), str(p.b)); } static public List classNames(Collection l) { return getClassNames(l); } static public List classNames(Object[] l) { return getClassNames(Arrays.asList(l)); } static public Class __javax; static public Class getJavaX() { try { return __javax; } catch (Exception __e) { throw rethrow(__e); } } static public boolean nemptyString(String s) { return s != null && s.length() > 0; } static public int strL(String s) { return s == null ? 0 : s.length(); } static public int listL(Collection l) { return l == null ? 0 : l.size(); } static public boolean neq(Object a, Object b) { return !eq(a, b); } static public String getStackTrace2(Throwable e) { return hideCredentials(getStackTrace(unwrapTrivialExceptionWraps(e)) + replacePrefix("java.lang.RuntimeException: ", "FAIL: ", hideCredentials(str(innerException2(e)))) + "\n"); } static public Object defaultDefaultClassFinder() { return new F1() { 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..."; } }; } static public boolean nempty(Collection c) { return !empty(c); } static public boolean nempty(CharSequence s) { return !empty(s); } static public boolean nempty(Object[] o) { return !empty(o); } static public boolean nempty(byte[] o) { return !empty(o); } static public boolean nempty(int[] o) { return !empty(o); } static public boolean nempty(Map m) { return !empty(m); } static public boolean nempty(Iterator i) { return i != null && i.hasNext(); } static public boolean nempty(Object o) { return !empty(o); } static public String formatSnippetIDOpt(String s) { return isSnippetID(s) ? formatSnippetID(s) : s; } static public String formatSnippetID(String id) { return "#" + parseSnippetID(id); } static public String formatSnippetID(long id) { return "#" + id; } static public Class getMainClass() { return mc(); } static public 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); } } static volatile public boolean ping_pauseAll = false; static public int ping_sleep = 100; static volatile public boolean ping_anyActions = false; static public Map ping_actions = newWeakHashMap(); static public ThreadLocal ping_isCleanUpThread = new ThreadLocal(); static public boolean ping() { if (ping_pauseAll || ping_anyActions) ping_impl(true); return true; } static public 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); } } static public A or(A a, A b) { return a != null ? a : b; } static public void rotateStringBuffer(StringBuffer buf, int max) { try { if (buf == null) return; synchronized (buf) { if (buf.length() <= max) return; 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); } buf.trimToSize(); } } catch (Exception __e) { throw rethrow(__e); } } static public void rotateStringBuilder(StringBuilder buf, int max) { try { if (buf == null) return; synchronized (buf) { if (buf.length() <= max) return; 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); } buf.trimToSize(); } } catch (Exception __e) { throw rethrow(__e); } } static public AutoCloseable tempSetThreadLocal(final ThreadLocal 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); } }; } static public 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 }"; } }; } static public WeakReference weakRef(A a) { return newWeakReference(a); } static public Throwable getInnerException(Throwable e) { if (e == null) return null; while (e.getCause() != null) e = e.getCause(); return e; } static public Throwable getInnerException(Runnable r) { return getInnerException(getException(r)); } static public String str(Object o) { return o == null ? "null" : o.toString(); } static public String str(char[] c) { return new String(c); } static public Object collectionMutex(List l) { return l; } static public Object collectionMutex(Object o) { if (o instanceof List) return 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; } static public Throwable getExceptionCause(Throwable e) { Throwable c = e.getCause(); return c != null ? c : e; } static public String joinWithSpace(Collection c) { return join(" ", c); } static public String joinWithSpace(String... c) { return join(" ", c); } static public boolean methodIsStatic(Method m) { return (m.getModifiers() & Modifier.STATIC) != 0; } static public boolean argumentCompatibleWithType(Object arg, Class type) { return arg == null ? !type.isPrimitive() : isInstanceX(type, arg); } static public void arraycopy(Object[] a, Object[] b) { if (a != null && b != null) arraycopy(a, 0, b, 0, min(a.length, b.length)); } static public void arraycopy(Object src, int srcPos, Object dest, int destPos, int n) { if (n != 0) System.arraycopy(src, srcPos, dest, destPos, n); } static public A[] arrayOfType(Class type, int n) { return makeArray(type, n); } static public A[] arrayOfType(int n, Class type) { return arrayOfType(type, n); } public static String join(String glue, Iterable strings) { if (strings == null) return ""; if (strings instanceof Collection) { if (((Collection) strings).size() == 1) return str(first(((Collection) strings))); } StringBuilder buf = new StringBuilder(); Iterator i = strings.iterator(); if (i.hasNext()) { buf.append(i.next()); while (i.hasNext()) buf.append(glue).append(i.next()); } return buf.toString(); } public static String join(String glue, String... strings) { return join(glue, Arrays.asList(strings)); } static public String join(Iterable strings) { return join("", strings); } static public String join(Iterable strings, String glue) { return join(glue, strings); } public static String join(String[] strings) { return join("", strings); } static public String join(String glue, Pair p) { return p == null ? "" : str(p.a) + glue + str(p.b); } static public List getClassNames(Collection l) { List out = new ArrayList(); if (l != null) for (Object o : l) out.add(o == null ? null : getClassName(o)); return out; } static public String hideCredentials(URL url) { return url == null ? null : hideCredentials(str(url)); } static public String hideCredentials(String url) { try { if (startsWithOneOf(url, "http://", "https://") && isAGIBlueDomain(hostNameFromURL(url))) return url; } catch (Throwable e) { print("HideCredentials", e); } return url.replaceAll("([&?])(_pass|key)=[^&\\s\"]*", "$1$2="); } static public String hideCredentials(Object o) { return hideCredentials(str(o)); } static public String getStackTrace(Throwable throwable) { lastException(throwable); return getStackTrace_noRecord(throwable); } static public String getStackTrace_noRecord(Throwable throwable) { StringWriter writer = new StringWriter(); throwable.printStackTrace(new PrintWriter(writer)); return hideCredentials(writer.toString()); } static public String getStackTrace() { return getStackTrace_noRecord(new Throwable()); } static public 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; } static public String replacePrefix(String prefix, String replacement, String s) { if (!startsWith(s, prefix)) return s; return replacement + substring(s, l(prefix)); } static public Throwable innerException2(Throwable e) { if (e == null) return null; while (empty(e.getMessage()) && e.getCause() != null) e = e.getCause(); return e; } static public boolean empty(Collection c) { return c == null || c.isEmpty(); } static public boolean empty(CharSequence s) { return s == null || s.length() == 0; } static public boolean empty(Map map) { return map == null || map.isEmpty(); } static public boolean empty(Object[] o) { return o == null || o.length == 0; } static public 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)); } static public boolean empty(Iterator i) { return i == null || !i.hasNext(); } static public boolean empty(float[] a) { return a == null || a.length == 0; } static public boolean empty(int[] a) { return a == null || a.length == 0; } static public boolean empty(long[] a) { return a == null || a.length == 0; } static public boolean empty(byte[] a) { return a == null || a.length == 0; } static public boolean empty(short[] a) { return a == null || a.length == 0; } static public boolean empty(MultiSet ms) { return ms == null || ms.isEmpty(); } static public 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; } static public boolean isAWTThread() { if (isAndroid()) return false; if (isHeadless()) return false; return isAWTThread_awt(); } static public boolean isAWTThread_awt() { return SwingUtilities.isEventDispatchThread(); } static public void failIfUnlicensed() { assertTrue("license off", licensed()); } static public Thread currentThread() { return Thread.currentThread(); } static public A setThreadLocal(ThreadLocal tl, A value) { if (tl == null) return null; A old = tl.get(); tl.set(value); return old; } static public WeakReference newWeakReference(A a) { return a == null ? null : new WeakReference(a); } static public Throwable getException(Runnable r) { try { callF(r); return null; } catch (Throwable e) { return e; } } static public String className(Object o) { return getClassName(o); } static public boolean eqOneOf(Object o, Object... l) { for (Object x : l) if (eq(o, x)) return true; return false; } static public boolean isInstanceX(Class type, Object arg) { if (type == boolean.class) return arg instanceof Boolean; if (type == int.class) return arg instanceof Integer; if (type == long.class) return arg instanceof Long; if (type == float.class) return arg instanceof Float; if (type == short.class) return arg instanceof Short; if (type == char.class) return arg instanceof Character; if (type == byte.class) return arg instanceof Byte; if (type == double.class) return arg instanceof Double; return type.isInstance(arg); } static public int min(int a, int b) { return Math.min(a, b); } static public long min(long a, long b) { return Math.min(a, b); } static public float min(float a, float b) { return Math.min(a, b); } static public float min(float a, float b, float c) { return min(min(a, b), c); } static public double min(double a, double b) { return Math.min(a, b); } static public double min(double[] c) { double x = Double.MAX_VALUE; for (double d : c) x = Math.min(x, d); return x; } static public float min(float[] c) { float x = Float.MAX_VALUE; for (float d : c) x = Math.min(x, d); return x; } static public byte min(byte[] c) { byte x = 127; for (byte d : c) if (d < x) x = d; return x; } static public short min(short[] c) { short x = 0x7FFF; for (short d : c) if (d < x) x = d; return x; } static public int min(int[] c) { int x = Integer.MAX_VALUE; for (int d : c) if (d < x) x = d; return x; } static public A[] makeArray(Class type, int n) { return (A[]) Array.newInstance(type, n); } static public Object first(Object list) { return first((Iterable) list); } static public A first(List list) { return empty(list) ? null : list.get(0); } static public A first(A[] bla) { return bla == null || bla.length == 0 ? null : bla[0]; } static public A first(IterableIterator i) { return first((Iterator) i); } static public A first(Iterator i) { return i == null || !i.hasNext() ? null : i.next(); } static public A first(Iterable i) { if (i == null) return null; Iterator it = i.iterator(); return it.hasNext() ? it.next() : null; } static public Character first(String s) { return empty(s) ? null : s.charAt(0); } static public A first(Pair p) { return p == null ? null : p.a; } static public String getClassName(Object o) { return o == null ? "null" : o instanceof Class ? ((Class) o).getName() : o.getClass().getName(); } static public boolean startsWithOneOf(String s, String... l) { for (String x : l) if (startsWith(s, x)) return true; return false; } static public boolean isAGIBlueDomain(String domain) { return domainIsUnder(domain, theAGIBlueDomain()); } static public String hostNameFromURL(String url) { try { return new URL(url).getHost(); } catch (Exception __e) { throw rethrow(__e); } } static volatile public PersistableThrowable lastException_lastException; static public PersistableThrowable lastException() { return lastException_lastException; } static public void lastException(Throwable e) { lastException_lastException = persistableThrowable(e); } static public String getType(Object o) { return getClassName(o); } static public long getFileSize(String path) { return path == null ? 0 : new File(path).length(); } static public long getFileSize(File f) { return f == null ? 0 : f.length(); } static public String shortenSnippetID(String snippetID) { if (snippetID.startsWith("#")) snippetID = snippetID.substring(1); String httpBlaBla = "http://tinybrain.de/"; if (snippetID.startsWith(httpBlaBla)) snippetID = snippetID.substring(httpBlaBla.length()); return "" + parseLong(snippetID); } static volatile public boolean licensed_yes = true; static public boolean licensed() { if (!licensed_yes) return false; ping_okInCleanUp(); return true; } static public void licensed_off() { licensed_yes = false; } static public boolean domainIsUnder(String domain, String mainDomain) { return eqic(domain, mainDomain) || ewic(domain, "." + mainDomain); } static public String theAGIBlueDomain() { return "agi.blue"; } static public long parseLong(String s) { if (empty(s)) return 0; return Long.parseLong(dropSuffix("L", s)); } static public long parseLong(Object s) { return Long.parseLong((String) s); } static public boolean eqic(String a, String b) { if ((a == null) != (b == null)) return false; if (a == null) return true; return a.equalsIgnoreCase(b); } static public 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); } static public boolean ewic(String a, String b) { return endsWithIgnoreCase(a, b); } static public boolean ewic(String a, String b, Matches m) { return endsWithIgnoreCase(a, b, m); } static public String dropSuffix(String suffix, String s) { return s.endsWith(suffix) ? s.substring(0, l(s) - l(suffix)) : s; } static public String asString(Object o) { return o == null ? null : o.toString(); } static public boolean endsWithIgnoreCase(String a, String b) { int la = l(a), lb = l(b); return la >= lb && regionMatchesIC(a, la - lb, b, 0, lb); } static public 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; } static public boolean regionMatchesIC(String a, int offsetA, String b, int offsetB, int len) { return a != null && a.regionMatches(true, offsetA, b, offsetB, len); } final static public class _MethodCache { final public Class c; final public HashMap> 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 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 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); } } } static public class PhilosophyBot1 { static public class LogicRule implements IFieldsToList, Transformable { public Object lhs; public Object rhs; public LogicRule() { } public LogicRule(Object lhs, Object rhs) { this.rhs = rhs; this.lhs = lhs; } public boolean equals(Object o) { if (!(o instanceof LogicRule)) return false; LogicRule x = (LogicRule) o; return eq(lhs, x.lhs) && eq(rhs, x.rhs); } public int hashCode() { int h = 274479962; h = boostHashCombine(h, _hashCode(lhs)); h = boostHashCombine(h, _hashCode(rhs)); return h; } public Object[] _fieldsToList() { return new Object[] { lhs, rhs }; } public Object transformUsing(IF1 f) { return new LogicRule(f.get(lhs), f.get(rhs)); } public int n; public String toString() { return (n == 0 ? "" : "[" + n + "] ") + lhs + " => " + rhs; } } static public class And implements IFieldsToList, Transformable { public Object a; public Object b; public And() { } public And(Object a, Object b) { this.b = b; this.a = a; } public String toString() { return "And(" + a + ", " + b + ")"; } public boolean equals(Object o) { if (!(o instanceof And)) return false; And x = (And) o; return eq(a, x.a) && eq(b, x.b); } public int hashCode() { int h = 65975; h = boostHashCombine(h, _hashCode(a)); h = boostHashCombine(h, _hashCode(b)); return h; } public Object[] _fieldsToList() { return new Object[] { a, b }; } public Object transformUsing(IF1 f) { return new And(f.get(a), f.get(b)); } } static public class If implements IFieldsToList, Transformable { public Object condition; public Object thenBlock; public Object elseBlock; public If() { } public If(Object condition, Object thenBlock, Object elseBlock) { this.elseBlock = elseBlock; this.thenBlock = thenBlock; this.condition = condition; } public String toString() { return "If(" + condition + ", " + thenBlock + ", " + elseBlock + ")"; } public boolean equals(Object o) { if (!(o instanceof If)) return false; If x = (If) o; return eq(condition, x.condition) && eq(thenBlock, x.thenBlock) && eq(elseBlock, x.elseBlock); } public int hashCode() { int h = 2365; h = boostHashCombine(h, _hashCode(condition)); h = boostHashCombine(h, _hashCode(thenBlock)); h = boostHashCombine(h, _hashCode(elseBlock)); return h; } public Object[] _fieldsToList() { return new Object[] { condition, thenBlock, elseBlock }; } public Object transformUsing(IF1 f) { return new If(f.get(condition), f.get(thenBlock), f.get(elseBlock)); } } static public class For implements IFieldsToList, Transformable { public Object var; public Object condition; public Object body; public For() { } public For(Object var, Object condition, Object body) { this.body = body; this.condition = condition; this.var = var; } public String toString() { return "For(" + var + ", " + condition + ", " + body + ")"; } public boolean equals(Object o) { if (!(o instanceof For)) return false; For x = (For) o; return eq(var, x.var) && eq(condition, x.condition) && eq(body, x.body); } public int hashCode() { int h = 70825; h = boostHashCombine(h, _hashCode(var)); h = boostHashCombine(h, _hashCode(condition)); h = boostHashCombine(h, _hashCode(body)); return h; } public Object[] _fieldsToList() { return new Object[] { var, condition, body }; } public Object transformUsing(IF1 f) { return new For(f.get(var), f.get(condition), f.get(body)); } } static public class ForIn implements IFieldsToList, Transformable { public Object var; public Object expr; public Object body; public ForIn() { } public ForIn(Object var, Object expr, Object body) { this.body = body; this.expr = expr; this.var = var; } public String toString() { return "ForIn(" + var + ", " + expr + ", " + body + ")"; } public boolean equals(Object o) { if (!(o instanceof ForIn)) return false; ForIn x = (ForIn) o; return eq(var, x.var) && eq(expr, x.expr) && eq(body, x.body); } public int hashCode() { int h = 68065198; h = boostHashCombine(h, _hashCode(var)); h = boostHashCombine(h, _hashCode(expr)); h = boostHashCombine(h, _hashCode(body)); return h; } public Object[] _fieldsToList() { return new Object[] { var, expr, body }; } public Object transformUsing(IF1 f) { return new ForIn(f.get(var), f.get(expr), f.get(body)); } } static public class While implements IFieldsToList, Transformable { public Object condition; public Object body; public While() { } public While(Object condition, Object body) { this.body = body; this.condition = condition; } public String toString() { return "While(" + condition + ", " + body + ")"; } public boolean equals(Object o) { if (!(o instanceof While)) return false; While x = (While) o; return eq(condition, x.condition) && eq(body, x.body); } public int hashCode() { int h = 83548945; h = boostHashCombine(h, _hashCode(condition)); h = boostHashCombine(h, _hashCode(body)); return h; } public Object[] _fieldsToList() { return new Object[] { condition, body }; } public Object transformUsing(IF1 f) { return new While(f.get(condition), f.get(body)); } } static public class CodeFragment { public String head; public IVF2, Env> body; public boolean keepBrackets = false; public CodeFragment(String head, IVF2, Env> body, boolean keepBrackets) { this.keepBrackets = keepBrackets; this.body = body; this.head = head; } public CodeFragment(String head, IVF2, Env> body) { this.body = body; this.head = head; } public String toString() { return stdToString(this); } } static public class Env { public boolean wantAlternatives = false; public boolean wantAlternatives() { return wantAlternatives; } } static public class WithAlternative implements IFieldsToList { public IF0 alternative; public Object result; public WithAlternative() { } public WithAlternative(IF0 alternative, Object result) { this.result = result; this.alternative = alternative; } public String toString() { return "WithAlternative(" + alternative + ", " + result + ")"; } public boolean equals(Object o) { if (!(o instanceof WithAlternative)) return false; WithAlternative x = (WithAlternative) o; return eq(alternative, x.alternative) && eq(result, x.result); } public int hashCode() { int h = -1195262233; h = boostHashCombine(h, _hashCode(alternative)); h = boostHashCombine(h, _hashCode(result)); return h; } public Object[] _fieldsToList() { return new Object[] { alternative, result }; } } static public class NativePredicate implements IFieldsToList { static final public String _fieldOrder = "head body"; public String head; public IF2, Env, Object> body; public NativePredicate() { } public NativePredicate(String head, IF2, Env, Object> body) { this.body = body; this.head = head; } public String toString() { return "NativePredicate(" + head + ", " + body + ")"; } public boolean equals(Object o) { if (!(o instanceof NativePredicate)) return false; NativePredicate x = (NativePredicate) o; return eq(head, x.head) && eq(body, x.body); } public int hashCode() { int h = 1520196416; h = boostHashCombine(h, _hashCode(head)); h = boostHashCombine(h, _hashCode(body)); return h; } public Object[] _fieldsToList() { return new Object[] { head, body }; } } transient public String program; transient public boolean programLoaded = false; transient public int maxRounds = 1000; transient public Set facts = linkedCISet(); transient public Set originalFacts = ciSet(); transient public LinkedHashSet logicRules = new LinkedHashSet(); transient public AllOnAll rulesOnFacts = new AllOnAll(); transient public AllOnAll codeOnFacts = new AllOnAll(); transient public AllOnAll, String> anyCodeOnFacts = new AllOnAll(); transient public List proceduresToRun = new ArrayList(); transient public long proceduresExecuted; transient public List nativePredicates = new ArrayList(); transient public boolean debugNativeCalls = true, debugAllCmds = true; transient public List onProcedureEnded = new ArrayList(); transient public List> onLogicRuleAdded = new ArrayList(); transient public List> onFactAdded = new ArrayList(); transient public boolean printNonMatches, debugContradictionChecks; transient public boolean standardImportsLoaded = false; transient public boolean curryAllRules = true; transient public int logicRulesCounter; transient public boolean thoughtBegun = false; transient public List> logicRulePreprocessors = new ArrayList(); transient public List> factPreprocessors = new ArrayList(); transient public List extraLogicOperations = new ArrayList(); transient public Set vars = litciset("x", "y", "z"); public PhilosophyBot1() { anyCodeOnFacts.newA(fact -> { Boolean b = checkNativeCondition(fact); if (debugContradictionChecks) print("Fact check: " + b + " - " + fact); if (isFalse(b)) addFact("contradiction"); }); _standardHandlers(); } public PhilosophyBot1(String program) { this(); this.program = program; } public void addRule(String s) { Pair p = splitAtFirstDoubleArrow(javaTokWithBrackets(s)); if (p == null) print("addRule failed: " + s); addLogicRule(new LogicRule(splitAtAmpersand2(p.a), p.b)); } public void addRules(Iterable l) { for (String s : unnull(l)) addRule(s); } public Object splitRuleRHS(Object rhs) { if (rhs instanceof String) { Pair p = splitAtFirstDoubleArrow(javaTokWithBrackets(((String) rhs))); if (p != null) return splitRuleRHS(new LogicRule(splitAtAmpersand2(p.a), splitRuleRHS(p.b))); return splitAtAmpersand2(((String) rhs)); } return rhs; } public LogicRule curryLHS(LogicRule rule) { while (licensed()) { Object lhs = rule.lhs; if (lhs instanceof And) { Object a = ((And) lhs).a; Object b = ((And) lhs).b; rule = new LogicRule(a, new LogicRule(b, rule.rhs)); } else break; } return rule; } public void addLogicRule(LogicRule rule) { rule.rhs = splitRuleRHS(rule.rhs); if (curryAllRules) rule = curryLHS(rule); for (IF1 p : logicRulePreprocessors) if (p.get(rule)) return; rule.n = ++logicRulesCounter; Boolean b = checkConditionOpt(rule.lhs); if (isFalse(b)) return; if (isTrue(b)) addRewrittenRHS(rule.rhs); if (syncAdd(logicRules, rule)) { print("Got logic rule", rule); pcallFAll(onLogicRuleAdded, rule); rulesOnFacts.newA(rule); } } public void addFacts(Iterable l) { for (String fact : unnull(l)) addFact(fact); } public void addFact(String fact) { fact = trim(fact); if (empty(fact)) return; fact = tok_deRoundBracket(fact); for (IF1 p : factPreprocessors) if (p.get(fact)) return; List tok = mainTokenize(fact); if (countCodeTokens(tok) == 2 && firstTokenEqic(tok, "proc") && isCurlyBracketed(getCodeToken(tok, 1))) { try { String proc = uncurly_keepSpaces(getCodeToken(tok, 1)); if (proceduresToRun.add(parseProcedure(proc))) { print("Got procedure:"); print(indentx("> ", proc)); } } catch (Throwable __e) { _handleException(__e); } } else if (facts.add(fact)) { print("Got fact: " + fact); pcallFAll(onFactAdded, fact); rulesOnFacts.newB(fact); codeOnFacts.newB(fact); anyCodeOnFacts.newB(fact); } } public void addRewrittenRHS(Object o) { if (o instanceof LogicRule) addLogicRule(((LogicRule) o)); else if (o instanceof And) { Object a = ((And) o).a; Object b = ((And) o).b; addRewrittenRHS(a); addRewrittenRHS(b); } else if (o != null) addFact((String) o); } public void addFactFromProgram(String fact) { if (countJavaTokens(fact) == 0) return; fact = javaDropAllComments(fact); originalFacts.add(fact); addFact(fact); } public void runProcedure(String proc) { try { print("Running procedure."); runParsedProcedure(parseProcedure(proc)); } catch (Throwable __e) { _handleException(__e); } } public void runParsedProcedure(List commands) { runParsedProcedure(commands, proceduresToRun); } public void runParsedProcedure(List commands, List whereToPostCode) { ++proceduresExecuted; Env env = new Env(); List remainingCommands = cloneLinkedList(commands); Object cmd; while ((cmd = popFirst_ping(remainingCommands)) != null) { if (cmd instanceof List) { runParsedProcedure(((List) cmd)); continue; } if (cmd instanceof Runnable) { ((Runnable) cmd).run(); continue; } if (debugAllCmds) print("Running cmd: " + sfu(cmd)); if (cmd instanceof If) { Object condition = ((If) cmd).condition; Object thenBlock = ((If) cmd).thenBlock; Object elseBlock = ((If) cmd).elseBlock; Object blockToRun = checkCondition(condition) ? thenBlock : elseBlock; runParsedProcedure(ll(blockToRun)); } else if (cmd instanceof For) { Object var = ((For) cmd).var; Object condition = ((For) cmd).condition; Object body = ((For) cmd).body; addLogicRule(new LogicRule(condition, "proc {\n" + body + "\n}")); } else if (cmd instanceof While) { Object condition = ((While) cmd).condition; Object body = ((While) cmd).body; boolean b = checkCondition(condition); if (!b) continue; whereToPostCode.add(ll(body, cmd)); } else if (cmd instanceof ForIn && ((ForIn) cmd).var instanceof String && ((ForIn) cmd).expr instanceof String) { String var = (String) (((ForIn) cmd).var); String expr = (String) (((ForIn) cmd).expr); Object body = ((ForIn) cmd).body; Object result = runNativePredicate(expr, new Env()); if (!(result instanceof Iterable)) { print("Warning: result of " + expr + " not iterable (" + shortClassName(result) + ")"); continue; } Iterator it = iterator((Iterable) result); Runnable step = new Runnable() { public void run() { try { if (!it.hasNext()) return; String value = str(it.next()); Map map = litcimap(var, value); Object body2 = replaceVars(body, map); whereToPostCode.add(ll(body2, this)); } catch (Exception __e) { throw rethrow(__e); } } public String toString() { return "if (!it.hasNext()) return;\r\n String value = str(it.next());\r\n ..."; } }; step.run(); } else if (cmd instanceof String) { Object result = runNativePredicate(((String) cmd), env); if (result != null) { result = unpackWithAlternativeOrIterator(result); if (isFalse(result)) return; if (isTrueOpt(result)) continue; Map mapping = (Map) result; List remainingCommands2 = mapToLinkedList(remainingCommands, c -> replaceVars(c, mapValues("optRound", mapping))); print("Applying var mapping " + mapping + " to " + remainingCommands + " => " + remainingCommands2); remainingCommands = remainingCommands2; } else addFact(((String) cmd)); } else if (cmd != null) throw fail("Unimplemented command: " + cmd); } pcallFAll(onProcedureEnded, commands); } public Object runNativePredicate(String s, Env env) { for (NativePredicate np : nativePredicates) { Map map = zipIt(np.head, s); if (map != null) { Object result = np.body.get(mapValues("tok_deRoundBracket", map), env); if (debugNativeCalls) print("Native predicate result: " + np.head + " => " + result); if (result instanceof Map && nempty(map)) { result = mapKeys((Map) result, var -> lookupOrKeep(map, var)); if (debugNativeCalls) print("Rewrote native predicate result: " + result); } { Object __1 = result; if (__1 != null) return __1; } } else if (printNonMatches) print("Non-match: " + quote(np.head) + " / " + quote(s)); } return null; } public boolean checkCondition(Object o) { return isTrue(checkConditionOpt(o)); } public Boolean checkConditionOpt(Object o) { if (o instanceof String) { if (contains(facts, ((String) o))) return true; { Boolean b = checkNativeCondition(((String) o)); if (b != null) return b; } } return null; } public Boolean checkNativeCondition(String o) { Object result = runNativePredicate(o, new Env()); result = unpackWithAlternativeOrIterator(result); if (result instanceof Boolean) return ((Boolean) result); if (result instanceof Map) return true; return null; } public boolean parsePythonesqueProcedure_debug = false; public List parsePythonesqueProcedure(String proc) { proc = withoutLinesEmptyAfterTrim(proc); proc = autoUnindent_honoringBrackets(proc); List l = groupPythonStyleIndents_honoringBrackets(proc); List out = new ArrayList(); If lastIf = null; for (int i = 0; i < l(l); i++) { String s = l.get(i); List tok = javaTokWithBrackets(s); if (eqic(firstCodeToken(tok), "if")) { assertEquals(s, ":", getCodeToken(tok, 2)); out.add(lastIf = new If(deRoundBracket(getCodeToken(tok, 1)), parsePythonesqueProcedure(joinSubList(tok, 3 * 2)), null)); continue; } if (eqic(firstCodeToken(tok), "unless")) { assertEquals(s, ":", getCodeToken(tok, 2)); out.add(lastIf = new If(deRoundBracket(getCodeToken(tok, 1)), null, parsePythonesqueProcedure(joinSubList(tok, 3 * 2)))); continue; } if (eqic(firstCodeToken(tok), "while")) { assertEquals(s, ":", getCodeToken(tok, 2)); out.add(new While(deRoundBracket(getCodeToken(tok, 1)), parsePythonesqueProcedure(joinSubList(tok, 3 * 2)))); continue; } if (eqic(firstCodeToken(tok), "else") && eqic(secondCodeToken(tok), "if")) { Object last = last(out); if (lastIf == null) throw fail("Else if without if"); assertEquals(s, ":", getCodeToken(tok, 3)); lastIf.elseBlock = lastIf = new If(deRoundBracket(getCodeToken(tok, 2)), parsePythonesqueProcedure(joinSubList(tok, 4 * 2)), null); continue; } if (eqic(firstCodeToken(tok), "else")) { Object last = last(out); if (lastIf == null) throw fail("Else without if"); assertEquals(s, ":", getCodeToken(tok, 1)); lastIf.elseBlock = joinSubList(tok, 2 * 2); continue; } lastIf = null; if (eqic(firstCodeToken(tok), "for")) { if (eq(getCodeToken(tok, 2), "in")) { int idx = indexOf(tok, ":"); assertTrue(s, idx >= 0); String var = getCodeToken(tok, 1); String expr = joinSubList(tok, 3 * 2 + 1, idx - 1); Object body = parsePythonesqueProcedure(joinSubList(tok, idx + 1)); out.add(new ForIn(var, expr, body)); } else { assertEquals(s, ":", getCodeToken(tok, 2)); String cond = getCodeToken(tok, 1); cond = deRoundBracket(cond); List tok2 = javaTok(cond); assertEquals(cond, "|", getCodeToken(tok2, 1)); String var = assertIdentifier(cond, getCodeToken(tok2, 0)); String actualCondition = trimJoinSubList(tok2, 2 * 2 + 1); out.add(new For(var, actualCondition, parsePythonesqueProcedure(joinSubList(tok, 3 * 2)))); } } else out.add(s); } if (parsePythonesqueProcedure_debug) pnl("Parsed procedure ", out); return out; } public List parseProcedure(String s) { return parsePythonesqueProcedure(s); } public Object splitAtAmpersand2(String s) { List l = tok_splitAtAmpersand(s); if (l(l) == 1) return s; return new And(first(l), splitAtAmpersand2(join(" & ", dropFirst(l)))); } public Map zipIt(String cond, String fact) { Map map = zipIt_keepBrackets(cond, fact); if (map == null) return null; return mapValues("tok_deRoundOrCurlyBracket", map); } public Map zipIt_deBracket(String pat, String s) { Map map = zipIt(pat, s); return map == null ? null : mapValues("tok_deRoundOrCurlyBracket", map); } public Map zipIt_keepBrackets(String cond, String fact) { Map map = gazelle_deepZip_keepBrackets(cond, fact); if (map == null) return null; if (!all(keys(map), s -> isVar(s))) return null; ; return map; } public boolean isVar(String s) { return s != null && (vars.contains(s) || s.startsWith("var_") || isDollarVar(s)); } public Object replaceVars(Object o, Map map) { if (empty(map)) return o; return transform(x -> replaceVars_base(x, map), o); } public Object replaceVars_base(Object o, Map map) { if (o instanceof String) return replaceCodeTokensUsingMap(((String) o), map); return null; } public String format(String s, Map map) { return replaceCodeTokensUsingMap(s, mapValues("optRound", map)); } public Object transform(IF1 f, Object o) { if (o == null) return null; ping(); { Object __2 = f.get(o); if (__2 != null) return __2; } if (o instanceof Transformable) return ((Transformable) o).transformUsing(x -> transform(f, x)); if (o instanceof List) return map(x -> transform(f, x), ((List) o)); throw fail("Don't know how to transform: " + className(o)); } public void applyLogicRuleToFact(LogicRule rule, String fact) { Object lhs = rule.lhs, rhs = rule.rhs; Object cond, remaining = null; if (lhs instanceof And) { Object a = ((And) lhs).a; Object b = ((And) lhs).b; cond = a; remaining = b; } else cond = lhs; Map map = zipIt_keepBrackets((String) cond, fact); if (map == null) { if (printNonMatches) print("Non-match: " + quote(cond) + " / " + quote(fact)); return; } print("Match: " + quote(cond) + " / " + quote(fact)); Object rhs_replaced = replaceVars(rhs, map); print("rhs_replaced", rhs_replaced); if (remaining == null) { addRewrittenRHS(rhs_replaced); } else { Object remaining_replaced = replaceVars(remaining, map); addLogicRule(new LogicRule(remaining_replaced, rhs_replaced)); } } public void run() { think(); } public boolean smartParser1_verbose = false; public void smartParser1(String program) { List paragraphs = map(s -> withoutLeadingLinesEmptyAfterTrim_autoUnindent(rtrim(s)), tok_splitAtEmptyLines(program)); if (smartParser1_verbose) print("Got " + n2(paragraphs, "parapraph")); if (smartParser1_verbose) print(joinWithEmptyLines(map(s -> indentx("> ", s), paragraphs))); List paragraphs2 = antiFilter(paragraphs, s -> isSingleLine(trim(s)) && isQuoted(trim(s)) || countJavaTokens(s) == 0 || endsWith(rtrim(s), "----")); if (smartParser1_verbose) print("Got " + n2(paragraphs2, "filtered paragraph")); if (smartParser1_verbose) print(joinWithEmptyLines(map(s -> indentx("> ", s), paragraphs2))); if (smartParser1_verbose) print(map("allLinesAreUnindented", paragraphs2)); Pair, List> p1 = filterAntiFilter(s -> !isSingleLine(trim(s)) && allLinesAreUnindented(s), paragraphs2); List multiFactParagraphs = p1.a, paragraphs3 = p1.b; for (String para : multiFactParagraphs) for (String s : tlft(para)) addFactFromProgram(s); List paragraphs4 = new ArrayList(); for (String para : paragraphs3) { Pair p = splitAtFirstDoubleArrow(javaTokWithBrackets(para)); if (p == null) { paragraphs4.add(para); continue; } addLogicRule(new LogicRule(splitAtAmpersand2(p.a), p.b)); } if (smartParser1_verbose) pnlStruct("Unparsed - assuming facts", paragraphs4); for (String para : paragraphs4) addFactFromProgram(para); } public void parseProgram() { if (programLoaded) return; programLoaded = true; loadProgram(program); } public void loadProgram(String program) { smartParser1(program); } public boolean doSomeLogic() { boolean anyAction = false; Pair p; while ((p = rulesOnFacts.next()) != null) { ping(); anyAction = true; applyLogicRuleToFact(p.a, p.b); } Pair p2; while ((p2 = codeOnFacts.next()) != null) { ping(); anyAction = true; applyCodeFragmentToFact(p2.a, p2.b); } Pair, String> p3; while ((p3 = anyCodeOnFacts.next()) != null) { ping(); anyAction = true; pcallF(p3.a, p3.b); } return anyAction; } public void applyCodeFragmentToFact(CodeFragment cf, String fact) { Map map = cf.keepBrackets ? zipIt_keepBrackets(cf.head, fact) : zipIt(cf.head, fact); if (map != null) cf.body.get(mapValues("tok_deRoundBracket", map), new Env()); } public long size() { return l(logicRules) + l(facts) + proceduresExecuted; } public void think() { parseProgram(); thoughtBegun = true; int round = 0; while (round++ < maxRounds) { ping(); long lastSize = size(); print("Logic round " + round + ", size: " + lastSize); while (doSomeLogic() && round++ < maxRounds) { } for (List proc : getAndClearList(proceduresToRun)) { ping(); runParsedProcedure(proc); } callFAll(extraLogicOperations); if (size() == lastSize) { print("No changes, exiting"); break; } } Collection madeFacts = factsDeduced(); pnlWithHeading("Facts I deduced", madeFacts); List output = new ArrayList(); for (String fact : madeFacts) { List tok = mainTokenize(fact); if (countCodeTokens(tok) == 2 && eqicOneOf(getCodeToken(tok, 0), "print", "say")) output.add(tok_dropRoundBrackets(getCodeToken(tok, 1))); } pnlWithHeading("Bot Output", output); } public void addNativePredicate(String head, IF0 body) { nativePredicates.add(new NativePredicate(head, (map, env) -> body.get())); } public void addNativePredicate(String head, IF1, Object> body) { nativePredicates.add(new NativePredicate(head, (map, env) -> body.get(map))); } public void addNativePredicate(String head, IF2, Env, Object> body) { nativePredicates.add(new NativePredicate(head, body)); } public Object unpackWithAlternativeOrIterator(Object result) { if (result instanceof Iterator) return first((Iterator) result); if (result instanceof WithAlternative) return ((WithAlternative) result).result; return result; } public void onFactDo(String head, IVF2, Env> body) { codeOnFacts.newA(new CodeFragment(head, body)); } public void onFactDo_keepBrackets(String head, IVF2, Env> body) { codeOnFacts.newA(new CodeFragment(head, body, true)); } public List filterByPattern(String pat, Iterable items) { return filter(items, i -> zipIt(pat, i) != null); } public List> matchFacts(String pat) { return matchStrings(pat, facts); } public Map matchString(String pat, String input) { return zipIt_deBracket(pat, input); } public List> matchStrings(String pat, Iterable items) { List> out = new ArrayList(); for (String s : items) { Map map = zipIt_deBracket(pat, s); if (map != null) out.add(map); } return out; } public List>> matchFacts2(String pat) { return matchStrings2(pat, facts); } public List>> matchStrings2(String pat, Iterable items) { List>> out = new ArrayList(); for (String s : items) { Map map = zipIt_deBracket(pat, s); if (map != null) out.add(pair(s, map)); } return out; } public List matchFacts(String var, String pat) { return map(matchFacts(pat), map -> map.get(var)); } public List> matchFacts_keepBrackets(String pat) { List> out = new ArrayList(); for (String fact : facts) { Map map = zipIt_keepBrackets(pat, fact); if (map != null) out.add(map); } return out; } public void openAllTheories() { for (Map map : matchFacts_keepBrackets("theory $x $y")) openTheory(tok_deRoundOrCurlyBracket(map.get("$x")), map.get("$y")); } public void openTheory(String name) { for (Map map : matchFacts_keepBrackets("theory $x $y")) if (eqic(properUnquote(tok_deRoundBracket($x(map))), name)) { openTheory(name, $y(map)); return; } throw fail("Theory not defined: " + quote(name)); } public void openTheory(String name, String body) { loadProgram(withoutLeadingLinesEmptyAfterTrim_autoUnindent(tok_deRoundOrCurlyBracket_keepFirstSpacing(body))); print("Opened theory " + name); } public void autoOpenTheories() { onFactDo_keepBrackets("theory $x $y", (map, env) -> openTheory(tok_deRoundOrCurlyBracket(map.get("$x")), map.get("$y"))); } public int checkExpectations() { int n = 0; for (Map map : matchFacts("expect $x")) { assertContains(facts, firstValue(map)); ++n; } for (Map map : matchFacts("don't expect $x")) { assertDoesntContain(facts, firstValue(map)); ++n; } return n; } public void standardImports() { if (standardImportsLoaded) return; standardImportsLoaded = true; registerImport("math", () -> philosophyBot1_math(this)); registerImport("bool", () -> philosophyBot1_bool(this)); registerImport("or", () -> philosophyBot1_orHandler(this)); registerImport("iota", () -> philosophyBot1_iotaHandler(this)); registerImport("tlft_honoringBrackets", () -> addNativePredicate("tlft_honoringBrackets $x", map -> print("tlft output", tlft_honoringBrackets($x(map))))); addNativePredicate("printNonMatches", () -> { printNonMatches = true; return true; }); } public void addFactPreprocessor(IF1 f) { factPreprocessors.add(f); } public void addLogicRulePreprocessor(IF1 f) { logicRulePreprocessors.add(f); } public void registerImport(String name, Runnable handler) { String line = "import " + name; factPreprocessors.add(s -> { if (eqic(s, line)) { print("Importing " + name); handler.run(); return true; } return false; }); } public boolean hasFact(String fact) { return contains(facts, fact); } public boolean hasContradiction() { return hasFact("contradiction"); } public List mainTokenize(String s) { return javaTokWithBrackets(s); } public String sanitizeInput(String s) { return joinWithSpace(antiFilter(words2_plusApostrophe(s), w -> isVar(w))); } public void deleteFacts(Iterable l) { Set set = asCISet(l); facts = filterCISet(facts, f -> !contains(set, f)); } public Collection factsDeduced() { return listMinusList(facts, originalFacts); } public boolean containsDollarVars(Object o) { Flag flag = new Flag(); withCancelPoint(cp -> { transform(x -> { if (x instanceof String) { if (main.containsDollarVars(((String) x))) { flag.raise(); cancelTo(cp); } return ((String) x); } return null; }, o); }); return flag.get(); } public List allLogicRulesWithoutLHSVars() { return filter(logicRules, r -> !containsDollarVars(leftmostCondition(r.lhs))); } public Object leftmostCondition(Object o) { while (o instanceof And) o = ((And) o).a; return o; } public void _standardHandlers() { philosophyBot_autoOpenTheoriesHandler(this); } } static public interface IF0 { public A get(); } static public interface IFieldsToList { public Object[] _fieldsToList(); } static public interface IF2 { public C get(A a, B b); } static public class AllOnAll { public List aList = new ArrayList(); public List bList = new ArrayList(); public List> todo = new LinkedList(); public List> todo2 = new LinkedList(); synchronized public void newA(A a) { add(aList, a); addPair(todo, intRange_last(aList), intRange(0, l(bList))); } synchronized public void newAs(Iterable l) { for (A a : unnull(l)) newA(a); } synchronized public void newB(B b) { add(bList, b); addPair(todo, intRange(0, l(aList)), intRange_last(bList)); } synchronized public void newBs(Iterable l) { for (B b : unnull(l)) newB(b); } synchronized public Pair next() { while (empty(todo2)) { if (empty(todo)) return null; Pair p = popFirst(todo); addAll(todo2, outerProduct_pairs(subList(aList, p.a), subList(bList, p.b))); } return popFirst(todo2); } } static public interface Transformable { public Object transformUsing(IF1 f); } static public interface IVF1 { public void get(A a); } static public interface IVF2 { public void get(A a, B b); } static public class Flag implements Runnable { public boolean up = false; public synchronized boolean raise() { if (!up) { up = true; notifyAll(); return true; } else return false; } public synchronized void waitUntilUp() { while (!up) { try { wait(); } catch (InterruptedException e) { e.printStackTrace(); } } } public synchronized void waitUntilUp(long timeout) { if (!up) { try { wait(timeout); } catch (InterruptedException e) { e.printStackTrace(); } } } public synchronized boolean isUp() { return up; } public boolean get() { return isUp(); } public String toString() { return isUp() ? "up" : "down"; } public void waitForThisOr(Flag otherFlag) { try { while (!isUp() && !otherFlag.isUp()) Thread.sleep(50); } catch (Exception __e) { throw rethrow(__e); } } public void run() { raise(); } } static public class Pair implements Comparable> { 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 p) { if (p == null) return 1; int i = ((Comparable) a).compareTo(p.a); if (i != 0) return i; return ((Comparable) b).compareTo(p.b); } } final static public class IntRange { public int start, end; public IntRange() { } public IntRange(int start, int end) { this.end = end; this.start = start; } public boolean equals(Object o) { return stdEq2(this, o); } public int hashCode() { return stdHash2(this); } public int length() { return end - start; } static public String _fieldOrder = "start end"; public String toString() { return "[" + start + ";" + end + "]"; } } static public boolean reflection_isForbiddenMethod(Method m) { return m.getDeclaringClass() == Object.class && eqOneOf(m.getName(), "finalize", "clone", "registerNatives"); } static public void multiMapPut(Map> map, A a, B b) { List l = map.get(a); if (l == null) map.put(a, l = new ArrayList()); l.add(b); } static public Field makeAccessible(Field f) { try { f.setAccessible(true); } catch (Throwable e) { vmBus_send("makeAccessible_error", e, f); } return f; } static public Method makeAccessible(Method m) { try { m.setAccessible(true); } catch (Throwable e) { vmBus_send("makeAccessible_error", e, m); } return m; } static public Constructor makeAccessible(Constructor c) { try { c.setAccessible(true); } catch (Throwable e) { vmBus_send("makeAccessible_error", e, c); } return c; } static public Set allInterfacesImplementedBy(Class c) { if (c == null) return null; HashSet set = new HashSet(); allInterfacesImplementedBy_find(c, set); return set; } static public void allInterfacesImplementedBy_find(Class c, Set set) { if (c.isInterface() && !set.add(c)) return; do { for (Class intf : c.getInterfaces()) allInterfacesImplementedBy_find(intf, set); } while ((c = c.getSuperclass()) != null); } static public Method findMethod(Object o, String method, Object... args) { return findMethod_cached(o, method, args); } static public 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; } static public 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; } static public 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; } static public 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; } static public int boostHashCombine(int a, int b) { return a ^ (b + 0x9e3779b9 + (a << 6) + (a >> 2)); } static public int _hashCode(Object a) { return a == null ? 0 : a.hashCode(); } static public String stdToString(Object o) { return standard_toString(o); } static public Set linkedCISet() { return new LinkedTreeSet(ciSet()); } static public TreeSet ciSet() { return caseInsensitiveSet(); } static public TreeSet litciset(String... items) { TreeSet set = caseInsensitiveSet(); for (String a : items) set.add(a); return set; } static public Pair splitAtFirstDoubleArrow(String s) { return splitAtFirstDoubleArrow(javaTok(s)); } static public Pair splitAtFirstDoubleArrow(List tok) { int i = indexOfSubList(tok, splitAtDoubleArrow_tok()); return i < 0 ? null : pair(trimJoin(subList(tok, 0, i)), trimJoin(subList(tok, i + 3))); } static public List javaTokWithBrackets(String s) { return javaTokPlusBrackets(s); } static public String unnull(String s) { return s == null ? "" : s; } static public Collection unnull(Collection l) { return l == null ? emptyList() : l; } static public List unnull(List l) { return l == null ? emptyList() : l; } static public Map unnull(Map l) { return l == null ? emptyMap() : l; } static public Iterable unnull(Iterable i) { return i == null ? emptyList() : i; } static public A[] unnull(A[] a) { return a == null ? (A[]) new Object[0] : a; } static public BitSet unnull(BitSet b) { return b == null ? new BitSet() : b; } static public Pt unnull(Pt p) { return p == null ? new Pt() : p; } static public Pair unnull(Pair p) { return p != null ? p : new Pair(null, null); } static public boolean syncAdd(Collection c, A b) { if (c == null) return false; synchronized (c) { return c.add(b); } } static public void syncAdd(List l, int idx, A b) { if (l != null) synchronized (l) { l.add(idx, b); } } static public void pcallFAll(Collection l, Object... args) { if (l != null) for (Object f : cloneList(l)) pcallF(f, args); } static public void pcallFAll(Iterator it, Object... args) { while (it.hasNext()) pcallF(it.next(), args); } static public String trim(String s) { return s == null ? null : s.trim(); } static public String trim(StringBuilder buf) { return buf.toString().trim(); } static public String trim(StringBuffer buf) { return buf.toString().trim(); } static public String tok_deRoundBracket(String s) { return tok_isRoundBracketed(s) ? join(dropFirstThreeAndLastThree(javaTok(s))) : s; } static public int countCodeTokens(String s) { return countTokens(s); } static public int countCodeTokens(List tok) { return countTokens(tok); } static public boolean firstTokenEqic(List tok, String t) { return eqic(get(tok, 1), t); } static public boolean isCurlyBracketed(String s) { return isCurlyBraced(s); } static public String getCodeToken(List tok, int i) { return get(tok, i * 2 + 1); } static public String uncurly_keepSpaces(String s) { return tok_unCurlyBracket_keepSpaces(s); } static public String indentx(String s) { return indentx(indent_default, s); } static public String indentx(int n, String s) { return dropSuffix(repeat(' ', n), indent(n, s)); } static public String indentx(String indent, String s) { return dropSuffix(indent, indent(indent, s)); } static public int countJavaTokens(String s) { return countTokens(s); } static public int countJavaTokens(List tok) { return countTokens(tok); } static public String javaDropAllComments(String s) { return join(javaDropAllComments(javaTok(s))); } static public List javaDropAllComments(List tok) { for (int i = 0; i < l(tok); i += 2) tok.set(i, tok_javaDropCommentsFromWhitespace(tok.get(i))); return tok; } static public LinkedList cloneLinkedList(Iterable l) { return l instanceof Collection ? cloneLinkedList((Collection) l) : asLinkedList(l); } static public LinkedList cloneLinkedList(Collection l) { if (l == null) return new LinkedList(); synchronized (collectionMutex(l)) { return new LinkedList(l); } } static public A popFirst_ping(List l) { ping(); return popFirst(l); } static public A popFirst_ping(Collection l) { ping(); return popFirst(l); } static public List popFirst_ping(int n, List l) { ping(); return popFirst(n, l); } static public String sfu(Object o) { return structureForUser(o); } static public boolean checkCondition(Object condition, Object... args) { return isTrue(callF(condition, args)); } static public boolean checkCondition(IF1 condition, A arg) { return isTrue(callF(condition, arg)); } static public 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); } static public Iterator iterator(Iterable c) { return c == null ? emptyIterator() : c.iterator(); } static public TreeMap litcimap(Object... x) { return litCIMap(x); } static public String replaceVars(String s, Map map) { return empty(map) ? s : join(replaceVars(javaTok(s), map)); } static public List replaceVars(List tok, Map map) { if (empty(map)) return tok; tok = cloneList(tok); for (String var : keys(map)) jreplace(tok, var, map.get(var)); return tok; } static public boolean isTrueOpt(Object o) { if (o instanceof Boolean) return ((Boolean) o).booleanValue(); return false; } static public LinkedList mapToLinkedList(Iterable l, Object f) { LinkedList x = new LinkedList(); if (l != null) for (Object o : l) x.add(callF(f, o)); return x; } static public LinkedList mapToLinkedList(Iterable l, IF1 f) { return mapToLinkedList(l, (Object) f); } static public 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; } static public Map mapValues(Map map, IF1 f) { return mapValues(f, map); } static public Map mapValues(Map map, Object func) { return mapValues(func, map); } static public String optRound(String s) { return roundBracketIfMoreThanOneToken(s); } static public Map mapKeys(Object func, Map map) { Map m = similarEmptyMap(map); for (Object key : keys(map)) m.put(callF(func, key), map.get(key)); return m; } static public Map mapKeys(Map map, Object func) { return mapKeys(func, map); } static public Map mapKeys(Map map, IF1 func) { return mapKeys(map, (Object) func); } static public A lookupOrKeep(Map map, A key) { return map != null && map.containsKey(key) ? map.get(key) : key; } static public String quote(Object o) { if (o == null) return "null"; return quote(str(o)); } static public 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(); } static public 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('"'); } static public boolean contains(Collection c, Object o) { return c != null && c.contains(o); } static public boolean contains(Object[] x, Object o) { if (x != null) for (Object a : x) if (eq(a, o)) return true; return false; } static public boolean contains(String s, char c) { return s != null && s.indexOf(c) >= 0; } static public boolean contains(String s, String b) { return s != null && s.indexOf(b) >= 0; } static public boolean contains(BitSet bs, int i) { return bs != null && bs.get(i); } static public List tok_splitAtAmpersand(String s) { return splitAtTokens(javaTokWithAllBrackets(s), "&"); } static public String[] dropFirst(int n, String[] a) { return drop(n, a); } static public String[] dropFirst(String[] a) { return drop(1, a); } static public Object[] dropFirst(Object[] a) { return drop(1, a); } static public List dropFirst(List l) { return dropFirst(1, l); } static public List dropFirst(int n, Iterable i) { return dropFirst(n, toList(i)); } static public List dropFirst(Iterable i) { return dropFirst(toList(i)); } static public List dropFirst(int n, List l) { return n <= 0 ? l : new ArrayList(l.subList(Math.min(n, l.size()), l.size())); } static public List dropFirst(List l, int n) { return dropFirst(n, l); } static public String dropFirst(int n, String s) { return substring(s, n); } static public String dropFirst(String s, int n) { return substring(s, n); } static public String dropFirst(String s) { return substring(s, 1); } static public String tok_deRoundOrCurlyBracket(String s) { return isCurlyBraced(s) || tok_isRoundBracketed(s) ? join(dropFirstThreeAndLastThree(javaTok(s))) : s; } static public Map gazelle_deepZip_keepBrackets(String inputA, String inputB, Object... __) { Map map = gazelle_zip_keepBrackets(inputA, inputB); if (map == null) return null; Map map2 = similarEmptyMap(map); for (String a : keys(map)) { String b = map.get(a); if (tok_isRoundOrCurlyBracketed(a) && tok_isRoundOrCurlyBracketed(b)) { String aa = tok_deRoundOrCurlyBracket(a); String bb = tok_deRoundOrCurlyBracket(b); Map subMap = gazelle_deepZip_keepBrackets(aa, bb, __); if (subMap == null) return null; if (!putAllStrictlyIC(map2, subMap)) return null; } else if (!strictPutIC(map2, a, b)) return null; } return map2; } static public boolean all(Object pred, Collection l) { if (l != null) for (Object o : l) if (!isTrue(callF(pred, o))) return false; return true; } static public boolean all(Iterable l, IF1 f) { if (l != null) for (A a : l) if (!f.get(a)) return false; return true; } static public Set keys(Map map) { return map == null ? new HashSet() : map.keySet(); } static public Set keys(Object map) { return keys((Map) map); } static public Set keys(MultiSet ms) { return ms.keySet(); } static public boolean isDollarVar(String s) { return startsWith(s, '$') && isJavaIdentifierAfter(s, 1); } static public String replaceCodeTokensUsingMap(String s, Map map) { return join(replaceCodeTokensUsingMap(javaTok(s), map)); } static public List replaceCodeTokensUsingMap(List tok, Map map) { List 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; } static public String replaceCodeTokensUsingMap(Map map, String s) { return replaceCodeTokensUsingMap(s, map); } static public List map(Iterable l, Object f) { return map(f, l); } static public List map(Object f, Iterable l) { List x = emptyList(l); if (l != null) for (Object o : l) x.add(callF(f, o)); return x; } static public List map(Iterable l, F1 f) { return map(f, l); } static public List map(F1 f, Iterable l) { List x = emptyList(l); if (l != null) for (A o : l) x.add(callF(f, o)); return x; } static public List map(IF1 f, Iterable l) { return map(l, f); } static public List map(Iterable l, IF1 f) { List x = emptyList(l); if (l != null) for (A o : l) x.add(f.get(o)); return x; } static public List map(IF1 f, A[] l) { return map(l, f); } static public List map(A[] l, IF1 f) { List x = emptyList(l); if (l != null) for (A o : l) x.add(f.get(o)); return x; } static public List map(Object f, Object[] l) { return map(f, asList(l)); } static public List map(Object[] l, Object f) { return map(f, l); } static public List map(Object f, Map map) { return map(map, f); } static public 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; } static public List map(Map map, IF2 f) { return map(map, (Object) f); } static public void think(String thought) { miniChat(thought); } static public Object pcallF(Object f, Object... args) { return pcallFunction(f, args); } static public A pcallF(F0 f) { try { return f == null ? null : f.get(); } catch (Throwable __e) { return null; } } static public B pcallF(F1 f, A a) { try { return f == null ? null : f.get(a); } catch (Throwable __e) { return null; } } static public void pcallF(VF1 f, A a) { try { if (f != null) f.get(a); } catch (Throwable __e) { _handleException(__e); } } static public List getAndClearList(Collection l) { if (l == null) return emptyList(); synchronized (collectionMutex(l)) { List out = cloneList(l); l.clear(); return out; } } static public List callFAll(Collection l, Object... args) { return callF_all(l, args); } static public A pnlWithHeading(String heading, A l) { printAsciiHeading(heading); return pnl(l); } static public boolean eqicOneOf(String s, String... l) { for (String x : l) if (eqic(s, x)) return true; return false; } static public String tok_dropRoundBrackets(String s) { return join(tok_dropRoundBrackets(javaTok(s))); } static public List tok_dropRoundBrackets(List tok) { for (int i = 1; i < l(tok); i += 2) { while (eqGetOneOf(tok, i, "(", ")")) { tokAppend(tok, i - 1, tok.get(i + 1)); removeSubList(tok, i, i + 2); } } return tok; } static public List filter(Iterable c, Object pred) { if (pred instanceof F1) return filter(c, (F1) pred); List x = new ArrayList(); if (c != null) for (Object o : c) if (isTrue(callF(pred, o))) x.add(o); return x; } static public List filter(Object pred, Iterable c) { return filter(c, pred); } static public List filter(Iterable c, F1 pred) { List x = new ArrayList(); if (c != null) for (B o : c) if (pred.get(o)) x.add(o); return x; } static public List filter(F1 pred, Iterable c) { return filter(c, pred); } static public List filter(Iterable c, IF1 pred) { List x = new ArrayList(); if (c != null) for (B o : c) if (pred.get(o)) x.add(o); return x; } static public List filter(IF1 pred, Iterable c) { return filter(c, pred); } static public Pair pair(A a, B b) { return new Pair(a, b); } static public Pair pair(A a) { return new Pair(a, a); } static public String properUnquote(String s) { return isProperlyQuoted(s) ? unquote(s) : s; } static public A $x(Map map) { return mapGet(map, "$x"); } static public A $y(Map map) { return mapGet(map, "$y"); } static public String withoutLeadingLinesEmptyAfterTrim_autoUnindent(String s) { return autoUnindent(withoutLeadingLinesEmptyAfterTrim(s)); } static public String tok_deRoundOrCurlyBracket_keepFirstSpacing(String s) { return isCurlyBraced(s) || tok_isRoundBracketed(s) ? join(dropFirstTwoAndLastThree(javaTok(s))) : s; } static public > C assertContains(C c, A y) { return assertContains(null, c, y); } static public > C assertContains(String msg, C c, A y) { if (!contains(c, y)) throw fail((msg != null ? msg + ": " : "") + y + " not contained in " + c); return c; } static public B firstValue(Map map) { return first(values(map)); } static public > C assertDoesntContain(C c, A y) { return assertDoesntContain(null, c, y); } static public > C assertDoesntContain(String msg, C c, A y) { if (contains(c, y)) throw fail((msg != null ? msg + ": " : "") + y + " contained in " + c); return c; } static public void philosophyBot1_math(PhilosophyBot1 bot) { bot.addNativePredicate("$x >= $y", (map) -> cmp(parseBigInt(map.get("$x")), parseBigInt(map.get("$y"))) >= 0); bot.addNativePredicate("$x <= $y", (map) -> cmp(parseBigInt(map.get("$x")), parseBigInt(map.get("$y"))) <= 0); bot.addNativePredicate("$x > $y", (map) -> cmp(parseBigInt(map.get("$x")), parseBigInt(map.get("$y"))) > 0); bot.addNativePredicate("$x < $y", (map) -> cmp(parseBigInt(map.get("$x")), parseBigInt(map.get("$y"))) < 0); } static public void philosophyBot1_bool(PhilosophyBot1 bot) { bot.addNativePredicate("true", (map) -> true); } static public void philosophyBot1_orHandler(PhilosophyBot1 bot) { bot.addLogicRulePreprocessor(rule -> { if (!(rule.lhs instanceof String)) return false; List tok = bot.mainTokenize(tok_deCurlyOrRound((String) rule.lhs)); if (countCodeTokens(tok) == 3 && eq(secondCodeToken(tok), "|")) { print("Splitting or: " + tok); bot.addLogicRule(new PhilosophyBot1.LogicRule(firstCodeToken(tok), rule.rhs)); bot.addLogicRule(new PhilosophyBot1.LogicRule(lastCodeToken(tok), rule.rhs)); return true; } return false; }); } static public void philosophyBot1_iotaHandler(PhilosophyBot1 bot) { bot.addNativePredicate("iota($x)", (map) -> iota(parseInt($x(map)))); } static public List tlft_honoringBrackets(String text) { return trimAll(lines_honoringBrackets(text)); } static public List antiFilter(Iterable c, Object pred) { if (pred instanceof F1) return antiFilter(c, (F1) pred); List x = new ArrayList(); if (c != null) for (Object o : c) if (!isTrue(callF(pred, o))) x.add(o); return x; } static public List antiFilter(Object pred, Iterable c) { return antiFilter(c, pred); } static public List antiFilter(Object pred, Object[] c) { return antiFilter(pred, wrapArrayAsList(c)); } static public List antiFilter(Iterable c, F1 pred) { List x = new ArrayList(); if (c != null) for (B o : c) if (!pred.get(o).booleanValue()) x.add(o); return x; } static public List antiFilter(F1 pred, Iterable c) { return antiFilter(c, pred); } static public List antiFilter(Iterable c, IF1 pred) { List x = new ArrayList(); if (c != null) for (B o : c) if (!pred.get(o).booleanValue()) x.add(o); return x; } static public List antiFilter(IF1 pred, Iterable c) { return antiFilter(c, pred); } static public List words2_plusApostrophe(String s) { List l = new ArrayList(); int n = l(s); for (int i = 0; i < n; ) { int j = i; while (j < n && isLetterOrDigitOrApostrophe(s.charAt(j))) ++j; if (j > i) l.add(substring(s, i, j)); while (j < n && !isLetterOrDigitOrApostrophe(s.charAt(j))) ++j; i = j; } return l; } static public TreeSet asCISet(Iterable c) { return toCaseInsensitiveSet(c); } static public TreeSet asCISet(String... x) { return toCaseInsensitiveSet(x); } static public Set filterCISet(Iterable c, Object pred) { Set x = ciSet(); if (c != null) for (String o : c) if (isTrue(callF(pred, o))) x.add(o); return x; } static public Set filterCISet(Object pred, Iterable c) { return filterCISet(c, pred); } static public Set filterCISet(Iterable c, IF1 pred) { return filterCISet(c, (Object) pred); } static public List listMinusList(Collection l, Collection stuff) { if (empty(stuff) && l instanceof List) return (List) l; List l2 = cloneList(l); for (Object o : stuff) l2.remove(o); return l2; } static public void withCancelPoint(VF1 r) { CancelPoint cp = newCancelPoint(); try { try { callF(r, cp); } catch (Throwable e) { e = innerException(e); if (!(e instanceof CancelToCancelPoint && ((CancelToCancelPoint) e).cp == cp)) rethrow(e); } } finally { _close(cp); } } static public void withCancelPoint(IVF1 r) { CancelPoint cp = newCancelPoint(); try { try { r.get(cp); } catch (Throwable e) { e = innerException(e); if (!(e instanceof CancelToCancelPoint && ((CancelToCancelPoint) e).cp == cp)) rethrow(e); } } finally { _close(cp); } } static public boolean containsDollarVars(String s) { List tok = javaTok(s); for (int i = 1; i < l(tok); i += 2) if (isDollarVar(tok.get(i))) return true; return false; } static public RuntimeException cancelTo(CancelPoint cp) { if (cp.closed) throw fail("cancel point closed"); throw new CancelToCancelPoint(cp); } static public void philosophyBot_autoOpenTheoriesHandler(PhilosophyBot1 bot) { bot.addFactPreprocessor(s -> { if (bot.matchString("auto open theories", s) == null) return false; bot.autoOpenTheories(); return true; }); } static public void add(BitSet bs, int i) { bs.set(i); } static public boolean add(Collection c, A a) { return c != null && c.add(a); } static public void add(Container c, Component x) { addToContainer(c, x); } static public void addPair(Collection> c, A a, B b) { if (c != null) c.add(pair(a, b)); } static public IntRange intRange_last(List l) { int n = l(l); return intRange(n - 1, n); } static public IntRange intRange(int start, int end) { return new IntRange(start, end); } static public A popFirst(List l) { if (empty(l)) return null; A a = first(l); l.remove(0); return a; } static public A popFirst(Collection l) { if (empty(l)) return null; A a = first(l); l.remove(a); return a; } static public List popFirst(int n, List l) { List part = cloneSubList(l, 0, n); removeSubList(l, 0, n); return part; } static public void addAll(Collection c, Iterable b) { if (c != null && b != null) for (A a : b) c.add(a); } static public boolean addAll(Collection c, Collection b) { return c != null && b != null && c.addAll(b); } static public boolean addAll(Collection c, B... b) { return c != null && c.addAll(Arrays.asList(b)); } static public Map addAll(Map a, Map b) { if (a != null) a.putAll(b); return a; } static public IterableIterator> outerProduct_pairs(Collection lA, Collection lB) { return outerProductPairs(lA, lB); } static public IterableIterator> outerProduct_pairs(Pair, ? extends Collection> p) { return outerProduct_pairs(p.a, p.b); } static public List subList(List l, int startIndex) { return subList(l, startIndex, l(l)); } static public List subList(int startIndex, int endIndex, List l) { return subList(l, startIndex, endIndex); } static public List subList(List 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); } static public List subList(List l, IntRange r) { return subList(l, r.start, r.end); } static public int hashCodeFor(Object a) { return a == null ? 0 : a.hashCode(); } static public boolean stdEq2(Object a, Object b) { if (a == null) return b == null; if (b == null) return false; if (a.getClass() != b.getClass()) return false; for (String field : allFields(a)) if (neq(getOpt(a, field), getOpt(b, field))) return false; return true; } static public int stdHash2(Object a) { if (a == null) return 0; return stdHash(a, toStringArray(allFields(a))); } static public 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); } static public void vmBus_send(String msg) { vmBus_send(msg, (Object) null); } static public 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 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 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); } } static public String standard_toString(Object o) { if (o == null) return "null"; String name = shortClassName(o); Set 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); })) + ")"; } static public TreeSet caseInsensitiveSet() { return caseInsensitiveSet_treeSet(); } static public TreeSet caseInsensitiveSet(Collection c) { return caseInsensitiveSet_treeSet(c); } static public TreeSet treeSet() { return new TreeSet(); } static public int javaTok_n, javaTok_elements; static public boolean javaTok_opt = false; static public List javaTok(String s) { ++javaTok_n; ArrayList 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)) || s.charAt(j) == '\'')); 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; } static public List javaTok(List tok) { return javaTokWithExisting(join(tok), tok); } static public int indexOfSubList(List x, List y) { return indexOfSubList(x, y, 0); } static public int indexOfSubList(List x, List 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; } static public int indexOfSubList(List 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; } static public List splitAtDoubleArrow_tok; static public List splitAtDoubleArrow_tok() { if (splitAtDoubleArrow_tok == null) splitAtDoubleArrow_tok = ll("=", "", ">"); return splitAtDoubleArrow_tok; } static public String trimJoin(List s) { return trim(join(s)); } static public List javaTokPlusBrackets(String s) { return tok_combineRoundOrCurlyBrackets_keep(javaTok(s)); } static public ArrayList emptyList() { return new ArrayList(); } static public ArrayList emptyList(int capacity) { return new ArrayList(max(0, capacity)); } static public ArrayList emptyList(Iterable l) { return l instanceof Collection ? emptyList(((Collection) l).size()) : emptyList(); } static public ArrayList emptyList(Object[] l) { return emptyList(l(l)); } static public ArrayList emptyList(Class c) { return new ArrayList(); } static public Map emptyMap() { return new HashMap(); } static public boolean tok_isRoundBracketed(String s) { List tok = tok_combineRoundBrackets_keep(javaTok(s)); return l(tok) == 3 && startsWithAndEndsWith(tok.get(1), "(", ")"); } static public List dropFirstThreeAndLastThree(List l) { return dropFirstAndLast(3, l); } static public int countTokens(String s) { return l(javaTokC(s)); } static public int countTokens(List tok) { return l(tok) / 2; } static public boolean isCurlyBraced(String s) { List tok = tok_combineCurlyBrackets_keep(javaTok(s)); return l(tok) == 3 && startsWithAndEndsWith(tok.get(1), "{", "}"); } static public String tok_unCurlyBracket_keepSpaces(String s) { return isCurlyBraced(s) ? join(dropFirstTwoAndLastTwo(javaTok(s))) : s; } static public 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); } static public List repeat(A a, int n) { n = Math.max(n, 0); List l = new ArrayList(n); for (int i = 0; i < n; i++) l.add(a); return l; } static public List repeat(int n, A a) { return repeat(a, n); } static public int indent_default = 2; static public String indent(int indent) { return repeat(' ', indent); } static public String indent(int indent, String s) { return indent(repeat(' ', indent), s); } static public String indent(String indent, String s) { return indent + s.replace("\n", "\n" + indent); } static public String indent(String s) { return indent(indent_default, s); } static public List indent(String indent, List lines) { List l = new ArrayList(); if (lines != null) for (String s : lines) l.add(indent + s); return l; } static public String tok_javaDropCommentsFromWhitespace(String s) { int l = l(s), j = 0; StringBuilder buf = new StringBuilder(); while (j < l) { char c = s.charAt(j); char d = j + 1 >= l ? '\0' : s.charAt(j + 1); 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 { buf.append(c); ++j; } } return str(buf); } static public LinkedList asLinkedList(Iterable s) { if (s instanceof LinkedList) return ((LinkedList) s); LinkedList l = new LinkedList(); if (s != null) for (A a : s) l.add(a); return l; } static public String structureForUser(Object o) { return beautifyStructure(struct_noStringSharing(o)); } static public 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); } static public Iterator emptyIterator() { return Collections.emptyIterator(); } static public TreeMap litCIMap(Object... x) { TreeMap map = caseInsensitiveMap(); litmap_impl(map, x); return map; } static public String jreplace(String s, String in, String out) { return jreplace(s, in, out, null); } static public String jreplace(String s, String in, String out, Object condition) { List tok = javaTok(s); return jreplace(tok, in, out, condition) ? join(tok) : s; } static public boolean jreplace(List tok, String in, String out) { return jreplace(tok, in, out, false, true, null); } static public boolean jreplace(List tok, String in, String out, Object condition) { return jreplace(tok, in, out, false, true, condition); } static public boolean jreplace(List tok, String in, String out, IF2, Integer, Boolean> condition) { return jreplace(tok, in, out, (Object) condition); } static public boolean jreplace(List 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 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)); } static public boolean jreplace_debug = false; static public Map similarEmptyMap(Map m) { if (m instanceof TreeMap) return new TreeMap(((TreeMap) m).comparator()); if (m instanceof LinkedHashMap) return new LinkedHashMap(); return new HashMap(); } static public String roundBracketIfMoreThanOneToken(String s) { return !tok_isRoundBracketed(s) && numberOfJavaTokens(s) > 1 ? roundBracket(s) : s; } static public List splitAtTokens(String s, List tokens) { return splitAtTokens(javaTok(s), tokens); } static public List splitAtTokens(List tok, List tokens) { List 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; } static public List splitAtTokens(List tok, String... tokens) { List 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; } static public List javaTokWithAllBrackets(String s) { return javaTokPlusBrackets2(s); } static public String[] drop(int n, String[] a) { n = Math.min(n, a.length); String[] b = new String[a.length - n]; System.arraycopy(a, n, b, 0, b.length); return b; } static public Object[] drop(int n, Object[] a) { n = Math.min(n, a.length); Object[] b = new Object[a.length - n]; System.arraycopy(a, n, b, 0, b.length); return b; } static public ArrayList toList(A[] a) { return asList(a); } static public ArrayList toList(int[] a) { return asList(a); } static public ArrayList toList(Set s) { return asList(s); } static public ArrayList toList(Iterable s) { return asList(s); } static public Map gazelle_zip_keepBrackets(String inputA, String inputB, Object... __) { Object tokenizer = optPar("tokenizer", __, "javaTokWithBrackets"); return gazelle_zipTwoTokenizationsToMap_keepBrackets(callTokenizer(tokenizer, inputA), callTokenizer(tokenizer, inputB)); } static public boolean tok_isRoundOrCurlyBracketed(String s) { return isCurlyBraced(s) || tok_isRoundBracketed(s); } static public boolean putAllStrictlyIC(Map map, Map adding) { return addMapToMapWithoutOverwritingIC(map, adding); } static public boolean strictPutIC(Map 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); } static public boolean isJavaIdentifierAfter(String s, int i) { int n = l(s); if (i >= n || !Character.isJavaIdentifierStart(s.charAt(i))) return false; for (i++; i < n; i++) if (!Character.isJavaIdentifierPart(s.charAt(i))) return false; return true; } static public boolean odd(int i) { return (i & 1) != 0; } static public boolean odd(long i) { return (i & 1) != 0; } static public boolean odd(BigInteger i) { return odd(toInt(i)); } static public void miniChat(String text) { String slackTS = getSlackTS(); if (slackTS == null) { print("Skipping mini-chat post (not on slack): " + quote(text)); return; } Object mcBot = getBot("#1002433"); call(mcBot, "addToMiniChat", "dc" + slackTS, getProgramID(), text); } static public Object pcallFunction(Object f, Object... args) { try { return callFunction(f, args); } catch (Throwable __e) { _handleException(__e); } return null; } static public List callF_all(Collection l, Object... args) { return map(l, f -> callF(f, args)); } static public void printAsciiHeading(String text) { print(asciiHeading2(text)); } static public A pnl(String prefix, A l) { printNumberedLines(prefix, l); return l; } static public A pnl(A l) { printNumberedLines(l); return l; } static public A pnl(A map) { printNumberedLines(map); return map; } static public A[] pnl(A[] a) { printNumberedLines(a); return a; } static public String pnl(String s) { printNumberedLines(lines(s)); return s; } static public boolean eqGetOneOf(List l, int i, A... options) { return eqOneOf(get(l, i), options); } static public void tokAppend(List tok, int i, String s) { tok.set(i, tok.get(i) + s); } static public void removeSubList(List l, int from, int to) { if (l != null) subList(l, from, to).clear(); } static public void removeSubList(List l, int from) { if (l != null) subList(l, from).clear(); } static public boolean isProperlyQuoted(String s) { return s.length() >= 2 && s.startsWith("\"") && s.endsWith("\"") && (!s.endsWith("\\\"") || s.endsWith("\\\\\"")) && !containsNewLine(s); } static public 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; } static public B mapGet(Map map, A a) { return map == null || a == null ? null : map.get(a); } static public B mapGet(A a, Map map) { return map == null || a == null ? null : map.get(a); } static public String autoUnindent(String s) { int n = getIndent(s); if (n == 0) return s; List l = toLines(s); for (int i = 0; i < l(l); i++) l.set(i, substring(l.get(i), n)); return fromLines(l); } static public String withoutLeadingLinesEmptyAfterTrim(String s) { int lineStart = 0; while (licensed()) { int i = lineStart; while (isSpaceOrTab(charAt(s, i))) ++i; if (!isNewLine(charAt(s, i))) break; while (isNewLine(charAt(s, i))) ++i; lineStart = i; } return substring(s, lineStart); } static public List dropFirstTwoAndLastThree(List l) { return dropFirstAndLast(2, 3, l); } static public Collection values(Map map) { return map == null ? emptyList() : map.values(); } static public int cmp(Number a, Number b) { return a == null ? b == null ? 0 : -1 : cmp(a.doubleValue(), b.doubleValue()); } static public int cmp(double a, double b) { return a < b ? -1 : a == b ? 0 : 1; } static public int cmp(Object a, Object b) { if (a == null) return b == null ? 0 : -1; if (b == null) return 1; return ((Comparable) a).compareTo(b); } static public BigInteger parseBigInt(String s) { return new BigInteger(s); } static public String tok_deCurlyOrRound(String s) { return tok_deRoundOrCurlyBracket(s); } static public String secondCodeToken(List tok) { return get(tok, 3); } static public String firstCodeToken(String s) { return firstJavaToken(s); } static public String firstCodeToken(List tok) { return get(tok, 1); } static public String lastCodeToken(String s) { return lastJavaToken(s); } static public String lastCodeToken(List tok) { return get(tok, l(tok) - 2); } static public IterableIterator iota(final int n) { return new IterableIterator() { public int i = 0; public boolean hasNext() { return i < n; } public Integer next() { return ++i; } }; } static public int parseInt(String s) { return emptyString(s) ? 0 : Integer.parseInt(s); } static public int parseInt(char c) { return Integer.parseInt(str(c)); } static public List trimAll(Collection l) { List l2 = new ArrayList(); if (l != null) for (String s : l) l2.add(trim(s)); return l2; } static public List lines_honoringBrackets(String text) { List lines = lines(text); List out = new ArrayList(); int bracketLevel = 0; int start = 0; for (int i = 0; i < l(lines); i++) { List tok = javaTok(lines.get(i)); for (int j = 1; j < l(tok); j += 2) { String t = tok.get(j); if (eqOneOf(t, "(", "{", "[")) ++bracketLevel; else if (eqOneOf(t, ")", "}", "]")) --bracketLevel; } if (bracketLevel == 0) { out.add(lines_rtrim(subList(lines, start, i + 1))); start = i + 1; } } addIfNempty(out, lines_rtrim(subList(lines, start))); return out; } static public List wrapArrayAsList(A[] a) { return a == null ? null : Arrays.asList(a); } static public boolean isLetterOrDigitOrApostrophe(char c) { return Character.isLetterOrDigit(c) || c == '\''; } static public TreeSet toCaseInsensitiveSet(Iterable c) { if (isCISet(c)) return (TreeSet) c; TreeSet set = caseInsensitiveSet(); addAll(set, c); return set; } static public TreeSet toCaseInsensitiveSet(String... x) { TreeSet set = caseInsensitiveSet(); addAll(set, x); return set; } static public CancelPoint newCancelPoint() { return new CancelPoint(); } static public 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);"; } }); } } static public List cloneSubList(List l, int startIndex, int endIndex) { return newSubList(l, startIndex, endIndex); } static public List cloneSubList(List l, int startIndex) { return newSubList(l, startIndex); } static public IterableIterator> outerProductPairs(Collection lA, Collection lB) { return nestedIterator(lA, new F1>>() { public Iterator> get(A a) { try { return mapI(lB, b -> pair(a, b)); } catch (Exception __e) { throw rethrow(__e); } } public String toString() { return "mapI(lB, b -> pair(a, b))"; } }); } static public Set allFields(Object o) { TreeSet 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; } static public int stdHash(Object a, String... fields) { if (a == null) return 0; int hash = getClassName(a).hashCode(); for (String field : fields) hash = boostHashCombine(hash, hashCode(getOpt(a, field))); return hash; } static public String[] toStringArray(Collection c) { String[] a = new String[l(c)]; Iterator it = c.iterator(); for (int i = 0; i < l(a); i++) a[i] = it.next(); return a; } static public String[] toStringArray(Object o) { if (o instanceof String[]) return (String[]) o; else if (o instanceof Collection) return toStringArray((Collection) o); else throw fail("Not a collection or array: " + getClassName(o)); } static public Object vmBus_wrapArgs(Object... args) { return empty(args) ? null : l(args) == 1 ? args[0] : args; } static public Set vm_busListeners_live_cache; static public Set vm_busListeners_live() { if (vm_busListeners_live_cache == null) vm_busListeners_live_cache = vm_busListeners_live_load(); return vm_busListeners_live_cache; } static public Set vm_busListeners_live_load() { return vm_generalIdentityHashSet("busListeners"); } static public Map vm_busListenersByMessage_live_cache; static public Map vm_busListenersByMessage_live() { if (vm_busListenersByMessage_live_cache == null) vm_busListenersByMessage_live_cache = vm_busListenersByMessage_live_load(); return vm_busListenersByMessage_live_cache; } static public Map vm_busListenersByMessage_live_load() { return vm_generalHashMap("busListenersByMessage"); } static public Set fieldNames(Object o) { return allFields(o); } static public List mapNonNulls(Iterable l, Object f) { return mapNonNulls(f, l); } static public List mapNonNulls(Object f, Iterable l) { List x = new ArrayList(); if (l != null) for (Object o : l) addIfNotNull(x, callF(f, o)); return x; } static public List mapNonNulls(Object f, Object[] l) { List x = new ArrayList(); if (l != null) for (Object o : l) addIfNotNull(x, callF(f, o)); return x; } static public List mapNonNulls(Iterable l, F1 f) { return mapNonNulls(f, l); } static public List mapNonNulls(F1 f, Iterable l) { List x = new ArrayList(); if (l != null) for (Object o : l) addIfNotNull(x, callF(f, o)); return x; } static public List mapNonNulls(A[] l, IF1 f) { return mapNonNulls(f, l); } static public List mapNonNulls(Iterable l, IF1 f) { List x = emptyList(l); if (l != null) for (A o : l) addIfNotNull(x, f.get(o)); return x; } static public List mapNonNulls(IF1 f, Iterable l) { return mapNonNulls(l, f); } static public TreeSet caseInsensitiveSet_treeSet() { return new TreeSet(caseInsensitiveComparator()); } static public TreeSet caseInsensitiveSet_treeSet(Collection c) { return toCaseInsensitiveSet_treeSet(c); } static public 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); } static public String javaTok_substringC(String s, int i, int j) { return s.substring(i, j); } static public List javaTokWithExisting(String s, List existing) { ++javaTok_n; int nExisting = javaTok_opt && existing != null ? existing.size() : 0; ArrayList 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; } static public boolean javaTokWithExisting_isCopyable(String t, String s, int i, int j) { return t.length() == j - i && s.regionMatches(i, t, 0, j - i); } static public List tok_combineRoundOrCurlyBrackets_keep(List tok) { List 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; } static public int max(int a, int b) { return Math.max(a, b); } static public int max(int a, int b, int c) { return max(max(a, b), c); } static public long max(int a, long b) { return Math.max((long) a, b); } static public long max(long a, long b) { return Math.max(a, b); } static public double max(int a, double b) { return Math.max((double) a, b); } static public float max(float a, float b) { return Math.max(a, b); } static public double max(double a, double b) { return Math.max(a, b); } static public int max(Collection c) { int x = Integer.MIN_VALUE; for (int i : c) x = max(x, i); return x; } static public double max(double[] c) { if (c.length == 0) return Double.MIN_VALUE; double x = c[0]; for (int i = 1; i < c.length; i++) x = Math.max(x, c[i]); return x; } static public 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; } static public byte max(byte[] c) { byte x = -128; for (byte d : c) if (d > x) x = d; return x; } static public short max(short[] c) { short x = -0x8000; for (short d : c) if (d > x) x = d; return x; } static public int max(int[] c) { int x = Integer.MIN_VALUE; for (int d : c) if (d > x) x = d; return x; } static public List tok_combineRoundBrackets_keep(List tok) { List l = new ArrayList(); for (int i = 0; i < l(tok); i++) { String t = tok.get(i); if (odd(i) && eq(t, "(")) { int j = findEndOfBracketPart(tok, i); l.add(joinSubList(tok, i, j)); i = j - 1; } else l.add(t); } return l; } static public boolean startsWithAndEndsWith(String s, String prefix, String suffix) { return startsWith(s, prefix) && endsWith(s, suffix); } static public List dropFirstAndLast(int n, List l) { return cloneSubList(l, n, l(l) - n); } static public List dropFirstAndLast(int m, int n, List l) { return cloneSubList(l, m, l(l) - n); } static public List dropFirstAndLast(List l) { return dropFirstAndLast(1, l); } static public String dropFirstAndLast(String s) { return substring(s, 1, l(s) - 1); } static public List javaTokC(String s) { if (s == null) return null; int l = s.length(); ArrayList 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; } static public List tok_combineCurlyBrackets_keep(List tok) { List 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; } static public List dropFirstTwoAndLastTwo(List l) { return dropFirstAndLast(2, l); } static public String beautifyStructure(String s) { List tok = javaTokForStructure(s); structure_addTokenMarkers(tok); jreplace(tok, "lhm", ""); return join(tok); } static public String struct_noStringSharing(Object o) { structure_Data d = new structure_Data(); d.noStringSharing = true; return structure(o, d); } static public int lastIndexOf(String a, String b) { return a == null || b == null ? -1 : a.lastIndexOf(b); } static public int lastIndexOf(String a, char b) { return a == null ? -1 : a.lastIndexOf(b); } static public TreeMap caseInsensitiveMap() { return new TreeMap(caseInsensitiveComparator()); } static public HashMap litmap(Object... x) { HashMap map = new HashMap(); litmap_impl(map, x); return map; } static public void litmap_impl(Map map, Object... x) { if (x != null) for (int i = 0; i < x.length - 1; i += 2) if (x[i + 1] != null) map.put(x[i], x[i + 1]); } static public Map javaTokForJFind_array_cache = synchronizedMRUCache(1000); static public 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; } static public int findCodeTokens(List tok, String... tokens) { return findCodeTokens(tok, 1, false, tokens); } static public int findCodeTokens(List tok, boolean ignoreCase, String... tokens) { return findCodeTokens(tok, 1, ignoreCase, tokens); } static public int findCodeTokens(List tok, int startIdx, boolean ignoreCase, String... tokens) { return findCodeTokens(tok, startIdx, ignoreCase, tokens, null); } static public HashSet findCodeTokens_specials = lithashset("*", "", "", "", "\\*"); static public int findCodeTokens_bails, findCodeTokens_nonbails; static public interface findCodeTokens_Matcher { public boolean get(String token); } static public int findCodeTokens(List tok, int startIdx, boolean ignoreCase, String[] tokens, Object condition) { 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; } findCodeTokens_Matcher[] matchers = new findCodeTokens_Matcher[nTokens]; for (int j = 0; j < nTokens; j++) { String p = tokens[j]; findCodeTokens_Matcher matcher; if (p.equals("*")) matcher = t -> true; else if (p.equals("")) matcher = t -> isQuoted(t); else if (p.equals("")) matcher = t -> isIdentifier(t); else if (p.equals("")) matcher = t -> isInteger(t); else if (p.equals("\\*")) matcher = t -> t.equals("*"); else if (ignoreCase) matcher = t -> eqic(p, t); else matcher = t -> t.equals(p); matchers[j] = matcher; } outer: for (; i < end; i += 2) { for (int j = 0; j < nTokens; j++) if (!matchers[j].get(tok.get(i + j * 2))) continue outer; if (condition == null || checkTokCondition(condition, tok, i - 1)) return i; } return -1; } static public String jreplaceExpandRefs(String s, List tokref) { List tok = javaTok(s); for (int i = 1; i < l(tok); i += 2) { String t = tok.get(i); if (t.startsWith("$") && isInteger(t.substring(1))) { String x = tokref.get(-1 + parseInt(t.substring(1)) * 2); tok.set(i, x); } else if (t.equals("\\")) { tok.set(i, ""); i += 2; } } return join(tok); } static public void clearAllTokens(List tok) { for (int i = 0; i < tok.size(); i++) tok.set(i, ""); } static public void clearAllTokens(List tok, int i, int j) { for (; i < j; i++) tok.set(i, ""); } static public List reTok(List tok) { replaceCollection(tok, javaTok(tok)); return tok; } static public List reTok(List tok, int i) { return reTok(tok, i, i + 1); } static public List reTok(List tok, int i, int j) { i = max(i & ~1, 0); j = min(l(tok), j | 1); if (i >= j) return tok; List t = javaTok(joinSubList(tok, i, j)); replaceListPart(tok, i, j, t); return tok; } static public List reTok(List tok, IntRange r) { if (r != null) reTok(tok, r.start, r.end); return tok; } static public int numberOfJavaTokens(String s) { return l(javaTokC(s)); } static public String roundBracket(String s) { return "(" + s + ")"; } static public List javaTokPlusBrackets2(String s) { return tok_combineRoundCurlySquareBrackets_keep(javaTok(s)); } static public A optPar(ThreadLocal tl, A defaultValue) { A a = tl.get(); if (a != null) { tl.set(null); return a; } return defaultValue; } static public A optPar(ThreadLocal tl) { return optPar(tl, null); } static public Object optPar(Object[] params, String name) { return optParam(params, name); } static public Object optPar(String name, Object[] params) { return optParam(params, name); } static public Object optPar(String name, Map params) { return optParam(name, params); } static public A optPar(Object[] params, String name, A defaultValue) { return optParam(params, name, defaultValue); } static public A optPar(String name, Object[] params, A defaultValue) { return optParam(params, name, defaultValue); } static public Map gazelle_zipTwoTokenizationsToMap_keepBrackets(List tokA, List tokB) { return ciMapWithoutKeysEqualToValues(zipTwoTokenizationsToCIMap_strict(tokA, tokB)); } static public List callTokenizer(Object tokenizer, String s) { return (List) callF(tokenizer, s); } static public boolean addMapToMapWithoutOverwritingIC(Map map, Map adding) { if (!canPutAllStrictlyIC(map, adding)) return false; { final Map __0 = unnull(adding); for (A key : keys(__0)) { String value = __0.get(key); strictPutIC(map, key, value); } } return true; } static public 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)); } static public int toInt(long l) { if (l != (int) l) throw fail("Too large for int: " + l); return (int) l; } static public String getSlackTS() { return (String) callOpt(getMainBot(), "getSlackTS"); } static public Object getBot(String botID) { return callOpt(getMainBot(), "getBot", botID); } static public Object callFunction(Object f, Object... args) { return callF(f, args); } static public String asciiHeading2(String title) { return asciiHeading(title) + "\n"; } static public void printNumberedLines(Map map) { printNumberedLines(mapToLines(map)); } static public A printNumberedLines(A l) { int i = 0; if (l != null) for (Object a : l) print((++i) + ". " + str(a)); return l; } static public A printNumberedLines(String prefix, A l) { int i = 0; if (l != null) for (Object a : l) print(prefix + (++i) + ". " + str(a)); return l; } static public void printNumberedLines(Object[] l) { printNumberedLines(asList(l)); } static public void printNumberedLines(Object o) { printNumberedLines(lines(str(o))); } static public String lines(Iterable lines) { return fromLines(lines); } static public String lines(Object[] lines) { return fromLines(asList(lines)); } static public List lines(String s) { return toLines(s); } static public boolean containsNewLine(String s) { return contains(s, '\n'); } static public boolean endsWith(String a, String b) { return a != null && a.endsWith(b); } static public boolean endsWith(String a, char c) { return nempty(a) && lastChar(a) == c; } static public boolean endsWith(String a, String b, Matches m) { if (!endsWith(a, b)) return false; m.m = new String[] { dropLast(l(b), a) }; return true; } static public int getIndent(String s) { int n = Integer.MAX_VALUE; for (String l : toLines(s)) n = min(n, getIndentOfLine(l)); return n; } static public IterableIterator toLines(File f) { return linesFromFile(f); } static public List toLines(String s) { List lines = new ArrayList(); if (s == null) return lines; int start = 0; while (true) { int i = toLines_nextLineBreak(s, start); if (i < 0) { if (s.length() > start) lines.add(s.substring(start)); break; } lines.add(s.substring(start, i)); if (s.charAt(i) == '\r' && i + 1 < s.length() && s.charAt(i + 1) == '\n') i += 2; else ++i; start = i; } return lines; } static public int toLines_nextLineBreak(String s, int start) { for (int i = start; i < s.length(); i++) { char c = s.charAt(i); if (c == '\r' || c == '\n') return i; } return -1; } static public String fromLines(Iterable lines) { StringBuilder buf = new StringBuilder(); if (lines != null) for (Object line : lines) buf.append(str(line)).append('\n'); return buf.toString(); } static public String fromLines(String... lines) { return fromLines(asList(lines)); } static public boolean isSpaceOrTab(char c) { return c == ' ' || c == '\t'; } static public char charAt(String s, int i) { return s != null && i >= 0 && i < s.length() ? s.charAt(i) : '\0'; } static public boolean isNewLine(char c) { return c == '\r' || c == '\n'; } static public List concatLists(Collection... lists) { List l = new ArrayList(); if (lists != null) for (Collection list : lists) if (list != null) l.addAll(list); return l; } static public List concatLists(Collection> lists) { List l = new ArrayList(); if (lists != null) for (Collection list : lists) if (list != null) l.addAll(list); return l; } static public String firstJavaToken(String s) { if (s == null) return null; int l = s.length(); int j = 0; 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 (j >= l) return null; int i = j; 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; return quickSubstring(s, i, j); } static public String lastJavaToken(String s) { return last(javaTokC(s)); } static public boolean emptyString(String s) { return s == null || s.length() == 0; } static public String lines_rtrim(Collection lines) { return rtrim_fromLines(lines); } static public void addIfNempty(Collection l, String s) { if (nempty(s)) l.add(s); } static public void addIfNempty(Collection l, Map m) { if (nempty(m)) l.add(m); } static public void addIfNempty(Collection l, Collection c) { if (nempty(c)) l.add(c); } static public boolean isCISet(Iterable l) { return l instanceof TreeSet && ((TreeSet) l).comparator() == caseInsensitiveComparator(); } static public Object swing(Object f) { return swingAndWait(f); } static public A swing(F0 f) { return (A) swingAndWait(f); } static public A swing(IF0 f) { return (A) swingAndWait(f); } static public List newSubList(List l, int startIndex, int endIndex) { return cloneList(subList(l, startIndex, endIndex)); } static public List newSubList(List l, int startIndex) { return cloneList(subList(l, startIndex)); } static public > IterableIterator nestedIterator(final Iterable c, final F1 makeInnerIterator) { return nestedIterator(iterator(c), makeInnerIterator); } static public > IterableIterator nestedIterator(final Iterator it1, final F1 makeInnerIterator) { if (it1 == null || !it1.hasNext()) return emptyIterableIterator(); return iff(new F0() { public A a; public Iterator innerIterator; { nextOuter(); } public void nextOuter() { a = it1.next(); innerIterator = callF(makeInnerIterator, a); } public Object get() { while (true) { ping(); if (innerIterator.hasNext()) return innerIterator.next(); if (!it1.hasNext()) return endMarker(); nextOuter(); } } }); } static public class mapI_It extends IterableIterator { public Object f; public Iterator i; public mapI_It() { } public mapI_It(Object f, Iterator i) { this.i = i; this.f = f; } public boolean hasNext() { return i.hasNext(); } public Object next() { return callF(f, i.next()); } public String toString() { return formatFunctionCall("mapI", f, i); } } static public IterableIterator mapI(final Object f, final Iterator i) { return new mapI_It(f, i); } static public IterableIterator mapI(IterableIterator i, Object f) { return mapI((Iterator) i, f); } static public IterableIterator mapI(Object f, IterableIterator i) { return mapI((Iterator) i, f); } static public IterableIterator mapI(Iterator i, Object f) { return mapI(f, i); } static public IterableIterator mapI(Iterable i, IF1 f) { return mapI(i, (Object) f); } static public IterableIterator mapI(IF1 f, Iterable i) { return mapI(i, (Object) f); } static public IterableIterator mapI(Iterable i, Object f) { return mapI(f, i.iterator()); } static public IterableIterator mapI(Object f, Iterable i) { return mapI(i, f); } static public Class _getClass(String name) { try { return Class.forName(name); } catch (ClassNotFoundException e) { return null; } } static public Class _getClass(Object o) { return o == null ? null : o instanceof Class ? (Class) o : o.getClass(); } static public Class _getClass(Object realm, String name) { try { return getClass(realm).getClassLoader().loadClass(classNameToVM(name)); } catch (ClassNotFoundException e) { return null; } } static public int hashCode(Object a) { return a == null ? 0 : a.hashCode(); } static public void addIfNotNull(Collection l, A a) { if (a != null && l != null) l.add(a); } static public void addIfNotNull(MultiSet ms, A a) { if (a != null && ms != null) ms.add(a); } static public Comparator caseInsensitiveComparator() { return betterCIComparator(); } static public TreeSet toCaseInsensitiveSet_treeSet(Iterable c) { if (isCISet(c)) return (TreeSet) c; TreeSet set = caseInsensitiveSet_treeSet(); addAll(set, c); return set; } static public TreeSet toCaseInsensitiveSet_treeSet(String... x) { TreeSet set = caseInsensitiveSet_treeSet(); addAll(set, x); return set; } static public int findEndOfBracketPart(List 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(); } static public String joinSubList(List l, int i, int j) { return join(subList(l, i, j)); } static public String joinSubList(List l, int i) { return join(subList(l, i)); } static public String joinSubList(List l, IntRange r) { return r == null ? null : joinSubList(l, r.start, r.end); } static public int findEndOfCurlyBracketPart(List 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(); } static public List javaTokForStructure(String s) { return javaTok_noMLS(s); } static public String structure_addTokenMarkers(String s) { return join(structure_addTokenMarkers(javaTokForStructure(s))); } static public List structure_addTokenMarkers(List tok) { TreeSet 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; if (idx >= l(tok)) continue; String t = ""; if (endsWithLetterOrDigit(tok.get(idx - 1))) t = " "; tok.set(idx, t + "m" + i + " " + tok.get(idx)); } return tok; } static public Map synchronizedMRUCache(int maxSize) { return synchroMap(new MRUCache(maxSize)); } static public String[] codeTokensAsStringArray(List 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; } static public int jfind(String s, String in) { return jfind(javaTok(s), in); } static public int jfind(List tok, String in) { return jfind(tok, 1, in); } static public int jfind(List tok, int startIdx, String in) { return jfind(tok, startIdx, in, null); } static public int jfind(List tok, String in, Object condition) { return jfind(tok, 1, in, condition); } static public int jfind(List tok, int startIdx, String in, Object condition) { return jfind(tok, startIdx, javaTokForJFind_array(in), condition); } static public int jfind(List tok, List tokin) { return jfind(tok, 1, tokin); } static public int jfind(List tok, int startIdx, List tokin) { return jfind(tok, startIdx, tokin, null); } static public int jfind(List tok, int startIdx, String[] tokinC, Object condition) { return findCodeTokens(tok, startIdx, false, tokinC, condition); } static public int jfind(List tok, int startIdx, List tokin, Object condition) { return jfind(tok, startIdx, codeTokensAsStringArray(tokin), condition); } static public List jfind_preprocess(List tok) { for (String type : litlist("quoted", "id", "int")) replaceSublist(tok, ll("<", "", type, "", ">"), ll("<" + type + ">")); replaceSublist(tok, ll("\\", "", "*"), ll("\\*")); return tok; } static public HashSet lithashset(A... items) { HashSet set = new HashSet(); for (A a : items) set.add(a); return set; } static public boolean isQuoted(String s) { if (isNormalQuoted(s)) return true; return isMultilineQuoted(s); } static public boolean isIdentifier(String s) { return isJavaIdentifier(s); } static public 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; } static public boolean checkTokCondition(Object condition, List tok, int i) { if (condition instanceof TokCondition) return ((TokCondition) condition).get(tok, i); return checkCondition(condition, tok, i); } static public void replaceCollection(Collection dest, Collection src) { dest.clear(); dest.addAll(src); } static public void replaceListPart(List l, int i, int j, List l2) { replaceSublist(l, i, j, l2); } static public List tok_combineRoundCurlySquareBrackets_keep(List tok) { List 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; } static public A optParam(ThreadLocal tl, A defaultValue) { return optPar(tl, defaultValue); } static public A optParam(ThreadLocal tl) { return optPar(tl); } static public Object optParam(String name, Map params) { return mapGet(params, name); } static public 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; } static public Object optParam(Object[] opt, String name) { return optParam(opt, name, null); } static public Map ciMapWithoutKeysEqualToValues(Map map) { if (map == null) return null; Map map2 = ciMap(); for (String key : keys(map)) { String value = map.get(key); if (!eqic(key, value)) map2.put(key, value); } return map2; } static public Map zipTwoTokenizationsToCIMap_strict(List l1, List l2) { int n = l(l1); if (n != l(l2)) return null; Map map = ciMap(); for (int i = 1; i < n; i += 2) if (!strictPutIC(map, l1.get(i), l2.get(i))) return null; return map; } static public boolean canPutAllStrictlyIC(Map map, Map map2) { { final Map __0 = unnull(map2); for (A key : keys(__0)) { String value = __0.get(key); if (!canPutStrictlyIC(map, key, value)) return false; } } return true; } static public Object mainBot; static public Object getMainBot() { return mainBot; } static public String asciiHeading(String title) { return "\n" + title + "\n" + rep(l(title), '-'); } static public List mapToLines(Map map) { List l = new ArrayList(); for (Object key : keys(map)) l.add(str(key) + " = " + str(map.get(key))); return l; } static public String mapToLines(Map map, Object f) { return lines(map(map, f)); } static public String mapToLines(Object f, Map map) { return lines(map(map, f)); } static public String mapToLines(Object f, Iterable l) { return lines(map(f, l)); } static public String mapToLines(Iterable l, IF1 f) { return mapToLines(f, l); } static public char lastChar(String s) { return empty(s) ? '\0' : s.charAt(l(s) - 1); } static public String[] dropLast(String[] a, int n) { n = Math.min(n, a.length); String[] b = new String[a.length - n]; System.arraycopy(a, 0, b, 0, b.length); return b; } static public List dropLast(List l) { return subList(l, 0, l(l) - 1); } static public List dropLast(int n, List l) { return subList(l, 0, l(l) - n); } static public List dropLast(Iterable l) { return dropLast(asList(l)); } static public String dropLast(String s) { return substring(s, 0, l(s) - 1); } static public String dropLast(String s, int n) { return substring(s, 0, l(s) - n); } static public String dropLast(int n, String s) { return dropLast(s, n); } static public int getIndentOfLine(String s) { int i = 0, n = l(s); while (i < n && s.charAt(i) == ' ') ++i; return i; } static public CloseableIterableIterator 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); } } static public CloseableIterableIterator linesFromFile(String path) { return linesFromFile(newFile(path)); } static public String quickSubstring(String s, int i, int j) { if (i == j) return ""; return s.substring(i, j); } static public A last(List l) { return empty(l) ? null : l.get(l.size() - 1); } static public char last(String s) { return empty(s) ? '#' : s.charAt(l(s) - 1); } static public int last(int[] a) { return l(a) != 0 ? a[l(a) - 1] : 0; } static public A last(A[] a) { return l(a) != 0 ? a[l(a) - 1] : null; } static public A last(Iterator it) { A a = null; while (it.hasNext()) { ping(); a = it.next(); } return a; } static public A last(SortedSet l) { return l == null ? null : l.last(); } static public String rtrim_fromLines(Collection lines) { StringBuilder buf = new StringBuilder(); if (lines != null) { boolean first = true; for (Object line : lines) { if (first) first = false; else buf.append('\n'); buf.append(str(line)); } } return buf.toString(); } static public void swingAndWait(Runnable r) { try { if (isAWTThread()) r.run(); else EventQueue.invokeAndWait(addThreadInfoToRunnable(r)); } catch (Exception __e) { throw rethrow(__e); } } static public 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(); } } static public IterableIterator emptyIterableIterator_instance = new IterableIterator() { public Object next() { throw fail(); } public boolean hasNext() { return false; } }; static public IterableIterator emptyIterableIterator() { return emptyIterableIterator_instance; } static public IterableIterator iff(Object f) { return iteratorFromFunction_withEndMarker(f); } static public IterableIterator iff(F0 f) { return iteratorFromFunction_withEndMarker(f); } static public IterableIterator iff(IF0 f) { return iteratorFromFunction_withEndMarker(f); } static public Object endMarker() { return iteratorFromFunction_endMarker; } static public String formatFunctionCall(String fname, Object... args) { return fname + "(" + joinWithComma(allToString(args)) + ")"; } static public Class getClass(String name) { try { return Class.forName(name); } catch (ClassNotFoundException e) { return null; } } static public Class getClass(Object o) { return o instanceof Class ? (Class) o : o.getClass(); } static public 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); } } static public String classNameToVM(String name) { return name.replace(".", "$"); } static public Object iteratorFromFunction_endMarker = new Object(); static public IterableIterator iteratorFromFunction_withEndMarker(final Object f) { class IFF extends IterableIterator { public A a; public boolean have, done; public boolean hasNext() { getNext(); return !done; } public A next() { getNext(); if (done) throw fail(); A _a = a; a = null; have = false; return _a; } public void getNext() { if (done || have) return; Object o = callF(f); if (o == iteratorFromFunction_endMarker) { done = true; return; } a = (A) o; have = true; } } ; return new IFF(); } static public IterableIterator iteratorFromFunction_withEndMarker(final F0 f) { return iteratorFromFunction_withEndMarker_f0(f); } static public betterCIComparator_C betterCIComparator_instance; static public betterCIComparator_C betterCIComparator() { if (betterCIComparator_instance == null) betterCIComparator_instance = new betterCIComparator_C(); return betterCIComparator_instance; } static public class betterCIComparator_C implements Comparator { 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; } } static public List javaTok_noMLS(String s) { ArrayList 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 == '\'' || 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))); else if (Character.isDigit(c)) { do ++j; while (j < l && Character.isDigit(s.charAt(j))); if (j < l && s.charAt(j) == 'L') ++j; } else ++j; tok.add(javaTok_substringC(s, i, j)); ++n; i = j; } if ((tok.size() % 2) == 0) tok.add(""); return tok; } static public Map synchroMap() { return synchroHashMap(); } static public Map synchroMap(Map map) { return Collections.synchronizedMap(map); } static public ArrayList litlist(A... a) { ArrayList l = new ArrayList(a.length); for (A x : a) l.add(x); return l; } static public List replaceSublist(List l, List x, List y) { if (x == null) return l; int i = 0; while (true) { i = indexOfSubList(l, x, i); if (i < 0) break; replaceSublist(l, i, i + l(x), y); i += l(y); } return l; } static public List replaceSublist(List l, int fromIndex, int toIndex, List y) { int n = y.size(), toIndex_new = fromIndex + n; if (toIndex_new < toIndex) { removeSubList(l, toIndex_new, toIndex); copyListPart(y, 0, l, fromIndex, n); } else { copyListPart(y, 0, l, fromIndex, toIndex - fromIndex); if (toIndex_new > toIndex) l.addAll(toIndex, subList(y, toIndex - fromIndex)); } return l; } static public List replaceSublist(List l, IntRange r, List y) { return replaceSublist(l, r.start, r.end, y); } static public 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; } static public 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) == '['; } static public 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; } static public int findEndOfBracketPart2(List 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(); } static public boolean even(int i) { return (i & 1) == 0; } static public boolean even(long i) { return (i & 1) == 0; } static public TreeMap ciMap() { return caseInsensitiveMap(); } static public boolean canPutStrictlyIC(Map map, A key, String value) { if (!(map != null && key != null && value != null)) return true; String old = map.get(key); return old == null || eqic(old, value); } static public String rep(int n, char c) { return repeat(c, n); } static public String rep(char c, int n) { return repeat(c, n); } static public List rep(A a, int n) { return repeat(a, n); } static public List rep(int n, A a) { return repeat(n, a); } static public CloseableIterableIterator emptyCloseableIterableIterator_instance = new CloseableIterableIterator() { public Object next() { throw fail(); } public boolean hasNext() { return false; } }; static public CloseableIterableIterator emptyCloseableIterableIterator() { return emptyCloseableIterableIterator_instance; } static public CloseableIterableIterator linesFromReader(Reader r) { final BufferedReader br = bufferedReader(r); return iteratorFromFunction_f0_autoCloseable(new F0() { public String get() { try { return readLineFromReaderWithClose(br); } catch (Exception __e) { throw rethrow(__e); } } public String toString() { return "ret readLineFromReaderWithClose(br);"; } }, _wrapIOCloseable(r)); } static public BufferedReader utf8bufferedReader(InputStream in) { try { return bufferedReader(_registerIOWrap(new InputStreamReader(in, "UTF-8"), in)); } catch (Exception __e) { throw rethrow(__e); } } static public BufferedReader utf8bufferedReader(File f) { try { return utf8bufferedReader(newFileInputStream(f)); } catch (Exception __e) { throw rethrow(__e); } } static public GZIPInputStream newGZIPInputStream(File f) { return gzInputStream(f); } static public GZIPInputStream newGZIPInputStream(InputStream in) { return gzInputStream(in); } static public File newFile(File base, String... names) { for (String name : names) base = new File(base, name); return base; } static public File newFile(String name) { return name == null ? null : new File(name); } static public File newFile(String base, String... names) { return newFile(newFile(base), names); } static public 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);"; } }; } static public List allToString(Iterable c) { List l = new ArrayList(); for (Object o : unnull(c)) l.add(str(o)); return l; } static public List allToString(Object[] c) { List l = new ArrayList(); for (Object o : unnull(c)) l.add(str(o)); return l; } static public IterableIterator iteratorFromFunction_withEndMarker_f0(final F0 f) { class IFF2 extends IterableIterator { public A a; public boolean have, done; public boolean hasNext() { getNext(); return !done; } public A next() { getNext(); if (done) throw fail(); A _a = a; a = null; have = false; return _a; } public void getNext() { if (done || have) return; Object o = f.get(); if (o == iteratorFromFunction_endMarker) { done = true; return; } a = (A) o; have = true; } } ; return new IFF2(); } static public Map synchroHashMap() { return Collections.synchronizedMap(new HashMap()); } static public void copyListPart(List a, int i1, List 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)); } static public BufferedReader bufferedReader(Reader r) { return r instanceof BufferedReader ? (BufferedReader) r : _registerIOWrap(new BufferedReader(r), r); } static public CloseableIterableIterator iteratorFromFunction_f0_autoCloseable(final F0 f, final AutoCloseable closeable) { class IFF2 extends CloseableIterableIterator { public A a; public boolean done = false; 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(); } static public String readLineFromReaderWithClose(BufferedReader r) { try { String s = r.readLine(); if (s == null) r.close(); return s; } catch (Exception __e) { throw rethrow(__e); } } static public 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); } }; } static public A _registerIOWrap(A wrapper, Object wrapped) { return wrapper; } static public FileInputStream newFileInputStream(File path) throws IOException { return newFileInputStream(path.getPath()); } static public FileInputStream newFileInputStream(String path) throws IOException { FileInputStream f = new FileInputStream(path); _registerIO(f, path, true); return f; } static public int gzInputStream_defaultBufferSize = 65536; static public GZIPInputStream gzInputStream(File f) { try { return gzInputStream(new FileInputStream(f)); } catch (Exception __e) { throw rethrow(__e); } } static public GZIPInputStream gzInputStream(File f, int bufferSize) { try { return gzInputStream(new FileInputStream(f), bufferSize); } catch (Exception __e) { throw rethrow(__e); } } static public GZIPInputStream gzInputStream(InputStream in) { return gzInputStream(in, gzInputStream_defaultBufferSize); } static public GZIPInputStream gzInputStream(InputStream in, int bufferSize) { try { return _registerIOWrap(new GZIPInputStream(in, gzInputStream_defaultBufferSize), in); } catch (Exception __e) { throw rethrow(__e); } } static public Runnable asRunnable(Object o) { return toRunnable(o); } static public void _inheritThreadInfo(Object info) { _threadInheritInfo(info); } static public void _registerIO(Object object, String path, boolean opened) { } static public class CancelPoint implements AutoCloseable { volatile public boolean closed = false; public void close() { closed = true; } } static public class MRUCache extends LinkedHashMap { public int maxSize = 10; public MRUCache() { } public MRUCache(int maxSize) { this.maxSize = maxSize; } public boolean removeEldestEntry(Map.Entry eldest) { return size() > maxSize; } public Object _serialize() { return ll(maxSize, cloneLinkedHashMap(this)); } static public MRUCache _deserialize(List l) { MRUCache m = new MRUCache(); m.maxSize = (int) first(l); m.putAll((LinkedHashMap) second(l)); return m; } } static public class CancelToCancelPoint extends QuickException { public CancelPoint cp; public CancelToCancelPoint(CancelPoint cp) { this.cp = cp; } } static abstract public class CloseableIterableIterator extends IterableIterator implements AutoCloseable { public void close() throws Exception { } } static public class Var implements IVar { 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()); } } static public class LinkedTreeSet extends AbstractSet { public Set set; public LinkedList list = new LinkedList(); public LinkedTreeSet() { set = new TreeSet(); } public LinkedTreeSet(Set set) { this.set = set; } public int size() { return list.size(); } public Iterator 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; } } } static abstract public class TokCondition { abstract public boolean get(List tok, int i); } static abstract public class IterableIterator implements Iterator, Iterable { public Iterator iterator() { return this; } public void remove() { unsupportedOperation(); } } static public class QuickException extends RuntimeException { public Throwable fillInStackTrace() { return this; } public QuickException() { } public QuickException(Throwable e) { super(e); } public QuickException(String msg) { super(msg); } public QuickException(String msg, Throwable e) { super(msg, e); } } static public interface IVar { public void set(A a); public A get(); default public boolean has() { return get() != null; } default public void clear() { set(null); } } static public boolean allLinesAreUnindented(String text) { for (String s : lines(text)) if (startsWithSpace(s)) return false; return true; } static public String withoutLinesEmptyAfterTrim(String text) { List lines = filter(lines(text), s -> !emptyAfterTrim(s)); return lines_possiblyRTrim(text, lines); } static public String autoUnindent_honoringBrackets(String s) { List l = lines_honoringBrackets(s); if (empty(l)) return s; int n = Integer.MAX_VALUE; for (String line : l) n = min(n, getIndentOfLine(line)); if (n == 0) return s; int _n = n; return lines_possiblyRTrim(s, map(l, line -> substring(line, _n))); } static public List groupPythonStyleIndents_honoringBrackets(String text) { List lines = lines_honoringBrackets(text); List out = new ArrayList(); int startOfBlock = 0; for (int i = 0; i < l(lines); i++) { boolean indented = startsWithSpace(lines.get(i)); if (!indented) { addIfNempty(out, lines_rtrim(subList(lines, startOfBlock, i))); startOfBlock = i; } } addIfNempty(out, lines_rtrim(subList(lines, startOfBlock))); return out; } static public A assertEquals(Object x, A y) { return assertEquals(null, x, y); } static public 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; } static public String deRoundBracket(String s) { if (startsWith(s, "(") && endsWith(s, ")")) return substring(s, 1, l(s) - 1); return s; } static public String assertIdentifier(String s) { return assertIsIdentifier(s); } static public String assertIdentifier(String msg, String s) { return assertIsIdentifier(msg, s); } static public String trimJoinSubList(List l, int i, int j) { return trim(join(subList(l, i, j))); } static public String trimJoinSubList(List l, int i) { return trim(join(subList(l, i))); } public static String rtrim(String s) { if (s == null) return null; int i = s.length(); while (i > 0 && " \t\r\n".indexOf(s.charAt(i - 1)) >= 0) --i; return i < s.length() ? s.substring(0, i) : s; } static public List tok_splitAtEmptyLines(String s) { List indices = new ArrayList(); List tok = javaTokWithAllBrackets(s); List out = new ArrayList(); int start = 0; String spacing = ""; for (int i = 2; i + 1 < l(tok); i += 2) { int idx = indexOf_regexp(tok.get(i), "\r?\n\\s*\r?\n"); if (idx < 0) continue; int idx2 = idx + 1; if (tok.get(i).charAt(idx) == '\r') ++idx2; out.add(dropPrefix("\n", spacing + joinSubList(tok, start, i))); start = i + 1; spacing = substring(tok.get(i), idx2); } if (start < l(tok)) out.add(dropPrefix("\n", spacing + joinSubList(tok, start))); return out; } static public String n2(long l) { return formatWithThousands(l); } static public String n2(Collection l) { return n2(l(l)); } static public String n2(double l, String singular) { return n2(l, singular, singular + "s"); } static public String n2(double l, String singular, String plural) { if (fraction(l) == 0) return n2((long) l, singular, plural); else return l + " " + plural; } static public String n2(long l, String singular, String plural) { return n_fancy2(l, singular, plural); } static public String n2(long l, String singular) { return n_fancy2(l, singular, singular + "s"); } static public String n2(Collection l, String singular) { return n2(l(l), singular); } static public String n2(Collection l, String singular, String plural) { return n_fancy2(l, singular, plural); } static public String n2(Map m, String singular, String plural) { return n_fancy2(m, singular, plural); } static public String n2(Map m, String singular) { return n2(l(m), singular); } static public String n2(Object[] a, String singular) { return n2(l(a), singular); } static public String n2(Object[] a, String singular, String plural) { return n_fancy2(a, singular, plural); } static public String n2(MultiSet ms, String singular, String plural) { return n_fancy2(ms, singular, plural); } static public String joinWithEmptyLines(List l) { return join("\n\n", map("rtrim", l)); } static public String joinWithEmptyLines(String... l) { return joinWithEmptyLines(asList(l)); } static public boolean isSingleLine(String s) { return !containsNewLine(s); } static public Pair, List> filterAntiFilter(Iterable c, Object pred) { List yes = new ArrayList(); List no = new ArrayList(); if (c != null) for (A o : c) (isTrue(callF(pred, o)) ? yes : no).add(o); return pair(yes, no); } static public Pair, List> filterAntiFilter(Iterable c, IF1 pred) { return filterAntiFilter(c, (Object) pred); } static public Pair, List> filterAntiFilter(IF1 pred, Iterable c) { return filterAntiFilter(c, pred); } static public Pair, List> filterAntiFilter(Object pred, Iterable c) { return filterAntiFilter(c, pred); } static public List tlft(String s) { return toLinesFullTrim(s); } static public List tlft(File f) { return toLinesFullTrim(f); } static public void pnlStruct(Object o) { if (o instanceof Collection) pnlStruct(((Collection) o)); else if (o instanceof Map) pnlStruct(((Map) o)); else if (o != null) pnlStruct(ll(o)); } static public > B pnlStruct(B l) { pnlStruct((Iterable) l); return l; } static public Iterable pnlStruct(Iterable l) { return pnlStruct("", l); } static public Iterable pnlStruct(String prefix, Iterable l) { int i = 0; if (l != null) for (A a : l) print(prefix + (++i) + ". " + struct_noStringSharing(a)); return l; } static public A[] pnlStruct(A[] l) { pnlStruct(asList(l)); return l; } static public Map pnlStruct(Map map) { pnl(map(map, new F2() { public Object get(A a, B b) { try { return sfu(a) + " = " + sfu(b); } catch (Exception __e) { throw rethrow(__e); } } public String toString() { return "sfu(a) + \" = \" + sfu(b)"; } })); return map; } static public LinkedHashMap cloneLinkedHashMap(Map map) { return map == null ? new LinkedHashMap() : new LinkedHashMap(map); } static public A second(List l) { return get(l, 1); } static public A second(Iterable l) { if (l == null) return null; Iterator it = iterator(l); if (!it.hasNext()) return null; it.next(); return it.hasNext() ? it.next() : null; } static public A second(A[] bla) { return bla == null || bla.length <= 1 ? null : bla[1]; } static public B second(Pair p) { return p == null ? null : p.b; } static public char second(String s) { return charAt(s, 1); } static public UnsupportedOperationException unsupportedOperation() { throw new UnsupportedOperationException(); } static public A set(A o, String field, Object value) { if (o == null) return null; if (o instanceof Class) set((Class) o, field, value); else try { Field f = set_findField(o.getClass(), field); makeAccessible(f); smartSet(f, o, value); } catch (Exception e) { throw new RuntimeException(e); } return o; } static public void set(Class c, String field, Object value) { if (c == null) return; try { Field f = set_findStaticField(c, field); makeAccessible(f); smartSet(f, null, value); } catch (Exception e) { throw new RuntimeException(e); } } static public 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()); } static public 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()); } static public boolean startsWithSpace(String s) { return nempty(s) && isSpace(first(s)); } static public boolean emptyAfterTrim(String s) { return empty(trim(s)); } static public String lines_possiblyRTrim(String originalText, List lines) { return endsWithNewLine(originalText) ? lines(lines) : lines_rtrim(lines); } static public ThreadLocal assertVerbose_value = new ThreadLocal(); static public void assertVerbose(boolean b) { assertVerbose_value.set(b); } static public boolean assertVerbose() { return isTrue(assertVerbose_value.get()); } static public A assertEqualsVerbose(Object x, A y) { assertEqualsVerbose((String) null, x, y); return y; } static public 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; } static public String assertIsIdentifier(String s) { if (!isIdentifier(s)) throw fail("Not an identifier: " + quote(s)); return s; } static public String assertIsIdentifier(String msg, String s) { if (!isIdentifier(s)) throw fail(msg + " - Not an identifier: " + quote(s)); return s; } static public int indexOf_regexp(String s, String pat) { Matcher m = compileRegexp(pat).matcher(s); return m.find() ? m.start() : -1; } static public String dropPrefix(String prefix, String s) { return s == null ? null : s.startsWith(prefix) ? s.substring(l(prefix)) : s; } static public String formatWithThousands(long l) { return formatWithThousandsSeparator(l); } static public double fraction(double d) { return d % 1; } static public String n_fancy2(long l, String singular, String plural) { return formatWithThousandsSeparator(l) + " " + trim(l == 1 ? singular : plural); } static public String n_fancy2(Collection l, String singular, String plural) { return n_fancy2(l(l), singular, plural); } static public String n_fancy2(Map m, String singular, String plural) { return n_fancy2(l(m), singular, plural); } static public String n_fancy2(Object[] a, String singular, String plural) { return n_fancy2(l(a), singular, plural); } static public String n_fancy2(MultiSet ms, String singular, String plural) { return n_fancy2(l(ms), singular, plural); } static public List toLinesFullTrim(String s) { List l = new ArrayList(); for (String line : toLines(s)) if (nempty(line = trim(line))) l.add(line); return l; } static public List toLinesFullTrim(File f) { List l = new ArrayList(); for (String line : linesFromFile(f)) if (nempty(line = trim(line))) l.add(line); return l; } static public 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; } } static public boolean isSpace(char c) { return " \t\r\n".indexOf(c) >= 0; } static public boolean endsWithNewLine(String s) { return endsWith(s, "\n"); } static public Map compileRegexp_cache = syncMRUCache(10); static public 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; } static public String formatWithThousandsSeparator(long l) { return NumberFormat.getInstance(new Locale("en_US")).format(l); } static public LinkedHashMap asLinkedHashMap(Map map) { if (map instanceof LinkedHashMap) return (LinkedHashMap) map; LinkedHashMap m = new LinkedHashMap(); if (map != null) synchronized (collectionMutex(map)) { m.putAll(map); } return m; } static public Map syncMRUCache(int size) { return synchroMap(new MRUCache(size)); } static abstract public class F2 { abstract public C get(A a, B b); } }