Exemplo n.º 1
0
/*
////////////////////////////////////////////////////////////////////////
-----------------------------------------------------------------------
                                  MAIN
-----------------------------------------------------------------------
\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
*/
int main(int argc, char **argv)
{
    /** VARIÁVEIS *****************************************************/
    int func_err; int test_mode = 0;
    clock_t init, end;
    int sair = 0;

    /* Struct com argumentos da linha de comando */
    Options args = { FLUX, HEIGHT, LENGTH, ITERATIONS, ZONE, ISLAND,
                     SEED, FREQ, STDOUT, 0, 0, 0};

    /** ARGUMENTOS/MENU ***********************************************/
    func_err = receive_arguments(argc, argv, &args);
    if(func_err) return EXIT_FAILURE;

    if(args.h == 1)
    {
        printf("\n%s\n", help);
        return EXIT_SUCCESS;
    }

    /* Modo de teste: */
    test_mode = args.t + args.T;

    /* Chamada para o nosso menu do usuário:
     * Quando ele devolve 'falha', o usuário quer sair do jogo */
    if(!test_mode) func_err = menu(&args);
    if(func_err == EXIT_FAILURE) return EXIT_SUCCESS;

    /** CONFIGURAÇÕES DO RIO ******************************************/
    river_config_flux    (args.F);
    river_config_size    (args.L, args.H);
    river_config_island  (args.i, args.f);
    river_config_margins (args.Z);

    /** ANIMAÇÃO DO RIO ***********************************************/
    test_mode = args.t + args.T;

    river_animation_init();
    if(test_mode) analyse_program(args.s, args.N, test_mode, args.o);
    else
    {
        river_animation_generate(args.s);
        while(!sair)
        {
            for(end = init = clock(); end-init < INTERVAL; end = clock());
            sair = river_animation_iterate();
        }
    }

    /** LIBERAÇÃO DE MEMÓRIA ******************************************/
    river_animation_finish();

    return EXIT_SUCCESS;
}
Exemplo n.º 2
0
cmm_error_t
frame_receive( int fd,
               frame_t **frame )
{
    unsigned char sender, dest;
    char type = -1;
    cmm_error_t err;

    if ( frame_buffer_read(fd, (char*)&sender, sizeof(sender))
         || frame_buffer_read(fd, (char*)&dest, sizeof(dest))
         || frame_buffer_read(fd, (char*)&type, sizeof(type)) ) {
        cm_trace(CM_TRACE_LEVEL_DEBUG,
                 "Warning ! frame_buffer_read failed" );
        return(CMM_ECONN);
    }

    *frame = frame_allocate( (frame_type_t)type, sender );
    if (!*frame) {
        cm_trace(CM_TRACE_LEVEL_ERROR, 
                 "frame_allocate failed" );
        return(CMM_ENOMEM);
    }

    (*frame)->dest = dest;
    (*frame)->type = (frame_type_t)type;

    err = receive_arguments(fd, *frame);
    if (err != CMM_OK) {
        cm_trace(CM_TRACE_LEVEL_ERROR, 
                 "receive_arguments failed");
        frame_free( frame );
        return(err);
    }

    if (type != FRAME_HEARTBEAT) {
        cm_trace(CM_TRACE_LEVEL_DEBUG,
                 "Received a frame of type %s from nodeid %d",
                 frame_type_strings[(int)type],
                 sender);
    }

    return(CMM_OK);
}
Exemplo n.º 3
0
/*
////////////////////////////////////////////////////////////////////////
-----------------------------------------------------------------------
                                  MAIN
-----------------------------------------------------------------------
\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
*/
int main(int argc, char **argv)
{
    /** VARIÁVEIS *****************************************************/
        int test_mode = 0; /* Auxiliar para por o programa em teste  */
        int func_err;      /* Faz a captura do resultado das saídas  */
        int exit = 0;      /* Auxiliar para definir quando sair      */
        clock_t init;      /* Início do relógio (para animação)      */
        clock_t end;       /* Fim do relógio (para animação)         */

        /* Struct com argumentos da linha de comando */
        Options args = { FLUX, HEIGHT, LENGTH, ITERATIONS, ZONE,
                         ISLAND, SEED, FREQ, STDOUT, 0, 0, 0};

    /** ARGUMENTOS/MENU/CONFIGURAÇÕES *********************************/
        func_err = receive_arguments(argc, argv, &args);
        if(func_err) return EXIT_FAILURE;

        if(args.h == 1)
        {
            printf("\n%s\n", help);
            return EXIT_SUCCESS;
        }

        func_err = system("ls options.conf; return $?");
        if(!func_err)
        {
            /* Arquivo de configuração: options.conf
             * Guarda o stream no padrão yyin do scanner */
            yyin = fopen("options.conf", "r");

            /* Chama o parser para ler opções */
            func_err = yyparse();
            if(func_err)
            {
                fprintf(stderr, "Problemas no arquivo de configuração!\n");
                return EXIT_FAILURE;
            }

            /* Atribui opções nos argumentos */
            args = yygetopt(&args);

            /* Fecha o arquivo configurado para leitura */
            fclose(yyin);
        }
        else printf("options.conf não identificado\n");

        /* Modo de teste: */
        test_mode = args.t + args.T;

    /** CICLO DO JOGO *************************************************/
        while(exit != EXIT_FAILURE)
        {
            /*- MENU ------------------------------------------------*/
                /* Chamada para o nosso menu do usuário:
                 * Quando devolve 'falha', o usuário quer sair */
                if(!test_mode) func_err = menu(&args);
                if(func_err == EXIT_FAILURE) break;

            /*- CONFIGURAÇÕES --------------------------------------*/
                river_config_flux    (args.F);
                river_config_size    (args.L, args.H);
                river_config_island  (args.i, args.f);
                river_config_margins (args.Z);

                test_mode = args.t + args.T;

            /*- ANIMAÇÃO -------------------------------------------*/
                river_animation_init();
                if(test_mode)
                    analyse_program(args.s, args.N, test_mode, args.o);
                else
                {
                    river_animation_generate(args.s);
                    while(!exit)
                    {
                        end = init = clock();
                        while(end-init < INTERVAL) end = clock();
                        exit = river_animation_iterate();
                    }
                    exit = 0;
                }

            /*- LIBERAÇÃO DE MEMÓRIA ------------------------------*/
                river_animation_finish();

        } /* while(exit != EXIT_FAILURE) */

    /** LIBERAÇÃO DE MEMÓRIA ******************************************/
        river_animation_finish();

    return EXIT_SUCCESS;
}