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.