ifdef PingV3

sbool ping(PingSource source default pingSource()) {

  ping_v3(source);

  true;

}

// don't think this is of any use anymore

sbool ping_impl(bool okInCleanUp) { ret ping(); }

//sbool ping_okInCleanUp() { ret ping(); }

// phase this out too!

static volatile bool ping_pauseAll;

endifdef

// legacy mode

ifndef PingV3

ifdef LeanMode

// you can change this function to allow interrupting long calculations from the outside. just throw a RuntimeException.

sbool ping() { true; }

sbool ping_impl(bool okInCleanUp) { true; }

endifdef

ifndef LeanMode

//sbool ping_actions_shareable = true;

static volatile bool ping_pauseAll;

static int ping_sleep = 100; // poll pauseAll flag every 100

static volatile bool ping_anyActions;

static Map<Thread, O> ping_actions = newWeakHashMap();

static new ThreadLocal<Bool> ping_isCleanUpThread;

// ignore pingSource if not PingV3

sbool ping(PingSource pingSource) { ret ping(); }

// always returns true

sbool ping() {

  //ifdef useNewPing

  newPing();

  //endifdef

  if (ping_pauseAll || ping_anyActions) ping_impl(true /* XXX */);

  //ifndef LeanMode ping_impl(); endifndef

  true;

}

// returns true when it slept

static bool ping_impl(bool okInCleanUp) ctex {

  if (ping_pauseAll && !isAWTThread()) {

    do

      Thread.sleep(ping_sleep);

    while (ping_pauseAll);

    true;

  }

  if (ping_anyActions) { // don't allow sharing ping_actions

    if (!okInCleanUp && !isTrue(ping_isCleanUpThread!))

      failIfUnlicensed();

    O 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"))

      fail("Thread cancelled.");

  }

  ret false;

}

endifndef

endifndef