Curso de scripvox - aula9 (Por Fabiano Ferreira)

    Execução externa e desvios
    Na aula anterior, vimos o comando desvia, que consiste em desviar o
fluxo normal de execussão para um ponto desejado dentro do programa,
ponto este que é marcado previamente com um rótulo.
    Nesta aula, vamos ver outras possibilidades de desvio da execussão
normal e, veremos também a execussão externa.



    *Comando chama;
    Este comando é parecido com o comando desvia que vimos na aula
anterior. Sua utilização requer que marquemos um ponto do programa com
um rótulo.

A diferença é que ele não desvia, literalmente, como acontece no comando
desvia.
   O bloco passado como parâmetro para o comando chama é trazido para cima do ponto onde o interpretador está lendo e é
executado.
    O bloco a ser chamado é marcado com um sinal de @ (arroba), seguido
de um nome de identificação, e, na maioria das vezes, é enserrado com o
comando retorna.
    Ao encontrar o comando retorna, o interpretador volta para o ponto
onde aquele bloco foi chamado e executa a linha imediatamente abaixo da
chamada do bloco.
    Forma geral de uso do comando chama:
chama, um espaço, sinal de arroba e o nome do bloco a ser chamado.
    Forma geral de marcação do bloco a ser chamado:
sinal de arroba e nome do bloco.
Nas linhas abaixo desenvolvemos a rotina pretendida.
    E fechamos o bloco com o comando retorna.

    Obs: o bloco a ser chamado deve estar sempre depois do comando chama
que o invoca.
    Uma dica é agrupar todos os blocos de chamadas ao final do programa.

Vejamos um exemplo prático:

Escreve "Digite um número de 1 a 3:"
Lê n &
se n=1 chama @rotina1
Se n=2 chama @rotina2
Se n=3 chama @rotina3
Escreve "Tchau."
    Termina mudo

@rotina1
Escreve "Esta é a rotina1."
Retorna

@rotina2
Escreve "Esta é a rotina2:"
Retorna

@rotina3
Escreve "Esta é a rotina3."
Retorna

    No exemplo acima, o interpretador chama uma das 3 rotinas, de acordo
com a opção teclada.
Após o término das rotinas, ele retorna e executa a próxima linha após a
linha que chamou aquela rotina.

    Vamos entender melhor nosso exemplo acima:

    Na parte de verificação da opção teclada, o interpretador verifica
se a opção digitada foi a 1,
Vamos supor que foi a 1 realmente.
    Então o programa chama o bloco denominado @rotina 1, executa o
bloco, que no caso, é só a escrita de uma mensagem e retorna para o
ponto de onde foi feita a chamada da rotina 1, ou seja, para a linha
onde diz que se n=1 chama @rotina 1.
Daí ele executará a linha que vem abaixo desta.
No nosso caso, é uma condicional para verificar se a opção digitada foi
2.
No nosso caso, não.
Então ele passa para a próxima linha e verifica se foi a opção3.
No caso, não.
Então ele executa a próxima linha que é a exibição da mensagem "Tchau" e
após o comando termina mudo.

    Notem que os blocos a serem chamados foram colocados após o comando
termina mudo.
    Isso pode ser feito, o que não poderia era termos inserido os blocos
no início do programa e utilizarmos o comando chama depois deles.

    No comando chama, é possível utilizar várias chamadas aninhadas, por
exemplo:

Escreve "Chamando rotina 1"
chama @rotina1
Escreve "Tchau."
Termina mudo

@rotina1
Escreve "Sou a rotina1:"
Escreve "Vou chamar a rotina 2:"
Chama @rotina2
Escreve "Devolta a rotina1."
Retorna

@rotina2
Escreve "Sou a rotina2, e vou chamar a rotina3:"
chama @rotina3
Escreve "Voltando a rotina2"
Retorna

@rotina3
Escreve "Eu sou a rotina3."
Retorna

    No exemplo acima, o programa principal chama a rotina 1;
Na rotina 1, chamamos a rotina 2; e na rotina 2, chamamos a rotina 3.
    Sendo assim, o comando retorna da rotina 3, nos leva de volta a
rotina 2.
O retorna da rotina 2 nos leva de volta para a rotina 1, e o retorna da
rotina 1 nos leva de volta ao programa principal.

    *Comando desvia;

    Na aula anterior, vimos o comando desvia.
    Aqui, vamos vê-lo novamente, mas com uma forma um pouco diferente.
    Esta forma permite que possamos chamar um outro arquivo cmd e
executá-lo, como se fosse o mesmo arquivo.
    Vamos imaginar o seguinte:
Um script chamado a.cmd, e um outro script chamado b.cmd.
    É possível chamar dentro de a.cmd, o script b.cmd e executá-lo,
como se fosse um código presente em a.cmd.
    A forma de uso do comando é a seguinte:
Desvia, um espaço, a palavra script, um espaço, nome do script entre
aspas.
    É possível ainda, desviar a execução para outro arquivo apontando um
rótulo que está dentro desse outro arquivo.
Para isso fazemos o seguinte:
Desvia, um espaço, a palavra script, um espaço, nome do arquivo entre
aspas, espaço, sinal de arroba e nome do rótulo.

    Exemplo:

*arquivo 1.cmd;
*Por Fabiano Ferreira;
*Em setembro de 2011;

Escreve "Esse é o arquivo 1.cmd"
Desvia script "2.cmd"
*fim do arquivo 1.

*Arquivo 2.cmd;
*Por Fabiano Ferreira;
*Em setembro de 2011;

Escreve "Esse é o arquivo 2.cmd"
Termina mudo
*Fim do arquivo 2.

    No exemplo acima temos dois códigos.
    Um faz parte do arquivo 1.cmd.
O outro faz parte do arquivo 2.cmd.
    Executamos o script 1.cmd.
    É exibida então a mensagem "Esse é o arquivo 1.cmd".
    Logo abaixo, temos um desvio para executar o código do script 2.cmd
    Daí, o programa abandona o 1.cmd e vai executar o 2.cmd
    No nosso caso, exibe a string "Esse é o arquivo 2.cmd"  o
interpretador é enserrado.

    Vejamos agora outro exemplo:

*Arquivo 1.cmd;
*Por Fabiano Ferreira;
*Em setembro de 2011;

Escreve "Esse é o arquivo 1.cmd"
Desvia script "2.cmd" @teste
*Fim do arquivo 1;

*Arquivo 2.cmd;
*Por Fabiano;
*Em setembro de 2011;

@teste
    Escreve "Esse é o arquivo 2.cmd"
Termina mudo
*Fim do arquivo 2;

    No exemplo acima temos a mesma situação do primeiro exemplo do
comando desvia.
Dois arquivos.
1.cmd e 2.cmd.
    Executamos 1.cmd e logo é mostrada e falada a mensagem "Esse é o
arquivo 1.cmd"
Logo abaixo, um desvio para o arquivo 2.cmd, com a especificação do
rótulo chamado @teste.
Este rótulo está dentro de 2.cmd
    Nesse momento, o programa abandona a execussão de 1.cmd e executar
2.cmd, a partir do rótulo que foi especificado.
    No nosso caso, exibiu a mensagem "Esse é o arquivo 2.cmd" e abaixo,
o comando termina mudo, para enserrar o programa.

    Assim teminamos a aula9.
    Na próxima aula, vamos continuar falando de execussão externa e
desvios.

    Exercício:

Construir uma calculadora básica, utilizando a linguagem scripvox.
Características do programa:
*realizar 4 operações: adição, subtração, multiplicação e divisão;
*A divisão deve ser simples, não retornando resto, caso ele exista;
*o programa terminará quando o usuário digitar 0 como primeiro termo de
uma operação.

    *Entregar a resposta até o dia 25/09 enviando para o seguinte email:
qst-scripvox@sanfersite.com.br

Boa sorte!
