Annotation of ADD_ver_10/Source Code/Source Files/GUI.c, revision 1.2

1.1       rico        1: /********************************************************************/
                      2: /*  GUI.c                                                           */
                      3: /*                                                                  */
1.2     ! rico        4: /*                                                                  */
1.1       rico        5: /*  Copyright (c) 1997-2006 Rafael Rico      (rafael.rico@uah.es)   */
                      6: /*                                                                  */
1.2     ! rico        7: /*  Este fichero forma parte de ADD                                 */
        !             8: /*  (Analizador de Dependencias de Datos)                           */
        !             9: /*  Version 5.10.                                                   */
        !            10: /*                                                                  */
1.1       rico       11: /*                                                                  */
1.2     ! rico       12: /*  ADD es software libre. Puede redistribuirlo y/o modificarlo     */
        !            13: /*  bajo los términos de la Licencia Pública General de GNU         */
        !            14: /*  según es publicada por la Free Software Foundation, bien bajo   */
        !            15: /*  la versión 2 de dicha Licencia o bien (según su elección)       */
        !            16: /*  bajo cualquier versión posterior.                               */
1.1       rico       17: /*                                                                  */
1.2     ! rico       18: /*  ADD se distribuye con la esperanza de que sea útil,             */
        !            19: /*  pero SIN NINGUNA GARANTÍA, incluso sin la garantía MERCANTIL    */
        !            20: /*  implícita y sin garantizar la CONVENIENCIA PARA UN PROPÓSITO    */
        !            21: /*  PARTICULAR. Véase la Licencia Pública General de GNU para       */
        !            22: /*  más detalles.                                                   */
1.1       rico       23: /*                                                                  */
1.2     ! rico       24: /*  Debería haber recibido una copia de la Licencia Pública General */
        !            25: /*  junto con ADD. Si no ha sido así, escriba a la Free Software    */
        !            26: /*  Foundation, Inc., 51 Franklin St, Fifth Floor,                  */
        !            27: /*  Boston, MA  02110-1301  EEUU.                                   */
1.1       rico       28: /*                                                                  */
1.2     ! rico       29: /*  -------------------------- Historia --------------------------- */
1.1       rico       30: /*                                                                  */
1.2     ! rico       31: /*  $Id$                                                            */
1.1       rico       32: /*                                                                  */
1.2     ! rico       33: /*  Revisión 1.2. 01/2006                                           */
        !            34: /*  Se añade la licencia GPL y documentación en estilo Javadoc      */
1.1       rico       35: /*                                                                  */
1.2     ! rico       36: /*  Revisión 1.1. 09/2005                                           */
        !            37: /*  Versión inicial                                                 */
1.1       rico       38: /*                                                                  */
                     39: /********************************************************************/
                     40: 
                     41: /******************************************************************************/
                     42: /* MÓDULO: GUI.c                                                              */
                     43: /*                                                                            */
                     44: /* Este módulo contiene las funciones de presentación visual.                 */
                     45: /******************************************************************************/
                     46: /* Fecha: 16 de septiembre de 2005                                            */
                     47: /******************************************************************************/
                     48: 
                     49: #include <stdio.h>
                     50: #include <string.h>
                     51: #include <time.h>
                     52: 
                     53: #include "defines.h"
                     54: #include "tipos.h"
                     55: #include "gui.h"
                     56: 
                     57: 
                     58: /* configuración */
                     59: extern struct argumentos configuracion;
                     60: 
                     61: /* contadores de instrucciones y ventanas */
                     62: extern unsigned long instruccion, ventana;
                     63: 
                     64: 
                     65: /* esta función presenta en la pantalla información acerca del análisis en curso */
                     66: void PresentarConfiguracionPantalla()
                     67: {
1.2     ! rico       68:     /* información sobre origen de datos */
        !            69:     printf("Procesando %s en '%s'\n\n", 
1.1       rico       70:             configuracion.origen==TRAZA ? "traza":"secuencia", 
1.2     ! rico       71:             configuracion.ficherodatos); 
        !            72: 
        !            73:     /* información sobre rango a procesar */
        !            74:     printf("Rango %2.2f%% desde %2.2f%%\n\n", 
1.1       rico       75:             configuracion.rango,
                     76:             configuracion.comienzo);
                     77: 
                     78:     /* información sobre el tamaño de la ventana de instrucciones */
1.2     ! rico       79:     printf("Tamaño de ventana = %d instrucciones\n\n", configuracion.ventana);
1.1       rico       80:     
                     81:     /* información sobre las contribuciones a tener en cuenta en */ 
                     82:     /* la composición de dependencias de datos */
                     83:     printf("Mapa de composción de dependencias:\n");
                     84:     printf("(T A O) (E I) (D A S C)\n");
                     85: 
                     86:     printf("(%c %c %c) (%c %c) (%c %c %c %c)", 
                     87:         configuracion.verdaderas==SI ? 'x':'o',
                     88:         configuracion.antidependencias==SI ? 'x':'o',
                     89:         configuracion.salida==SI ? 'x':'o',
                     90:         configuracion.explicitos==SI ? 'x':'o',
                     91:         configuracion.implicitos==SI ? 'x':'o',
                     92:         configuracion.datos==SI ? 'x':'o',
                     93:         configuracion.direcciones==SI ? 'x':'o',
                     94:         configuracion.pila==SI ? 'x':'o',
                     95:         configuracion.cc==SI ? 'x':'o');
                     96: 
                     97:     printf("\n\n");
                     98: }
                     99: 
                    100: 
                    101: /* esta función muestra información acerca del procesamiento en curso */
                    102: 
                    103: void MostrarCabecera()
                    104: {
                    105:     if(configuracion.origen != CADENAHEX)
                    106:     {
                    107:         printf("ADD 5.10 --Analizador de Dependencias de Datos--\n\n");
                    108:         
                    109:         /*
                    110:         printf("Procesando %s en '%s' (rango %2.2f%%)\n\n", 
                    111:             configuracion.origen==TRAZA ? "traza":"secuencia", 
                    112:             configuracion.ficherodatos, 
                    113:             configuracion.rango);
                    114:         */
                    115: 
                    116:         PresentarConfiguracionPantalla();
                    117:     }
                    118: }
                    119: 
                    120: 
                    121: /* esta función muestra el estado de procesamiento */
                    122: 
                    123: void PresentarEstadoProcesamiento(unsigned long total, unsigned long encurso)
                    124: {
                    125:     time_t tiempo;
                    126:     struct tm *ptr_tm;
                    127:     char fechahora[40];
                    128: 
                    129:     static char paso25;   /* flags para indicar estado de procesamiento */
                    130:     static char paso50;
                    131:     static char paso75;
                    132: 
1.2     ! rico      133:     /* inicializo los flags la primera vez y escribo la hora de comienzo */
        !           134:     if(encurso == 1)
        !           135:     {
        !           136:         paso25=SI; paso50=SI; paso75=SI;
        !           137:         /* fecha y hora */
        !           138:         tiempo = time(NULL);
        !           139:         ptr_tm = localtime(&tiempo);
        !           140:         strftime(fechahora, MAX_LINE, "%d/%m/%y %H:%M", ptr_tm);
        !           141:         printf("Hora de comienzo   [%s]\n", fechahora);
        !           142:     }
1.1       rico      143:     
                    144:     if(paso75==SI)
                    145:     {
                    146:         if(paso50==SI)
                    147:         {
                    148:             if(paso25==SI)
                    149:             {
                    150:                 if(((double)encurso/total) > 0.25) 
                    151:                 {
                    152:                     /* fecha y hora */
                    153:                     tiempo = time(NULL);
                    154:                     ptr_tm = localtime(&tiempo);
                    155:                     strftime(fechahora, MAX_LINE, "%d/%m/%y %H:%M", ptr_tm);
                    156:                     printf("Completado el 25%%  [%s]\n", fechahora);
                    157:                     paso25=NO;
                    158:                 }
                    159:             }
                    160:             else
                    161:             {
                    162:                 if(((double)encurso/total) > 0.50) 
                    163:                 {
                    164:                     /* fecha y hora */
                    165:                     tiempo = time(NULL);
                    166:                     ptr_tm = localtime(&tiempo);
                    167:                     strftime(fechahora, MAX_LINE, "%d/%m/%y %H:%M", ptr_tm);
                    168:                     printf("Completado el 50%%  [%s]\n", fechahora);
                    169:                     paso50=NO;
                    170:                 }
                    171:             }
                    172:         }
                    173:         else
                    174:         {
                    175:             if(((double)encurso/total) > 0.75) 
                    176:             {
                    177:                 /* fecha y hora */
                    178:                 tiempo = time(NULL);
                    179:                 ptr_tm = localtime(&tiempo);
                    180:                 strftime(fechahora, MAX_LINE, "%d/%m/%y %H:%M", ptr_tm);
                    181:                 printf("Completado el 75%%  [%s]\n", fechahora);
                    182:                 paso75=NO;
                    183:             }
                    184:         }
                    185:     }
                    186: }
                    187: 
                    188: 
                    189: /* esta función muestra en la pantalla la información de la tarjeta de operandos */
                    190: 
                    191: void MostrarTarjeta(fichainstruccion *tarjetaoperandos)
                    192: {
                    193:     /* imprimo la tarjeta de la instrucción para ver si funciona bien */
                    194:     
                    195:     int i;
                    196:     unsigned long total;
                    197:     char cadena[MAX_LINE];
                    198: 
                    199:     /* todo esto no funciona aquí */
                    200:     /* printf("\x01B[2J"); */   /* código de escape ANSI para borrar la pantalla */
                    201:     /* printf("\027[2J");  */   /* código de escape ANSI para borrar la pantalla */
                    202:     /* printf("%c[2J", 27);*/   /* código de escape ANSI para borrar la pantalla */
                    203:     /* printf("\033[2J");  */ 
                    204: 
                    205:     printf("\n");
                    206:     total = configuracion.ultima - configuracion.primera + 1;
                    207:     i = printf("-| instruccion %lu de %lu (%.2f%%) |", instruccion, total, 100.00*instruccion/total);
                    208:     /* parece que '.2' redondea algo hacia arriba (llegamos al 100% cuando estamos en 99.99%) */
                    209:     i += printf("-| ventana %lu de %lu (%d ins/ven) |", ventana, total/configuracion.ventana, configuracion.ventana);
                    210:     for(i; i<80; i++) printf("-");
                    211: 
                    212:     printf("%-14s  ", tarjetaoperandos->hexadecimal);
                    213: 
                    214:     /* formato de instrucción (notación de INTEL) */
                    215:     /*
                    216:     printf("%s%s", tarjetaoperandos->prefijo, tarjetaoperandos->prefijo[0]!='\0' ? " ":"");
                    217: 
                    218:     printf("%s", tarjetaoperandos->nemonico);
                    219:     printf("%s%s", tarjetaoperandos->op1[0]!='\0' ? " ":"", tarjetaoperandos->op1);
                    220:     printf("%s%s%s", (tarjetaoperandos->op1[0]!='\0' && tarjetaoperandos->op2[0]!='\0') ? ",":"", tarjetaoperandos->op2[0]!='\0' ? " ":"", tarjetaoperandos->op2);
                    221:     */
                    222:     /* igual con la función del módulo 'Auxiliares.c' */
                    223:     CadenaEnsamblador(tarjetaoperandos->prefijo, tarjetaoperandos->nemonico, tarjetaoperandos->op1, tarjetaoperandos->op2, INTEL, cadena);
                    224:     printf("%s", cadena);
                    225: 
                    226:     printf("   ");
                    227:     
                    228:     printf("(long:%d", tarjetaoperandos->longitud);
                    229:     switch(tarjetaoperandos->salto)
                    230:     {
                    231:         case INCONDICIONAL:
                    232:         printf(" salto:INCONDICIONAL");
                    233:         break;
                    234: 
                    235:         case NO_SALTO:
                    236:         printf(" salto:NO SALTO");
                    237:         break;
                    238: 
                    239:         case TOMADO:
                    240:         printf(" salto:TOMADO");
                    241:         break;
                    242: 
                    243:         case NOTOMADO:
                    244:         printf(" salto:NO TOMADO");
                    245:         break;
                    246:     }
                    247: 
                    248:     printf(" ALU=%d", tarjetaoperandos->ciclosALU);
                    249:     printf(" BIU=%d)\n", tarjetaoperandos->ciclosBIU);
                    250: 
                    251:     printf("\nExpl leido datos:    %s", tarjetaoperandos->leidoexpldatos);
                    252:     printf("\nExpl leido dir:      %s", tarjetaoperandos->leidoexpldir);
                    253:     printf("\nExpl leido pila:     %s", tarjetaoperandos->leidoexplpila);
                    254:     printf("\nExpl leido estado:   %s", tarjetaoperandos->leidoexplestado);
                    255:     printf("\nExpl escrito datos:  %s", tarjetaoperandos->escritoexpldatos);
                    256:     printf("\nExpl escrito dir:    %s", tarjetaoperandos->escritoexpldir);
                    257:     printf("\nExpl escrito pila:   %s", tarjetaoperandos->escritoexplpila);
                    258:     printf("\nExpl escrito estado: %s", tarjetaoperandos->escritoexplestado);
                    259:     printf("\nImpl leido datos:    %s", tarjetaoperandos->leidoimpldatos);
                    260:     printf("\nImpl leido dir:      %s", tarjetaoperandos->leidoimpldir);
                    261:     printf("\nImpl leido pila:     %s", tarjetaoperandos->leidoimplpila);
                    262:     printf("\nImpl leido estado:   %s", tarjetaoperandos->leidoimplestado);
                    263:     printf("\nImpl escrito datos:  %s", tarjetaoperandos->escritoimpldatos);
                    264:     printf("\nImpl escrito dir:    %s", tarjetaoperandos->escritoimpldir);
                    265:     printf("\nImpl escrito pila:   %s", tarjetaoperandos->escritoimplpila);
                    266:     printf("\nImpl escrito estado: %s", tarjetaoperandos->escritoimplestado);
                    267: 
                    268:     printf("\n");
                    269: 
                    270:     getchar();
                    271: }
                    272: 
                    273: 
                    274: 
                    275: /* esta función muestra en la pantalla la información relativa a la ventana en curso */
                    276: 
                    277: void MostrarVentana()
                    278: {
                    279:     printf("\nEsta función no ha sido implementada\n");
                    280: }
                    281: 
                    282: 

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>