/* Find and store all of the directories, and index them in the dpointers array */
long get_directories(void)
{
char temp[80];
long count,c,rcnt=0;
count = getfnl("*", dirs, sizeof(dirs), FA_SUBDIR );
if (count > 0) {
if (strbpl(dpointers,300,dirs)!=count) {
fprintf(stderr, "Too many mailbox directories\n");
deinitialize();
exit(1);
}
strsrt( dpointers, count );
for (c=0;c<count;c++) {
if (dpointers[c][0]=='.') { continue; }
rcnt++;
/* sprintf( temp, "[0][Checking Directory |%s][OK]", dpointers[c] ); */
/* form_alert( 1, temp ); */
}
sprintf( temp, "[0][You have %ld Mail Directories][OK]", rcnt );
form_alert( 1, temp );
} else {
if (_OSERR) poserr( "DIRS");
else fprintf(stderr, "Too many mailbox directories\n");
deinitialize();
exit(1);
}
return(count);
}
RenderableSphericalGrid::~RenderableSphericalGrid(){
deinitialize();
// Delete not done in deinitialize because new is done in constructor
delete[] _varray;
delete[] _iarray;
}
SimpleOverlay::~SimpleOverlay()
{
if(mInitialized)
{
deinitialize();
}
}
void OperatorItem::setInitialized(bool value)
{
if(value == true)
initialize();
else
deinitialize();
}
OperatorKernel::~OperatorKernel()
{
deactivate();
deinitialize();
for(std::vector<const Input*>::const_iterator iter = m_inputs.begin();
iter != m_inputs.end();
++iter)
{
delete *iter;
}
for(std::vector<const Output*>::const_iterator iter = m_outputs.begin();
iter != m_outputs.end();
++iter)
{
delete *iter;
}
for(std::vector<const Parameter*>::const_iterator iter = m_parameters.begin();
iter != m_parameters.end();
++iter)
{
delete *iter;
}
}
/**
** FIXME - actual support for multiple volumes
**/
bool CFile::initialize(int volume)
{
volatile uint8_t err=0;
mInitialized=false;
do {
deinitialize(volume);
if ( (mFileSystem = (FATFS*)malloc(sizeof(FATFS))) )
{
memset(mFileSystem,0,sizeof(FATFS));
if ( ( err = disk_initialize(volume) ) == FR_OK )
{
if ( ( err = disk_status(volume) ) == FR_OK )
{
if ( ( err = f_mount(mFileSystem,"",0) ) == FR_OK )
{
mInitialized=true;
}
}
}
if ( !initialized() )
{
free(mFileSystem);
mFileSystem=NULL;
disk_init_fail(err);
}
}
} while ( err );
disk_init_fail(0); // clear the status/diag LEDs
return mInitialized;
}
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) {
int action, device, value;
unsigned char buffer[64], i, bmRequestType, bRequest;
unsigned int vendorID, productID, wValue, wIndex, wLength;
double *ret, *out;
action = (int)(mxGetScalar(prhs[0]));
switch (action) {
case INITIALIZE:
initialize();
break;
case DEINITIALIZE:
deinitialize();
break;
case SET_DEBUG:
value = (int)(mxGetScalar(prhs[1]));
set_debug(value);
break;
case OPEN_DEVICE:
vendorID = (unsigned int)(mxGetScalar(prhs[1]));
productID = (unsigned int)(mxGetScalar(prhs[2]));
value = (int)(mxGetScalar(prhs[3]));
value = open_device(vendorID, productID, value);
plhs[0] = mxCreateDoubleMatrix(1, 1, mxREAL);
ret = mxGetPr(plhs[0]);
ret[0] = (double)value;
break;
case CLOSE_DEVICE:
device = (int)(mxGetScalar(prhs[1]));
value = close_device(device);
plhs[0] = mxCreateDoubleMatrix(1, 1, mxREAL);
ret = mxGetPr(plhs[0]);
ret[0] = (double)value;
break;
case NUM_DEVICES_OPEN:
value = num_devices_open();
plhs[0] = mxCreateDoubleMatrix(1, 1, mxREAL);
ret = mxGetPr(plhs[0]);
ret[0] = (double)value;
break;
case CONTROL_TRANSFER:
device = (int)(mxGetScalar(prhs[1]));
bmRequestType = (unsigned char)(mxGetScalar(prhs[2]));
bRequest = (unsigned char)(mxGetScalar(prhs[3]));
wValue = (unsigned int)(mxGetScalar(prhs[4]));
wIndex = (unsigned int)(mxGetScalar(prhs[5]));
wLength = (unsigned int)(mxGetScalar(prhs[6]));
value = control_transfer(device, bmRequestType, bRequest, wValue, wIndex, wLength, buffer);
plhs[0] = mxCreateDoubleMatrix(1, 1, mxREAL);
ret = mxGetPr(plhs[0]);
ret[0] = (double)value;
plhs[1] = mxCreateDoubleMatrix(1, 64, mxREAL);
out = mxGetPr(plhs[1]);
for (i = 0; i<64; i++)
out[i] = (double)buffer[i];
break;
default:
mexErrMsgTxt("Illegal action specified.");
}
}
MidiOutPort_visual::~MidiOutPort_visual() {
objectCount--;
if (objectCount == 0) {
deinitialize();
} else if (objectCount < 0) {
cerr << "Error: bad MidiOutPort object count!: " << objectCount << endl;
exit(1);
}
}
Common::Error TSageEngine::run() {
// Basic initialisation
initialize();
g_globals->_sceneHandler->registerHandler();
g_globals->_game->execute();
deinitialize();
return Common::kNoError;
}
int main(int argc, char** argv) {
parse_arguments(argc, argv);
initialize();
create_threads();
join_threads();
deinitialize();
return EXIT_SUCCESS;
}
MidiInPort_alsa::~MidiInPort_alsa() {
objectCount--;
if (objectCount == 0) {
deinitialize();
} else if (objectCount < 0) {
std::cerr << "Error: bad MidiInPort_alsa object count!: "
<< objectCount << std::endl;
exit(1);
}
}
void main()
{
char buffer[20000];
char *commits[1000];
int numcommits, i;
numcommits = getHashes(buffer, commits);
treeInit(commits, numcommits);
printGraph(commits, numcommits);
deinitialize(numcommits);
}
Common::Error TitanicEngine::run() {
initialize();
// Main event loop
while (!shouldQuit()) {
_events->pollEventsAndWait();
}
deinitialize();
return Common::kNoError;
}
bool UeventObserver::initialize()
{
mListeners.clear();
if (mUeventFd != -1) {
return true;
}
mThread = new UeventObserverThread(this);
if (!mThread.get()) {
ETRACE("failed to create uevent observer thread");
return false;
}
// init uevent socket
struct sockaddr_nl addr;
// set the socket receive buffer to 64K
// NOTE: this is only called for once
int sz = 64 * 1024;
memset(&addr, 0, sizeof(addr));
addr.nl_family = AF_NETLINK;
addr.nl_pid = pthread_self() | getpid();
addr.nl_groups = 0xffffffff;
mUeventFd = socket(PF_NETLINK, SOCK_DGRAM, NETLINK_KOBJECT_UEVENT);
if (mUeventFd < 0) {
DEINIT_AND_RETURN_FALSE("failed to create uevent socket");
}
if (setsockopt(mUeventFd, SOL_SOCKET, SO_RCVBUFFORCE, &sz, sizeof(sz))) {
WTRACE("setsockopt() failed");
//return false;
}
if (bind(mUeventFd, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
DEINIT_AND_RETURN_FALSE("failed to bind scoket");
return false;
}
memset(mUeventMessage, 0, UEVENT_MSG_LEN);
int exitFds[2];
if (pipe(exitFds) < 0) {
ETRACE("failed to make pipe");
deinitialize();
return false;
}
mExitRDFd = exitFds[0];
mExitWDFd = exitFds[1];
return true;
}
void animation_movement_controller::OnFrame( )
{
m_pKinematicsC->CalculateBones( );
if(CBlend::eFREE_SLOT == m_control_blend->blend)
{
deinitialize();
return;
}
if( m_control_blend->blend == CBlend::eAccrue && m_control_blend->blendPower - EPS_L > m_control_blend->blendAmount )
m_control_blend->timeCurrent =0;
}
int MazurkaTransformer::initialize(int size) {
if (fftSignalN == size) {
return 1;
}
deinitialize();
if (size <= 0) {
return 0;
}
fftSignalN = size;
fftSignalNd2 = size/2;
fftSpectrumN = size/2 + 1;
fftSignal = (double*)fftw_malloc(fftSignalN * sizeof(double));
fftSpectrum = (fftw_complex*)fftw_malloc(fftSpectrumN * sizeof(fftw_complex));
// r2c_1d = real to complex, 1-dimensional
// signal size = n, spectrum size = (n/2+1) complex numbers
fftPlan = fftw_plan_dft_r2c_1d(size, fftSignal, fftSpectrum, FFTW_ESTIMATE);
fftPlan_inverse = fftw_plan_dft_c2r_1d(size, fftSpectrum, fftSignal,
FFTW_ESTIMATE);
// Also can use: FFTW_ESTIMATE | FFTW_PRESERVE_INPUT
// if you don't want the input to be destroyed
// during the transform process.
// http://www.fftw.org/fftw3_doc/Planner-Flags.html#Planner-Flags
// FFTW_ESTIMATE
// FFTW_MEASURE
// FFTW_PATIENT
// FFTW_EXHAUSTIVE
if (fftPlan == NULL || fftPlan_inverse == NULL) {
deinitialize();
return 0; // unsuccessful initialization
}
return 1; // successful initialization
}
int core_application::app_main(const int argc, const char** argv) {
init_info init_info;
construct_init_info(argc, argv, init_info);
deinit_info deinit_info;
construct_deinit_info(deinit_info);
initialize(init_info);
main_loop();
deinitialize(deinit_info);
return 0;
}
/* Find and store all of the mailboxes, and index them in the pointers array */
long get_mailboxes(void)
{
char temp[80];
long count;
count = getfnl("*.MBX", boxes, sizeof(boxes), 0 );
if (count > 0) {
if (strbpl(pointers,200,boxes)!=count) {
fprintf(stderr, "Too many mailbox files\n");
deinitialize();
exit(1);
}
sprintf( temp, "[0][You have %ld Mailboxes][OK]", count );
form_alert( 1, temp );
strsrt( pointers, count );
} else {
if (_OSERR) poserr( "FILES");
else fprintf(stderr, "Too many mailbox files\n");
deinitialize();
exit(1);
}
return(count);
}
/*
* Library Initialization
*/
void LibraryInitializer::initialize(const std::string& arg_string)
{
bool thread_safe = false;
const std::vector<std::string> arg_list = split_on(arg_string, ' ');
for(u32bit j = 0; j != arg_list.size(); ++j)
{
if(arg_list[j].size() == 0)
continue;
std::string name, value;
if(arg_list[j].find('=') == std::string::npos)
{
name = arg_list[j];
value = "true";
}
else
{
std::vector<std::string> name_and_value = split_on(arg_list[j], '=');
name = name_and_value[0];
value = name_and_value[1];
}
bool is_on =
(value == "1" || value == "true" || value == "yes" || value == "on");
if(name == "thread_safe")
thread_safe = is_on;
}
try
{
/*
This two stage initialization process is because Library_State's
constructor will implicitly refer to global state through the
allocators and so for, so global_state() has to be a valid
reference before initialize() can be called. Yeah, gross.
*/
set_global_state(new Library_State);
global_state().initialize(thread_safe);
}
catch(...)
{
deinitialize();
throw;
}
}
pool& pool::operator=(pool&& that)
{
if (this != &that)
{
deinitialize();
blocks_ = that.blocks_; that.blocks_ = nullptr;
stride_ = that.stride_; that.stride_ = 0;
nblocks_ = that.nblocks_; that.nblocks_ = 0;
nfree_ = that.nfree_; that.nfree_ = 0;
head_ = that.head_; that.head_ = nullidx;
}
return *this;
}
/*************************************************
* Library Initialization *
*************************************************/
void LibraryInitializer::initialize(const InitializerOptions& args,
Modules& modules)
{
try
{
set_global_state(new Library_State);
global_state().initialize(args, modules);
}
catch(...)
{
deinitialize();
throw;
}
}
int
main ( /*int argc, char *argv[] */ )
{
if (!initialize ())
{
return 1;
}
run_into_screen ();
run_main_game ();
deinitialize ();
return 0;
}
LRESULT CALLBACK WndProc(HWND window, UINT msg, WPARAM wParam, LPARAM lParam)
{
HDC dstDc;
PAINTSTRUCT paintInfo;
BOOL result;
switch (msg)
{
case WM_CREATE:
if (initFrameBuffer())
return -1;
if (!SetTimer(window, SCREEN_UPDATE_TIMER_ID, USER_TIMER_MINIMUM, NULL))
{
reportSysError(_T("Failed to create the display update timer."));
return -1;
}
break;
case WM_DESTROY:
deinitialize();
PostQuitMessage(exitCode);
break;
case WM_KEYDOWN:
if (wParam == VK_ESCAPE)
DestroyWindow(window);
break;
case WM_TIMER:
InvalidateRect(window, NULL, FALSE);
break;
case WM_PAINT:
dstDc = BeginPaint(window, &paintInfo);
updateScreen();
BitBlt(dstDc, - (int) bufOffset, 0, WIDTH, HEIGHT, bufDc, 0, 0, SRCCOPY);
EndPaint(window, &paintInfo);
updateFps();
break;
default:
return DefWindowProc(window, msg, wParam, lParam);
}
return 0;
}
Common::Error CruiseEngine::run() {
// Initialize backend
initGraphics(320, 200, false);
if (!loadLanguageStrings()) {
error("Could not setup language data for your version");
return Common::kUnknownError; // for compilers that don't support NORETURN
}
initialize();
Cruise::changeCursor(Cruise::CURSOR_NORMAL);
CursorMan.showMouse(true);
lastTick = 0;
lastTickDebug = 0;
mainLoop();
deinitialize();
return Common::kNoError;
}
void indri::thread::UtilityThread::run() {
indri::thread::ScopedLock lock( _lock );
try {
UINT64 waitTime = initialize();
while( _runThread ) {
bool noTimeout = _quit.wait( _lock, waitTime );
if( noTimeout )
continue; // interrupted
waitTime = work();
}
while( hasWork() )
work();
deinitialize();
} catch( lemur::api::Exception& e ) {
std::cout << "UtilityThread exiting from exception " << e.what() << std::endl;
}
}
void MonsterManager::reload()
{
deinitialize();
initialize();
}
IndexBufferDx::~IndexBufferDx() {
deinitialize();
}
VertexBufferDx::~VertexBufferDx() {
deinitialize();
}
CanvasGL::~CanvasGL() {
deinitialize();
}
jHWRJapanese::~jHWRJapanese()
{
deinitialize();
}
