/**

public static final int UNKNOWN_COUNT = -2;

/* Jython-specific gc flags: */

/**

public static final short MONITOR_GLOBAL = (1<<0);

/**

public static final short DONT_FINALIZE_CYCLIC_GARBAGE = (1<<1);

/**

public static final short PRESERVE_WEAKREFS_ON_RESURRECTION = (1<<2);

/**

public static final short DONT_FINALIZE_RESURRECTED_OBJECTS = (1<<3);

public static final short FORCE_DELAYED_FINALIZATION = (1<<4);

public static final short FORCE_DELAYED_WEAKREF_CALLBACKS = (1<<5);

/**

public static final short DONT_TRAVERSE_BY_REFLECTION = (1<<6);

/**

public static final short SUPPRESS_TRAVERSE_BY_REFLECTION_WARNING = (1<<7);

/**

public static final short INSTANCE_TRAVERSE_BY_REFLECTION_WARNING = (1<<8);

/**

public static final short USE_PY_WRITE_DEBUG = (1<<9);

/**

public static final short VERBOSE_COLLECT = (1<<10);

/**

public static final short VERBOSE_WEAKREF = (1<<11);

/**

public static final short VERBOSE_DELAYED = (1<<12);

/**

public static final short VERBOSE_FINALIZE = (1<<13);

/**

public static final short VERBOSE =

VERBOSE_COLLECT | VERBOSE_WEAKREF | VERBOSE_DELAYED | VERBOSE_FINALIZE;

/* set for debugging information */

/**

public static final int DEBUG_STATS = (1<<0);

/**

public static final int DEBUG_COLLECTABLE = (1<<1);

/**

public static final int DEBUG_UNCOLLECTABLE = (1<<2);

/**

public static final int DEBUG_INSTANCES = (1<<3);

/**

public static final int DEBUG_OBJECTS = (1<<4);

/**

public static final int DEBUG_SAVEALL = (1<<5);

/**

public static final int DEBUG_LEAK = DEBUG_COLLECTABLE |

DEBUG_UNCOLLECTABLE |

DEBUG_INSTANCES |

DEBUG_OBJECTS |

DEBUG_SAVEALL;

private static short gcFlags = DONT_TRAVERSE_BY_REFLECTION;

private static int debugFlags = 0;

private static boolean monitorNonTraversable = false;

private static boolean waitingForFinalizers = false;

private static final AtomicBoolean gcRunning = new AtomicBoolean(false);

private static final Set<WeakReferenceGC> monitoredObjects = new HashSet<>();

private static HashSet<Class<? extends PyObject>> reflectionWarnedClasses;

private static ReferenceQueue<Object> gcTrash;

private static int finalizeWaitCount = 0;

private static int initWaitTime = 10, defaultWaitFactor = 2;

private static long lastRemoveTimeStamp = -1, maxWaitTime = initWaitTime;

private static int gcMonitoredRunCount = 0;

public static long gcRecallTime = 4000;

/**

public static PyList garbage = new PyList();

/* Finalization preprocess/postprocess-related declarations: */

private static final List<Runnable> preFinalizationProcess = new ArrayList<>();

private static final List<Runnable> postFinalizationProcess = new ArrayList<>();

private static final List<Runnable> preFinalizationProcessRemove = new ArrayList<>();

private static final List<Runnable> postFinalizationProcessRemove = new ArrayList<>();

private static Thread postFinalizationProcessor;

public static long postFinalizationTimeOut = 100;

private static long postFinalizationTimestamp = System.currentTimeMillis()-2*postFinalizationTimeOut;

private static int openFinalizeCount = 0;

private static boolean postFinalizationPending = false;

private static boolean lockPostFinalization = false;

/* Resurrection-safe finalizer- and weakref-related declarations: */

private static IdentityHashMap<PyObject, PyObject> delayedFinalizables, resurrectionCriticals;

private static int abortedCyclicFinalizers = 0;

/* Some modes to control aspects of delayed finalization: */

private static final byte DO_NOTHING_SPECIAL = 0;

private static final byte MARK_REACHABLE_CRITICALS = 1;

private static final byte NOTIFY_FOR_RERUN = 2;

private static byte delayedFinalizationMode = DO_NOTHING_SPECIAL;

private static boolean notifyRerun = false;

public static final String __doc__ =

"This module provides access to the garbage collector for reference cycles.\n" +

"\n" +

"enable() -- Enable automatic garbage collection (does nothing in Jython).\n" +

"disable() -- Disable automatic garbage collection (raises NotImplementedError in Jython).\n" +

"isenabled() -- Returns True because Java garbage collection cannot be disabled.\n" +

"collect() -- Do a full collection right now (potentially expensive).\n" +

"get_count() -- Return the current collection counts (raises NotImplementedError in Jython).\n" +

"set_debug() -- Set debugging flags.\n" +

"get_debug() -- Get debugging flags.\n" +

"set_threshold() -- Set the collection thresholds (raise NotImplementedError in Jython).\n" +

"get_threshold() -- Return the current the collection thresholds (raise NotImplementedError in Jython).\n" +

"get_objects() -- Return a list of all objects tracked by the collector (raises NotImplementedError in Jython).\n" +

"is_tracked() -- Returns true if a given object is tracked (i.e. monitored in Jython).\n" +

"get_referrers() -- Return the list of objects that refer to an object (only finds monitored referrers in Jython).\n" +

"get_referents() -- Return the list of objects that an object refers to.\n";

public static final String __name__ = "gc";

public static final PyString __doc__enable = new PyString(

"enable() -> None\n" +

"\n" +

"Enable automatic garbage collection.\n" +

"(does nothing in Jython)\n");

public static final PyString __doc__disable = new PyString(

"disable() -> None\n" +

"\n" +

"Disable automatic garbage collection.\n" +

"(raises NotImplementedError in Jython)\n");

public static final PyString __doc__isenabled = new PyString(

"isenabled() -> status\n" +

"\n" +

"Returns true if automatic garbage collection is enabled.\n");

public static final PyString __doc__collect = new PyString(

"collect([generation]) -> n\n" +

"\n" +

"With no arguments, run a full collection. The optional argument\n" +

"may be an integer specifying which generation to collect. A ValueError\n" +

"is raised if the generation number is invalid.\n\n" +

"The number of unreachable objects is returned.\n" +

"(Jython emulates CPython cyclic trash counting if objects are monitored.\n" +

"If no objects are monitored, returns -2\n");

public static final PyString __doc__get_count = new PyString(

"get_count() -> (count0, count1, count2)\n" +

"\n" +

"Return the current collection counts\n" +

"(raises NotImplementedError in Jython)\n");

public static final PyString __doc__set_debug = new PyString(

"set_debug(flags) -> None\n" +

"\n" +

"Set the garbage collection debugging flags. Debugging information is\n" +

"written to sys.stderr.\n" +

"\n" +

"flags is an integer and can have the following bits turned on:\n" +

"\n" +

" DEBUG_STATS - Print statistics during collection.\n" +

" DEBUG_COLLECTABLE - Print collectable objects found.\n" +

" DEBUG_UNCOLLECTABLE - Print unreachable but uncollectable objects found.\n" +

" DEBUG_INSTANCES - Print instance objects.\n" +

" DEBUG_OBJECTS - Print objects other than instances.\n" +

" DEBUG_SAVEALL - Save objects to gc.garbage rather than freeing them.\n" +

" DEBUG_LEAK - Debug leaking programs (everything but STATS).\n");

public static final PyString __doc__get_debug = new PyString(

"get_debug() -> flags\n" +

"\n" +

"Get the garbage collection debugging flags.\n");

public static final PyString __doc__set_thresh = new PyString(

"set_threshold(threshold0, [threshold1, threshold2]) -> None\n" +

"\n" +

"Sets the collection thresholds. Setting threshold0 to zero disables\n" +

"collection.\n" +

"(raises NotImplementedError in Jython)\n");

public static final PyString __doc__get_thresh = new PyString(

"get_threshold() -> (threshold0, threshold1, threshold2)\n" +

"\n" +

"Return the current collection thresholds\n" +

"(raises NotImplementedError in Jython)\n");

public static final PyString __doc__get_objects = new PyString(

"get_objects() -> [...]\n" +

"\n" +

"Return a list of objects tracked by the collector (excluding the list\n" +

"returned).\n" +

"(raises NotImplementedError in Jython)\n");

public static final PyString __doc__is_tracked = new PyString(

"is_tracked(obj) -> bool\n" +

"\n" +

"Returns true if the object is tracked by the garbage collector.\n" +

"(i.e. monitored in Jython)\n");

public static final PyString __doc__get_referrers = new PyString(

"get_referrers(*objs) -> list\n" +

"Return the list of objects that directly refer to any of objs.\n" +

"(only finds monitored referrers in Jython)");

public static final PyString __doc__get_referents = new PyString(

"get_referents(*objs) -> list\n" +

"Return the list of objects that are directly referred to by objs.");

public static class CycleMarkAttr {

private boolean cyclic = false;

private boolean uncollectable = false;

public boolean monitored = false;

CycleMarkAttr() {

}

CycleMarkAttr(boolean cyclic, boolean uncollectable) {

this.cyclic = cyclic;

this.uncollectable = uncollectable;

}

public boolean isCyclic() {

return cyclic || uncollectable;

}

public boolean isUncollectable() {

return uncollectable;

}

public void setFlags(boolean cyclic, boolean uncollectable) {

this.cyclic = cyclic;

this.uncollectable = uncollectable;

}

}

private static class WeakReferenceGC extends WeakReference<PyObject> {

int hashCode = 0;

public String str = null, inst_str = null;

public String cls;

boolean isInstance;

boolean hasFinalizer = false;

CycleMarkAttr cycleMark;

WeakReferenceGC(PyObject referent) {

super(referent);

isInstance = referent instanceof PyInstance;

cycleMark = (CycleMarkAttr)

JyAttribute.getAttr(referent, JyAttribute.GC_CYCLE_MARK_ATTR);

hashCode = System.identityHashCode(referent);

cls = referent.getClass().getName();

updateHasFinalizer();

}

WeakReferenceGC(PyObject referent, ReferenceQueue<Object> q) {

super(referent, q);

isInstance = referent instanceof PyInstance;

cycleMark = (CycleMarkAttr)

JyAttribute.getAttr(referent, JyAttribute.GC_CYCLE_MARK_ATTR);

hashCode = System.identityHashCode(referent);

cls = referent.getClass().getName();

updateHasFinalizer();

}

public void updateHasFinalizer() {

PyObject gt = get();

Object fn = JyAttribute.getAttr(gt, JyAttribute.FINALIZE_TRIGGER_ATTR);

hasFinalizer = fn != null && ((FinalizeTrigger) fn).isActive();

}

public void initStr(PyObject referent) {

PyObject ref = referent;

if (referent == null) {

ref = get();

}

try {

if (ref instanceof PyInstance) {

String name = ((PyInstance) ref).fastGetClass().__name__;

if (name == null) {

name = "?";

}

inst_str = String.format("<%.100s instance at %s>",

name, Py.idstr(ref));

}

str = String.format("<%.100s %s>",

ref.getType().getName(), Py.idstr(ref));

} catch (Exception e) {

str = "<"+ref.getClass().getSimpleName()+" "

+System.identityHashCode(ref)+">";

}

}

@Override

public String toString() {

return str;

}

@Override

public int hashCode() {

return hashCode;

}

@Override

public boolean equals(Object ob) {

Object ownReferent = get();

if (ob instanceof WeakReferenceGC) {

Object otherReferent = ((WeakReferenceGC) ob).get();

if (ownReferent == null || otherReferent == null) {

return ownReferent == otherReferent &&

/* We compare the cached hash codes in order to get an idea

hashCode == ((WeakReferenceGC) ob).hashCode;

} else {

return otherReferent.equals(ownReferent)

/* Here the hash codes are only compared as a consistency check. */

&& ((WeakReferenceGC) ob).hashCode == hashCode;

}

} else if (ob instanceof WeakrefGCCompareDummy) {

if (ownReferent == null ||

((WeakrefGCCompareDummy) ob).compare == null) {

return ownReferent ==

((WeakrefGCCompareDummy) ob).compare &&

/* We compare the cached hash codes in order to get an idea

hashCode == ((WeakrefGCCompareDummy) ob).hashCode;

} else {

return ownReferent.equals(((WeakrefGCCompareDummy) ob).compare)

/* Here the hash codes are only compared as a consistency check. */

&& hashCode == ((WeakrefGCCompareDummy) ob).hashCode;

}

} else {

return false;

}

}

}

private static class WeakrefGCCompareDummy {

public static WeakrefGCCompareDummy defaultInstance =

new WeakrefGCCompareDummy();

protected PyObject compare;

int hashCode = 0;

public void setCompare(PyObject compare) {

this.compare = compare;

hashCode = System.identityHashCode(compare);

}

public void clearCompare() {

compare = null;

hashCode = 0;

}

@Override

public int hashCode() {

return hashCode;

}

@Override

@SuppressWarnings("rawtypes")

public boolean equals(Object ob) {

if (ob instanceof Reference) {

return compare.equals(((Reference) ob).get());

} else if (ob instanceof WeakrefGCCompareDummy) {

return compare.equals(((WeakrefGCCompareDummy) ob).compare);

} else {

return compare.equals(ob);

}

}

}

private static class GCSentinel {

Thread waiting;

public GCSentinel(Thread notifyOnFinalize) {

waiting = notifyOnFinalize;

}

@Override

protected void finalize() throws Throwable {

notifyPreFinalization();

if ((gcFlags & VERBOSE_COLLECT) != 0) {

writeDebug("gc", "Sentinel finalizer called...");

}

if (lastRemoveTimeStamp != -1) {

long diff = maxWaitTime*defaultWaitFactor-System.currentTimeMillis()+lastRemoveTimeStamp;

while (diff > 0) {

try {

Thread.sleep(diff);

} catch (InterruptedException ie) {}

diff = maxWaitTime*defaultWaitFactor-System.currentTimeMillis()+lastRemoveTimeStamp;

}

}

if (waiting != null) {

waiting.interrupt();

}

if ((gcFlags & VERBOSE_COLLECT) != 0) {

writeDebug("gc", "Sentinel finalizer done");

}

notifyPostFinalization();

}

}

/**

public static void writeDebug(String type, String msg) {

if ((gcFlags & USE_PY_WRITE_DEBUG) != 0) {

Py.writeDebug(type, msg);

} else {

System.err.println(type + ": " + msg);

}

}

/**

public static void restoreFinalizer(PyObject obj) {

FinalizeTrigger ft =

(FinalizeTrigger) JyAttribute.getAttr(obj, JyAttribute.FINALIZE_TRIGGER_ATTR);

boolean notify = false;

if (ft != null) {

FinalizeTrigger.ensureFinalizer(obj);

/* ensure that the old finalize won't run in any case */

ft.clear();

((FinalizeTrigger) JyAttribute.getAttr(obj,

JyAttribute.FINALIZE_TRIGGER_ATTR)).flags = ft.flags;

notify = (ft.flags & FinalizeTrigger.NOTIFY_GC_FLAG) != 0;

}

if ((gcFlags & VERBOSE_DELAYED) != 0 || (gcFlags & VERBOSE_FINALIZE) != 0) {

writeDebug("gc", "restore finalizer of "+obj);

}

CycleMarkAttr cm = (CycleMarkAttr)

JyAttribute.getAttr(obj, JyAttribute.GC_CYCLE_MARK_ATTR);

if (cm != null && cm.monitored) {

monitorObject(obj, true);

}

if (notify) {

boolean cyclic;

if (cm != null && cm.isUncollectable()) {

cyclic = true;

} else {

markCyclicObjects(obj, true);

cm = (CycleMarkAttr) JyAttribute.getAttr(obj, JyAttribute.GC_CYCLE_MARK_ATTR);

cyclic = cm != null && cm.isUncollectable();

}

if ((gcFlags & VERBOSE_DELAYED) != 0 || (gcFlags & VERBOSE_FINALIZE) != 0) {

writeDebug("gc", "notify finalizer abort; cyclic? "+cyclic);

}

notifyAbortFinalize(obj, cyclic);

}

}

/**

public static void restoreWeakReferences(PyObject rst) {

ReferenceBackend toRestore = (ReferenceBackend)

JyAttribute.getAttr(rst, JyAttribute.WEAK_REF_ATTR);

if (toRestore != null) {

toRestore.restore(rst);

}

}

private static class DelayedFinalizationProcess implements Runnable {

static DelayedFinalizationProcess defaultInstance =

new DelayedFinalizationProcess();

private static void performFinalization(PyObject del) {

if ((gcFlags & VERBOSE_DELAYED) != 0) {

writeDebug("gc", "delayed finalize of "+del);

}

FinalizeTrigger ft = (FinalizeTrigger)

JyAttribute.getAttr(del, JyAttribute.FINALIZE_TRIGGER_ATTR);

if (ft != null) {

ft.performFinalization();

} else if ((gcFlags & VERBOSE_DELAYED) != 0) {

writeDebug("gc", "no FinalizeTrigger");

}

}

@Override

public void run() {

if ((gcFlags & VERBOSE_DELAYED) != 0) {

writeDebug("gc", "run delayed finalization. Index: "+

gcMonitoredRunCount);

}

Set<PyObject> criticals = resurrectionCriticals.keySet();

if (delayedFinalizationMode == DO_NOTHING_SPECIAL &&

(gcFlags & (PRESERVE_WEAKREFS_ON_RESURRECTION |

DONT_FINALIZE_RESURRECTED_OBJECTS)) == 0) {

/* In this case we can do a cheap variant... */

if ((gcFlags & FORCE_DELAYED_WEAKREF_CALLBACKS) != 0) {

if ((gcFlags & VERBOSE_DELAYED) != 0) {

writeDebug("gc", "process delayed callbacks (force-branch)");

}

GlobalRef.processDelayedCallbacks();

}

if ((gcFlags & FORCE_DELAYED_FINALIZATION) != 0) {

if ((gcFlags & VERBOSE_DELAYED) != 0) {

writeDebug("gc", "process delayed finalizers (force-branch)");

}

for (PyObject del: delayedFinalizables.keySet()) {

performFinalization(del);

}

for (PyObject cr: criticals) {

performFinalization(cr);

}

delayedFinalizables.clear();

resurrectionCriticals.clear();

}

if ((gcFlags & VERBOSE_DELAYED) != 0) {

writeDebug("gc", "forced delayed finalization run done");

}

return;

}

Set<PyObject> cyclicCriticals = removeNonCyclic(criticals);

cyclicCriticals.retainAll(criticals);

criticals.removeAll(cyclicCriticals);

Set<PyObject> criticalReachablePool = findReachables(criticals);

/* to avoid concurrent modification: */

ArrayList<PyObject> criticalReachables = new ArrayList<>();

FinalizeTrigger fn;

if (delayedFinalizationMode == MARK_REACHABLE_CRITICALS) {

for (PyObject obj: criticalReachablePool) {

fn = (FinalizeTrigger) JyAttribute.getAttr(obj,

JyAttribute.FINALIZE_TRIGGER_ATTR);

if (fn != null && fn.isActive() && fn.isFinalized()) {

criticalReachables.add(obj);

JyAttribute.setAttr(obj,

JyAttribute.GC_DELAYED_FINALIZE_CRITICAL_MARK_ATTR,

Integer.valueOf(gcMonitoredRunCount));

}

}

} else {

for (PyObject obj: criticalReachablePool) {

fn = (FinalizeTrigger) JyAttribute.getAttr(obj,

JyAttribute.FINALIZE_TRIGGER_ATTR);

if (fn != null && fn.isActive() && fn.isFinalized()) {

criticalReachables.add(obj);

}

}

}

criticals.removeAll(criticalReachables);

if ((gcFlags & PRESERVE_WEAKREFS_ON_RESURRECTION) != 0) {

if ((gcFlags & VERBOSE_DELAYED) != 0) {

writeDebug("gc", "restore potentially resurrected weak references...");

}

for (PyObject rst: criticalReachablePool) {

restoreWeakReferences(rst);

}

GlobalRef.processDelayedCallbacks();

}

criticalReachablePool.clear();

if ((gcFlags & DONT_FINALIZE_RESURRECTED_OBJECTS) != 0) {

/* restore all finalizers that might belong to resurrected objects: */

if ((gcFlags & VERBOSE_DELAYED) != 0) {

writeDebug("gc", "restore "+criticalReachables.size()+

" potentially resurrected finalizers...");

}

for (PyObject obj: criticalReachables) {