next up previous
Next: About this document Up: Editor interactivo v1 Previous: Editor interactivo v1

Editor interactivo v1 (SOLUCIÓN)

 

Grafo de Procesos

Tabla de Bloqueos

Tabla de Desbloqueos

<M W>

MODULE EDITOR;
(*
****************************************************************************
* Module           : EDITOR
* Subject          : Programa CC-modula que implementa un editor
* Authors          : 
* Created on       :
* Last modified by :
* Last modified on :
* Status           : OK
*)

IMPORT COLA;

IMPORT <<...>>;


MODULE DOCUMENTO;
(*
****************************************************************************
* Module           : DOCUMENTO
* Subject          : Modulo local que controla el documento
*)
IMPORT COLA;

EXPORT QUALIFIED ConstruirOrden, Actualizar, Visualizar;

TYPE
     Documento = << Tipo abstracto de un documento >>;
     Orden = << operaciones posibles sobre un Documento >>;

VAR
     documento : Documento;

MONITOR ACCESO;
(*
****************************************************************************
* Module           : ACCESO (Monitor)
* Subject          : Monitor que controla el acceso a un documento
*)

IMPORT Documento, Orden;

IMPORT COLA;

PUBLIC AlmacenarOrden, InicioActualizar, FinActualizar,
       InicioVisualizar, FinVisualizar;

VAR
(*  Recurso:                                                              *)
     ordenes : COLA.Cola;               (*  almacen de ordenes pendientes *)
     actualizando : BOOLEAN;            (*  alguien actualizando          *)
     visualizando : BOOLEAN;            (*  alguien visualizando          *)
     coherente    : BOOLEAN;            (*  visualizado coherente         *)

(*  Colas de espera:                                                      *)
     permisoAlmacenarOrden : CONDITION;
     permisoActualizar : CONDITION;
     permisoVisualizar : CONDITION;

PROCEDURE AlmacenarOrden (oden : Orden);
(*        ^^^^^^^^^^^^^^                                                  *)
BEGIN
     IF COLA.Llena(ordenes) THEN
          Delay(permisoAlmacenarOrden);
     END (* if *);
                                         (*  PRE: "ordenes" no llena      *)
(*  Operacion                                                             *)
     COLA.Insertar(ordenes,orden);

                                         (*  POS: "ordenes" no vacia      *)
     IF NOT visualizando THEN
          Continue(permisoActualizar);
     END (* if *);
END AlmacenarOrden;

PROCEDURE InicioActualizar (VAR orden : Orden);
(*        ^^^^^^^^^^^^^^^^                                                *)
BEGIN
     IF visualizando OR COLA.Vacia(ordenes) THEN
          Delay(permisoActualizar);
     END (* if *);
                                         (*  PRE: nadie visualizando y    *)
                                         (*       "ordenes" no vacia      *)
(*  Operacion                                                             *)
     COLA.Extraer(ordenes,orden);
     actualizando := TRUE;

                                         (*  POS: "ordenes" no llena,     *)
                                         (*       alguien actualizando    *)
     Continue(permisoAlmacenarOrden);
END InicioActualizar;

PROCEDURE FinActualizar;
(*        ^^^^^^^^^^^^^                                                   *)
BEGIN

(*  Operacion                                                             *)
     actualizando := FALSE;
     coherente := FALSE;

                                         (*  POS: nadie actualizando y    *)
                                         (*       visualizado no coherente*)
     IF COLA.Vacia(ordenes) THEN
          Continue(permisoVisualizar);
     END (* if *);
END FinActualizar;


PROCEDURE InicioVisualizar;
(*        ^^^^^^^^^^^^^^^^                                                *)
BEGIN
     IF coherente OR actualizando OR (NOT COLA.Vacia(ordenes)) THEN
          Delay(permisoVisualizar);
     END (* if *);
                                         (*  PRE: informacion no coherente*)
                                         (*       nadie actualizando y    *)
                                         (*       "ordenes" vacia         *)
(*  Operacion                                                             *)
     visualizando := TRUE;

                                         (*  POS: alguien visualizando    *)
END InicioVisualizar;

PROCEDURE FinVisualizar;
(*        ^^^^^^^^^^^^^                                                   *)
BEGIN

(*  Operacion                                                             *)
     visualizando := FALSE;
     coherente := TRUE;

                                         (*  POS: nadie visualizando y    *)
                                         (*       visualizado coherente   *)
     IF NOT COLA.Vacia(ordenes) THEN
          Continue(permisoActualizar);
     END (* if *);
END FinVisualizar;

END MONITOR;
(*************************************)


PROCEDURE ConstruirOrden;
(*        ^^^^^^^^^^^^^^                                                  *)
VAR
     orden : Orden;
BEGIN
     << Recoger caracteres del teclado hasta construir "orden" >>;
     ACCESO.AlmacenarOrden(orden);
END ConstruirOrden;


PROCEDURE Actualizar;
(*        ^^^^^^^^^^                                                      *)
VAR
     orden : Orden;
BEGIN
     ACCESO.InicioActualizar(orden);
     << En funcion de "orden" actualizar "documento" >>;
     ACCESO.FinActualizar;
END Actualizar;

PROCEDURE Visualizar;
(*        ^^^^^^^^^^                                                      *)
BEGIN
     ACCESO.InicioVisualizar;
     << Visualizacion de "documento" >>;
     ACCESO.FinVisualizar;
END Visualizar;

END DOCUMENTO;
(*************************************)

TASK ReconocedorOrdenes;
(*   ^^^^^^^^^^^^^^^^^^                                                   *)
BEGIN
     LOOP
          DOCUMENTO.ConstruirOrden;
     END (* loop *)
END ReconocedorOrdenes;

          
TASK Editor;
(*   ^^^^^^                                                               *)
BEGIN
     LOOP
          DOCUMENTO.Actualizar;
     END (* loop *);
END Editor;

TASK Visualizador;
(*   ^^^^^^^^^^^^                                                         *)
BEGIN
     LOOP
          DOCUMENTO.Visualizar;
     END (* loop *);
END Visualizador;

(************** PROGRAMA PRINCIPAL ****************)
BEGIN
     COBEGIN
          ReconocedorOrdenes;
          Editor;
          Visualizador;
     COEND;
END EDITOR.



Angel Herranz Nieva
Thu Oct 31 20:10:28 MET 1996