Controle da Execução do Programa de Controle

Previous  Top  Next

Estes comandos fornecem as estruturas sobre as quais pode ser erguida a lógica de um programa-fonte de alto nível. As estruturas de controle da execução implementadas na LCE são enquanto, repete, para (loop for), vai_para (goto), sub-rotina, seqüência, finaliza_scan, e stop:

enquanto: os comandos são repetidos enquanto a condição cond for verdadeira. Se cond já for falsa no momento em que o programa de controle atinge essa instrução, não executa os comandos nem uma vez:

      enquanto (cond)
      {
       comandos
      }

Obs.: para implementação desse laço, o compilador da LCE gera na IL labels da forma ENQX, onde X representa um número seqüencial, e as instruções LDN V_0 e JMP ENQ1 para fins da repetição do laço enquanto cond for verdadeira, desde que V_0, com status de palavra reservada, não seja utilizada em nenhum outro lugar do programa, mantendo-se sempre falsa.

repete: os comandos são repetidos enquanto a condição cond for verdadeira. Se cond já for falsa no momento em que o programa de controle atinge essa instrução, executa os comandos apenas uma vez:

      repete
      {
       comandos
      }
      enquanto (cond)

Obs.: para implementação desse laço, o compilador da LCE gera na IL labels da forma REPX, onde X representa um número seqüencial.

para (loop for): se a condição cond for verdadeira, os comandos são repetidos à medida que a variável Var vai, de um em um, do primeiro valor Var_ou_Cte1 ao segundo valor Var_ou_Cte2, ou seja, o que estiver entre o para e o fim_para respectivo será executado repetidamente por (Var_ou_Cte1 - Var_ou_Cte2 + 1) vezes:

      se (cond)
      {
       para Var de Var_ou_Cte1 a Var_ou_Cte2
       comandos
       fim_para
      }

vai_para (goto): se a condição cond for verdadeira, transfere a execução do ciclo de varredura para outro ponto, definido pelo Desvio:

      ...

      se (cond) { vai_para Desvio; }

      ...

      destino Desvio:

      ...

sub-rotina: define o código-fonte de uma sub-rotina (similar ao conceito matemático de função):

      sub_rotina nome (idVar1, idVar2)
       código
      fim_sub_rotina

   Para retornar condicionalmente de uma sub-rotina, utilize o comando

      se (condição) {
       retorna;
      }

   A sub-rotina será condicionalmente chamada, no programa-fonte, pelo nome acompanhado dos parâmetros:

      se (condição) {
       nome (idVar1, idVar2);
      }

Obs. 1: ainda não são permitidas chamadas recursivas às funções.

Obs. 2: as definições de todas as sub-rotinas do controle devem ser feitas no final do programa-fonte, antes dos códigos tratadores de interrupções, se houver.

Obs. 3: no final da sub-rotina há uma instrução implícita de retorno incondicional.

seqüência: cria uma seqüência dentro do controle, para modularização temporal do programa, facilitando o uso da técnica SFC (Sequential Function Chart - Diagrama Funcional Seqüencial) ou GRAFCET (Graphe Fonctionnel de Commande Etape/Transition - Grafo Funcional de Comando Etapa-Transição):

      seqüência S1

       ...      
       circuito
       ...

      fim_circuito_seqüência

      rede N1 // Comentários1

      se (cond) transfere_seqüência S2

      rede N2 // Comentários2

      fim_seqüência;

      rede outra // Comentários ...
       ...


No exemplo acima, as instruções dentro da seqüência S1 (entre as cláusulas seqüência e fim_seqüência) somente serão executadas quando a variável S1 for ligada. Estando ativa, somente se transferirá o controle para a outra seqüência S2 quando a condição cond de transfere_seqüência for verdadeira (o que desligará a variável S1 e ligará S2).

finaliza_scan: se a condição cond for verdadeira, finaliza o ciclo de varredura no ponto em que ele estiver e inicia um novo ciclo, do início:

      se (cond) { finaliza_scan; }

stop: se a condição cond for verdadeira, pára a execução do programa de controle e volta ao modo stop (stop mode):

      se (cond) { stop; }


Sinônimos:    enquanto: while;
         repete: do, repeat, faça;
         para: for;
         fim_para: end_for;
         de: from;
         a: to;
         vai_para: goto;
         destino: label, destination;
         sub-rotina: subroutine;
         fim_sub_rotina: end_subroutine;
         retorna: return;
         seqüência: sequence;
         fim_circuito_seqüência: end_circuit_sequence;
         transfere_seqüência: transfer_sequence;
         fim_seqüência: end_sequence;
         finaliza_scan: finish_scan;
         stop: pare