static boolean findFunctionInvocations_debug;

// these prefix tokens mark a non-invocation (TODO: expand)

static Set<S> findFunctionInvocations_pre = new HashSet(litlist(".", "void", "S", "String", "int", "bool", "boolean", "A", "Object", "O", "]", "double", "float", "short", "char", "long"));

static Set<String> findFunctionInvocations(S src, SS sf) {

  ret findFunctionInvocations(javaTok(src), sf);

}

static Set<String> findFunctionInvocations(L<S> tok, SS sf) {

  ret findFunctionInvocations(tok, sf, null);

}

// sf = set of functions to search for or null for any function

static Set<String> findFunctionInvocations(L<S> tok, SS sf, Collection<S> hardReferences) {

  ret findFunctionInvocations(tok, sf, hardReferences, null);

}

static Set<String> findFunctionInvocations(L<S> tok, SS sf, Collection<S> hardReferences, Set<S> haveFunctions) {

  ret findFunctionInvocations(tok, sf, hardReferences, haveFunctions, false);

}

// tok: the code

// sf: map of functions (keys) to look for - null to record every function call

// hardReferences (out parameter): records every "please include"  statement if not null

// haveFunctions: functions to skip (or null)

// includePossiblyMapLikes: include calls with pre-brackets argument (e.g. map l(...))

// mainClassName: name of program's main class (calls to this class will be skipped)

static Set<S> findFunctionInvocations(LS tok, SS sf, Cl<S> hardReferences, Set<S> haveFunctions, bool includePossiblyMapLikes, S mainClassName default "main") {

  new LinkedHashSet<S> l;

  for (int i : jfindAll(tok, "please include functions")) {

    int j = i + 6;

    while licensed {

      String fname = tok.get(j);

      assertIdentifier("in please include functions section", get(tok, j));

      l.add(fname);

      add(hardReferences, fname);

      j += 2;

      if (eqGet(tok, j, ".")) break;

      while (eqGetOneOf(tok, j, ",", "and")) j += 2;

    }

    clearAllTokens(tok.subList(i, j+2));

  }

  for (int i : jfindAll(tok, "please include function *.")) {

    String fname = tok.get(i+6);

    l.add(fname);

    add(hardReferences, fname);

    clearAllTokens(tok.subList(i, i+10));

  }

  int i, n = tok.size();

  boolean result = false;

  for (i = 1; i+2 < n; i += 2) {

    S f = tok.get(i);

    if (!isIdentifier_quick(f)) continue;

    // main.<A>bla()

    if (eq(mainClassName, f) && eq(tok.get(i+2), ".") && eqGet(tok, i+4, "<")) {

      i = findEndOfTypeArgs(tok, i+4)+1;

      f = tok.get(i);

      if (!isIdentifier(f)) continue;

    }

    if (findFunctionInvocations_debug)

      print("Testing identifier " + f);

    // e.g. ... html_findLIs(LS [auto htmlTok] tok) { ... }

    if (eqGet(tok, i-4, "[") && eqGet(tok, i-2, "auto")) {

      // ok

    } else if (eqGet(tok, i-2, ":") && eqGet(tok, i-4, ":") && eqGet(tok, i-6, mainClassName)) {

      // ok, function reference (main::bla)

    } else if (eqGet(tok, i+2, "(")) {

      // ok, normal function invocation

    } else if (includePossiblyMapLikes && eqGet(tok, i+4, "(") && isIdentifier(get(tok, i+2))) {

      // ok, mapLike invocation (bla blubb(...))

    } else

      // not an invocation

      continue;

    if (i == 1

        || !findFunctionInvocations_pre.contains(tok.get(i-2))

        || eqGet(tok, i-2, ".") && eqGet(tok, i-4, mainClassName)) {

      boolean inSF = sf == null || sf.containsKey(f);

      if (findFunctionInvocations_debug)

        print("Possible invocation: " + f + ", inSF: " + inSF);

      if (inSF && !contains(haveFunctions, f) && l.add(f))

        if (findFunctionInvocations_debug)

          print("Found reference to standard function " + f + ": " + lineAroundToken(tok, i));

    }

  }

  return l;

}