Warning: session_start(): open(/var/lib/php/sessions/sess_61s7c2a5ha07k1fbflq94mcjvk, O_RDWR) failed: No space left on device (28) in /var/www/tb-usercake/models/config.php on line 51
Warning: session_start(): Failed to read session data: files (path: /var/lib/php/sessions) in /var/www/tb-usercake/models/config.php on line 51
!1006722
// ifdef in cached includes? => i think cached includes still contain the ifdefs, so it's fine. tok_ifdef is not called within localStuff1
set flag noAI.
set flag isQuoted_dirty. // should be OK, we're dealing with tokens
static bool autoQuine = true;
static int maxQuineLength = 80;
sbool assumeTriple = true;
// _registerThread usually costs nothing because we need
// the registerWeakHashMap mechanism anyway for ping().
// Anyway - no forced functions for now :)
static L functionsToAlwaysInclude = ll(
//"_registerThread",
//"asRuntimeException"
);
// classes with two type parameters that can written with just one
// e.g. Pair => Pair
static Set pairClasses = lithashset("Pair", "Either", "Map", "AbstractMap", "HashMap", "TreeMap", "LinkedHashMap", "MultiMap", "CompactHashMap", "WrappedMap", "F1");
!include #1001496 // Matches
!include #1000882 // EGDiff
!include #1000883 // BlockDiffer
!include #1001065 // DialoGIO
!include #1004045 // IndexedList2
//include #1001296 // MultiMap
!include #1000988 // MultiSet
!include #1004543 // DynamicObject
!include #1005575 // CompilerBot
!include #1002662 // isTrue
!include #1010581 // unquote
sS transpilingSnippetID;
static int varCount;
static new Map snippetCache;
static bool useIndexedList = true, opt_javaTok = true;
static bool cacheStdFunctions = true, cacheStdClasses = true;
static new HashMap cachedIncludes;
static ExecutorService executor;
static L lclasses;
static long startTime, lastPrint;
// These variables have to be cleared manually for each transpilation
static new HashSet included;
static Set definitions = ciSet();
static new HashMap rewrites;
static new HashSet shouldNotIncludeFunction, shouldNotIncludeClass;
static new HashSet doNotIncludeFunction;
static new HashSet addedFunctions;
static new HashSet addedClasses;
static new HashSet hardFunctionReferences;
static new HashSet mapLikeFunctions;
static new HashSet mapMethodLikeFunctions;
sbool quickmainDone1, quickmainDone2;
static new TreeSet libs;
sS mainBaseClass, mainPackage, mainClassName;
sbool localStuffOnly; // for transpiling a fragment
sclass CachedInclude {
S javax;
Future java;
S realJava;
S java() {
ret realJava != null ? realJava : getFuture(java);
}
Future javaFuture() {
ret realJava != null ? nowFuture(realJava) : java;
}
void clean {
if (java != null) {
realJava = getFuture(java);
java = null;
}
}
}
p {
startTime = lastPrint = sysNow();
pcall { vmKeepWithProgramMD5_get('cachedIncludes); }
executor = Executors.newFixedThreadPool(numberOfCores());
transpilingSnippetID = or(getThreadLocal((ThreadLocal) getOpt(javax(), 'transpilingSnippetID)), transpilingSnippetID);
print(+transpilingSnippetID);
O oldPrint = interceptPrintInThisThread(new F1() {
Bool get(S s) {
long now = sysNow();
long time = now-lastPrint; // -startTime;
lastPrint = now;
print_raw("[" + formatInt(time/1000, 2) + ":" + formatInt(time % 1000, 3) + "] " + s);
false;
}
});
try {
_main();
} finally {
interceptPrintInThisThread(oldPrint);
executor.shutdown();
executor = null;
localStuffOnly = false;
}
}
svoid _main() ctex {
//reTok_modify_check = true;
if (useIndexedList) findCodeTokens_debug = true;
javaTok_opt = opt_javaTok;
findCodeTokens_indexed = findCodeTokens_unindexed = 0;
findCodeTokens_bails = findCodeTokens_nonbails = 0;
javaTok_n = javaTok_elements = 0;
S in = loadMainJava();
print("759 STARTING " + identityHashCode(main.class));
included.clear();
definitions.clear();
rewrites.clear();
definitions.add("SymbolAsString");
shouldNotIncludeFunction.clear();
shouldNotIncludeClass.clear();
doNotIncludeFunction.clear();
addedFunctions.clear();
addedClasses.clear();
hardFunctionReferences.clear();
mapLikeFunctions = cloneHashSet(tok_mapLikeFunctions());
mapMethodLikeFunctions = cloneHashSet(tok_mapMethodLikeFunctions());
libs.clear();
mainBaseClass = mainPackage = mainClassName = null;
varCount = 0;
quickmainDone1 = quickmainDone2 = false;
//L ts = findTranslators(toLines(join(tok)));
//print("Translators in source at start: " + structure(ts));
// "duplicate" statement - unused
/*L lines = toLines(in);
call(getJavaX(), "findTranslators", lines);
in = fromLines(lines);
new Matches m;
if (match("duplicate *", in, m)) {
// actual copying - unused
// tok = jtok(loadSnippet(m.get(0)));
// reference by include()
in = "m { p { callMain(include(" + quote(m.get(0)) + ")); } }";
}*/
L tok = jtok(in);
tok_definitions(tok);
// add m { }
if (!localStuffOnly && !hasCodeTokens(tok, "m", "{") && !hasCodeTokens(tok, "main", "{") && !hasCodeTokens(tok, "class", "main")) {
//tok = jtok(moveImportsUp("m {\n" + in + "\n}"));
replaceTokens_reTok(tok, 1, 2, "m {\n\n" + tok.get(1));
replaceTokens_reTok(tok, l(tok)-2, l(tok)-1, tok.get(l(tok)-2) + "}");
tok_moveImportsUp(tok);
}
// standard translate
//ts = findTranslators(toLines(join(tok)));
//print("Translators in source: " + structure(ts));
if (tok_hasTranslators(tok))
tok = jtok(defaultTranslate(join(tok)));
//print("end of default translate");
//print(join(tok));
//tok_autoCloseBrackets(tok);
tok = tok_processIncludes(tok); // before standard functions
if (processConceptsDot(tok))
tok = tok_processIncludes(tok);
tok = localStuff1(tok);
if (!localStuffOnly) {
int safety = 0;
boolean same;
do {
S before = join(tok);
// XXX tok = localStuff1(tok);
// shortened method declarations BEFORE standardFunctions
jreplace(tok, "svoid", "static void");
jreplace(tok, "void {", "$1 $2() {");
jreplace(tok, "String {", "$1 $2() {");
jreplace(tok, "Object {", "$1 $2() {");
jreplace(tok, "List {", "$1 $2() {");
// do the non-local stuff (flags and rewrites)
tok_mainClassNameAndPackage(tok);
tok_definitions(tok);
tok_ifndef(tok);
tok_ifdef(tok);
defineMapLikes(tok);
if (tok_applyMapLikeFunctions(tok, mapLikeFunctions))
functionReferences(tok);
defineMapMethodLikes(tok);
tok_applyMapMethodLikeFunctions(tok, mapMethodLikeFunctions);
tok_replaceWith(tok);
tok_findRewrites(tok);
tok_processRewrites(tok);
try {
if (safety == 0) tok = quickmain(tok);
} catch e {
printSources(tok);
rethrow(e);
}
// Hack to allow DynModule to reimplement _registerThread
/*if (tok.contains("DynModule") && !addedClasses.contains("DynModule"))
addStandardClasses_v2(tok);*/
tok = standardFunctions(tok);
tok = stdstuff(tok); // all the keywords, standard
S diff;
long startTime = now();
//diff = unidiff(before, join(tok));
//print("unidiff: " + (now()-startTime) + " ms");
//same = eq(diff, "");
same = tok_sameTest(tok, before);
if (!same) {
print("Not same " + safety + ".");
//print(indent(2, diff));
}
if (safety++ >= 10) {
//print(unidiff(before, join(tok)));
printSources(tok);
fail("safety 10 error!");
}
} while (!same);
print("Post.");
if (mainBaseClass != null) {
jreplace1(tok, "class main", "class main extends " + mainBaseClass);
mainBaseClass = null;
}
print('moveImportsUp); tok_moveImportsUp(tok);
print('Indexing); tok = indexedList2(tok);
// POST-PROCESSING after stdstuff loop
if (transpilingSnippetID != null)
jreplace_dyn(tok, "class whatever",
func(L tok, int cIndex) -> S {
pcall { ret "class " + stringToLegalIdentifier(getSnippetTitle(transpilingSnippetID)); }
ret "class Whatever";
});
//print("Type"); // Type to Type
print('extendClasses); tok = extendClasses(tok);
print('libs); libs(tok);
print('sourceCodeLine); sourceCodeLine(tok);
// escaping for lambdas
//jreplace(tok, "-=>", "->");
// Stuff that depends on the list of inner classes (haveClasses)
HashSet haveClasses = haveClasses_actual(tok);
print('innerClassesVar); innerClassesVar(tok, haveClasses);
fillVar_transpilationDate(tok);
haveClasses_addImported(tok, haveClasses);
print('ifclass); tok_ifclass(tok, haveClasses);
print('slashCasts); slashCasts(tok, haveClasses);
print('newWithoutNew); newWithoutNew(tok, haveClasses);
if (!assumeTriple) {
print('Triple);
if (tok.contains("Triple") && !haveClasses.contains("Triple")) {
jreplace(tok, "Triple", "T3");
haveClasses.remove("Triple");
haveClasses.add("T3");
slashCasts(tok, lithashset("T3"));
tok_quickInstanceOf(tok, lithashset("T3"));
}
expandTriple(tok);
}
if (hasDef("SymbolAsString"))
jreplace(tok, "Symbol", "String");
print('classReferences); expandClassReferences_lazy(tok, haveClasses);
// Error-checking
print("Error-checking");
Set functions = new HashSet(findFunctions(tok));
for (S f : hardFunctionReferences)
if (!functions.contains(f))
fail("Function " + f + " requested, but not supplied");
print('autoImports); tok = autoImports(tok); // faster to do it at the end
print("definitions=" + sfu(definitions));
if (containsOneOfIC(definitions, "allpublic", "reparse")) {
bool dontPrintSource = false;
// Fire up the Java parser & pretty printer!
print(containsIC(definitions, "allpublic")? "Making all public." : "Reparsing.");
try {
S src = join(tok);
try {
if (containsIC(definitions, "keepComments"))
src = javaParser_makeAllPublic_keepComments(src);
else if (containsIC(definitions, "allpublic"))
src = javaParser_makeAllPublic(src);
else
src = javaParser_reparse_keepComments(src);
} catch e {
extractAndPrintJavaParseError(src, e);
dontPrintSource = true;
throw e;
}
tok = jtok(src);
} catch e {
S src = join(tok);
if (!dontPrintSource)
print(src);
print(f2s(saveProgramTextFile("error.java", src)));
throw rethrow(e);
}
}
// Do this after JavaParser (because it doesn't like package after class)
if (mainPackage != null) {
print('mainPackage);
tokPrepend(tok, 1, "package " + mainPackage + ";\n");
reTok(tok, 1, 2);
}
if (mainClassName != null) {
print('mainClassName);
jreplace(tok, "class main", "class " + mainClassName);
jreplace(tok, "main.class", mainClassName + ".class");
//tokPrepend(tok, 1, "class main {}\n"); // so main.class is generated and compiler sanity checks succeed. we can later skip it in the JavaXClassLoader
}
if (nempty(libs))
for (S lib : libs)
tok.add(concatMap_strings(func(S s) -> S { "\n!" + s }, libs));
} // if (!localStuffOnly)
/*if (useIndexedList)
print("Indexed/unindexed lookups: " + findCodeTokens_indexed + "/" + findCodeTokens_unindexed + ", lists made: " + IndexedList2.instances);
print("findCodeToken bails: " + findCodeTokens_bails + "/" + findCodeTokens_nonbails);
print("javaToks: " + javaTok_n + "/" + javaTok_elements);*/
print("Saving.");
// for dexcompile.php
if (mainClassName != null)
tokPrepend(tok, 0, "//FILENAME: "
+ (mainPackage != null ? mainPackage.replace(".", "/") + "/" : "") + mainClassName + ".java\n");
if (mainJava != null)
mainJava = join(tok);
else if (tok.contains("package"))
splitJavaFiles(tok);
else
saveMainJava(tok);
}
static L localStuff1(L tok) {
int safety = 0, i;
boolean same;
tok = indexedList2(tok);
do {
S before = join(tok);
earlyStuff(tok);
conceptDeclarations(tok);
tok_recordDecls(tok);
tok = multilineStrings(tok);
tok_singleQuoteIdentifiersToStringConstants(tok);
inStringEvals(tok);
tok_listComprehensions(tok);
tok_doubleFor_v2(tok);
tok_ifCast(tok);
forPing(tok);
directSnippetRefs(tok);
quicknu(tok);
//tok_juxtaposeCalls(tok);
expandVarCopies(tok);
jreplace(tok, "LS", "L");
jreplace(tok, "do ping {", "do { ping();");
replaceKeywordBlock(tok,
"swing",
"{ swing(r {",
"}); }");
replaceKeywordBlock(tok, "afterwards", "temp tempAfterwards(r {", "});");
replaceKeywordBlock(tok,
"tokcondition",
"new TokCondition { bool get(final L tok, final int i) {",
"}}");
jreplace(tok, "synced ", "synchronized $2");
replaceKeywordBlock(tok, "answer",
"static S answer(S s) {\nfinal new Matches m;\n",
"\nret null;\n}");
replaceKeywordBlock(tok, "static-pcall",
"static { pcall {",
"}}");
replaceKeywordBlock(tok, "loading",
"{ JWindow _loading_window = showLoadingAnimation(); try {",
"} finally { disposeWindow(_loading_window); }}");
replaceKeywordPlusQuotedBlock(tok, "loading",
new O { S[] get(L tok, int i) {
S text = tok.get(i+2);
ret new S[] {
"{ JWindow _loading_window = showLoadingAnimation(" + text + "); try {",
"} finally { disposeWindow(_loading_window); }}" };
}});
jreplace(tok, "visualize {", "JComponent visualize() {", tokCondition_beginningOfMethodDeclaration());
jreplace(tok, "visualize2 {", "JComponent visualize2() {", tokCondition_beginningOfMethodDeclaration());
jreplace(tok, "start {", "void start() { super.start();", tokCondition_beginningOfMethodDeclaration());
replaceKeywordBlock(tok, "html",
"static O html(S uri, fMap params) ctex " + "{\n", "}");
replaceKeywordBlock(tok, "afterVisualize",
"visualize { JComponent _c = super.visualize();",
"ret _c; }");
replaceKeywordBlock(tok, "enhanceFrame",
"void enhanceFrame(Container f) { super.enhanceFrame(f);",
"}");
if (assumeTriple) {
jreplace(tok, "Triple", "T3");
expandTriple(tok);
}
tok_shortFinals(tok);
tok_moduleClassDecls(tok);
jreplace(tok, "static sync", "static synchronized");
jreplace(tok, "sclass", "static class");
jreplace(tok, "srecord", "static record");
jreplace(tok, "record noeq", "noeq record");
jreplace(tok, "asclass", "abstract static class");
jreplace(tok, "sinterface", "static interface");
jreplace(tok, "ssynchronized", "static synchronized");
jreplace(tok, "ssvoid", "static synchronized void");
jreplace(tok, "sbool", "static bool");
jreplace(tok, "sint", "static int");
jreplace(tok, "snew", "static new");
jreplace(tok, "sv ", "static void $2");
jreplace(tok, "pvoid", "public void");
// "sS" => static S
jreplace(tok, "sS", "static S");
// "sO" => static O
jreplace(tok, "sO", "static O");
// "sL" => static L
jreplace(tok, "sL", "static L");
// "toString {" => "public S toString() {"
jreplace(tok, "toString {", "public S toString() {");
jreplace(tok, "Int", "Integer");
jreplace(tok, "Bool", "Boolean");
jreplace(tok, "BigInt", "BigInteger");
jreplace(tok, "Char", "Character");
jreplace(tok, "Sym", "Symbol");
jreplace(tok, "SymSym", "SymbolSymbol");
jreplace(tok, "SS", "Map");
jreplace(tok, "SymbolSymbol", "Map");
jreplace(tok, "PairS", "Pair");
jreplace(tok, "LPairS", "L>");
jreplace(tok, "ItIt", "IterableIterator");
jreplace(tok, "class > {", "class $2 extends $4 {");
jreplace(tok, "class > <> {", "class $2 extends $4 $5 $6 $7 {");
// "on fail {" => "catch (Throwable _e) { ... rethrow(_e); }"
replaceKeywordBlock(tok, "on fail",
"catch (Throwable _e) {",
"\nthrow rethrow(_e); }");
// "catch {" => "catch (Throwable _e) {"
jreplace(tok, "catch {", "catch (Throwable _e) {");
// "catch print e {" => "catch e { _handleException(e); "
jreplace(tok, "catch print {", "catch $3 { _handleException($3);");
// "catch print short e {" => "catch e { printExceptionShort(e); "
jreplace(tok, "catch print short {", "catch $4 { printExceptionShort($4);");
// "catch X e {" => "catch (X e) {"
jreplace(tok, "catch {", "catch ($2 $3) {");
// "catch e {" => "catch (Throwable e) {" (if e is lowercase)
jreplace(tok, "catch {", "catch (Throwable $2) {", tokcondition {
S word = tok.get(i+3);
ret startsWithLowerCaseOrUnderscore(word);
});
jreplace(tok, "+ +", "+", tokcondition {
//printStructure("++: ", subList(tok, i-1, i+6));
if (empty(_get(tok, i+2))) ret false; // no space between the pluses
if (empty(_get(tok, i)) && eq("+", _get(tok, i-1))) ret false; // an actual "++" at the left
if (empty(_get(tok, i+4)) && eq("+", _get(tok, i+5))) ret false; // an actual "++" at the right
//print("doing it");
ret true;
});
// some crazy fancy syntax
jreplace(tok, "set ;", "$2 = true;");
// [stdEq] -> implementation of equals() and hashCode()
jreplace(tok, "[stdEq]",
"public bool equals(O o) { ret stdEq2(this, o); }\n" +
"public int hashCode() { ret stdHash2(this); }");
// [concepts] "concept.field!" for dereferencing references
jreplace(tok, "*!", "$1.get()", tokcondition {
S l = tok.get(i+1);
if (!(isIdentifier(l) || eq(l, ")"))) false;
if (tok.get(i+2).contains("\n")) false; // no line break between and !
if (nempty(tok.get(i+4))) true; // space after = ok
S t = _get(tok, i+5);
if (t == null) ret false;
if (isIdentifier(t) || eqOneOf(t, "=", "(")) false;
true;
});
// [concepts] "field := value" for defining fields e.g. in "uniq"
while ((i = jfind(tok, " :=")) >= 0) {
tok.set(i, quote(tok.get(i)));
tok.set(i+2, ",");
tok.set(i+4, "");
reTok(tok, i, i+5);
}
// "quoted" := value
while ((i = jfind(tok, " :=")) >= 0) {
tok.set(i, tok.get(i));
tok.set(i+2, ",");
tok.set(i+4, "");
reTok(tok, i, i+5);
}
jreplace(tok, "for ( )", "for ($3 $4 : list($3))");
jreplace(tok, "for (final )", "for (final $4 $5 : list($4))");
// "continue unless"
while ((i = jfind(tok, "continue unless")) >= 0) {
int j = scanOverExpression(tok, getBracketMap(tok), i+4, ";");
replaceTokens(tok, i, i+4, "{ if (!(");
tok.set(j, ")) continue; }");
reTok(tok, i, j+1);
}
// "continue if"
while ((i = jfind(tok, "continue if")) >= 0) {
int j = scanOverExpression(tok, getBracketMap(tok), i+4, ";");
replaceTokens(tok, i, i+4, "{ if (");
tok.set(j, ") continue; }");
reTok(tok, i, j+1);
}
// "return if"
while ((i = jfind(tok, "return if")) >= 0) {
int j = scanOverExpression(tok, getBracketMap(tok), i+4, ";");
replaceTokens(tok, i, i+4, "{ if (");
tok.set(j, ") return; }");
reTok(tok, i, j+1);
}
// "return unless"
while ((i = jfind(tok, "return unless")) >= 0) {
int j = scanOverExpression(tok, getBracketMap(tok), i+4, ";");
replaceTokens(tok, i, i+4, "{ if (!(");
tok.set(j, ")) return; }");
reTok(tok, i, j+1);
}
// "return with " / "continue with " / "break with "
while ((i = jfind(tok, " with", tokcondition { ret eqOneOf(tok.get(i+1), "return", "continue", "break"); })) >= 0) {
int j = scanOverExpression(tok, getBracketMap(tok), i+4, ";");
tok.set(j, "; " + tok.get(i) + "; }");
replaceTokens(tok, i, i+3, "{");
reTok(tok, i, j+1);
}
// return "bla" with
while ((i = jfindOneOf(tok,
"return with", "return with")) >= 0) {
S result = tok.get(i+2);
int j = scanOverExpression(tok, getBracketMap(tok), i+6, ";");
replaceTokens(tok, i, i+5, "{");
tok.set(j, "; return " + result + "; }");
reTok(tok, i, j+1);
}
// while not null ()
while ((i = jfind(tok, "while not null (")) >= 0) {
int closingBracket = findEndOfBracketPart(tok, i+6)-1;
replaceTokens(tok, i+2, i+6, "(");
tok.set(closingBracket, ") != null)");
reTok(tok, i, closingBracket+1);
}
// Replace $1 with m.unq(0) etc. - caveat: this blocks identifiers $1, $2, ...
for (i = 1; i < l(tok); i += 2) {
S s = tok.get(i);
if (s.startsWith("$")) {
s = substring(s, 1);
if (isInteger(s)) {
tok.set(i, "m.unq(" + (parseInt(s)-1) + ")");
reTok(tok, i);
}
}
}
// instanceof trickery
jreplace(tok, "is a ", "instanceof $3");
jreplace(tok, "! instanceof .", "!($2 instanceof $4.$6)");
jreplace(tok, "! instanceof ", "!($2 instanceof $4)");
jreplace(tok, " !instanceof ", "!($1 instanceof $4)");
// map func1 func2 func3(...) => mapFGH(f func1, f func2, f func3, ...)
jreplace(tok, "map (", "mapFGH(f $2, f $3, f $4,");
// map func1 func2(...) => mapFG(f func1, f func2, ...)
jreplace(tok, "map (", "mapFG(f $2, f $3,");
// "ref->bla" for dereferencing Concept.Ref or ThreadLocal or other
// For lambdas, use SPACES on the left or right of the arrow!
//jreplace(tok, " ->", "$1.get().");
jreplace(tok, "->", ".get().", tokcondition {
ret empty(tok.get(i)) // no space on left of arrow
&& empty(tok.get(i+2)) // no space inside of arrow
&& empty(tok.get(i+4)) // no space on right of arrow
&& !eq(_get(tok, i-1), "-"); // i-->0;
});
// shortened subconcept declaration (before star constructors!)
shortenedSubconcepts(tok);
// "case" as a variable name ( => _case)
caseAsVariableName(tok);
// "do" as a function name ( => dO)
tok_doAsMethodName(tok);
// "continue" as a function name ( => _continue)
continueAsFunctionName(tok);
tok_extend(tok);
jreplace(tok, "pn {", "p-noconsole {");
// Do these BEFORE awt replacement! ("p-awt" contains "awt" token)
replaceKeywordBlock(tok, "r-awt", "r { awt {", "}}");
if (hasCodeTokens(tok, "p", "-")) tok_p_old(tok);
replaceKeywordBlock(tok, "awt-messagebox", "awt { pcall-messagebox {", "}}");
replaceKeywordBlock(tok, "awt", "swingLater(r {", "});");
unswing(tok);
lockBlocks(tok);
tempBlocks(tok);
tok_switchTo(tok);
// trim x;
jreplace(tok, "trim ;", "$2 = trim($2);");
// crazy stuff
jreplace (tok, "for over :", "for (int $2 = 0; $2 < l($4); $2++)");
jreplace (tok, "for , over : {", "for (int $2 = 0; $2 < l($7); $2++) { $4 $5 = $7.get($2);");
jreplace (tok, "for to :", "for (int $2 = 0; $2 < $4; $2++)");
jreplace (tok, "for to :", "for (int $2 = 0; $2 < $4; $2++)");
tok = expandShortTypes(tok);
if (containsToken(tok, "cast")) {
// TODO: use tokens
S s = join(tok);
s = s.replaceAll("(\\w+<[\\w\\s,\\[\\]]+>|\\w+|\\w+\\[\\]|\\w+\\[\\]\\[\\])\\s+(\\w+)\\s*=\\s*cast(\\W[^;]*);", "$1 $2 = ($1) ($3);");
tok = jtok(s);
}
replaceKeywordBlock(tok, "r-thread-messagebox", "r-thread { pcall-messagebox {", "}}");
replaceKeywordBlock(tok, "thread-messagebox", "thread { pcall-messagebox {", "}}");
jreplace(tok, "rThread {", "r-thread {");
replaceKeywordBlock(tok, "r-thread", "runnableThread(r {", "})");
rNamedThread(tok);
// only works in the scope of a DynModule
jreplace(tok, "rEnter {", "r { temp enter(); ");
replaceKeywordBlock(tok, "r-messagebox", "r { pcall-messagebox {", "}}");
// runnable and r - now also with automatic toString if enabled
for (S keyword : ll("runnable", "r")) {
while ((i = jfind(tok, keyword + " {")) >= 0) {
int idx = findCodeTokens(tok, i, false, "{");
int j = findEndOfBracketPart(tok, idx);
L contents = subList(tok, idx+1, j-1);
replaceTokens(tok, i, j+1, "new Runnable {"
+ " public void run() ctex { " + tok_addSemicolon(contents) + "\n}"
+ (autoQuine ? tok_autoQuineFunc(contents) : "")
+ "}");
reTok(tok, i, j+1);
}
while ((i = jfind(tok, keyword + " {")) >= 0) {
int idx = findCodeTokens(tok, i, false, "{");
int j = findEndOfBracketPart(tok, idx);
L contents = subList(tok, idx+1, j-1);
replaceTokens(tok, i, j+1, "new Runnable {"
+ " public void run() ctex { " + tok_addSemicolon(contents) + "\n}"
+ " toString { ret " + tok.get(i+2) + "; }"
+ (autoQuine ? tok_autoQuineFunc(contents, '_shortenedSourceCode) : "")
+ "}");
reTok(tok, i, j+1);
}
}
replaceKeywordBlock(tok,
"expectException",
"{ bool __ok = false; try {",
"} catch { __ok = true; } assertTrue(\"expected exception\", __ok); }");
while ((i = tok.indexOf("tex")) >= 0) {
tok.set(i, "throws Exception");
tok = jtok(tok);
}
// shorter & smarter whiles
jreplace(tok, "while true", "while (true)");
jreplace(tok, "while licensed", "while (licensed())");
jreplace(tok, "repeat {", "while (licensed()) {");
tok_repeatWithSleep(tok);
// null; => return null; etc.
O cond = tokcondition {
ret tok_tokenBeforeLonelyReturnValue(tok, i-1);
};
jreplace(tok, "null;", "return null;", cond);
jreplace(tok, "false;", "return false;", cond);
jreplace(tok, "true;", "return true;", cond);
jreplace(tok, "this;", "return this;", cond);
// ok => ret "OK" with
jreplace(tok, "ok ", "return \"OK\" with $2");
replaceKeywordBlock(tok, "ok", "{", " return \"OK\"; }");
// "myFunction;" instead of "myFunction();" - quite rough
// (isolated identifier as function call)
cond = new TokCondition {
bool get(L tok, int i) {
S word = tok.get(i+3);
//print("single word: " + word);
ret !eqOneOf(word, "break", "continue", "return", "else", "endifdef", "endif");
}
};
for (S pre : litlist("}", ";"))
jreplace(tok, pre + " ;", "$1 $2();", cond);
// shorter match syntax for answer methods
jreplace(tok, "if || ",
"if (matchOneOf(s, m, $2, $5))");
// "...bla..."
jreplace(tok, "if ", "if (find3plusRestsX($2, s, m))",
tokcondition {
ret startsAndEndsWith(unquote(tok.get(i+3)), "...");
});
// "bla..."
jreplace(tok, "if ", "if (matchStartX($2, s, m))",
tokcondition {
ret unquote(tok.get(i+3)).endsWith("...");
});
// "bla * bla | blubb * blubb"
jreplace_dyn(tok, "if ", func(L tok, int cIdx) -> S {
S s = unquote(tok.get(cIdx+2));
//print("multimatch: " + quote(s));
new L l;
for (S pat : splitAtJavaToken(s, "|")) {
//print("multimatch part: " + quote(pat));
if (javaTok(pat).contains("*"))
l.add("match(" + quote(trim(pat)) + ", s, m)");
else
l.add("match(" + quote(trim(pat)) + ", s)");
}
ret "if (" + join(" || ", l) + ")";
}, tokcondition {
ret javaTokC(unquote(tok.get(i+3))).contains("|");
});
// "bla"
jreplace(tok, "if ", "if (match($2, s))",
tokcondition {
ret !javaTokC(unquote(tok.get(i+3))).contains("*");
});
// "bla * bla"
jreplace(tok, "if ", "if (match($2, s, m))");
jreplace(tok, "if match ", "if (match($3, s, m))");
// extra commas ("litlist(1, 2,)")
jreplace(tok, ",)", ")");
// additional translations (if necessary)
jreplace(tok, "pcall ping {", "pcall { ping();");
replaceKeywordBlock(tok, ") pcall",
") { pcall {",
"}}");
replaceKeywordBlock(tok,
"pcall",
"try {",
"} catch (Throwable __e) { _handleException(__e); }");
replaceKeywordBlock(tok,
"pcall-short",
"try {",
"} catch (Throwable __e) { print(exceptionToStringShort(__e)); }");
replaceKeywordBlock(tok,
"pcall-silent",
"try {",
"} catch (Throwable __e) { silentException(__e); }");
replaceKeywordBlock(tok,
"pcall-messagebox",
"try {",
"} catch __e { messageBox(__e); }");
replaceKeywordBlock(tok,
"pcall-infobox",
"try {",
"} catch __e { infoBox(__e); }");
tok = dialogHandler(tok);
replaceKeywordBlock(tok, "exceptionToUser",
"try {",
"} catch (Throwable __e) { ret exceptionToUser(__e); }");
if (hasCodeTokens(tok, "twice", "{"))
replaceKeywordBlock(tok, "twice",
"for (int __twice = 0; __twice < 2; __twice++) {",
"}");
while ((i = findCodeTokens(tok, "repeat", "*", "{")) >= 0) {
S v = makeVar("repeat");
tok.set(i, "for (int " + v + " = 0; " + v + " < " + tok.get(i+2) + "; " + v + "++)");
tok.set(i+2, "");
reTok(tok, i, i+3);
}
while ((i = findCodeTokens(tok, "bench", "*", "{")) >= 0) {
int j = findEndOfBracketPart(tok, i+4)-1;
S time = makeVar("time");
S v = makeVar("bench");
S n = tok.get(i+2);
tok.set(i, "{ long " + time + " = sysNow(); for (int " + v + " = 0; " + v + " < " + n + "; " + v + "++)");
tok.set(i+2, "");
tok.set(j, "} printBenchResult(sysNow()-" + time + ", " + n + "); }");
reTok(tok, i, j+1);
}
replaceKeywordBlockDyn(tok,
"time",
new O { S[] get() {
S var = makeVar("startTime");
ret new S[] {
"{ long " + var + " = sysNow(); try { ",
"} finally { " + var + " = sysNow()-" + var + "; saveTiming(" + var + "); } }"};
}});
// version without { }
replaceKeywordBlockDyn(tok,
"time2",
new O { S[] get() {
S var = makeVar("startTime");
ret new S[] {
"long " + var + " = sysNow(); ",
" " + var + " = sysNow()-" + var + "; saveTiming(" + var + "); "};
}});
// time "bla" {
replaceKeywordPlusQuotedBlock(tok,
"time",
new O { S[] get(L tok, int i) {
S var = makeVar("startTime");
ret new S[] {
"long " + var + " = sysNow(); ",
" done2_always(" + tok.get(i+2) + ", " + var + "); "};
}});
if (hasCodeTokens(tok, "assertFail", "{")) {
S var = makeVar("oops");
replaceKeywordBlock(tok,
"assertFail",
"boolean " + var + " = false; try {",
"\n" + var + " = true; } catch (Exception e) { /* ok */ } assertFalse(" + var + ");");
}
replaceKeywordBlock(tok,
"yo",
"try {",
"} catch (Exception " + makeVar("e") + ") { ret false; }",
tokcondition {
ret neqOneOf(_get(tok, i-1), "svoid", "void");
});
replaceKeywordBlock(tok,
"awtIfNecessary",
"swingNowOrLater(r " + "{",
"});");
ctex(tok);
replaceKeywordBlock(tok,
"actionListener",
"new java.awt.event.ActionListener() { " +
"public void actionPerformed(java.awt.event.ActionEvent _evt) { pcall-messagebox {",
"}}}");
for (S keyword : ll("autocloseable", "autoCloseable"))
/*replaceKeywordBlock(tok,
keyword,
"new AutoCloseable() { public void close() throws Exception {",
"}}");*/
replaceKeywordBlock_dyn2_legacy(tok, keyword, new O {
S[] get(LS tok, int iOpening, int iClosing) {
LS contents = subList(tok, iOpening+1, iClosing);
ret new S[] {
"new AutoCloseable() { toString { ret " + quote(shorten(maxQuineLength, trimJoin(contents))) + "; } public void close() throws Exception {",
"}}"
};
}
});
namedThreads(tok);
threads(tok);
// try answer (string, test with nempty)
while ((i = findCodeTokens(tok, "try", "answer")) >= 0) {
int j = findEndOfStatement(tok, i);
S v = makeVar("a");
tok.set(i, "{ S " + v);
tok.set(i+2, "=");
tok.set(j-1, "; if (!empty(" + v + ")) ret " + v + "; }");
reTok(tok, i, j);
}
// try bool[ean] (try answer with Bool type)
while ((i = findCodeTokens(tok, "try", "boolean")) >= 0) {
int j = findEndOfStatement(tok, i);
S v = makeVar("a");
tok.set(i, "{ Bool " + v);
tok.set(i+2, "=");
tok.set(j-1, "; if (" + v + " != null) ret " + v + "; }");
reTok(tok, i, j);
}
// return optional (return if not null)
while ((i = jfind(tok, "return optional =")) >= 0) {
int j = findEndOfStatement(tok, i);
S v = tok.get(i+4);
clearTokens(tok, i+2, i+4);
tok.set(i, "{");
tok.set(j-1, "; if (" + v + " != null) ret " + v + "; }");
reTok(tok, i, j);
}
// try object (return if not null)
while ((i = jfind(tok, "try object")) >= 0) {
int j = findEndOfStatement(tok, i);
clearTokens(tok, i, i+3);
bool isDecl = isIdentifier(get(tok, i+4)) && isIdentifier(get(tok, i+6)) && eqGet(tok, i+8, "=");
if (isDecl) {
S v = get(tok, i+6);
tok.set(i, "{");
tok.set(j-1, "; if (" + v + " != null) ret " + v + "; }");
} else {
S v = makeVar();
tok.set(i, "{ O " + v + "=");
tok.set(j-1, "; if (" + v + " != null) ret " + v + "; }");
}
reTok(tok, i, j);
}
// debug print ...; => if (debug) print(...);
while ((i = jfind(tok, "debug print")) >= 0) {
int j = findEndOfStatement(tok, i);
replaceTokens(tok, i, i+4, "if (debug) print(");
tok.set(j-1, ");");
reTok(tok, i, j);
}
functionReferences(tok);
tok_expandLPair(tok);
quicknew2(tok);
tok_unpair(tok);
tok_cachedFunctions(tok);
throwFailEtc(tok);
tok_typeAA(tok, pairClasses);
// do this after expanding sclass etc.
tok = expandStarConstructors(tok);
tok_kiloConstants(tok);
// end of localStuff1
same = tok_sameTest(tok, before);
/*if (!same)
print("local not same " + safety + " (" + l(tok) + " tokens)");*/
if (safety++ >= 10) {
printSources(tok);
fail("safety 10 error!");
}
} while (!same);
ret tok;
}
static L reTok_include(L tok, int i, int j) {
ret reTok_modify(tok, i, j, f localStuff1);
}
static L includeInMainLoaded_reTok(L tok, int i, int j) {
ret reTok_include(tok, i, j);
}
static L stdstuff(L tok) {
//if (++level >= 10) fail("woot? 10");
print("stdstuff!");
int i;
new L ts;
tok_findTranslators(tok, ts);
if (nempty(ts))
print("DROPPING TRANSLATORS: " + structure(ts));
print('quickmain); tok = quickmain(tok);
print('includes); tok = tok_processIncludes(tok);
print('conceptsDot); if (processConceptsDot(tok))
tok = tok_processIncludes(tok);
//print('starConstructors); tok = expandStarConstructors(tok);
// drop Java 8 annotations since we're compiling for Java 7
jreplace(tok, "@Nullable", "");
// STANDARD CLASSES & INTERFACES
print("standard classes");
final Set haveClasses = addStandardClasses_v2(tok);
tok_quickInstanceOf(tok, haveClasses);
// concept-related stuff
// auto-import concepts
bool _a = tok_hasClassRef2(tok, /*"extends",*/ "Concept") || tok_hasClassRef2(tok, "Concepts"), _b = !haveClasses.contains("Concept");
//print("auto-import: " + _a + ", " + _b);
if (_a && _b) {
print("Auto-including concepts.");
if (shouldNotIncludeClass.contains("Concepts")) {
print(join(tok));
fail("Unwanted concepts import");
}
printStruct(haveClasses);
tok = includeInMainLoaded(tok, "concepts.");
reTok(tok, l(tok)-1, l(tok));
//processConceptsDot(tok);
}
ret tok;
} // end of stdStuff!
static L multilineStrings(L tok) {
for (int i = 1; i < tok.size(); i += 2) {
S t = tok.get(i);
if (isQuoted(t))
if (t.startsWith("[") || t.contains("\r") || t.contains("\n"))
tok.set(i, quote(unquote(t)));
}
ret tok;
}
static void inStringEvals(L tok) {
bool change = false;
for (int i = 1; i < tok.size(); i += 2) {
S t = tok.get(i);
if (!isQuoted(t)) continue;
if (t.contains("\\*") && !t.contains("\\\\")) { // << rough
tok.set(i, inStringEval(t));
change = true;
}
}
if (change) reTok(tok);
}
static S inStringEval(S t) {
t = dropPrefix("\"", dropSuffix("\"", t));
new L l;
int idx;
while ((idx = t.indexOf("\\*")) >= 0) {
int j = indexOf(t, idx, "*/");
if (j < 0) break;
if (idx > 0)
l.add("\"" + substring(t, 0, idx) + "\"");
l.add("(" + trim(substring(t, idx+2, j)) + ")");
t = substring(t, j+2);
}
if (nempty(t))
l.add("\"" + t + "\"");
ret "(" + join(" + ", l) + ")";
}
static L quickmain(L tok) {
if (quickmainDone1 && quickmainDone2) ret tok;
int i = findCodeTokens(tok, "main", "{");
if (i < 0) i = findCodeTokens(tok, "m", "{");
if (i >= 0 && !(i-2 > 0 && tok.get(i-2).equals("class"))) {
tokSet(tok, i, "class main");
quickmainDone1 = true;
}
i = findCodeTokens(tok, "psvm", "{");
if (i < 0) i = findCodeTokens(tok, "p", "{");
if (i >= 0) {
int idx = i+2;
int j = findEndOfBracketPart(tok, idx)-1;
L contents = subList(tok, idx+1, j);
//print("contents: " + sfu(contents));
tok.set(i, "public static void main(final String[] args) throws Exception");
replaceTokens(tok, idx+1, j, tok_addSemicolon(contents));
reTok(tok, i, j);
quickmainDone2 = true;
}
ret tok;
}
static S makeVar(S name) {
ret "_" + name + "_" + varCount++;
}
static S makeVar() { ret makeVar(""); }
/*static L standardFunctions(L tok) {
ret rtq(tok, "#1002474");
}*/
static L rtq(L tok, S id) {
ret runTranslatorQuick(tok, id);
}
static L expandShortTypes(L tok) {
// replace with
for (int i = 1; i+4 < tok.size(); i += 2)
if (tok.get(i).equals("<")
&& litlist(">", ",").contains(tok.get(i+4))) {
String type = tok.get(i+2);
if (type.equals("int")) type = "Integer";
else if (type.equals("long")) type = "Long";
tok.set(i+2, type);
}
// O = Object, S = String, ret = return
for (int i = 1; i < tok.size(); i += 2) {
String t = tok.get(i);
if (t.equals("O")) t = "Object";
if (t.equals("S")) t = "String";
else if (t.equals("L")) t = "List";
//else if (t.equals("F")) t = "Function";
else if (t.equals("ret") && neqOneOf(get(tok, i+2), "=", ")", ".")) t = "return";
else if (t.equals("bool") && i+2 < tok.size() && neq(tok.get(i+2), "(")) t = "boolean"; // bool -> boolean if it's not a function name
tok.set(i, t);
}
jreplace(tok, "LL< >", "L>");
jreplace(tok, "LL", "L>");
jreplace(tok, "LL", "L");
jreplace(tok, "Clusters< >", "Map<$3, Collection<$3>>");
ret tok;
}
static L autoImports(L tok) {
HashSet imports = new HashSet(tok_findImports(tok));
new StringBuilder buf;
for (S c : standardImports)
if (!(imports.contains(c)))
buf.append("import " + c + ";\n");
if (buf.length() == 0) ret tok;
tok.set(0, buf+tok.get(0));
ret reTok(tok, 0, 1);
}
static String[] standardImports = {
"java.util.*",
"java.util.zip.*",
"java.util.List",
"java.util.regex.*",
"java.util.concurrent.*",
"java.util.concurrent.atomic.*",
"java.util.concurrent.locks.*",
"javax.swing.*",
"javax.swing.event.*",
"javax.swing.text.*",
"javax.swing.table.*",
"java.io.*",
"java.net.*",
"java.lang.reflect.*",
"java.lang.ref.*",
"java.lang.management.*",
"java.security.*",
"java.security.spec.*",
"java.awt.*",
"java.awt.event.*",
"java.awt.image.*",
"javax.imageio.*",
"java.math.*"
};
static L expandStarConstructors(L tok) {
mainLoop: for (int i = 3; i+6 < tok.size(); i += 2) {
String t = tok.get(i), l = tok.get(i-2);
if (!t.equals("*"))
continue;
if (!tok.get(i+2).equals("("))
continue;
if (!eqOneOf(l, "}", "public", "private", "protected", ";", "{", "endif") && neq(get(tok, i-4), "ifclass")) // is this correct...??
continue;
// ok, it seems like a constructor declaration.
// Now find class name by going backwards.
int j = i, level = 1;
while (j > 0 && level > 0) {
t = tok.get(j);
if (t.equals("}")) ++level;
if (t.equals("{")) --level;
j -= 2;
}
// search for class name
while (j > 0) {
t = tok.get(j);
if (t.equals("class")) {
String className = tok.get(j+2);
tok.set(i, className); // exchange constructor name!
// now for the parameters.
// Syntax: *(Learner *learner) {
// We will surely add type inference here in time... :)
j = i+2;
while (!tok.get(j).equals("{"))
j += 2;
int block = j+1;
for (int k = i+2; k < block-1; k += 2)
if (tok.get(k).equals("*")) {
tok.remove(k);
tok.remove(k);
block -= 2;
String name = tok.get(k);
tok.addAll(block, Arrays.asList(new String[] {
"\n ", "this", "", ".", "", name, " ", "=", " ", name, "", ";" }));
}
continue mainLoop;
}
j -= 2;
}
}
ret tok;
}
static L tok_processIncludes(L tok) {
int safety = 0;
while (hasCodeTokens(tok, "!", "include") && ++safety < 100)
tok = tok_processIncludesSingle(tok);
//tok_autoCloseBrackets(tok);
ret tok;
}
static L tok_processIncludesSingle(L tok) {
int i;
while ((i = jfind(tok, "!include #")) >= 0) {
S id = tok.get(i+6);
included.add(parseLong(id));
replaceTokens(tok, i, i+8, "\n" + cacheGet(id) + "\n");
reTok_include(tok, i, i+8);
}
while ((i = jfind(tok, "!include once #")) >= 0) {
S id = tok.get(i+8);
bool isNew = included.add(parseLong(id));
replaceTokens(tok, i, i+10,
isNew ? "\n" + cacheGet(id) + "\n" : "");
reTok_include(tok, i, i+10);
}
ret tok;
}
static void ctex(L tok) {
replaceKeywordBlock(tok, "ctex",
"{ try {",
"} catch (Exception __e) { throw rethrow(__e); } }");
replaceKeywordBlock(tok, "null on exception",
"{ try {",
"} catch (Throwable __e) { return null; } }");
replaceKeywordBlock(tok, "false on exception",
"{ try {",
"} catch (Throwable __e) { return false; } }");
}
static L dialogHandler(L tok) {
ret replaceKeywordBlock(tok,
"dialogHandler",
"new DialogHandler() {\n" +
"public void run(final DialogIO io) {",
"}}");
}
static void quicknew2(L tok) {
jreplace(tok, "new ;", "$2 $3 = new $2;");
jreplace(tok, "new <> ;", "$2<$4> $6 = new $2;");
jreplace(tok, "new . ;", "$2.$4 $5 = new $2.$4();");
jreplace(tok, "new <> , ;", "$2<$4> $6 = new $2, $8 = new $2;");
jreplace(tok, "new <,> ;", "$2<$4,$6> $8 = new $2;");
jreplace(tok, "new <<>> ;", "$2 $3 $4 $5 $6 $7 $8 $9 = new $2;");
jreplace(tok, "new <[]> ;", "$2 $3 $4 $5 $6 $7 $8 = new $2;");
jreplace(tok, "new < <>, > ;", "$2 $3 $4 $5 $6 $7 $8 $9 $10 $11 = new $2;");
jreplace(tok, "new < <,> > ;", "$2 $3 $4 $5 $6 $7 $8 $9 $10 $11 = new $2;");
jreplace(tok, "new < , <> > ;", "$2 $3 $4 $5 $6 $7 $8 $9 $10 $11 = new $2;");
jreplace(tok, "new < <,,> > ;", "$2 $3 $4 $5 $6 $7 $8 $9 $10 $11 $12 $13 = new $2;");
jreplace(tok, "new < <,>, > ;", "$2 $3 $4 $5 $6 $7 $8 $9 $10 $11 $12 $13 = new $2;");
// [abandoned, confusing, looks like a function definition] with arguments - new A a(...); => A a = new A(...);
//jreplace(tok, "new (", "$2 $3 = new $2(");
jreplace(tok, "for args " + "{", "for (int i = 0; i < args.length; i++) { final String arg = args[i];");
// Constructor calls without parentheses
// So you can say something like: predictors.add(new P1);
jreplace1(tok, "new ", "new $2()", tokcondition {
ret eqOneOf(_get(tok, i+5), "{", ",", ")", ";", ":");
});
jreplace1(tok, "new < >", "new $2<$4>()", tokcondition {
ret eqOneOf(_get(tok, i+11), "{", ",", ")", ";", ":");
});
jreplace(tok, "new List(", "new ArrayList(");
jreplace(tok, "new Map(", "new HashMap(");
jreplace(tok, "new Set(", "new HashSet(");
jreplace(tok, "new (Hash)Set", "new HashSet"); // rough
jreplace(tok, "new (Tree)Set", "new TreeSet");
jreplace(tok, "new (Hash)Map", "new HashMap");
jreplace(tok, "new (Tree)Map", "new TreeMap");
jreplace(tok, "\\*[] ;", "$2[] $6 = new $2[$4];");
// X x = new(...) => X x = new X(...)
// X x = new {...} => X x = new X {...}
// X x = new => X x = new
jreplace(tok, " = new", "$1 $2 = new $1", tokcondition {
ret eqOneOf(_get(tok, i+9), "(", ";", ",", ")", "{");
});
jreplace(tok, " = new \\*", "$1 $2 = new $1");
jreplace(tok, "\\* = new ", "$5 $2 = new $5");
jreplace(tok, "<> = new", "$1 $2 $3 $4 $5 = new $1", tokcondition {
ret eqOneOf(_get(tok, i+9+3*2), "(", ";", ",", ")");
});
jreplace(tok, "<,> = new", "$1 $2 $3 $4 $5 $6 $7 = new $1", tokcondition {
ret eqOneOf(_get(tok, i+9+5*2), "(", ";", ",", ")");
});
}
static L extendClasses(L tok) {
int i;
while ((i = jfind(tok, "extend {")) >= 0) {
S className = tok.get(i+2);
int idx = findCodeTokens(tok, i, false, "{");
int j = findEndOfBracketPart(tok, idx+2);
S content = join(subList(tok, idx+1, j-1));
L c = findInnerClassOfMain(tok, className);
print("Extending class " + className);
clearTokens(tok.subList(i, j+1));
if (c == null) {
print("Warning: Can't extend class " + className + ", not found");
continue;
}
int startOfClass = indexOfSubList(tok, c); // magicIndexOfSubList is broken
int endOfClass = startOfClass + l(c)-1;
//print("Extending class " + className + " ==> " + join(subList(tok, startOfClass, endOfClass)));
while (neq(tok.get(endOfClass), "}")) --endOfClass;
//print("Extending class " + className + " ==> " + join(subList(tok, startOfClass, endOfClass)));
tok.set(endOfClass, content + "\n" + tok.get(endOfClass));
doubleReTok(tok, i, j+1, endOfClass, endOfClass+1);
}
ret tok;
}
// for ping / while ping
static void forPing(L tok) {
int i;
for (S keyword : ll("for", "while"))
while ((i = jfind(tok, keyword + " ping (")) >= 0) {
int bracketEnd = findEndOfBracketPart(tok, i+4)-1;
int iStatement = bracketEnd+2;
int iEnd = findEndOfStatement(tok, iStatement);
tok.set(i+2, "");
// turn into block
if (!eq(get(tok, iStatement), "{")) {
tok.set(iStatement, "{ " + tok.get(iStatement));
tok.set(iEnd-1, tok.get(iEnd-1) + " }");
}
// add ping
tok.set(iStatement, "{ ping(); " + dropPrefixTrim("{", tok.get(iStatement)));
reTok(tok, i+2, iEnd);
}
}
// lib 123 => !123
static void libs(L tok) {
int i;
while ((i = jfind(tok, "lib ")) >= 0) {
S id = tok.get(i+2);
print("lib " + id);
if (!libs.contains(id)) {
libs.add(id);
clearAllTokens(tok, i, i+3);
/*tok.set(i, "!");
tok.set(i+1, "");*/
} else {
print("...ignoring (duplicate)");
clearAllTokens(tok, i, i+3);
reTok(tok, i, i+3);
}
}
print("libs found: " + libs);
}
// sourceCodeLine() => 1234
static void sourceCodeLine(L tok) {
int i ;
while ((i = jfind(tok, "sourceCodeLine()")) >= 0) {
replaceTokens(tok, i, i+5, str(countChar(join(subList(tok, 0, i)), '\n')+1));
reTok(tok, i, i+5);
}
}
// done before any other processing
static void earlyStuff(L tok) {
int i;
tok_scopes(tok);
tok_autosemi(tok);
tok_autoCloseBrackets(tok);
jreplace(tok, "°", "()");
// Note: this makes the word "quine" a special operator
// (unusable as a function name)
while ((i = jfind(tok, "quine(")) >= 0) {
int idx = findCodeTokens(tok, i, false, "(");
int j = findEndOfBracketPart(tok, idx+2);
tok.set(i, "new Quine");
tok.set(idx, "(" + quote(join(subList(tok, idx+1, j-1))) + ", ");
reTok(tok, i, idx+1);
}
// do this before func & voidfunc because otherwise they swallow it
jreplace(tok, "enter {", "{ temp enter();");
// func keyword for lambdas - now automatically quines toString() if enabled
// do func & voidfunc early to preserve original code as toString
while ((i = jfind(tok, "func(")) >= 0) {
int argsFrom = i+4, argsTo = findCodeTokens(tok, i, false, ")");
int idx = findCodeTokens(tok, argsTo, false, "{");
int j = findEndOfBracketPart(tok, idx);
L contents = subList(tok, idx+1, j-1);
S returnType = "O";
if (eq(tok.get(argsTo+2), "-") && eq(tok.get(argsTo+4), ">"))
returnType = tok_toNonPrimitiveTypes(join(subList(tok, argsTo+6, idx-1)));
S toString = autoQuine ? " public S toString() { ret " + quote(shorten(maxQuineLength, trimJoin(contents))) + "; }" : "";
L args = cloneSubList(tok, argsFrom-1, argsTo);
tok_shortFinals(args);
tok_toNonPrimitiveTypes(args);
L types = tok_typesOfParams(args);
O type = "O";
if (l(types) <= 3)
type = "F" + l(types) + "<" + joinWithComma(types) + ", " + returnType + ">";
S body = tok_addReturn(contents);
replaceTokens_reTok(tok, i, j,
"new " + type + "() { "
+ returnType + " get(" + trimJoin(args) + ") ctex { "
+ body
+ " }\n" +
+ toString + "}");
}
while ((i = jfind(tok, "voidfunc(")) >= 0) {
int argsFrom = i+4, argsTo = findCodeTokens(tok, i, false, ")");
int idx = findCodeTokens(tok, argsTo, false, "{");
int j = findEndOfBracketPart(tok, idx);
L contents = subList(tok, idx+1, j-1);
L args = cloneSubList(tok, argsFrom-1, argsTo);
tok_shortFinals(args);
tok_toNonPrimitiveTypes(args);
L types = tok_typesOfParams(args);
O type = "O";
if (l(types) <= 4)
type = "VF" + l(types) + "<" + joinWithComma(types) + ">";
replaceTokens(tok, i, j, "new " + type + "() { public void get(" + trimJoin(args) + ") ctex { " + tok_addSemicolon(contents) + " }\n" +
(autoQuine ? " public S toString() { ret " + quote(shorten(maxQuineLength, trim(join(contents)))) + "; }" : "") + "}");
reTok(tok, i, j);
}
jreplace(tok, "func {", "func -> O {");
jreplace(tok, "f {", "f -> O {");
// swing -> S { ... } => swing(func -> S { ... })
while ((i = jfind(tok, "swing ->")) >= 0) {
int bracket = findCodeTokens(tok, i, false, "{");
int j = findEndOfBracketPart(tok, bracket);
tok.set(i, "swing(func");
tok.set(j-1, "})");
reTok(tok, i, j);
}
for (S keyword : ll("f", "func")) {
while ((i = jfind(tok, keyword + " ->")) >= 0) {
// I think there is a bug here for something like func -> x { new x { } }
int idx = findCodeTokens(tok, i, false, "{");
int j = findEndOfBracketPart(tok, idx);
S returnType = tok_toNonPrimitiveTypes(join(subList(tok, i+6, idx-1)));
L contents = subList(tok, idx+1, j-1);
replaceTokens(tok, i, j, "new F0<" + returnType + ">() { " + returnType + " get() ctex { " + tok_addReturn(contents) + " }\n" +
(autoQuine ? " public S toString() { ret " + quote(shorten(maxQuineLength, trim(join(contents)))) + "; }" : "") + "}");
reTok(tok, i, j);
}
}
}
static void throwFailEtc(L tok) {
bool anyChange = false;
for (int i = 1; i+4 < l(tok); i += 2)
if (eqOneOf(get(tok, i+2), "fail", "todo")
&& eq(get(tok, i+4), "(")
&& !eqOneOf(get(tok, i), "throw", "RuntimeException", "return", "f", "function")) {
tok.set(i+2, "throw " + tok.get(i+2));
anyChange = true;
}
if (anyChange)
reTok(tok);
}
static void namedThreads(L tok) {
for (int i = 0; i < 100; i++) {
int idx = findCodeTokens(tok, "thread", "", "{");
if (idx < 0) idx = findCodeTokens(tok, "thread", "", "{");
if (idx < 0)
break;
int j = findEndOfBracketPart(tok, idx+4);
S tName = tok.get(idx+2);
S var = "_t_" + i;
S pre = "{ Thread " + var + " = new Thread(" + tName + ") {\n" +
"public void run() { pcall {\n";
S post = "} }\n};\n" +
"startThread(" + var + "); }";
tok.set(idx, pre);
tok.set(idx+2, "");
tok.set(idx+4, "");
tok.set(j-1, post);
//print(join(subList(tok, idx, j)));
reTok(tok, idx, j);
}
}
static void rNamedThread(L tok) {
for (int i = 0; i < 100; i++) {
int idx = findCodeTokens(tok, "r", "-", "thread", "", "{");
if (idx < 0) idx = findCodeTokens(tok, "r", "-", "thread", "", "{");
if (idx < 0)
break;
int j = findEndOfBracketPart(tok, idx+8);
S tName = tok.get(idx+6);
S pre = "r { thread " + tName + " {";
S post = "}}";
replaceTokens(tok, idx, idx+9, pre);
tok.set(j-1, post);
reTok(tok, idx, j);
}
}
static void threads(L tok) {
for (bool daemon : litlist(false, true))
for (int i = 0; i < 100; i++) {
int idx = findCodeTokens(tok, daemon ? "daemon" : "thread", "{");
if (idx < 0)
break;
int j = findEndOfBracketPart(tok, idx+2);
S var = "_t_" + i;
S pre = "{ Thread " + var + " = new Thread() {\n" +
"public void run() { pcall\n";
S post = "} }\n};\n" +
(daemon ? var + ".setDaemon(true);\n" : "") +
"startThread(" + var + "); }";
tok.set(idx, pre);
tok.set(j-1, post);
reTok(tok, idx, j);
}
}
static Map