gamehack wrote:

Hello all,

I've thought about having to implement 2 functions, say
enter_main_loop(func_name); and a function called quit_application();
which terminates the program. The enter_main_loop() can be defined as
something like:
int enter_main_loop(func_name)

This might as well be void enter_main_loop() as it never returns.

{
while(1)
{
func_name();
}

Making this redundant as well.

return 0;
}

But then how am I going to implement the quit_application(); ? The
only way I thought it could be handled is changing enter_main_loop to
something like:
int terminate = 0;

int enter_main_loop(func_name)
{
if(!terminate)
func_name();

return 0;
}

This is not at all same as your first example, as it doesn't loop.

and then quit_application(); can simply do
int quit_application()
{
return (terminate = 1);
}

Where would you call this from (and why)?

What do you think about this approach? Any better ways of achieving
the same effect? I'm planning to use the quit_application() in a
multithreaded environment so I assume it should be thread-safe (but it
isn't now, is it)?

I think you're on more-or-less right track. Could this be what you want:

#include <stdlib.h>

#define QUIT_LPIN (1)
#define KEEP_LPIN !(QUIT_LPIN)

int func_name(/* whatever */);
int quit_application(/* whatever */);
void enter_main_loop(/* whatever */);

int main(void)
{
enter_main_loop(/* whatever */);

return quit_application(/* whatever */);
}

void enter_main_loop(/* whatever */)
{
while (1)
{
if (QUIT_LPIN == func_name()) return;
}
}

int func_name(/* whatever */)
{
int time_to_quit = KEEP_LPIN;

/* do stuff possibly changing time_to_quit value */

return time_to_quit;
}

int quit_application(/* whatever */)
{
int success = EXIT_SUCCESS;

/* do cleanup stuff possibly setting success = EXIT_FAILURE */

return success;
}

Cheers

Vladimir

Vladimir S. wrote:
gamehack wrote:

Hello all,

I've thought about having to implement 2 functions, say
enter_main_loop(func_name); and a function called quit_application();
which terminates the program. The enter_main_loop() can be defined as
something like:
int enter_main_loop(func_name)

This might as well be void enter_main_loop() as it never returns.

{
while(1)
{
func_name();
}
--
Making this redundant as well.

return 0;
}

But then how am I going to implement the quit_application(); ? The
only way I thought it could be handled is changing enter_main_loop to
something like:
int terminate = 0;

int enter_main_loop(func_name)
{
if(!terminate)
func_name();

return 0;
}

This is not at all same as your first example, as it doesn't loop.
--
and then quit_application(); can simply do
int quit_application()
{
return (terminate = 1);
}

Where would you call this from (and why)?
--
What do you think about this approach? Any better ways of achieving
the same effect? I'm planning to use the quit_application() in a
multithreaded environment so I assume it should be thread-safe (but it
isn't now, is it)?

I think you're on more-or-less right track. Could this be what you want:

#include <stdlib.h>

#define QUIT_LPIN (1)
#define KEEP_LPIN !(QUIT_LPIN)

int func_name(/* whatever */);
int quit_application(/* whatever */);
void enter_main_loop(/* whatever */);

int main(void)
{
enter_main_loop(/* whatever */);

return quit_application(/* whatever */);
}

void enter_main_loop(/* whatever */)
{
while (1)
{
if (QUIT_LPIN == func_name()) return;
}
}

int func_name(/* whatever */)
{
int time_to_quit = KEEP_LPIN;

/* do stuff possibly changing time_to_quit value */

return time_to_quit;
}

int quit_application(/* whatever */)
{
int success = EXIT_SUCCESS;

/* do cleanup stuff possibly setting success = EXIT_FAILURE */

return success;
}

Cheers

Vladimir

Sat, 28 Jan 2006 16:09:16 UTC, "gamehack" <gamehack@gmail.com>
wrote:

This is what I meant:

int func_name();
void enter_main_loop(func_name);
void quit_main_loop(void);

volatile int terminate = 0; /* thread save */

void enter_main_loop(func_name)
{
while(!terminate)
{
>func_name();
}
}
--
void quit_main_loop(void)
{
terminate = 1;
}

and then in main.c:

int main(int argc, char* argv[])
{
enter_main_loop(func_name);

return 0;
}

The only problem I can see is that func_name() can hold the termination
if it is synchronous. The func_name() function will be responsible for
making async calls(implemented with threads) to other sync functions
which operate on a call queue so I can call quit_main_loop(); from
anywhere and it will terminate the program without waiting for some
function to finish doing its work.

Thanks

For your problem the standard defines volatile - even C knows nothing
about threads.
So whenever a thread needs to quit the whole app it will change
terminate to not be 0 (it is on quit_main_loop to determine that all
threads are ready to let main (and themrself die.

Malcolm wrote:

"gamehack" <gamehack@gmail.comwrote
>What do you think about this approach? Any better ways of achieving
>the same effect? I'm planning to use the quit_application() in a
>multithreaded environment so I assume it should be thread-safe (but
>it isn't now, is it)?
>>
Use setjmp() and lngjmp().

there is no option than to make every function in your
program return a "terminate" flag.

<T>
I don't think setjmp() and lngjmp() are thread safe either. I don't
think they're very safe/good practice either, threads or no threads.
</T>