void
mono_gc_enable (void)
{
#ifdef HAVE_GC_ENABLE
GC_enable ();
#else
g_assert_not_reached ();
#endif
}
GC_API void * WRAP_DLFUNC(dlopen)(const char *path, int mode)
{
void * result;
# ifndef USE_PROC_FOR_LIBRARIES
/* Disable collections. This solution risks heap growth (or, */
/* even, heap overflow) but there seems no better solutions. */
disable_gc_for_dlopen();
# endif
result = REAL_DLFUNC(dlopen)(path, mode);
# ifndef USE_PROC_FOR_LIBRARIES
GC_enable(); /* undoes disable_gc_for_dlopen */
# endif
return(result);
}
void org_xmlvm_runtime_FinalizerNotifier_preventGarbageCollection___boolean(JAVA_BOOLEAN n1)
{
//XMLVM_BEGIN_NATIVE[org_xmlvm_runtime_FinalizerNotifier_preventGarbageCollection___boolean]
#ifndef XMLVM_NO_GC
if (n1) {
// Disable garbage collection. Even GC_gcollect calls will be ineffective.
GC_disable();
} else {
// Reenable garbage collection. GC_disable() and GC_enable() calls
// nest. Garbage collection is enabled if the number of calls to both
// functions is equal.
GC_enable();
}
#endif
//XMLVM_END_NATIVE
}
static void PlayStopReally(bool doit){
pc->isplaying=false;
pc->initplaying=false;
pc->playertask_has_been_called = false;
pc->is_playing_range = false;
printf("PlayStopReally called: %s\n",doit==true?"true":"false");
if (PLAYER_current_thread_has_lock()){
RError("Potential deadlock detected: Calling PlayStopReally while holding player lock.");
return;
}
if (PLAYER_is_running())
while(pc->peq!=NULL) OS_WaitForAShortTime(20);
StopAllInstruments();
#if !USE_OPENGL
if(doit) (*Ptask2MtaskCallBack)();
#endif
pc->end_time=0;
pc->end_time_f=0;
pc->play_id++;
struct Tracker_Windows *window = root->song->tracker_windows;
struct WBlocks *wblock = window->wblock;
ScrollEditorToRealLine(window,wblock,wblock->curr_realline);
#if !USE_OPENGL
DrawWBlockSpesific(window,wblock,wblock->curr_realline,wblock->curr_realline); // clear cursor shade.
UpdateAllWTracks(window,wblock,wblock->curr_realline,wblock->curr_realline); // same here.
#endif
printf("[hb gakkgakk: %d\n",GC_dont_gc);
PATCH_reset_time();
//while(GC_is_disabled())
while(GC_dont_gc>0)
GC_enable();
MIDI_insert_recorded_midi_events();
}
static bool Load_CurrPos_org(struct Tracker_Windows *window, const wchar_t *filename){
bool ret = false;
// So many things happen here, that we should turn off garbage collection while loading.
//
// For instance, the instrument widget contains pointers (which are unreachable from the GC) to Patch
// and PatchData objects. The instrument widget is updated after setting a new root, so it may access
// that memory while a new song is loaded (since we don't have control over what Qt may do while we
// access it). Not unlikely to be other similar situations.
if(0){
GC_disable();
}
PlayStop();
if(Undo_are_you_shure_questionmark()==false)
goto exit;
if(filename==NULL)
filename=GFX_GetLoadFileName(window,NULL,"Select file to load", NULL, NULL);
if(filename==NULL) goto exit;
if (STRING_ends_with(filename,".MMD2") ||
STRING_ends_with(filename,".MMD3") ||
STRING_ends_with(filename,".MMD") ||
STRING_ends_with(filename,".mmd2") ||
STRING_ends_with(filename,".mmd3") ||
STRING_ends_with(filename,".mmd")
)
{
mmp2filename=filename;
ret = Load(STRING_create("new_song.rad"));
} else {
OS_set_loading_path(filename);
{
ret = Load(filename);
}
OS_unset_loading_path();
GFX_SetWindowTitle(root->song->tracker_windows, filename);
GFX_EditorWindowToFront(root->song->tracker_windows);
struct WBlocks *wblock = root->song->tracker_windows->wblock;
GFX_update_instrument_patch_gui(wblock->wtrack->track->patch);
DrawUpTrackerWindow(root->song->tracker_windows);
fprintf(stderr,"Got here (loading finished)\n");
}
exit:
if(0){
GC_enable();
}
if(mmp2filename!=NULL) {
LoadMMP2(root->song->tracker_windows, mmp2filename);
mmp2filename=NULL;
}
if (ret)
ResetUndo();
return ret;
}