Análisis del sistema
Fco. Javier Bohórquez Ogalla

Índice General

• Modelo conceptual
  • Intérprete
  • Nodos ejecutables
  • Tipos de datos
  • Sentencias de control de flujo
  • Definiciones
  • Asignaciones
  • Operadores aritméticos
  • Operadores lógicos
  • Operadores sobre cadenas
  • Operadores sobre array
  • Operadores sobre expresiones regulares
  • Conversión de tipos
  • Operadores de acceso
  • Operadores condicionales
  • Operadores de entrada/salida
  • Operadores informativos
  • Procesos
  • Ficheros
  • Fechas
  • Errores
  • Extensiones
  • rTree
  
  
• Modelo de casos de uso
  • Actores
  • Intérprete
  • runTree
  
  
• Visión general
• Diagramas de secuencia del sistema
  • Intérprete
  • runTree
  
  
• Contratos de operaciones del sistema
  • Intérprete
  • runTree
  
  
• Modelo de interfaz de usuario
  • Intérprete
  • runTree
  • Sitio web

Modelo conceptual

El presente documento representa un análisis de los datos que construyen el sistema OMI y cómo estos se relacionan. El documento describe el modelo conceptual de datos del sistema mediante diagramas de clases. Las clases son organizadas en paquetes para facilitar la modularidad del sistema y su entendimiento.

El proceso de interpretar consiste en tomar código fuente, procesarlo y ejecutar su significado semántico. Por tanto el modelo de datos estará constituido por entidades que guardan un significado concreto y preciso dentro del lenguaje. Estos elementos, que representan la unidad semántica mínima, son denominados nodos ejecutables, debido a que cuando son ejecutados producen el resultado semántico asociado. Muchos nodos ejecutables por si solos no presentan un resultado semántico completo, por lo que precisan de otros nodos.

El diagrama general de paquetes describe los paquetes que componen el sistema según el carácter funcional de las entidades que contienen. Un paquete podrá contener clases u otros paquetes.

El paquete ``interpreter'' describe las entidades que procesan el contenido fuente según el léxico y la gramática del lenguaje OMI. El objetivo es generar el árbol de nodos ejecutables correspondiente al programa. Al procesarse este árbol se aplicará la semántica que encierran las líneas de código del contenido fuente, produciéndose de esta forma la ejecución del programa.

El paquete ``runNode'' describe el nodo ejecutable y aquellos tipos de nodos derivados de este, que son abstractos y que serán extendidos por tipos más específicos.

El paquete ``typeData'' describe los nodos correspondientes a los tipos de datos básicos que pueden ser manipulados por el sistema.

El paquete ``error'' describe el sistema de errores y los nodos ejecutables que permiten su control.

El paquete ``extensions'' describe el sistema de extensiones del interprete, el cual permite extender la funcionalidades del lenguaje de una forma dinámica. Además contiene dos el modelado de dos extensiones concretas.

Los paquetes siguientes categorizan y agrupan nodos ejecutables según la funcionalidad que encierran y el tipo de dato sobre el que operan.

El último paquete ``rtree'' describe el modelo de datos correspondiente al sistema software cliente. Una aplicación web que hace uso del interprete de forma online y representa el estado de este.

Intérprete

El sistema OMI se corresponde con un interprete que opera sobre un contenido fuente escrito en el lenguaje con el mismo nombre. El interprete se compone de un analizador sintáctico que encierra la gramática del lenguaje, esta es descrita a partir de una serie de tokens.

El analizador sintáctico se vale de un analizador léxico que validará y obtendrá los tokens (bajo petición) desde el código fuente. El analizador léxico debe controlar el fichero que contiene el código fuente, así como la línea y posición que se encuentra procesando en el mismo.

Los tokens obtenidos se definen por un identificador y la línea del código fuente en la que se generó, además pueden tener asociado un valor que puede ser numérico o cadena. Serán utilizados por el analizador sintáctico para determinar las reglas gramaticales que se deben aplicar y construir el árbol sintáctico correspondiente. Este árbol está formado por nodos denominados ejecutables, dado que al ser procesados en profundidad se llevará a cabo la ejecución del programa. Los nodos ejecutables dan singnificado semántico a cada una de las sentencias que componen el contenido fuente.

El interprete se compone además de un contexto denominado principal, que será sobre el que opere de forma predeterminada. Un contexto está formado por una serie de tablas de símbolos que serán manipuladas por ciertos nodos ejecutables cuando sean procesados. Estas tablas guardan referencias a nodos ejecutables correspondientes a símbolos variables, funciones y clases de objetos que son definidos en el código fuente. Existen determinados nodos que al ser ejecutados pueden cambiar el contexto en uso.

El interprete es ejecutado con una serie de argumentos que alteran su funcionamiento.

Nodos ejecutables

Se definen un nodo ejecutable para cada aspecto o funcionalidad que contemple el lenguaje. Cada sentencia se corresponde con un nodo ejecutable, que a su vez puede estar compuestos de otros nodos. Cada nodo ejecutable guarda el número de nodos que lo referencian para que se pueda hacer un uso óptimo del mismo.

Las expresiones son nodos ejecutables que tomarán un valor tras ser procesados. Generalmente forman parte de otros nodos correspondientes a sentencias u otras expresiones. El valor que toman pueden ser de un tipo determinado y conocido (numérico, lógico, etc), o de tipo indeterminado o no conocido hasta que el nodo es procesado.

Las expresiones de tipo determinado son extendidas por cada tipo de dato soportado por el lenguaje. Además pueden ser consideradas tipos de objetos y estar así asociadas a una clase. De esta forma toda expresión puede disponer de métodos y atributos según el tipo de dato que guarde.

Las expresiones de tipo indeterminado se componen de una referencia al nodo que guarda el valor tras la ejecución, este podrá ser una expresión de tipo determinado.

Las expresiones son nodos imprimibles lo que significa que tienen una representación gráfica asociada que puede ser volcada en la salida estándar.

Tipos de datos

Este paquete contiene los nodos que representan expresiones con tipos de datos definidos. Se describe cada tipo de dato como un nodo con un valor asociado (en algunos casos el tipo puede comprender un único valor).

Muchos nodos son especializaciones de tipos de datos, correspondiéndose con expresiones que guardan un valor del tipo de dato al que extienden. Así por ejemplo los nodos de operaciones aritméticas generalmente extenderán al nodo del mismo tipo de dato.

Algunos nodos de tipos datos son concretados por nodos que representan un valor constante de dicho tipo de dato.

Sentencias de control de flujo

Sentencia

Sentencia vacía

include

exit

goto

if

switch

while

do...while

for

foreach

iloop

continue

break

try

throw

with

Definiciones

Variables

Funciones

Clases

Objetos

Listas

Pares clave/valor

Etiquetas

Definiciones globales

Generadores

Asignaciones

Asignación

Asignación de referencia

Operadores aritméticos

Suma

Diferencia

Producto

División

Potencia

Módulo

Tamaño

Incremento y asignación

Asignación e incremento

Decremento y asignación

Asignación y decremento

Operadores lógicos

Or

And

Negación

Igual que

Distinto que

Menor que

Menor o igual que

Mayor que

Mayor o igual que

Idéntico a

No idéntico a

Es nulo

Vacío

Operadores sobre cadenas

Concatenación

explode

implode

sprintf

Buscar subcadena

Buscar y remplazar

Remplazar subcadena

Convertir a mayúsculas

Convertir a minúsculas

Operadores sobre array

Dividir en fragmentos

Reducir mediante función

Obtener último

Obtener primero

Insertar en posición

Eliminar posición

Insertar al inicio

Insertar al final

Eliminar del inicio

Eliminar del final

Operadores sobre expresiones regulares

Crear expresión regular

match

search

Conversión de tipos

Conversión a lógico

Conversión a entero

Conversión a flotante

Conversión a cadena

Operadores de acceso

Acceso a clave

Acceso a función

Acceso a variable de entorno

Operadores condicionales

Ternario

Fusión de nulos

Operadores de entrada/salida

Salida estándar

Entrada estándar

Operadores informativos

Tipo de

Tamaño de

Información sobre

Procesos

Crear proceso

Esperar finalización

Obtener identificador

Obtener identificador padre

Ejecutar como proceso

Salir de proceso

Señal a proceso

Manejador de señales

Evaluar cadena

Ejecutar comando del sistema

Ficheros

Obtener un flujo a fichero

Escribir en flujo a fichero

Leer de flujo a fichero

Cambiar posición en fichero

Obtener posición en flujo a fichero

Cerrar flujo a fichero

Leer fichero

Escribir en fichero

Escribir al final de fichero

Fechas

Tiempo Unix

Fecha y hora con formato

sleep

Errores

Extensiones

Biblioteca GNU de internacionalización (gettext)

gettext

setlocale

dgettext

bindtextdomain

textdomain

rTree

El intérprete OMI tiene la capacidad de generar una salida relativa a su estado y funcionamiento. Para completar el proyecto se precisa de una herramienta capaz de interpretar y representar este estado interno de forma gráfica y textual.

El modelo de datos del cliente OMI se define de forma similar al intérprete. La principal diferencia es que en el intérprete este modelo de datos se usa para procesar y ejecutar el código fuente, mientras que en el cliente se usa para representar gráficamente el proceso llevado a cabo. Es por ello que el modelo de datos del cliente es más abstracto.

Modelo de casos de uso

En esta sección se detallan los casos de usos que recogen los sistemas que conforman el proyecto OMI. Un caso de uso describe la secuencia de interacciones entre el sistema y sus actores como consecuencia de un evento.

En primer lugar se describen los actores que hacen uso del sistema, llegándose a distinguir dos que serán nominados usuario y sistema externo. Luego se describen los casos de uso del sistema intérprete y del cliente runTree.

Actores

Los actores humanos que interactúan con los sistemas OMI presentan todos un mismo rol. Así el único actor definido será llamado usuario. Los usuarios que hacen uso del intérprete pueden ser desarrolladores, estudiantes u otros perfiles técnicos, pero todos usarán el sistema de la misma forma.

Por otro lado el intérprete OMI puede ser usado por otros sistemas, viéndose estos actores de determinados casos de uso. Algunos sistemas del proyecto OMI hacen uso del intérprete para llevar a cabo su propósito.

Intérprete

Interpretar entrada estándar

Caso de Uso:

Interpretar entrada estándar.

Tipo:

General.

Descripción:

El usuario introduce un bloque de código en forma de cadena de caracteres mediante la entrada estándar. El sistema lo interpreta y ejecuta.

Actores:

Usuario.

Precondiciones:

El sistema debe estar esperando un bloque de código mediante la entrada estándar.

Postcondiciones:

El código introducido es interpretado y ejecutado.

Escenario principal:

1. El usuario inicia el sistema facilitando un listado de argumentos.
2. El sistema asigna como variables cada argumento y solicita contenido fuente al usuario.
3. El usuario introduce un bloque de código en la entrada estándar.
4. El sistema obtiene el bloque de código a interpretar mediante la entrada estándar.
5. Incluir (Interpretar).

Interpretar fichero

Caso de Uso:

Interpretar fichero.

Tipo:

General.

Descripción:

El usuario indica un fichero que contiene código y que será interpretado y ejecutado por el sistema.

Actores:

Usuario.

Precondiciones:

El sistema espera que se le indique un fichero.

Postcondiciones:

El fichero es leído y el código en el mismo es interpretado y ejecutado.

Escenario principal:

1. El usuario indica la ruta a un fichero y una serie de argumentos
2. El sistema lee el fichero y obtiene el código en el mismo, además asigna cada argumento a variables.
3. Incluir (Interpretar).

Flujo alternativo:

1. 1. El fichero indicado no se encuentra.
      1. El sistema informa del error y finaliza.

Interpretar línea

Caso de Uso:

Interpretar línea.

Tipo:

General.

Descripción:

El usuario introduce bloques de códigos denominados líneas de una forma interactiva. El sistema solicita por la entrada estándar las líneas de código, que serán interpretadas y ejecutadas.

Actores:

Usuario.

Precondiciones:

El sistema se encuentra en modo interactivo.

Postcondiciones:

Se interpreta cada línea introducida por el usuario

Escenario principal:

1. El usuario inicia el sistema facilitando un listado de argumentos y la opción de interprete de línea.
2. El sistema asigna como variables cada argumento y muestra un prompt que indica que espera una línea de código.
3. El usuario introduce una línea de código.
4. El sistema lee de la entrada estándar la línea introducida.
5. Include (Interpretar).
   
   El sistema repite el caso de uso hasta que se interpreta una sentencia que produzca la salida.

Interpretar

Caso de Uso:

Interpretar.

Tipo:

General.

Nivel:

Subfunción.

Descripción:

El sistema analiza, interpreta y ejecuta un bloque de código facilitado por el usuario. Para ello comprueba que este cumple con el léxico y la gramática del lenguaje que define, dividiéndolo a su vez en sentencias que serán interpretadas.

Precondiciones:

Se dispone de un bloque de código.

Postcondiciones:

El bloque de código es interpretado.

Escenario principal:

1. El sistema procesa y comprueba el bloque de código, aplicando la gramática y léxico que define.
2. El sistema obtiene e interpreta cada sentencia en el código, produciéndose el significado semántico que estas encierran.

Flujo alternativo:

1. 1. El código no respeta el léxico del lenguaje.
      1. El sistema informa del error y finaliza.

1. 1. El código no respeta la gramática del lenguaje.
      1. El sistema informa del error y finaliza.

1. 1. El código no contiene ninguna sentencia.
      1. El sistema finaliza.

Ver ayuda

Caso de Uso:

Ver ayuda.

Tipo:

General.

Descripción:

Se muestra una ayuda que detalla cada opción disponible en el sistema.

Actores:

Usuario.

Precondiciones:

Sin precondiciones.

Postcondiciones:

El sistema muestra un listado que presenta las distintas opciones.

Escenario principal:

1. El usuario indica que quiere visualizar la ayuda.
2. El sistema muestra un listado completo de las opciones que presenta.

Cargar extensión

Caso de Uso:

Cargar extensión.

Tipo:

General.

Descripción:

El usuario indica que una extensión que será cargada por el sistema.

Actores:

Usuario.

Precondiciones:

Sin precondiciones.

Postcondiciones:

El sistema cargar la extensión facilitada.

Escenario principal:

1. El usuario indica la ruta a la extensión que desea cargar.
2. El sistema carga la extensión para disponer de las distintas opciones que ofrece.

Flujo alternativo:

1. 1. La extensión indicada no se encuentra.
      1. El sistema informa del error.

1. 1. La extensión indicada no es una extensión válida.
      1. El sistema informa del error.

Listar extensiones

Caso de Uso:

Listar extensiones.

Tipo:

General.

Descripción:

Lista las extensiones que serán cargadas en cada ejecución del sistema.

Actores:

Usuario.

Precondiciones:

Sin precondiciones.

Postcondiciones:

El sistema lista las extensiones que serán cargadas.

Escenario principal:

1. El usuario indica que desea listar las extensiones cargadas.
2. El sistema lista las extensiones cargadas por defecto.

Iniciar interpretación red

Caso de Uso:

Iniciar interpretación red

Tipo:

Red

Descripción:

Un sistema externo inicia una interpretación por red, estableciendo el contenido fuente que será interpretado. El sistema procesa la petición y abre un nuevo proceso de interpretación por pasos.

Precondiciones:

No tiene.

Postcondiciones:

Se establece el código fuente a interpretar y se inicia una interpretación por pasos.

Escenario principal:

1. El sistema espera una petición de interpretación por red.
2. El sistema externo inicia la comunicación y facilita el código fuente.
3. El sistema establece el código fuente y abre un nuevo proceso de interpretación por pasos.

Flujo alternativo:

1. 1. El servicio no se encuentra disponible.
      1. Se devuelve un estado de error.

Obtener pasos interpretación red

Caso de Uso:

Obtener pasos interpretación red

Tipo:

Red

Descripción:

Un sistema externo obtiene un nuevo estado dentro de los pasos en el proceso de interpretación del código fuente establecido.

Precondiciones:

Se ha establecido código fuente para una interpretación por pasos.

Postcondiciones:

Se lleva a cabo un nuevo paso dentro del proceso de interpretación. Obteniéndose el siguiente estado.

Escenario principal:

1. El sistema espera la petición de un nuevo paso en una iterpretación por red.
2. El sistema externo realiza la petición de un nuevo paso.
3. Incluir (Interpretar).
4. El sistema devuelve una estructura de datos que representa el estado actual del proceso de interpretación.

Flujo alternativo:

1. 1. El servicio no se encuentra disponible.
      1. Se devuelve un estado de error.

1. 1. El código fuente presenta errores sintáctico o léxicos.
      1. Se devuelve un estado de error.

runTree

Enviar código fuente

Caso de Uso:

Enviar código fuente

Tipo:

runTree

Descripción:

El usuario envía texto correspondiente a código fuente para su interpretación y análisis. El sistema cliente envía el código al servidor que lo establecerá como fuente a interpretar y enviará datos relativos al proceso. El cliente imprime el árbol sintáctico y espera acciones del usuario.

Precondiciones:

No tiene.

Postcondiciones:

Se ha establecido el código fuente para el análisis del proceso de interpretación y se ha imprimido el árbol sintáctico.

Escenario principal:

1. El sistema solicita código fuente escrito en OMI.
2. El usuario introduce código fuente escrito en el lenguaje OMI.
3. El sistema cliente runtree envía el código fuente al servidor para su interpretación.
4. El sistema servidor devuelve una representación de los datos que describen el árbol sintáctico relativo al código fuente enviado.
5. El sistema cliente imprime el árbol sintáctico.

Flujo alternativo:

1. 1. El código fuente no presenta una sintaxis OMI correcta.
      1. Se devuelve un estado de error.

1. 1. El servicio no se encuentra disponible.
      1. Se devuelve un estado de error.

Siguiente paso

Caso de Uso:

Siguiente paso

Tipo:

runTree

Descripción:

El usuario usuario solicita un nuevo paso en el proceso de interpretación. El sistema cliente obtiene el nuevo paso del servidor y lo representa en pantalla.

Precondiciones:

• Existe un código fuente establecido para estudio.
• El estado actual del proceso no es final.
• La ejecución automática se encuentra desactivada.

Postcondiciones:

Se representa en nuevo paso.

Escenario principal:

1. El usuario solicita un nuevo paso en el proceso de interpretación
2. El sistema cliente solicita la resolución de un nuevo paso y representa el nuevo estado en pantalla.

Flujo alternativo:

1. 1. El servicio no se encuentra disponible.
      1. Se devuelve un estado de error.

Siguiente sentencia

Caso de Uso:

Siguiente sentencia

Tipo:

runTree

Descripción:

El usuario solicita la resolución de la siguiente sentencia. El sistema cliente obtiene el estado correspondiente a la interpretación de la siguiente sentencia dentro del proceso de interpretación y lo representa en pantalla.

Precondiciones:

• Existe un código fuente establecido para estudio.
• El estado actual del proceso no es final.
• La ejecución automática se encuentra desactivada.

Postcondiciones:

Se representa en nuevo estado correspondiente a la interpretación de una sentencia completa.

Escenario principal:

1. El usuario solicita la resolución de una nueva senterncia en el proceso de interpretación.
2. El sistema cliente solicita la resolución de la sentencia completa y representa el nuevo estado en pantalla.

Flujo alternativo:

1. 1. El servicio no se encuentra disponible.
      1. Se devuelve un estado de error.

Activar ejecución automática

Caso de Uso:

Activar ejecución automática

Tipo:

runTree

Descripción:

El usuario solicita la ejecución automática. El sistema cliente obtiene y representa cada paso dentro del proceso de interpretación hasta obtenerse un estado final.

Precondiciones:

• Existe un código fuente establecido para estudio.
• El estado actual del proceso no es final.
• La ejecución automática se encuentra desactivada.

Postcondiciones:

Se obtiene un estado final.

Escenario principal:

1. El usuario activa la ejecución automática.
2. El sistema obtiene y representa cada paso en el proceso de interpretación hasta que se obtiene un estado final.

Flujo alternativo:

1. 1. El servicio no se encuentra disponible.
      1. Se devuelve un estado de error.

Desactivar ejecución automática

Caso de Uso:

Desactivar ejecución automática

Tipo:

runTree

Descripción:

El usuario solicita la detención de la ejecución automática. El sistema cliente detiene la ejecución automática y representa el estado actual.

Precondiciones:

• Existe un código fuente establecido para estudio.
• El estado actual del proceso no es final.
• La ejecución automática se encuentra activada.

Postcondiciones:

Se obtiene el estado actual del proceso.

Escenario principal:

1. El usuario desactiva la ejecución automática.
2. El sistema cliente para la ejecución automática y representa el estado actual

Limpiar salida

Caso de Uso:

Limpiar salida

Tipo:

runTree

Descripción:

El usuario solicita la limpieza de los datos de salida. El sistema cliente elimina la información disponible en la consola de salida.

Precondiciones:

No tiene.

Postcondiciones:

La consola de salida queda vacía.

Escenario principal:

1. El usuario solicita la limpieza de la salida.
2. El sistema cliente limpia la información disponible en la consola de salida.

Ver información de nodo

Caso de Uso:

Ver información de nodo.

Tipo:

runTree

Descripción:

El usuario marca un nodo para ver su información. El sistema cliente muestra la información relativa al nodo.

Precondiciones:

Existe un código fuente establecido para estudio.

Postcondiciones:

Se muestra información relativa al nodo.

Escenario principal:

1. El usuario marca un nodo para ver su información.
2. El sistema muestra información relativa al nodo tal como su posición de memoria interna, su tamaño, su tipo y su nombre.

Ver contenido de la tabla de símbolos

Caso de Uso:

Ver contenido de la tabla de símbolos.

Tipo:

runTree

Descripción:

El usuario marca una tabla de símbolos para ver su contenido. El sistema cliente muestra la información relativa a la tabla de símbolos.

Precondiciones:

Existe un código fuente establecido para estudio.

Postcondiciones:

Se muestra información relativa a la tabla de símbolos.

Escenario principal:

1. El usuario indica una tabla de símbolos para ver su contenido.
2. El sistema cliente muestra los nodos referenciados desde la tabla de símbolos dada.

Guardar código fuente

Caso de Uso:

Guardar código fuente.

Tipo:

runTree

Descripción:

El usuario solicita guardar el codigo fuente escrito en un fichero local y el cliente abre el cuadro de diálogo correspondiente.

Precondiciones:

Existe un código escrito en el cliente

Postcondiciones:

Se guarda el código fuente en un fichero local.

Escenario principal:

1. El usuario solicita guardar el código fuente en un fichero local.
2. El sistema abre el cuadro de diálogo correspondiente.

Abrir código fuente

Caso de Uso:

Abrir código fuente.

Tipo:

runTree

Descripción:

El usuario solicita cargar código fuente desde un fichero local.

Precondiciones:

No tiene.

Postcondiciones:

Se carga el código fuente contenido en el fichero.

Escenario principal:

1. El usuario solicita abrir un fichero de código fuente.
2. El sistema abre el cuadro de diálogo correspondiente.
3. El sistama carga el contenido del código fuente.

Flujo alternativo:

1. 1. El fichero no contiene código en texto plano.
      1. Se devuelve un estado de error.

Visión general

El presente documento constituye el modelo de comportamiento del sistema.

Partiendo de los casos de usos se presentan los diagramas de secuencias que modelan los eventos que el sistema puede recibir del usuario y los valores de retorno que produce como consecuencia de estos. Esta sección considera tanto al sistema intérprete como el cliente.

A partir de los diagramas de secuencia del sistema se obtienen las operaciones que este presenta. Luego se describen los contratos de cada una de las operaciones.

Diagramas de secuencia del sistema

Intérprete

Interpretar entrada estándar

Interpretar línea

Interpretar fichero

Ver ayuda

Cargar extensión

Listar extensiones

Iniciar interpretación red

Obtener pasos interpretación red

runTree

Enviar código fuente

Siguiente paso

Siguiente sentencia

Activar ejecución automática

Desctivar ejecución automática

Limpiar salida

Ver infomación de nodo

Ver contenido tabla de símbolo

Guardar código fuente

Abrir código fuente

Contratos de operaciones del sistema

En esta sección se listan las operaciones del sistema y se detallan los contratos de aquellas que implican un cambio en la estructura de datos interna del programa.

Intérprete

Operación inicio_interprete_stdin

Nombre:

inicio_interprete_stdin(args)

Responsabilidades:

Iniciar la interpretación de la entrada estándar.

Referencias Cruzadas:

Caso de Uso: Interpretar entrada estándar

Precondiciones:

No tiene.

Postcondiciones:

• Se creó una instancia ``i'' de ``interpreter'' (creación de objeto).
• Se inicializaron los atributos de ``i''.
• Se crearon las instancias ``$a_0...a_n$'' de ``arg'' por cada argumento en ``args'' (creación de objeto).
• Se asignó ``args$_i$'' a ``$a_i.value$'' ( $a_i.value =$args$_i$) (modificación de atributos).
• Se asoció los ``arg'' ``$a_0...a_n$'' al objeto ``i'' de ``interpreter'' (creación de enlace).
• Se creó una instancia ``p'' de ``parser'' (creación de objeto).
• Se inicializaron los atributos de ``p''.
• Se creó una instancia ``s'' de ``scanner'' (creación de objeto).
• Se inicializaron los atributos de ``s''.
• Se asoció el ``scanner'' ``s'' al objeto ``p'' de ``parser'' (creación de enlace).
• Se asoció el ``parser'' ``p'' al objeto ``i'' de ``interpreter'' (creación de enlace).
• Se creó una instancia ``c'' de ``context'' (creación de objeto).
• Se inicializaron los atributos de ``c''.
• Se creó una instancia ``var'' de ``varSymbols'' (creación de objeto).
• Se inicializaron los atributos de ``var''.
• Se asoció el ``varSymbols'' ``var'' al objeto ``c'' de ``context'' (creación de enlace).
• Se creó una instancia ``func'' de ``funcSymbols'' (creación de objeto).
• Se inicializaron los atributos de ``func''.
• Se asoció el ``funcSymbols'' ``func'' al objeto ``c'' de ``context'' (creación de enlace).
• Se creó una instancia ``class'' de ``classSymbols'' (creación de objeto).
• Se inicializaron los atributos de ``class''.
• Se asoció el ``classSymbols'' ``class'' al objeto ``c'' de ``context'' (creación de enlace).
• Se asoció el ``context'' ``c'' al objeto ``i'' de ``interpreter'' (creación de enlace).

Operación inicio_interprete_linea

Nombre:

inicio_interprete_linea(args)

Responsabilidades:

Iniciar la interpretación interactiva línea a línea.

Referencias Cruzadas:

Caso de Uso: Interpretar línea

Precondiciones:

No tiene.

Postcondiciones:

• Se creó una instancia ``i'' de ``interpreter'' (creación de objeto).
• Se inicializaron los atributos de ``i''.
• Se crearon las instancias ``$a_0...a_n$'' de ``arg'' por cada argumento en ``args'' (creación de objeto).
• Se asignó ``args$_i$'' a ``$a_i.value$'' ( $a_i.value =$args$_i$) (modificación de atributos).
• Se asoció los ``arg'' ``$a_0...a_n$'' al objeto ``i'' de ``interpreter'' (creación de enlace).
• Se creó una instancia ``p'' de ``parser'' (creación de objeto).
• Se inicializaron los atributos de ``p''.
• Se creó una instancia ``s'' de ``scanner'' (creación de objeto).
• Se inicializaron los atributos de ``s''.
• Se asoció el ``scanner'' ``s'' al objeto ``p'' de ``parser'' (creación de enlace).
• Se asoció el ``parser'' ``p'' al objeto ``i'' de ``interpreter'' (creación de enlace).
• Se creó una instancia ``c'' de ``context'' (creación de objeto).
• Se inicializaron los atributos de ``c''.
• Se creó una instancia ``var'' de ``varSymbols'' (creación de objeto).
• Se inicializaron los atributos de ``var''.
• Se asoció el ``varSymbols'' ``var'' al objeto ``c'' de ``context'' (creación de enlace).
• Se creó una instancia ``func'' de ``funcSymbols'' (creación de objeto).
• Se inicializaron los atributos de ``func''.
• Se asoció el ``funcSymbols'' ``func'' al objeto ``c'' de ``context'' (creación de enlace).
• Se creó una instancia ``class'' de ``classSymbols'' (creación de objeto).
• Se inicializaron los atributos de ``class''.
• Se asoció el ``classSymbols'' ``class'' al objeto ``c'' de ``context'' (creación de enlace).
• Se asoció el ``context'' ``c'' al objeto ``i'' de ``interpreter'' (creación de enlace).

Operación interpretar_cadena

Nombre:

interpretar_cadena(str)

Responsabilidades:

Interpreta el contenido fuente almacenado en la cadena ``str''

Referencias Cruzadas:

• Caso de Uso: Interpretar entrada estándar
• Caso de Uso: Interpretar línea

Precondiciones:

• Se creó un ``interpreter'' ``i''.
• Se creó y asoció una instancia de ``parser'' y ``scanner'' a ``i''.
• Se creó y asoció una instancia de ``varSymblos'', ``funcSymbols'' y ``classSymbols'' a ``i''.

Postcondiciones:

• Se creó una instancia ``s'' de ``source'' (creación de objeto).
• Se asignó ``str'' a ``s.src'' (s.src = str) (modificación de atributos)
• Se asoció ``s'' al ``scanner'' componente del ``interpreter'' ``i'' (creación de enlace).
• Se creó un conjunto ``$t_0...t_n$'' de ``token'' a partir del análisis léxico (creación de objeto).
• Se creó un conjunto ``$n_0...n_n$'' de ``runNode'' a partir del análisis sintáctico (creación de objetos).
• Se asoció `` $n_i \epsilon n_0...n_n$'' a `` $n_k \epsilon n_0...n_n$'' para construir el árbol sintáctico (creación de enlace).
• Se asoció `` $n_r \epsilon n_0...n_n$'', raíz del árbol sintáctico, al ``interprter'' ``i'' (creación de enlace).
• Se creó un conjunto `` $var_0...var_n$'' de ``refNode'' correspondientes a las variables definidas en el contenido fuente (creación de objetos).
• Se creó un conjunto `` $val_0...val_n$'' de ``runNode'' correspondientes a los valores asignados a las variables definidas en el contenido fuente (creación de objetos).
• Se asoció `` $val_i \epsilon val_0...val_n$'' a `` $var_i \epsilon var_0...var_n$'' donde $val_i$ es el valor de la variable $var_i$ (creación de enlace).
• Se asoció todo ``refNode'' `` $var_0...var_n$'' al componente ``varSymbols'' de ``i'' (creación de enlace).
• Se creó un conjunto `` $func_0...func_n$'' de ``refNode'' correspondientes a las funciones con identificador definidas en el contenido fuente (creación de objetos).
• Se asoció `` $func_i \epsilon func_0...func_n$'' a `` $n_i \epsilon n_0...n_n$'' donde $n_i$ es un ``funcNode'' correspondiente a la definición de la función $func_i$ (creación de enlaces).
• Se asoció todo ``refNode'' `` $func_0...func_n$'' al componente ``funcSymbols'' de ``i'' (creación de enlace).
• Se creó un conjunto `` $class_0...class_n$'' de ``refNode'' correspondientes a las clases definidas en el contenido fuente (creación de objetos).
• Se asoció `` $class_i \epsilon class_0...class_n$'' a `` $n_i \epsilon n_0...n_n$'' donde $n_i$ es un ``classNode'' correspondiente a la definición de la clase $class_i$ (creación de enlaces).
• Se asoció todo ``refNode'' `` $class_0...class_n$'' al componente ``classSymbols'' de ``i'' (creación de enlace).

Operación interpretar_fichero

Nombre:

interpretar_fichero(fichero, args)

Responsabilidades:

Interpreta el contenido fuente almacenado en ``fichero''

Referencias Cruzadas:

Caso de Uso: Interpretar fichero

Precondiciones:

No tiene.

Postcondiciones:

• Se creó una instancia ``i'' de ``interpreter'' (creación de objeto).
• Se inicializaron los atributos de ``i''.
• Se creó el conjunto ``$a_0...a_n$'' de ``arg'' según el número de argumentos en ``args'' (creación de objeto).
• Se asignó ``args$_i$'' a ``$a_i.value$'' ( $a_i.value =$args$_i$) (modificación de atributos).
• Se asoció los ``arg'' ``$a_0...a_n$'' al objeto ``i'' de ``interpreter'' (creación de enlace).
• Se creó una instancia ``p'' de ``parser'' (creación de objeto).
• Se inicializaron los atributos de ``p''.
• Se creó una instancia ``s'' de ``scanner'' (creación de objeto).
• Se inicializaron los atributos de ``s''.
• Se asoció el ``scanner'' ``s'' al objeto ``p'' de ``parser'' (creación de enlace).
• Se asoció el ``parser'' ``p'' al objeto ``i'' de ``interpreter'' (creación de enlace).
• Se creó una instancia ``c'' de ``context'' (creación de objeto).
• Se inicializaron los atributos de ``c''.
• Se creó una instancia ``var'' de ``varSymbols'' (creación de objeto).
• Se inicializaron los atributos de ``var''.
• Se asoció el ``varSymbols'' ``var'' al objeto ``c'' de ``context'' (creación de enlace).
• Se creó una instancia ``func'' de ``funcSymbols'' (creación de objeto).
• Se inicializaron los atributos de ``func''.
• Se asoció el ``funcSymbols'' ``func'' al objeto ``c'' de ``context'' (creación de enlace).
• Se creó una instancia ``class'' de ``classSymbols'' (creación de objeto).
• Se inicializaron los atributos de ``class''.
• Se asoció el ``classSymbols'' ``class'' al objeto ``c'' de ``context'' (creación de enlace).
• Se asoció el ``context'' ``c'' al objeto ``i'' de ``interpreter'' (creación de enlace).

• Se creó una instancia ``src'' de ``source'' (creación de objeto).
• Se asignó el contenido de ``fichero'' a ``src.src'' (src.src = fichero) (modificación de atributos)
• Se asoció ``src'' al ``scanner'' ``s'' componente del ``interpreter'' ``i'' (creación de enlace).
• Se creó un conjunto ``$t_0...t_n$'' de ``token'' a partir del análisis léxico (creación de objeto).
• Se creó un conjunto ``$n_0...n_n$'' de ``runNode'' a partir del análisis sintáctico (creación de objetos).
• Se asoció `` $n_i \epsilon n_0...n_n$'' a `` $n_k \epsilon n_0...n_n$'' para construir el árbol sintáctico (creación de enlace).
• Se asoció `` $n_r \epsilon n_0...n_n$'', raíz del árbol sintáctico, al ``interprter'' ``i'' (creación de enlace).
• Se creó un conjunto `` $var_0...var_n$'' de ``refNode'' correspondientes a las variables definidas en el contenido fuente (creación de objetos).
• Se creó un conjunto `` $val_0...val_n$'' de ``runNode'' correspondientes a los valores asignados a las variables definidas en el contenido fuente (creación de objetos).
• Se asoció `` $val_i \epsilon val_0...val_n$'' a `` $var_i \epsilon var_0...var_n$'' donde $val_i$ es el valor de la variable $var_i$ (creación de enlace).
• Se asoció todo ``refNode'' `` $var_0...var_n$'' al componente ``varSymbols'' de ``i'' (creación de enlace).
• Se creó un conjunto `` $func_0...func_n$'' de ``refNode'' correspondientes a las funciones con identificador definidas en el contenido fuente (creación de objetos).
• Se asoció `` $func_i \epsilon func_0...func_n$'' a `` $n_i \epsilon n_0...n_n$'' donde $n_i$ es un ``funcNode'' correspondiente a la definición de la función $func_i$ (creación de enlaces).
• Se asoció todo ``refNode'' `` $func_0...func_n$'' al componente ``funcSymbols'' de ``i'' (creación de enlace).
• Se creó un conjunto `` $class_0...class_n$'' de ``refNode'' correspondientes a las clases definidas en el contenido fuente (creación de objetos).
• Se asoció `` $class_i \epsilon class_0...class_n$'' a `` $n_i \epsilon n_0...n_n$'' donde $n_i$ es un ``classNode'' correspondiente a la definición de la clase $class_i$ (creación de enlaces).
• Se asoció todo ``refNode'' `` $class_0...class_n$'' al componente ``classSymbols'' de ``i'' (creación de enlace).

Operación iniciar_interpretacion_red

Nombre:

iniciar_interpretacion_red (src)

Responsabilidades:

Iniciar la interpretación de una petición por red.

Referencias Cruzadas:

Caso de Uso: Iniciar interpretación red

Precondiciones:

No tiene.

Postcondiciones:

• Se creó una instancia ``i'' de ``interpreter'' (creación de objeto).
• Se inicializaron los atributos de ``i''.
• Se creó una instancia ``p'' de ``parser'' (creación de objeto).
• Se inicializaron los atributos de ``p''.
• Se creó una instancia ``s'' de ``scanner'' (creación de objeto).
• Se inicializaron los atributos de ``s''.
• Se asoció el ``scanner'' ``s'' al objeto ``p'' de ``parser'' (creación de enlace).
• Se asoció el ``parser'' ``p'' al objeto ``i'' de ``interpreter'' (creación de enlace).
• Se creó una instancia ``c'' de ``context'' (creación de objeto).
• Se inicializaron los atributos de ``c''.
• Se creó una instancia ``var'' de ``varSymbols'' (creación de objeto).
• Se inicializaron los atributos de ``var''.
• Se asoció el ``varSymbols'' ``var'' al objeto ``c'' de ``context'' (creación de enlace).
• Se creó una instancia ``func'' de ``funcSymbols'' (creación de objeto).
• Se inicializaron los atributos de ``func''.
• Se asoció el ``funcSymbols'' ``func'' al objeto ``c'' de ``context'' (creación de enlace).
• Se creó una instancia ``class'' de ``classSymbols'' (creación de objeto).
• Se inicializaron los atributos de ``class''.
• Se asoció el ``classSymbols'' ``class'' al objeto ``c'' de ``context'' (creación de enlace).
• Se asoció el ``context'' ``c'' al objeto ``i'' de ``interpreter'' (creación de enlace).
• Se creó una instancia ``src'' de ``source'' (creación de objeto).
• Se asignó el contenido de ``fichero'' a ``src.src'' (src.src = fichero) (modificación de atributos)
• Se asoció ``src'' al ``scanner'' ``s'' componente del ``interpreter'' ``i'' (creación de enlace).
• Se creó un conjunto ``$t_0...t_n$'' de ``token'' a partir del análisis léxico (creación de objeto).
• Se creó un conjunto ``$n_0...n_n$'' de ``runNode'' a partir del análisis sintáctico (creación de objetos).
• Se asoció `` $n_i \epsilon n_0...n_n$'' a `` $n_k \epsilon n_0...n_n$'' para construir el árbol sintáctico (creación de enlace).
• Se asoció `` $n_r \epsilon n_0...n_n$'', raíz del árbol sintáctico, al ``interprter'' ``i'' (creación de enlace).

Operación obtener_paso_interpretacion_red

Nombre:

obtener_paso_interpretacion_red

Responsabilidades:

Obtiene el siguiente paso de la interpretación de una petición por red abierta.

Referencias Cruzadas:

Caso de Uso: Obtener pasos interpretación red

Precondiciones:

• Se creó un ``interpreter'' ``i''.
• Se creó y asoció una instancia de ``parser'' y ``scanner'' a ``i''.
• Se creó y asoció una instancia de ``varSymblos'', ``funcSymbols'' y ``classSymbols'' a ``i''.
• Se creó una instancia ``src'' de ``source''.
• Se asoció ``src'' al ``scanner'' ``s'' componente del ``interpreter'' ``i''.
• Se creó un conjunto ``$t_0...t_n$'' de ``token'' a partir del análisis léxico.
• Se creó un conjunto ``$n_0...n_n$'' de ``runNode'' a partir del análisis sintáctico.
• Se asoció `` $n_i \epsilon n_0...n_n$'' a `` $n_k \epsilon n_0...n_n$'' para construir el árbol sintáctico.
• Se asoció `` $n_r \epsilon n_0...n_n$'', raíz del árbol sintáctico, al ``interprter'' ``i''.

Postcondiciones:

• Se creó un conjunto `` $var_0...var_n$'' de ``refNode'' correspondientes a las variables definidas en el paso correspondiente (creación de objetos).
• Se creó un conjunto `` $val_0...val_n$'' de ``runNode'' correspondientes a los valores asignados a las variables definidas en el paso correspondiente (creación de objetos).
• Se asoció `` $val_i \epsilon val_0...val_n$'' a `` $var_i \epsilon var_0...var_n$'' donde $val_i$ es el valor de la variable $var_i$ (creación de enlace).
• Se asoció todo ``refNode'' `` $var_0...var_n$'' al componente ``varSymbols'' de ``i'' (creación de enlace).
• Se creó un conjunto `` $func_0...func_n$'' de ``refNode'' correspondientes a las funciones con identificador definidas en el paso correspondiente (creación de objetos).
• Se asoció `` $func_i \epsilon func_0...func_n$'' a `` $n_i \epsilon n_0...n_n$'' donde $n_i$ es un ``funcNode'' correspondiente a la definición de la función $func_i$ (creación de enlaces).
• Se asoció todo ``refNode'' `` $func_0...func_n$'' al componente ``funcSymbols'' de ``i'' (creación de enlace).
• Se creó un conjunto `` $class_0...class_n$'' de ``refNode'' correspondientes a las clases definidas en el paso correspondiente (creación de objetos).
• Se asoció `` $class_i \epsilon class_0...class_n$'' a `` $n_i \epsilon n_0...n_n$'' donde $n_i$ es un ``classNode'' correspondiente a la definición de la clase $class_i$ (creación de enlaces).
• Se asoció todo ``refNode'' `` $class_0...class_n$'' al componente ``classSymbols'' de ``i'' (creación de enlace).

runTree

Operación enviar_codigo_fuente

Nombre:

enviar_codigo_fuente (src)

Responsabilidades:

Envía código fuente para una interpretación por red.

Referencias Cruzadas:

Caso de Uso: Enviar código fuente

Precondiciones:

No tiene.

Postcondiciones:

• Se creó un ``tree'' ``t'' a partir del código enviado a interpretación (creación de objeto).
• Se creó un conjunto ``$n_0...n_n$'' de ``node'' a partir de los datos recibidos de la petición (creación de objeto).
• Se asoció `` $n_i \epsilon n_0...n_n$'' a `` $n_k \epsilon n_0...n_n$'' para construir el árbol sintáctico (creación de enlace).
• Se asoció `` $n_r \epsilon n_0...n_n$'', raíz del árbol sintáctico, al ``tree'' ``t'' (creación de enlace).
• Se inicializó el atributo ``canvas'' del ``tree'' `t'' para dibujar el árbol correspondiente a los nodos `` $n_0...n_n$''.
• Se creó un ``symbols'' ``s'' (creación de objeto).
• Se creó tres instancias de ``table'': ``vars'', ``funcs'' y ``class'' (creación de objeto).
• Se asociarón ``vars'', ``funcs'' y ``class'' a ``s'' (creación de enlace).

Operación siguiente_paso

Nombre:

siguiente_paso

Responsabilidades:

Obtiene el siguiente paso del proceso de interpretación abierto.

Referencias Cruzadas:

Caso de Uso: Siguiente paso

Precondiciones:

• Se creó un ``tree'' ``t''.
• Se creó un conjunto ``$n_0...n_n$'' de ``node''.
• Se asoció `` $n_i \epsilon n_0...n_n$'' a `` $n_k \epsilon n_0...n_n$'' para construir el árbol sintáctico.
• Se asoció `` $n_r \epsilon n_0...n_n$'', raíz del árbol sintáctico, al ``tree'' ``t''.
• Se creó un ``symbols'' ``s''.
• Se creó tres instancias de ``table'': ``vars'', ``funcs'' y ``class''.
• Se asociarón ``vars'', ``funcs'' y ``class'' a ``s''.

Postcondiciones:

• Se creó el conjunto ``$r_0...r_n$'' de `refs'' según el nuevo paso del proceso de interpretación (creación de objeto).
• Se creó el conjunto ``$v_0...v_m$'' de `node'' correspondiente a los valores generados en el paso del proceso de interpretación (creación de objeto).
• Se asoció ``$v_i$'' a ``$r_i$'' como valor de la refercia (creación de enlace).
• Se asoció `` $r_i \epsilon r_0...r_n$'' a ``vars'', ``funcs'' o ``class'' según el paso del proceso de interpretación (creación de enlace).
• Se actualizó el valor del atributo ``canvas'' de ``s'' para reflejar el nuevo estado tras la ejecución del paso.
• Se actualizó el valor del atributo ``canvas'' de ``t'' para reflejar el nuevo estado tras la ejecución del paso.

Operación siguiente_sentencia

Nombre:

siguiente_sentencia

Responsabilidades:

Obtiene la siguiente sentencia dentro del proceso de interpretación abierto.

Referencias Cruzadas:

Caso de Uso: Siguiente sentencia

Precondiciones:

• Se creó un ``tree'' ``t''.
• Se creó un conjunto ``$n_0...n_n$'' de ``node''.
• Se asoció `` $n_i \epsilon n_0...n_n$'' a `` $n_k \epsilon n_0...n_n$'' para construir el árbol sintáctico.
• Se asoció `` $n_r \epsilon n_0...n_n$'', raíz del árbol sintáctico, al ``tree'' ``t''.
• Se creó un ``symbols'' ``s''.
• Se creó tres instancias de ``table'': ``vars'', ``funcs'' y ``class''.
• Se asociarón ``vars'', ``funcs'' y ``class'' a ``s''.

Postcondiciones:

• Se creó el conjunto ``$r_0...r_n$'' de `refs'' según la nueva sentencia interpretada (creación de objeto).
• Se creó el conjunto ``$v_0...v_m$'' de `node'' correspondiente a los valores generados en la sentencia interpretada (creación de objeto).
• Se asoció ``$v_i$'' a ``$r_i$'' como valor de la refercia (creación de enlace).
• Se asoció `` $r_i \epsilon r_0...r_n$'' a ``vars'', ``funcs'' o ``class'' según la sentencia interpretada (creación de enlace).
• Se actualizó el valor del atributo ``canvas'' de ``s'' para reflejar el nuevo estado tras la ejecución de la sentencia.
• Se actualizó el valor del atributo ``canvas'' de ``t'' para reflejar el nuevo estado tras la ejecución del la sentencia.

Operación activar_ejecucion_automatica

Nombre:

activar_ejecucion_automatica

Responsabilidades:

Activa la ejecución automática del proceso de interpretación.

Referencias Cruzadas:

Caso de Uso: Activar ejecución automática

Precondiciones:

• Se creó un ``tree'' ``t''.
• Se creó un conjunto ``$n_0...n_n$'' de ``node''.
• Se asoció `` $n_i \epsilon n_0...n_n$'' a `` $n_k \epsilon n_0...n_n$'' para construir el árbol sintáctico.
• Se asoció `` $n_r \epsilon n_0...n_n$'', raíz del árbol sintáctico, al ``tree'' ``t''.
• Se creó un ``symbols'' ``s''.
• Se creó tres instancias de ``table'': ``vars'', ``funcs'' y ``class''.
• Se asociarón ``vars'', ``funcs'' y ``class'' a ``s''.

Postcondiciones:

• Se establece a ``1'' el atributo ``auto'' de ``t''.

Operación desactivar_ejecucion_automatica

Nombre:

desactivar_ejecucion_automatica

Responsabilidades:

Desactiva la ejecución automática del proceso de interpretación.

Referencias Cruzadas:

Caso de Uso: Desactivar ejecución automática

Precondiciones:

• Se creó un ``tree'' ``t''.
• Se creó un conjunto ``$n_0...n_n$'' de ``node''.
• Se asoció `` $n_i \epsilon n_0...n_n$'' a `` $n_k \epsilon n_0...n_n$'' para construir el árbol sintáctico.
• Se asoció `` $n_r \epsilon n_0...n_n$'', raíz del árbol sintáctico, al ``tree'' ``t''.
• Se creó un ``symbols'' ``s''.
• Se creó tres instancias de ``table'': ``vars'', ``funcs'' y ``class''.
• Se asociarón ``vars'', ``funcs'' y ``class'' a ``s''.

Postcondiciones:

• Se establece a ``0'' el atributo ``auto'' de ``t''.

Operación limpiar_salida

Nombre:

limpiar_salida

Responsabilidades:

Limpia la salida producida por el proceso de interpretación

Referencias Cruzadas:

Caso de Uso: Limpiar salida

Precondiciones:

• Se creó un ``tree'' ``t''.
• Se creó un conjunto ``$n_0...n_n$'' de ``node''.
• Se asoció `` $n_i \epsilon n_0...n_n$'' a `` $n_k \epsilon n_0...n_n$'' para construir el árbol sintáctico.
• Se asoció `` $n_r \epsilon n_0...n_n$'', raíz del árbol sintáctico, al ``tree'' ``t''.
• Se creó un ``symbols'' ``s''.
• Se creó tres instancias de ``table'': ``vars'', ``funcs'' y ``class''.
• Se asociarón ``vars'', ``funcs'' y ``class'' a ``s''.

Postcondiciones:

• Se restablece los valores del atributo ``canvas'' de ``t''.

Operación ver_informacion_nodo

Nombre:

ver_informacion_nodo

Responsabilidades:

Muestra la información de un nodo

Referencias Cruzadas:

Caso de Uso: Ver información nodo

Precondiciones:

• Se creó un ``tree'' ``t''.
• Se creó un conjunto ``$n_0...n_n$'' de ``node''.
• Se asoció `` $n_i \epsilon n_0...n_n$'' a `` $n_k \epsilon n_0...n_n$'' para construir el árbol sintáctico.
• Se asoció `` $n_r \epsilon n_0...n_n$'', raíz del árbol sintáctico, al ``tree'' ``t''.
• Se creó un ``symbols'' ``s''.
• Se creó tres instancias de ``table'': ``vars'', ``funcs'' y ``class''.
• Se asociarón ``vars'', ``funcs'' y ``class'' a ``s''.

Postcondiciones:

• Se establece los valores del atributo ``canvas'' de ``t'' para representar la información del nodo.

Operación ver_tabla_simbolos

Nombre:

ver_tabla_simbolos

Responsabilidades:

Muestra la información contenida en una tabla de símbolos

Referencias Cruzadas:

Caso de Uso: Ver información nodo

Precondiciones:

• Se creó un ``tree'' ``t''.
• Se creó un conjunto ``$n_0...n_n$'' de ``node''.
• Se asoció `` $n_i \epsilon n_0...n_n$'' a `` $n_k \epsilon n_0...n_n$'' para construir el árbol sintáctico.
• Se asoció `` $n_r \epsilon n_0...n_n$'', raíz del árbol sintáctico, al ``tree'' ``t''.
• Se creó un ``symbols'' ``s''.
• Se creó tres instancias de ``table'': ``vars'', ``funcs'' y ``class''.
• Se asociarón ``vars'', ``funcs'' y ``class'' a ``s''.

Postcondiciones:

• Se establece los valores del atributo ``canvas'' de ``s'' para representar la información de la tabla de símbolos.

Modelo de interfaz de usuario

En esta sección se procede al análisis de la interfaz de usuario. Para ello se analizará la interfaz precisa para el intérprete y para el cliente runTree.

El intérprete utilizará una interfaz de consola de comandos. Toda la información de salida la presentará como cadenas de caracteres. Así mismo toda la información de entrada la tomará del teclado en formato orden y opciones.

Por otro lado el cliente runTree presentará una interfaz en la que se disponga de una descripción gráfica de todo el proceso de interpretación. Para una descripción del proceso de interpretación se precisa de la visualización del código fuente, un árbol con los nodos que encierran el significado semántico del código, las distintas tablas de símbolos que referenciarán a varibles, funciones y clases, y una consola en la que se mostrará información textual.

También un diagrama de navegación en el que se expone las distintas ventanas de la web OMI.

Intérprete

El interprete será accesible como cualquier otro comando de la consola del sistema. Este recibirá una serie de opciones y parámetros. Las opciones del intérprete tendrán los siguientes propósitos:

• Determinar cómo se toma el código fuente, pudiéndo ser desde la entrada estándar, un fichero o la propia línea de comandos
• Ejecutar el intérprete de forma interactiva, mostrando un prompt en el que se introdusca directamente las sentencias
• Listar y cargar los módulos del intérprete.
• Ver la ayuda.
• Abrir un puerto de escucha para peticiones de red.
• Configurar el formato de la salida que describe el proceso de interpretación.

Como cualquier interprete que tome su entrada de la estrada estándar, el interprete OMI puede ser ejecutado por el sistema operativo si se indica al comienzo de un script como el shebang del mismo.

runTree

El cliente runTree será accesible desde un navegador web, y presentará una interfaz gráfica compatible con las versiones actuales de estos. La interfaz gráfica del cliente deberá contener la siguiente información:

• El código fuente introducido por el usuario y que será enviado a interpretar.
• El árbol de nodos resultado del análisis léxico y sintáctico.
• Las distintas tablas de símbolos que guardarán información sobre las variables, las funciones y las clases que serán creadas.
• La explicación del proceso semántico llevado a cabo.
• La salida producida como fruto de la ejecución del código fuente.
• La entrada introducida por el usuario y que ha sido solicitada por el código fuente.
• Información relativa a los nodos y tablas de símbolos que el usuario señale.

Wireframe

Sitio web

El proyecto OMI incluye un sitio web que sirve como presentación del mismo, además de como medio de acceso a la documentación y el software desarrollado. Todas las páginas web pertenecientes al sitio contienen información relativa al proyecto y a las áreas que este ocupa.

El sitio web OMI se compone de:

Página de inicio:

Describe e introduce brevemente el proyecto. Contiene enlaces a las demás secciones del sitio web. Además presenta un listado de noticias y enlaces de descargas a la última versión del intérprete.

Índice de documentación:

Página que representa un índice de los documentos que conforman el proyecto.

Documentos:

Páginas relativas a la documentación del proyecto en si.

Navegador de clases:

Páginas relativas a la documentación de las clases incluidas en la biblioteca.

Navegador de ficheros:

Páginas relativas a la documentación de los ficheros que conforman el código fuente de la biblioteca y el intérprete.

Navegador de gramática:

Páginas relativas a la documentación gráfica de la gramática del lenguaje.

Descargas:

Página que enlaza la descarga de las distintas versiones del software que conforma el proyecto, disponibles en varios formatos de instalación.

Sobre OMI:

Página con información relativa a la motivación y circunstancias en las que se ha dado el proyecto. Además da detalles sobre los autores y los organismos implicados en el desarrollo del mismo.

Contacto:

Página con información de contacto.

Wireframe

Sobre este documento...

This document was generated using the LaTeX2HTML translator Version 2008 (1.71)

Copyright © 1993, 1994, 1995, 1996, Nikos Drakos, Computer Based Learning Unit, University of Leeds.
Copyright © 1997, 1998, 1999, Ross Moore, Mathematics Department, Macquarie University, Sydney.

The command line arguments were:
latex2html -no_subdir -split 0 head.tex -html_version 4.0,latin1,unicode

The translation was initiated by franj on 2016-01-14