Controlador de Diálogo

O Controlador de Diálogo é, basicamente, um animador de Guiões de Interacção e foi desenvolvido sobre um animador de Petri Nets[9] (o formalismo utilizado para implementar os Guiões). É composto, ainda, por um interpretador da linguagem de comandos utilizada nos Guiões, por módulos de tratamento dos modelos de dados (funções finitas, relações, conjuntos, listas e tuplos) e por um módulo responsável pela comunicação com os restantes componentes.

Animador de Petri Nets

Sendo o comportamento dos Guiões de Interacção modelado por Petri Nets, o Controlador de Diálogo foi desenvolvido sobre um animador dessas redes que aqui se apresenta.

Formalmente as redes utilizadas podem ser modeladas da seguinte forma:

  PetriNet :: B : Case
              Ev: Events
              Fi: Flow
              Fo: Flow
              Cb: Case
              Ce: Case;
  Conditions = CId -> Bool;
  Events = Event-set;
  Flow = Event -> Case;
  Case = CId-set;

B é o conjunto de todos os lugares da rede, Ev é o conjunto de todas as transições, Fi e Fo são os fluxos de entrada e saída dessas transições (de que lugares retiram tokens e em que lugares os colocam) e Cb e Ce são as marcações inicial e final, respectivamente. Como a definição da Petri Net será partilhada por todas as instâncias de um Guião ela não inclui a marcação actual, devendo cada instância conservar a sua.

A utilização do animador é feita por meio das seguintes funções:

startpn: PetriNet InstId Conditions

firepn: PetriNet Conditions Event InstId Conditions

endpn: PetriNet Conditions Bool

Adicionalmente existe a função:

valideventspn: PetriNet Conditions InstId Event-set

O Interpretador de Instruções

Outra tarefa, bem definida, que o Controlador de Diálogo deve realizar, é a execução das instruções e cálculo das expressões colocadas em INIT e TRANS. Para o efeito foi desenvolvido um interpretador de instruções.

Na sua versão actual estão previstas expressões envolvendo atribuições, invocações de operações (com ou sem resultado), a instrução out, as instruções condicional, if...then...else... e cíclica, while...do.... Foi ainda incluído o tratamento de expressões do tipo inteiro, string e booleano.

A utilização do interpretador é feita através das operações

docode: Code InstId

dotypedexp: TypedExp InstId OpcGISym Value

A Inclusão dos Tipos  

Ao nível da especificação os valores dos argumentos são sempre considerados como tokens léxicos, independentemente do seu tipo. Na implementação, no entanto, torna-se necessário controlar a leitura desses valores. Se os tipos básicos (inteiros, strings, etc.) não apresentam problemas, o mesmo já não se pode dizer dos que são definidos à custa de modelos. A leitura de uma Função Finita ou de um Conjunto não é uma tarefa trivial, existem vários valores a serem lidos e condições que devem ser verificadas. Coloca-se, então, o problema de decidir quem/como controlar esse diálogo.

A solução implementada foi colocar esse controlo no Controlador de Diálogo. Para tal, desenvolveu-se uma série de pseudo-Guiões, um para cada modelo. Assim, quando uma variável é de um tipo definido com recurso a modelos estruturados, o seu tipo léxico é substituído pela indicação do GI que deverá controlar a interacção a ela referente. No Controlador de Diálogo, por sua vez, o controlador "desvia" o processamento dos eventos para um módulo de tratamento apropriado. Este processo é transparente uma vez que o protocolo de comunicação continua a ser o mesmo.

Este modo de funcionamento permite ter vários métodos de leitura para cada um dos modelos, bastando para tal definir tipos de Guiões e os respectivos módulos de processamento associados. Actualmente estão definidos tipos de Guiões para a leitura de Funções Finitas (FFSYNTH), Relações (RELSYNTH), Listas (LISTSYNTH), Conjuntos (SETSYNTH) e Tuplos (TUPSYNTH). A definição dos módulos de processamento para cada um destes Guiões baseou-se, em parte, na experiência adquirida em [4].

Os Guiões do tipo FFSYNTH e RELSYNTH geram um diálogo em que os pares domínio/contradomínio (variáveis dom e ran) são apresentados/lidos um a um, sendo disponibilizados, para além de OK e CANCEL, os comandos NEW (inicializar a vazio), UP (par anterior), DOWN (par seguinte) e DEL (apagar o par actual). Internamente, o valor é representado por quatro listas de valores:

• dup - valores do domínio anteriores ao valor actualmente apresentado;
• rup - valores do contradomínio correspondentes;
• ddown - na cabeça está o valor actualmente apresentado e na cauda os restantes;
• rdown - valores do contradomínio correspondentes.

Os Guiões do tipo SETSYNTH e LISTSYNTH são semelhantes aos anteriores mas a variável utilizada para apresentar os valores é elem.

Por último, os Guiões TUPSYNTH geram um diálogo correspondente à expressão

input(sel1) input(sel2) ... input(seln)

Estrutura Geral do Controlador

A informação necessária ao Controlador de Diálogo consiste na definição dos Guiões de Interacção, na descrição das instâncias existentes e nos canais de comunicação com os outros componentes de MIU. Temos então:

  CD :: DEFS:  GISym -> GIdef
        INSTS: InstId -> InstDescr
        OUTSM: CHAN
        INSM:  CHAN
        INLX:  CHAN
        OUTLX: CHAN;
  GIdef = DECISION | SYNTH | VALSYNTH | FFSYNTH | RELSYNTH | 
          SISTSYNTH | SETSYNTH | TUPSYNTH;
  FFSYNTH :: DREF: TypeId;
  InstDescr :: FATHER:  NIL | InstId
               VARS:    VarId -> Value
               EVSEQ:   Conditions
               CMDLINE: NIL | CmdLineDescr;

O seu funcionamento consiste basicamente em:

• criar as instâncias, quando tal é pedido;
• idem para a sua remoção;
• validar e efectuar, na Petri Net da instância indicada, as transições relativas aos eventos que lhe são comunicados;
• indicar ao Modelo da Apresentação quais os eventos válidos em cada momento;
• indicar, também, alterações nos valores das variáveis conhecidas pelo Modelo da Apresentação;
• construir e enviar a frase ao Modelo da Aplicação para avaliação e receber o resultado, passando-o ao Modelo da Apresentação.

  
Figure 2: Composição do Controlador de Diálogo

Na fig. 2 são apresentados os ficheiros que compõem o Controlador de Diálogo. Note-se que as setas representam uma relação de inclusão textual, pelo que podem existir (e existem de facto) referências cruzadas entre os ficheiros.

O ficheiro cd.n contém o corpo principal do Controlador. Em cdcom.n estão as funções de comunicação e este por sua vez inclui msgs.n onde são definidos os protocolos de comunicação; petrinet.n é o animador de Petri Nets e mkpn.n um gerador das mesmas a partir das definições dos GI's; si.n é o interpretador de instruções e cdff.n a cdtup.n são os módulos de tratamento dos modelos.

Finalmente, em share.n são feitas definições globais aos três componentes do MIU. Tanto este ficheiro como msgs.n são partilhados pelos três componentes do sistema.