Return to GUI.c CVS log

Up to [Repository ATC2] / ADD_ver_10

*** empty log message ***

/********************************************************************/
/*  GUI.c                                                           */
/*                                                                  */
/*  Copyright (c) 1997-2006 Rafael Rico      (rafael.rico@uah.es)   */
/*                                                                  */
/*  This file is part of ADD version 5.10.                          */
/*                                                                  */
/*  ADD is free software; you can redistribute it and/or modify     */
/*  it under the terms of the GNU General Public License as         */
/*  published by the Free Software Foundation; either version 2 of  */
/*  the License, or (at your option) any later version.             */
/*                                                                  */
/*  ADD is distributed in the hope that it will be useful,          */
/*  but WITHOUT ANY WARRANTY; without even the implied warranty of  */
/*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the   */
/*  GNU General Public License for more details.                    */
/*                                                                  */
/*  You should have received a copy of the GNU General Public       */
/*  License along with ADD; if not, write to the Free Software      */
/*  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA        */
/*  02111-1307  USA                                                 */
/*                                                                  */
/*  --------------------------- History --------------------------- */
/*                                                                  */
/*  Revision 1.3. 02/2006                                           */
/*  Improve interactive presentation in screen                      */
/*                                                                  */
/*  Revision 1.2. 01/2006                                           */
/*  Added GPL License and JavaDoc style documentation               */
/*                                                                  */
/*  Revision 1.1. 09/2005                                           */
/*  Initial Revision                                                */
/*                                                                  */
/********************************************************************/

/******************************************************************************/
/* MÓDULO: GUI.c                                                              */
/*                                                                            */
/* Este módulo contiene las funciones de presentación visual.                 */
/******************************************************************************/
/* Fecha: 16 de septiembre de 2005                                            */
/******************************************************************************/

#include <stdio.h>
#include <string.h>
#include <time.h>

#include "defines.h"
#include "tipos.h"
#include "gui.h"


/* configuración */
extern struct argumentos configuracion;

/* contadores de instrucciones y ventanas */
extern unsigned long instruccion, ventana;


/* esta función presenta en la pantalla información acerca del análisis en curso */
void PresentarConfiguracionPantalla()
{
    /* información sobre origen de datos y rango a procesar */
    printf("Procesando %s en '%s' (rango %2.2f%% desde %2.2f%%)\n\n", 
            configuracion.origen==TRAZA ? "traza":"secuencia", 
            configuracion.ficherodatos, 
            configuracion.rango,
            configuracion.comienzo);

    /* información sobre el tamaño de la ventana de instrucciones */
    printf("Tamaño de la ventana = %d instrucciones\n\n", configuracion.ventana);
    
    /* información sobre las contribuciones a tener en cuenta en */ 
    /* la composición de dependencias de datos */
    printf("Mapa de composción de dependencias:\n");
    printf("(T A O) (E I) (D A S C)\n");

    printf("(%c %c %c) (%c %c) (%c %c %c %c)", 
        configuracion.verdaderas==SI ? 'x':'o',
        configuracion.antidependencias==SI ? 'x':'o',
        configuracion.salida==SI ? 'x':'o',
        configuracion.explicitos==SI ? 'x':'o',
        configuracion.implicitos==SI ? 'x':'o',
        configuracion.datos==SI ? 'x':'o',
        configuracion.direcciones==SI ? 'x':'o',
        configuracion.pila==SI ? 'x':'o',
        configuracion.cc==SI ? 'x':'o');

    printf("\n\n");
}


/* esta función muestra información acerca del procesamiento en curso */

void MostrarCabecera()
{
    if(configuracion.origen != CADENAHEX)
    {
        printf("ADD 5.10 --Analizador de Dependencias de Datos--\n\n");
        
        /*
        printf("Procesando %s en '%s' (rango %2.2f%%)\n\n", 
            configuracion.origen==TRAZA ? "traza":"secuencia", 
            configuracion.ficherodatos, 
            configuracion.rango);
        */

        PresentarConfiguracionPantalla();
    }
}


/* esta función muestra el estado de procesamiento */

void PresentarEstadoProcesamiento(unsigned long total, unsigned long encurso)
{
    time_t tiempo;
    struct tm *ptr_tm;
    char fechahora[40];

    static char paso25;   /* flags para indicar estado de procesamiento */
    static char paso50;
    static char paso75;

    /* inicializo los flags la primera vez */
    if(encurso == 1) {paso25=SI; paso50=SI; paso75=SI;}
    
    if(paso75==SI)
    {
        if(paso50==SI)
        {
            if(paso25==SI)
            {
                if(((double)encurso/total) > 0.25) 
                {
                    /* fecha y hora */
                    tiempo = time(NULL);
                    ptr_tm = localtime(&tiempo);
                    strftime(fechahora, MAX_LINE, "%d/%m/%y %H:%M", ptr_tm);
                    printf("Completado el 25%%  [%s]\n", fechahora);
                    paso25=NO;
                }
            }
            else
            {
                if(((double)encurso/total) > 0.50) 
                {
                    /* fecha y hora */
                    tiempo = time(NULL);
                    ptr_tm = localtime(&tiempo);
                    strftime(fechahora, MAX_LINE, "%d/%m/%y %H:%M", ptr_tm);
                    printf("Completado el 50%%  [%s]\n", fechahora);
                    paso50=NO;
                }
            }
        }
        else
        {
            if(((double)encurso/total) > 0.75) 
            {
                /* fecha y hora */
                tiempo = time(NULL);
                ptr_tm = localtime(&tiempo);
                strftime(fechahora, MAX_LINE, "%d/%m/%y %H:%M", ptr_tm);
                printf("Completado el 75%%  [%s]\n", fechahora);
                paso75=NO;
            }
        }
    }
}


/* esta función muestra en la pantalla la información de la tarjeta de operandos */

void MostrarTarjeta(fichainstruccion *tarjetaoperandos)
{
    /* imprimo la tarjeta de la instrucción para ver si funciona bien */
    
    int i;
    unsigned long total;
    char cadena[MAX_LINE];

    /* todo esto no funciona aquí */
    /* printf("\x01B[2J"); */   /* código de escape ANSI para borrar la pantalla */
    /* printf("\027[2J");  */   /* código de escape ANSI para borrar la pantalla */
    /* printf("%c[2J", 27);*/   /* código de escape ANSI para borrar la pantalla */
    /* printf("\033[2J");  */ 

    printf("\n");
    total = configuracion.ultima - configuracion.primera + 1;
    i = printf("-| instruccion %lu de %lu (%.2f%%) |", instruccion, total, 100.00*instruccion/total);
    /* parece que '.2' redondea algo hacia arriba (llegamos al 100% cuando estamos en 99.99%) */
    i += printf("-| ventana %lu de %lu (%d ins/ven) |", ventana, total/configuracion.ventana, configuracion.ventana);
    for(i; i<80; i++) printf("-");

    printf("%-14s  ", tarjetaoperandos->hexadecimal);

    /* formato de instrucción (notación de INTEL) */
    /*
    printf("%s%s", tarjetaoperandos->prefijo, tarjetaoperandos->prefijo[0]!='\0' ? " ":"");

    printf("%s", tarjetaoperandos->nemonico);
    printf("%s%s", tarjetaoperandos->op1[0]!='\0' ? " ":"", tarjetaoperandos->op1);
    printf("%s%s%s", (tarjetaoperandos->op1[0]!='\0' && tarjetaoperandos->op2[0]!='\0') ? ",":"", tarjetaoperandos->op2[0]!='\0' ? " ":"", tarjetaoperandos->op2);
    */
    /* igual con la función del módulo 'Auxiliares.c' */
    CadenaEnsamblador(tarjetaoperandos->prefijo, tarjetaoperandos->nemonico, tarjetaoperandos->op1, tarjetaoperandos->op2, INTEL, cadena);
    printf("%s", cadena);

    printf("   ");
    
    printf("(long:%d", tarjetaoperandos->longitud);
    switch(tarjetaoperandos->salto)
    {
        case INCONDICIONAL:
        printf(" salto:INCONDICIONAL");
        break;

        case NO_SALTO:
        printf(" salto:NO SALTO");
        break;

        case TOMADO:
        printf(" salto:TOMADO");
        break;

        case NOTOMADO:
        printf(" salto:NO TOMADO");
        break;
    }

    printf(" ALU=%d", tarjetaoperandos->ciclosALU);
    printf(" BIU=%d)\n", tarjetaoperandos->ciclosBIU);

    printf("\nExpl leido datos:    %s", tarjetaoperandos->leidoexpldatos);
    printf("\nExpl leido dir:      %s", tarjetaoperandos->leidoexpldir);
    printf("\nExpl leido pila:     %s", tarjetaoperandos->leidoexplpila);
    printf("\nExpl leido estado:   %s", tarjetaoperandos->leidoexplestado);
    printf("\nExpl escrito datos:  %s", tarjetaoperandos->escritoexpldatos);
    printf("\nExpl escrito dir:    %s", tarjetaoperandos->escritoexpldir);
    printf("\nExpl escrito pila:   %s", tarjetaoperandos->escritoexplpila);
    printf("\nExpl escrito estado: %s", tarjetaoperandos->escritoexplestado);
    printf("\nImpl leido datos:    %s", tarjetaoperandos->leidoimpldatos);
    printf("\nImpl leido dir:      %s", tarjetaoperandos->leidoimpldir);
    printf("\nImpl leido pila:     %s", tarjetaoperandos->leidoimplpila);
    printf("\nImpl leido estado:   %s", tarjetaoperandos->leidoimplestado);
    printf("\nImpl escrito datos:  %s", tarjetaoperandos->escritoimpldatos);
    printf("\nImpl escrito dir:    %s", tarjetaoperandos->escritoimpldir);
    printf("\nImpl escrito pila:   %s", tarjetaoperandos->escritoimplpila);
    printf("\nImpl escrito estado: %s", tarjetaoperandos->escritoimplestado);

    printf("\n");

    getchar();
}



/* esta función muestra en la pantalla la información relativa a la ventana en curso */

void MostrarVentana()
{
    printf("\nEsta función no ha sido implementada\n");
}