Uso do MS JITDebug integrado ao E3.

O E3 suporta a criação de scripts na linguagem VBScript, incorporando quase todos os recursos disponíveis nessa linguagem. Existe uma extensa documentação para o VBScript disponível em diferentes fontes, como livros, sites, fóruns, etc., além da que acompanha o E3.

Entretanto, existem algumas pequenas restrições na implementação do VBScript para o E3. Duas delas são:

1. Não é possível criar funções do usuário. Isso quer dizer que, se um usuário precisa executar uma determinada função em mais de uma situação (como, por exemplo, atualizar um status em uma tabela de banco de dados), essa função deve estar associada a um evento suportado pelo E3 (por exemplo, a variação de um tag).
2. As variáveis no E3 não tem tipo definido. Isso pode ser visto quando se usa, por exemplo, o comando DIM para declarar uma variável. O tipo da variável deve ser ajustado no script: isso quer dizer que uma variável do tipo inteiro poderia receber um string, sem indicar erro e sem restringir o valor recebido. Essas resoluções são feitas por código.

Apesar dessas características, é possível criar qualquer solução que seja necessária a um determinado objeto ou processo com scripts do E3. Essa tarefa eventualmente pode se tornar trabalhosa, devido à complexidade frequentemente encontrada na hora de codificar um script. Para contornar essa situação, existe um modo interessante de depurar scripts no E3: o uso de arquivos texto, onde cada variável de interesse tem seu valor impresso nesse arquivo. Isso funciona basicamente como um log, mas tem como inconveniência o fato de exigir que sejam inseridos no código do script os comandos necessários às escritas de tais valores. Depois de depurado o script, ainda é necessário “limpar” o código, para evitar o uso desnecessário de recursos do servidor.

Para eliminar essas necessidades, apresentamos nesse artigo um depurador bastante versátil e poderoso, que é distribuído gratuitamente pela Microsoft. O software está disponível no CD de instalação do Windows (Fig. 1) ou através de download no site da Microsoft

Figura 1: Instalação do depurador a partir do instalador do Windows

2) O MS JITDebug

Feita a instalação do JIT, é necessário habilitá-lo pelo registro do Windows. Essa habilitação pode ser desfeita, e recomenda-se que se mantenha habilitado o depurador apenas durante o período em que estiver trabalhando com ele, visto que qualquer tipo de erro de script (seja no E3, seja em outros softwares) fará com que seja aberta uma tela de opção de abertura do depurador. Isso acontecerá, por exemplo, ao navegar por páginas da Internet que contenham erros.

Para habilitar o Just-in-time Debugger, basta entrar no REGEDIT e configurar a chave “HKEY_CURRENT_USER\Software\Microsoft\Windows Script\Settings\JITDebug” com o valor 1. Para desabilitá-lo, configure o valor como 0.

3) Depurando scripts no E3

Para utilizar o JIT, precisaremos criar um projeto simples, com dois tags e alguns scripts. A Figura 2 mostra a aparência do Organizer quando todos os itens tiverem sido inseridos.

Figura 2: Organizer com todos os dados inseridos

A TelaInicial deverá ser configurada como mostrado na Figura 3. Será uma tela simples, com um texto, um display e um retângulo de cor azul. O display deverá mostrar o item “TagDemo1.Value”.

Figura 3: TelaInicial a ser desenvolvida

Depois de desenhada a tela, crie o script mostrado na Figura 4. O script começará com o comando “stop”, que faz com que a execução do script seja interrompida e que o JITDebug seja aberto: essa é a primeira maneira de abrir o depurador pelo E3. O depurador também será aberto sempre que houver erros em algum script no aplicativo do E3.

Figura 4: Script a ser depurado

Depois de configurado o script da TelaInicial, crie o script da Figura 5 no evento OnClick do retângulo.

Figura 5: Script do evento Click do retângulo

Perceba que o script não trata um erro sério (divisão por zero) quando a propriedade VerticalPercentFill tem o seu valor zerado. Como poderemos ver, sempre que acontece um erro detectado pelo depurador e que não tenha sido tratado no próprio script, o depurador é aberto automaticamente, mostrando onde está o erro.

4) MS JITDebug em ação

Depois de configurado o projeto, é necessário executá-lo. Quando o E3 Viewer for aberto, clique sobre a área livre da tela. O depurador será aberto, e o script será mostrado com uma das linhas em amarelo (ponto atual da execução do script). A Figura 6 ilustra o que deverá ser mostrado a essa altura.

Figura 6: Depuração do script do evento OnClick da TelaInicial

A ferramenta mais importante do JIT Debug é a Command Window, que permite que sejam:

• Visualizados valores de variáveis do E3.
• Executados comandos do VBScript, e recuperado o valor de retorno.
• Alterados valores de dados do E3, com o objetivo de estudar o comportamento do E3 com esses novos valores.

A Figura 7 mostra alguns comandos possíveis de serem executados no Command Window. Nessa figura, foi solicitado que o script retornasse a hora atual (? NOW) e que fosse exibida uma mensagem “Teste” na tela.

Figura 7: Command Window executando funções do VBScript

Para verificarmos os valores de variáveis do E3, devemos:

• começar a pergunta sempre com um sinal de interrogação (?).
• colocar o caminho da variável. Por exemplo: Application.GetObject(“Tag”).Value.
• garantir que a variável tenha sido inicializada corretamente.

5) Exercícios com o depurador

Para garantir as condições iniciais que serão citadas aqui, é necessário primeiramente parar o aplicativo. A seguir, execute novamente o projeto e siga os passos descritos abaixo.

1. Clique sobre a TelaInicial, e então será aberto o depurador. Note que antes disso, o display mostrava diferentes valores do TagDemo1, gerados automaticamente. Ao abrir o depurador, essa atualização deixa de ser efetuada, pois o servidor estará parado esperando o fechamento do processo de depuração.
2. Antes de executar qualquer ação no debugger, abra a janela Command Window. Nela, execute o comando “? Screen.Item(“Texto1″).value”. O valor retornado deverá ser “Texto a ser modificado“.
3. Volte ao depurador e execute um comando através da tecla F8. Execute novamente o comando anterior. O retorno deverá ser algo como “TESTE!!! Data: 8/3/2004 14:03:55”, onde a data mostrada deverá ser a data de execução do teste e a mesma do micro nesse momento.
4. Execute depois o comando “? Application.GetObject(“Dados.TagInterno1″).Value”. Deverá ser retornado o valor 0. Volte ao depurador e execute mais um passo (deverá ser o correspondente ao TagInterno1). A seguir, execute o comando no Command Window. O resultado esperado é a data anterior à data do teste (now – 1).
5. Por último, execute o comando “? Application.GetObject(“Dados.TagDemo1″).Enabled”, cujo resultado será verdadeiro. Execute na janela do script o último comando e rode novamente a pergunta sobre a propriedade Enabled no Command Window. Perceba que, como esperado, o valor da propriedade passou a ser falso.
6. Feche o depurador e verifique que o TagDemo1 não está variando o seu valor, pois ele está desabilitado. Para habilitá-lo, basta novamente executar o script OnClick da TelaInicial. Será aberto o depurador mais uma vez, no comando stop, conforme esperado. Para evitar que seja necessário passar por todos os passos do script, posicione um breakpoint na última linha de comando do script. Para chegar até essa linha, pressione a opção Step Out no menu Debug. O script será executado até encontrar um breakpoint. Finalize a depuração desse script e veja o valor do TagDemo1 sendo modificado automaticamente.
7. Feche o depurador, mas mantenha o E3 Viewer aberto. Depois, clique sobre o retângulo (será mostrada uma mensagem com o inverso do valor da propriedade VerticalPercentFill), e repita essa operação até que o depurador seja chamado automaticamente.
8. Quando isso acontecer, execute o comando “? VerticalPercentFill” no Command Window. Verifique que o valor é igual a zero, o que deverá gerar um erro de divisão por zero. Para evitar esse erro, altere o valor da propriedade VerticalPercentFill para 1, usando o comando “VerticalPercentFill = 1” no Command Window. Finalize a execução do script, e verifique que a mensagem a ser exibida não diz respeito a erros de divisão e sim ao resultado da inversão (1/VerticalPercentFill), como nos casos anteriores.
9. Com esse exercício, foi demonstrado como eliminar erros de script por ajustes feitos com o depurador, ajustes esses que não são definitivos e que devem ser inseridos no código quando necessário.

6) Considerações finais

Em caso de comportamento errático, ou mesmo de resultados inesperados em scripts, deve-se sempre recorrer a ferramentas de depuração para detectar e eliminar tais anomalias no menor tempo possível. Nesse artigo, foi demonstrado o uso de um depurador que é parte integrante do Windows, podendo ser instalado em qualquer máquina, sem custo para o desenvolvedor.

Caso haja qualquer problema ou dificuldade na execução desse projeto, entre em contato com o Suporte Técnico da Elipse Software.