svoid tok_swappableFunctions(LS tok) {

  jreplace(tok, "swappable static", "static swappable");

  jreplace(tok, "pswappable <id>", "persistently swappable $2");

  jreplace(tok, "persistent swappable <id>", "persistently swappable $3");

  jreplace(tok, "transient swappable <id>", "swappable $3");

  int i;

  while ((i = jfind_any(tok,

    "swappable <id> <id>(", "swappable <id> <", "swappable <id>.", "swappable <id>[")) >= 0) {

    // left-scan for modifiers

    int iModEnd = i;

    bool persistently = eqGet(tok, i-2, "persistently");

    if (persistently) iModEnd -= 2;

    int iMod = leftScanModifiers(tok, iModEnd);

    S modifiers = joinSubList(tok, iMod, iModEnd);

    // scan annotations

    int iAnnot = iMod;

    bool atOverride = subListEquals(tok, iAnnot-4, "@", "", "Override");

    if (atOverride) iAnnot -= 4;

    // scan return type, find function name

    int iEndOfType = tok_findEndOfType(tok, i+2);

    S returnType = joinSubList(tok, i+2, iEndOfType-1);

    S name = assertIdentifier(tok.get(iEndOfType));

    int iArgs = iEndOfType+2;

    assertEquals("(", get(tok, iArgs));

    try {

      int iCurly = indexOf(tok, iEndOfType, "{");

      int iArgsEnd = lastIndexOf(tok, iCurly, ")");

      assertTrue(iArgsEnd >= 0);

      S throwsClauses = joinSubList(tok, iArgsEnd+1, iCurly-1); // TODO

      LS tokArgs = subList(tok, iArgs+1, iArgsEnd);

      LPairS args = tok_typesAndNamesOfParams(tokArgs);

      S args1 = join(tokArgs);

      S args2 = joinWithComma(pairsB(args));

      bool isVoidMethod = eq(returnType, "void");

      LS types = pairsA(args);

      if (!isVoidMethod) types.add(returnType);

      S typeParams = joinWithComma(map(type -> tok_varArgTypeToArray(tok_toNonPrimitiveTypes(type)), types)); // TODO: modifiers

      S base = name + "_base", fallback = name + "_fallback";

      S mods = modifiers + (persistently || containsJavaToken(modifiers, "static") ? "" : "transient ");

      S mainFunctionModifiers = modifiers;

      S baseFunctionModifiers = modifiers;

      if (atOverride) mainFunctionModifiers = "@Override " + mainFunctionModifiers;

      S src;

      if (isVoidMethod)

        if (empty(args))

          // no args, returning void

          src = mods + "Runnable \*name*/;\n" + 

            "\*mainFunctionModifiers*/\*returnType*/ \*name*/(\*args1*/) { if (\*name*/ != null) \*name*/.run(); else \*base*/(\*args2*/); }\n" +

            "final \*modifiers*/\*returnType*/ \*fallback*/(Runnable _f, \*args1*/) { if (_f != null) _f.run(); else \*base*/(); }\n" +

            "\*baseFunctionModifiers*/\*returnType*/ \*base*/(\*args1*/) {";

        else {

          // args, returning void

          S varType = "IVF\*l(args)*/<\*typeParams*/>"; 

          src = "\*mods*/ \*varType*/ \*name*/;\n" + 

            "\*mainFunctionModifiers*/\*returnType*/ \*name*/(\*args1*/) { if (\*name*/ != null) \*name*/.get(\*args2*/); else \*base*/(\*args2*/); }\n" +

            "final \*modifiers*/\*returnType*/ \*fallback*/(\*varType*/ _f, \*args1*/) { if (_f != null) _f.get(\*args2*/); else \*base*/(\*args2*/); }\n" +

            "\*baseFunctionModifiers*/\*returnType*/ \*base*/(\*args1*/) {";

        }

      else {

        // zero or more args, not returning void

        S varType = "IF\*l(args)*/<\*typeParams*/>";

        src = "\*mods*/ \*varType*/ \*name*/;\n" + 

          "\*mainFunctionModifiers*/\*returnType*/ \*name*/(\*args1*/) { ret \*name*/ != null ? \*name*/.get(\*args2*/) : \*base*/(\*args2*/); }\n" +

            "final \*modifiers*/\*returnType*/ \*fallback*/(\*varType*/ _f, \*args1*/) { ret _f != null ? _f.get(\*args2*/) : \*base*/(\*args2*/); }\n" +

          "\*baseFunctionModifiers*/\*returnType*/ \*base*/(\*args1*/) {";

      }

      replaceTokens_reTok(tok, iAnnot, iCurly+1, src);

    } catch e {

      fail("Was processing function " + name, e);

    }

  }

}