Protheus IDE

AP5 IDE

Documentação e Guia do Usuário

CopyRight © 1999 Microsiga Software S.A.

AP5 IDE – Documentação e Guia do Usuário CopyRight © 1999 Microsiga Software S.A.

Sumário

O AP5 IDE...................................................................................................................................4

Configurando o AP5 IDE............................................................................................................5

Configurações do Debugger.................................................................................................................5Definindo o Padrão de Teclas de Atalho.........................................................................................................5Definindo o Número de Arquivos na Lista de Recentemente Abertos...........................................................6Utilizando a Régua com o Número de Linhas................................................................................................6Definindo a Localização de Arquivos.............................................................................................................6Ignorando Arquivos Não Encontrados............................................................................................................6

Configurações de Código......................................................................................................................7Elementos de Texto.........................................................................................................................................7Definindo o Estilo do Texto.............................................................................................................................7Definindo a Cor do Texto................................................................................................................................7Definindo a Cor de Fundo do Texto................................................................................................................7Desabilitando a Diferenciação de Sintaxe.......................................................................................................7

Configurações de Controle de Versão..................................................................................................8Utilizando o Controle de Versão......................................................................................................................8Software Controlador de Versão.....................................................................................................................8Path Inicial do Software Controlador de Versão.............................................................................................8Linha de Comando para Obtenção da Última Versão.....................................................................................9Linha de Comando para Reservar Arquivo.....................................................................................................9Linha de Comando para Cancelar Reserva.....................................................................................................9Linha de Comando para Confirmar Arquivo...................................................................................................9Linha de Comando para Adicionar Arquivo...................................................................................................9Linha de Comando para Remover Arquivo.....................................................................................................9

Utilizando o AP5 IDE................................................................................................................10

A Edição de Arquivos.........................................................................................................................10Criando e Editando Arquivos........................................................................................................................10Recursos de Edição........................................................................................................................................11

Modificações de Texto..........................................................................................................................11Inserção de Texto em um Arquivo........................................................................................................12Localização e Substituição de Texto.....................................................................................................12Utilizando Book Marks.........................................................................................................................14

Grupos de Projetos e a Compilação de Arquivos.............................................................................14Trabalhando com Grupos de Projetos...........................................................................................................14Compilando Arquivos de Código-Fonte.......................................................................................................15Configurações de um Grupo de Projetos.......................................................................................................16

Utilizando o Debugger do AP5 IDE...................................................................................................19Os Comandos de Debug................................................................................................................................19As Janelas de Inspeção do AP5 IDE.............................................................................................................21

A Janela de Break Points.......................................................................................................................21A janela de Pilha de Chamadas.............................................................................................................22A Janela de Watchs...............................................................................................................................22As Janelas de Inspeção de Variáveis.....................................................................................................23A Janela de Inspeção de Tabelas e Campos..........................................................................................24O Inspetor de Objetos............................................................................................................................25

Controlando Versões de Arquivos Através do AP5 IDE.........................................................26


Os Softwares para Controle de Versões de Arquivos......................................................................26

O Controle de Versões Através do AP5 IDE....................................................................................26A Reserva Automática de um Arquivo.........................................................................................................26Executando Outras Macros de Controle de Versão.......................................................................................26

Utilizando os Assistentes do AP5 IDE.......................................................................................29

O Assistente de Geração de Código...................................................................................................29

O Assistente de Conversão de Código...............................................................................................30Selecionando os Arquivos.............................................................................................................................30Convertendo os Arquivos..............................................................................................................................30Diretório para Gravação dos Arquivos Convertidos.....................................................................................30Criação de Projeto e Compilação Automáticos.............................................................................................31

Tabela de Macros.......................................................................................................................32

Glossário.....................................................................................................................................34


O AP5 IDE

O AP5 IDE é um ambiente de desenvolvimento integrado que acompanha o Advanced Protheus, permitindo ao usuário editar, compilar e depurar programas escritos na linguagem ADVPL.

Como ferramenta de edição, possui todos os recursos das ferramentas mais populares, como cortar e colar, levar o cursor até determinada linha do código, localização e substituição de texto, etc., e recursos adicionais, como identação de código, inserção de comentários de documentação, etc.

Como ferramenta de debug, dispõe de ações de debug como Percorrer Linha, Pular Linha, Executar, Seguir até o Retorno, Pausar Execução, Derrubar Client, etc., permitindo ao usuário executar e depurar suas rotinas de dentro de seu ambiente integrado, inspecionando o ambiente de execução de suas rotinas através de diversas janelas de informações, como variáveis (divididas entre variáveis locais, variáveis públicas, variáveis privadas e variáveis estáticas), expressões em Watch, tabelas, índices e campos, break points, programas registrados (inspetor de objetos) e pilha de chamadas. Além disso, os programas criados são compilados diretamente do AP5 IDE, onde são mantidos em projetos e grupos de projetos. Os grupos de projetos facilitam a compilação de um ou mais projetos de arquivos, utilizando conceitos de repositórios e diretivas de compilação, possibilitando inclusive a manutenção de bibliotecas de rotinas do usuário.

AP5 IDE – Documentação e Guia do Usuário 4CopyRight © 1999 Microsiga Software S.A.

Configurando o AP5 IDE

Antes de iniciar a utilização do AP5 IDE, deve-se configurá-lo para um melhor aproveitamento de seus recursos. Na opção de preferências, encontrada no menu Arquivo, item Preferências, são definidas as informações que influenciam no comportamento do AP5 IDE. Ao acionar este item do menu, a janela de Preferências é exibida, contendo informações divididas em três pastas. Todas as informações das preferências bem como as diversas informações armazenadas pelo AP5 IDE, são mantidas no arquivo chamado AP5IDE.INI que se encontra no mesmo diretório de execução do IDE.

Configurações do Debugger

A pasta de configurações do debugger (figura 1), exibe as opções básicas para o processamento do AP5 IDE em modo de debug e do editor. Aqui são definidas as configurações para a localização dos arquivos de código fonte durante o processo de debug, se o AP5 IDE deve ignorar automaticamente os arquivos não encontrados, o tamanho da tabulação, do número de Undo's, etc.

Definindo o Padrão de Teclas de Atalho

O padrão de teclas utilizado identifica quais serão as teclas para o acionamento das principais funções de debug do AP5 IDE. Os padrões possíveis são os mesmos utilizados pelas linguagens de programação FiveWin, Visual C++ e Delphi, tornando fácil a assimilação para usuários de algumas destas ferramentas. Para cada um dos padrões utilizados, as combinações de teclas para o acionamento das ações de debug serão:

FiveWinPercorrer Linha F8 Seguir até o Retorno F7Pular Linha F10 Localizar Ctrl+LExecutar F5 Localizar Próximo F3Adicionar Break Point F9 Ir para a linha "n" Ctrl+G

Visual C++Percorrer Linha F11 Seguir até o Retorno Ctrl+F10Pular Linha F10 Localizar Ctrl+FExecutar F5 Localizar Próximo F3Adicionar Break Point F9 Ir para a linha "n" Ctrl+G

DelphiPercorrer Linha F7 Seguir até o Retorno F4Pular Linha F8 Localizar Ctrl+FExecutar F9 Localizar Próximo F3Adicionar Break Point F5 Ir para a linha "n" Ctrl+G


Figura 1 - A pasta Debugger da janela de Preferências do AP5 IDE

Definindo a Tabulação

O campo Tabulação indica o número de caracteres que serão usados para cada tecla de tabulação (código ASC II #9), na identação do código.

Definindo o Número de Undo's

O campo de Número Máximo de Undo's indica o número máximo de modificações no texto que o AP5 IDE irá armazenar para permitir o Undo e/ou Redo. As ações são armazenadas de modo que assim que é atingido o limite estabelecido as últimas ações passam a ser descartadas a cada nova ação.Os Undo's e Redo's são mantidos por arquivo, e são resetados quando o arquivo é salvo. Indicando zero (0), o armazenamento máximo torna-se infinito (dependente apenas da memória disponível).

Definindo o Número de Arquivos na Lista de Recentemente Abertos

O campo Arquivos na Lista de Recentemente Abertos indica o número máximo de arquivos que serão mantidos na lista de recentemente abertos, que se encontra no final do menu Arquivo, para possibilitar a abertura rápida dos mesmos. Indicando zero (0), não será mantida uma lista dos arquivos recentemente abertos.

Utilizando a Régua com o Número de Linhas

A opção Exibir Régua com o Número de Linhas indica se o AP5 IDE deve exibir uma régua com os números das linhas em um novo gutter na margem esquerda de cada arquivo aberto, para facilitar a localização visual do usuário.

Definindo a Localização de Arquivos

Quando em processo de debug, especificamente durante os comandos de Percorrer Linha e Pular Linha, a execução é feita linha-a-linha do código. Para isso, o AP5 IDE localiza os arquivos de código fonte, abre-os e posiciona o cursor na linha em execução. Para os arquivos não encontrados, o IDE questionará o usuário por seu caminho. Se não forem encontrados, não poderão ser abertos para o posicionamento da linha e serão colocados em uma lista de arquivos ignorados (até que o IDE seja reinicializado). Para facilitar a localização, pode-se digitar neste campo uma lista de paths onde os arquivos devem ser procurados. Os paths devem ser separados com o sinal de ponto-e-vírgula (;).

Ignorando Arquivos Não Encontrados

Quando em processo de debug, especificamente durante os comandos de Percorrer Linha e Pular Linha, a execução é feita inha-a-linha do código. Para isso, o AP5 IDE localiza os arquivos de código fonte, abre-os e posiciona o cursor na linha em execução. Porém se não for possível encontrar o arquivo de código fonte, o IDE questionará o usuário pelo caminho onde o arquivo pode ser encontrado. Se o usuário realmente não tiver o arquivo e cancelar a localização do mesmo, o IDE não o questionará mais (até que o IDE seja reinicializado). Para evitar que seja questionado a cada arquivo não encontrado, pode-se marcar esta opção. Assim todos os arquivos não encontrados serão adicionados automaticamente à lista de arquivos ignorados.

Note que os break points eventualmente contidos em um fonte não encontrado não farão com que o processamento pare. Do mesmo modo, executando o comando Percorrer Linha sobre uma função que esteja em um arquivo de código-fonte não encontrado, fará com que a função seja normalmente executada e a parada volte a ocorrer somente na próxima linha, depois do retorno da função.


Configurações de Código

A pasta de configurações do código (figura 2), exibe as opções para controle da diferenciação de sintaxe no editor do AP5 IDE. Aqui você pode habilitar ou desabilitar a diferenciação de sintaxe bem como configurar as cores para cada elemento de texto que pode ser diferenciado.

Elementos de Texto

Os elementos de texto são tipos de expressões que devido a sua finalidade são classificados em grupos separados. Como por exemplo, palavras reservadas ao compilador, strings de caracteres, números, etc. Nesta lista são apresentados os diferentes elementos de texto que permitem a diferenciação de sintaxe no AP5 IDE. O elemento deve ser selecionado nesta lista para que se possa configurar suas cores e estilo. Todas as demais configurações nesta mesma pasta serão, então, relacionadas com o elemento atualmente selecionado.

Definindo o Estilo do Texto

Nesta lista de opções pode-se escolher qual o estilo será aplicado ao elemento de texto selecionado na lista de elementos.

Definindo a Cor do Texto

Nesta lista de cores pode-se escolher qual será a cor aplicada ao elemento de texto selecionado na lista de elementos.

Definindo a Cor de Fundo do Texto

Nesta lista de cores pode-se escolher qual será a cor de fundo aplicada ao elemento de texto selecionado na lista de elementos.

Desabilitando a Diferenciação de Sintaxe

Selecionando-se esta opção, o AP5 IDE não se utilizará da diferenciação de sintaxe no código dos arquivos abertos. Apesar de que o uso diferenciação de sintaxe não consuma muitos recursos, o atualização das janelas pode ficar mais rápida com esse recurso desabilitado. Desabilitando a diferenciação, as cores de todo o texto serão aquelas definidas no Windows da estação.

Para a alteração da fonte do texto, utilize a opção Escolha de Fonte no menu Arquivo. A fonte não pode ser diferenciada para os elementos de texto do código. Apenas o estilo e as cores.


Figura 2 - A pasta Código da janela de Preferências do AP5 IDE

Configurações de Controle de Versão

A pasta de configurações de Controle de Versão (figura 3), exibe as opções para a integração de um software de controle de versão ao AP5 IDE. Nesta pasta são definidos os comandos básicos para acionamento do software controlador de versão através de linha de comando. Estes comandos podem ser acionados automaticamente pelo AP5 IDE ou pela requisição do usuário através dos botões da barra de ferramentas de controle de versão.

Utilizando o Controle de Versão

A opção Utiliza Controle de Versão indica que será utilizado um software de controle de versão para controlar a reserva e a alteração de arquivos de código-fonte. Ao acionar esta opção uma janela com os softwares controladores de versão compatíveis (figura 4) será apresentada para que o usuário escolha aquele que esteja utilizando. A confirmação desta janela traz nos campos das linhas de comando as sintaxes utilizadas pelo software escolhido sugeridas. Caso o software utilizado não se encontre na lista de softwares compatíveis, o usuário deverá consultar a documentação que o acompanha e fornecer manualmente as sintaxes para as linhas de comandos.

Software Controlador de Versão

O campo Software indica o caminho para o software que receberá as linhas de comando enviadas pelo AP5 IDE para as ações de controle de versão.

Path Inicial do Software Controlador de Versão

O campo Iniciar Em indica o path onde o software controlador de versão será iniciado quando receber as linhas de comando.


Figura 3 - A pasta Controle de Versão da janela de Preferências do AP5 IDE

Figura 4 - Seleção de um software de controle de versão compatível. A confirmação do diálogo preenche os campos de linhas de comando de acordo com as sintaxes do software escolhido.

Linha de Comando para Obtenção da Última Versão

O campo Última Versão indica os parâmetros passados para o Software Controlador de Versão para realizar uma obtenção da última versão do arquivo de código aberto no momento. Pode-se utilizar macros para obtenção do nome do arquivo corrente, path, etc. Veja a Tabela de Macros para informações das macros disponíveis no AP5 IDE.

Linha de Comando para Reservar Arquivo

O campo Reservar indica os parâmetros passados para o Software Controlador de Versão para realizar a reserva do arquivo de código fonte aberto no momento. Pode-se utilizar macros para a obtenção do nome do arquivo corrente, path, etc. Veja a Tabela de Macros para informações das macros disponíveis no AP5 IDE.

Note que apesar desta linha de comando poder ser acessada através da barra de ferramentas, não se deve fugir de seu objetivo (reservar o arquivo aberto no servidor de arquivos), pois quando o uso de controle de versão está habilitado no AP5 IDE, esta linha de comando é executada automaticamente no momento que alguma alteração está prestes a ser efetuada em um arquivo. Caso necessite executar algo diferente, utilize-se das ferramentas no menu Ferramentas.

Linha de Comando para Cancelar Reserva

O campo Cancelar indica os parâmetros passados para o Software Controlador de Versão para realizar o cancelamento da última reserva efetuada pelo usuário, do arquivo de código aberto no momento. Pode-se utilizar macros para obtenção do nome do arquivo corrente, path, etc. Veja a Tabela de Macros para informações das macros disponíveis no AP5 IDE.

Linha de Comando para Confirmar Arquivo

O campo Confirmar indica os parâmetros passados para o Software Controlador de Versão para realizar a confirmação do arquivo de código fonte aberto no momento. Pode-se utilizar macros para obtenção do nome do arquivo corrente, path, etc. Veja a Tabela de Macros para informações das macros disponíveis no AP5 IDE.

Linha de Comando para Adicionar Arquivo

O campo Adicionar indica os parâmetros passados para o Software Controlador de Versão para adicionar o arquivo de código fonte aberto no momento no controle de versão. Pode-se utilizar macros para a obtenção do nome do arquivo corrente, path, etc. Veja a Tabela de Macros para informações das macros disponíveis no AP5 IDE.

Linha de Comando para Remover Arquivo

O campo Remover indica os parâmetros passados para o Software Controlador de Versão para remover o arquivo de código fonte aberto no momento do controlador de versão. Pode-se utilizar macros para a obtenção do nome do arquivo corrente, path, etc. Veja a Tabela de Macros para informações das macros disponíveis no AP5 IDE.


Utilizando o AP5 IDE

A Edição de Arquivos

O AP5 IDE suporta a edição de arquivos no formato texto, sendo que as extensões padrões são PRW, PRX e PRG. Todos os arquivos gravados pelo IDE, são gravados contendo como finalizadores de linha os caracteres de código ASC II 10 e 13 (LF e CR). Através das opções dos menus o usuário tem um controle amplo da formatação do texto, com facilidades de cópia e edição de múltiplos arquivos como uma aplicação MDI.

Criando e Editando ArquivosO menu Arquivo (figura 5) contém todas as opções necessárias para a criação e edição de arquivos. A opção Novo criará um novo arquivo para edição abrindo-o em uma nova janela de documento na área de trabalho do AP5 IDE. A opção Abrir irá exibir a caixa de diálogo de seleção de arquivos padrão do Windows, onde o usuário poderá escolher ou digitar o nome do arquivo que deseja editar. Se o usuário não digitar a extensão, a extensão padrão (.PRW) ou a extensão do tipo de arquivo exibido na caixa de diálogo será assumida na tentativa de abertura do arquivo. Após a seleção do arquivo, o mesmo será carregado em uma nova janela de documento na área de trabalho do AP5 IDE. O limite para o tamanho dos arquivos, bem como para o número de arquivos abertos, é dependente apenas da memória disponível na máquina que executa o AP5 IDE.

A gravação dos arquivos é efetuada pelos itens Salvar e Salvar Como. Para um arquivo novo, a seleção da opção Salvar irá exibir a caixa de diálogo de seleção de arquivos para a escolha do nome para gravação. Após o arquivo ter sido gravado, a seleção da opção Salvar gravará o arquivo sem questionar o usuário pelo nome.

Ao contrário, a opção Salvar Como sempre questiona o usuário por um nome de arquivo e grava-o com o nome informado. As opções Imprimir e Configurar Impressora permitem ao usuário imprimir o arquivo corrente ou uma seleção de texto através das impressoras definidas no Windows. Pode-se também enviar o arquivo aberto por e-mail utilizando a opção Enviar via e-mail.

A opção Escolha de Fonte permite ao usuário escolher qual a fonte gráfica e qual o tamanho dos caracteres que utilizará para editar seus arquivos. A escolha de fonte não faz parte da diferenciação de sintaxe. Para uma perfeita exibição dos caracteres gráficos utilizados para a moldura de comentários nos arquivos de código-fonte criados, existe um arquivo de fonte chamado LINEDRAW.TTF (MS LineDraw) que os exibe como são exibidos em editores para ambiente DOS. O AP5 IDE está preparado para tentar detectar a existência desse arquivo no diretório de seu executável e instalá-lo no ambiente do usuário assim que for iniciado.Para finalizar a execução do AP5 IDE, o usuário pode escolher a opção Sair, utilizar a combinação de teclas Alt+F4 ou clicar no ícone em forma de x na barra de títulos da janela principal. Ao finalizar, o AP5 IDE grava


Figura 5 - Os itens do menu Arquivo

Figura 6 - Diferenciação de Sintaxe em um arquivo aberto no AP5 IDE, utilizando o fonte MS LineDraw.

todas as informações das preferências bem como informações do ambiente do usuário (como janelas abertas, posicionamento, etc.). Porém, se o usuário estiver com uma sessão de debug em progresso, o AP5 IDE irá questioná-lo para encerrar a sessão de debug antes de finalizar.

Para o envio de um arquivo via e-mail o usuário deve ter instalado e configurado em sua máquina um cliente de e-mail como por exemplo o Microsoft Outlook. O arquivo físico, ou seja, a cópia gravada no disco será enviado como um "attachment" via e-mail. Portanto qualquer alteração efetuada no buffer de edição que não tenha sido gravada não constará do "attachment" no e-mail.

Muito importante: Se o usuário finalizar o AP5 IDE sem que uma sessão de debug tenha sido encerrada, o AP5 IDE irá tentar encerrar esta sessão antes de finalizar enviando ao Server o comando Derrubar Client (que será detalhado mais a frente no tópico sobre Utilização do Debug do AP5 IDE). Porém, a finalização do AP5 Remote nem sempre é imediata visto que o controle do envio das mensagens pode não estar com o AP5 IDE no momento da finalização. Isto pode acarretar na finalização do AP5 IDE sem que o AP5 Remote seja finalizado, ou seja, o processo de execução do AP5 Remote ficará preso na memória da estação.

Recursos de Edição

O menu Editar (figura 7) contém todas as opções necessárias para a edição e formatação dos textos nos arquivos abertos. Contem os recursos de Copiar, Recortar e Colar blocos de texto utilizando-se da área de transferência, permitindo também que textos copiados de outros arquivos de código-fonte sejam copiados para arquivos abertos. Possui também os recursos de Desfazer e Refazer ações, ou seja, as modificações efetuadas no texto podem ser desfeitas até o limite inicial da abertura ou da última gravação do arquivo e refeitas até o limite do número de ações armazenadas. O número de ações que o AP5 IDE pode armazenar é configurável, como já foi detalhado no tópico Configurando o AP5 IDE.

Modificações de Texto

No item Texto, existem opções para transformar o texto selecionado para caracteres maiúsculos ou minúsculos e até mesmo uma opção para identar o arquivo.

A identação modifica as tabulações do código de maneira a tornar mais fácil a visualização do início e do encerramento das estruturas de controle de fluxo (como IF-ENDIF, WHILE-ENDDO, etc.). Porém a identação não faz o papel do compilador, avaliando as expressões. Por esse motivo, o AP5 IDE não é capaz de identar arquivos que contenham a linha de código do comando IF dessa maneira:

If(<Expressão>)<Comando>Endif

Isso se deve ao fato de que o comando IF seguido de um parênteses é confundido com a função IF: IF(<Expressão>,<Comando1>,<Comando2>) que não é um indicador de início de bloco de controle de fluxo, ou seja, não termina com um ENDIF. Isto é facilmente corrigido incluindo-se um caracter de espaço entre o comando e o sinal de parênteses:

If (<Expressão>)


Figura 7 - Os itens do menu Editar

<Comando>Endif

Se o AP5 IDE encontrar uma linha como a descrita anteriormente simplesmente exibirá uma mensagem de erro na identação, exibindo a linha onde tal erro foi encontrado, e cancelará o processo de identação. O usuário também pode cancelar o processo de identação clicando no botão Cancela que aparece na barra de status do AP5 IDE. Em qualquer um dos casos, quando a identação é cancelada, o código não é alterado.

Inserção de Texto em um Arquivo

Existem também opções para inserir caracteres ASC II e os comentários padronizados para documentação no código, utilizando a fonte configurada. Também no menu Editar se encontram as opções de navegação no código. São as opções para posicionamento do cursor em determinado número de linha e posicionamento do cursor na linha em execução (somente quando o AP5 IDE estiver com uma sessão de debug aberta) no arquivo selecionado. A opção Localizar exibe a janela de localização de texto.

Localização e Substituição de Texto

É possível localizar textos no arquivo corrente ou realizar uma pesquisa em mais de um arquivo, estando ele aberto ou não no AP5 IDE. A pasta Localizar (figura 8) pesquisa por expressões no arquivo corrente. Pode-se pesquisar acima ou abaixo da posição do cursor. Ainda pode-se indicar se a pesquisa deve considerar a coincidência dos caracteres, ou seja, encontrar exatamente a expressão fornecida, ou ignorar as diferenças entre caracteres maiúsculos ou minúsculos. Para isso o usuário deve marcar a caixa Coincidir Maiúsc./Minúsc. Pode-se também indicar se a expressão deve ser localizada em qualquer lugar do texto ou somente se for uma palavra inteira. Uma palavra inteira é o texto considerado entre dois delimitadores.

Assim que o texto é localizado, o AP5 IDE move o cursor até sua localização e marca o texto encontrado, fechando a janela de localização de texto. Pode-se utilizar a opção Repetir Procura para continuar localizando a expressão com as mesmas configurações sem precisar abrir a janela de localização novamente.

A pasta Localizar em Arquivos (figura 9) permite uma pesquisa mais ampla com todas as opções da localização detalhada anteriormente. Pode-se localizar expressões em arquivos de um diretório, pode-se localizar expressões em todos os arquivos abertos e pode-se localizar expressões em todos os arquivos do grupo de projetos aberto (a utilização de grupos de projetos será detalhada no tópico Criação de Grupos de Projetos e Compilação de Arquivos). Porém os resultados da pesquisa serão exibidos na Janela de Resultados da Localização em Arquivos (figura 10).


Figura 8 - Pasta Localizar da janela de localização do AP5 IDE.

Figura 9 - Pasta Localizar em Arquivos da janela de localização do AP5 IDE.

Nesta pasta as opções de direção são substituídas pelas opções de localização, ou seja, onde a pesquisa deve ser efetuada. Se o usuário optar por pesquisar em um diretório, o quadro de opções Diretório de Pesquisa será habilitado, permitindo ao usuário digitar no campo Máscara de Pesquisa o diretório e a máscara de arquivos que deseja pesquisar (por exemplo, C:\FONTES\*.PRX). A máscara padrão de pesquisa é *.PR?. Se o usuário desejar utilizar uma máscara diferente (por exemplo, pesquisar em arquivos texto com extensão TXT), deverá selecionar a caixa Usa Caracteres Curinga que nesta pasta está habilitada.

Se o path informado juntamente com a máscara não for informado, será considerado o path atual. Se o path for inválido, não haverá erros emitidos ao usuário. Apenas nenhuma ocorrência da expressão será encontrada. Se o usuário desejar pesquisar a mesma máscara nos subdiretórios, deverá marcar a opção Pesquisar Subdiretórios. A seleção da opção Repetir Procura não vale para a localização em arquivos. Se for requisita a pesquisa será feita como uma localização comum no arquivo aberto.

Durante a localização em arquivos, uma janela de localização é exibida. Pressionando-se a tecla <ESC> ou fechando-se esta janela a pesquisa é interrompida. Após a finalização da localização em arquivos, basta efetuar um duplo clique em qualquer uma das ocorrências encontradas para que o arquivo seja editado e o cursor posicionado na linha da ocorrência. Diferentemente da localização simples, esta não traz o texto selecionado no editor do AP5 IDE.

A opção Substituir (figura 11) funciona exatamente como a localização simples, porém substituindo as expressões encontradas por uma expressão definida pelo usuário. Tem as mesmas opções de pesquisa e um campo para a digitação da expressão a ser substituída. Pressionando o botão OK o AP5 IDE irá substituir apenas a primeira ocorrência da expressão encontrada.

Para substituir todas as ocorrências o usuário deve pressionar o botão Tudo. O AP5 IDE não perguntará ao usuário se deve substituir as expressões a menos que a caixa Perguntar Antes de Substituir seja selecionada. Nesse caso, para cada uma das expressões encontradas, será exibido um diálogo perguntando ao usuário se deseja substituir a expressão com os botões Sim, Não, Cancela e Tudo. O botão Sim, substitui a ocorrência e continua a pesquisa, o botão Não não substitui a ocorrência e continua a pesquisa, o botão Cancela finaliza a pesquisa mantendo as substituições até então efetuadas e o botão Tudo termina de substituir todas as ocorrências sem questionar o usuário.

A rotina de substituição, como a rotina de localização de expressões, também marca as ocorrências encontradas. Porém, para facilitar a visualização, o AP5 IDE tenta posicionar a caixa de diálogo que questiona o usuário sobre a substituição das ocorrências de modo a permitir a visualização do texto marcado de um modo que a caixa de


Figura 10 - Janela com os resultados da localização. Um duplo clique abre o arquivo para edição posicionando na linha onde a expressão foi encontrada.

Figura 11 - Janela de substituição, com as mesmas opções de pesquisa da localização simples.

diálogo esteja totalmente visível. Caso não seja possível posicioná-la de modo que fique totalmente visível e que seja possível visualizar o texto, a caixa de diálogo será centralizada.

Utilizando Book Marks

Este é recurso de edição bastante útil que não se encontra disponível através dos menus ou botões das barras de ferramentas. Um book mark é um ponto marcado em uma linha que permite a rápida localização e posicionamento do cursor, permitindo ao usuário marcar pontos importantes no código para poder voltar o posicionamento do cursor no local marcado através de uma combinação de teclas. Para adicionar ou remover um book mark em uma linha de código, o usuário deve posicionar o cursor sobre a linha desejada e utilizar a combinação de teclas CTRL+SHIFT+<n>, onde n é um número de 0 a 9. Pode-se manter apenas 10 book marks por arquivo. Para localizar um book mark, o usuário deve utilizar a combinação de teclas CTRL+<n>. Os book marks existentes são indicados na borda esquerda dos arquivos através de imagens contendo o número do book mark (figura 12).

A localização simples e a substituição somente estão disponíveis quando ao menos um arquivo se encontra aberto no AP5 IDE. Caso contrário, somente a localização em arquivos se encontrará disponível.

Tanto na janela de localização como na janela de substituição, os campos da expressão a localizar e da expressão a substituir são listas "drop-down", ou seja, acumulam as

últimas 50 expressões digitadas. Essas informações também são gravadas no arquivo AP5IDE.INI que é mantido no diretório de instalação do Windows da estação.

Grupos de Projetos e a Compilação de Arquivos

Como um ambiente integrado, o AP5 IDE é o portal de entrada para as rotinas específicas. Além de permitir a criação e edição dos arquivos de código-fonte, é através do AP5 IDE que tais arquivos são enviados e compilados no AP5 Server. Para isso, foi criado o conceito de Grupo de Projetos.

Trabalhando com Grupos de Projetos

O menu Projetos (figura 13) exibe as opções para se trabalhar com grupos de projetos, compilação de arquivos, etc. Um grupo de projetos é uma coleção de projetos e pastas que mantém listas de arquivos de código (extensões *.PR?) e de definições (extensão *.CH) e também as configurações de compilação. Os grupos de projetos são editados através da janela do Gerenciador de Projetos (figura 14). Utilizando as opções do menu Projetos pode-se criar novos grupos, editá-los e gravá-los. A extensão padrão para a gravação dos grupos de projetos é .PRJ.


Figura 14 - A janela do Gerenciador de Projetos, com diversos arquivos de código e de definições estruturados em diferentes projetos e pastas

Figura 13 - O menu Projetos

Figura 12 - Linhas marcadas com Book Marks

O único meio de compilar um arquivo de código-fonte através do AP5 IDE é utilizando um grupo de projetos. Os arquivos devem ser adicionados a pastas criadas para cada projeto. A divisão dos arquivos em projetos e pastas organiza o trabalho, pois os arquivos podem ser divididos de acordo com a utilização, com um título explanatório em seu projeto ou pasta. A edição dos projetos, ou seja, a criação de novas pastas, novos projetos, renomeação, adicionamento de arquivos, edição das configurações, etc., é efetuada através do clique do botão direito do mouse sobre qualquer área da janela do gerenciador de projetos. Pode-se também editar os arquivos através do duplo clique do mouse ou do pressionamento da tecla <ENTER> sobre um arquivo na lista.

No menu acionado pelo botão direito do mouse ainda existem duas opções para importação e exportação do Grupo de Projetos de/para um arquivo texto. Isto permite ao usuário manter cópias de segurança de grupos de projetos longos, de modo que se ocorrer algum problema no arquivo binário onde os projetos são mantidos, as informações possam ser facilmente restauradas do arquivo texto formatado.

Adicionar um arquivo em uma pasta significa adicionar o nome do arquivo em uma lista, e não adicionar o arquivo propriamente dito ao projeto. Para qualquer tratamento com o arquivo, o AP5 IDE irá localizá-lo no path gravado. Assim os arquivos podem ser mantidos em outros diretórios que não o da execução do sistema. O Gerenciador de Projetos utiliza os seguintes ícones de imagens para indicar situações nos arquivos mantidos na lista:

Quando o arquivo for compilado com sucesso, o AP5 IDE indicará através deste ícone. Quando o grupo de projetos é gravado, um flag de compilado é gravado para o arquivo. Isto é necessário para evitar a recompilação do arquivo até que o mesmo seja alterado ou que o usuário acione o comando "Compilar Tudo".

Quando houver alterações no arquivo, o AP5 IDE indicará através deste ícone. A identificação de alteração é efetuada através da data e hora do arquivo que é mantida no arquivo de grupo de projetos desde sua última gravação. Desse modo, o AP5 IDE somente identificará que o arquivo teve modificações quando o mesmo for gravado. Ou seja, alterações efetuadas no buffer de edição do arquivo que não forem gravadas, não serão consideradas na gravação. O AP5 IDE sempre compilará o arquivo encontrado no path indicado no Gerenciador de Projetos. Quando o arquivo é indicado como modificado, o flag de compilado (se existir) será removido para indicar que o arquivo deve ser recompilado.

Se o arquivo não for encontrado no path indicado no Gerenciador de Projetos, o AP5 IDE indicará através deste ícone. Isto pode acontecer, por exemplo, se o arquivo for deletado do diretório sem ser removido do projeto em que se encontra.

A reavaliação do status dos arquivos (que poderá exibir os ícones acima) é efetuada sempre que possível nas principais operações referentes ao Gerenciador de Projetos. Por exemplo, quando um arquivo é adicionado ou removido, quando o nome de um projeto ou pasta é modificado, quando uma pasta ou um projeto é criado ou removido, quando um projeto é compilado, quando um arquivo contido no Gerenciador de Projetos é gravado, etc. Desse modo, por exemplo a deleção de um arquivo não exibirá o ícone de não encontrado imediatamente, e sim após a realização da reavaliação do status.

Compilando Arquivos de Código-Fonte

Para a compilação, o AP5 IDE não poderá estar em modo de debug. Existem três opções de compilação: a compilação de tudo, que ignora o flag de compilado nos arquivos, simplesmente enviando novamente todos

os arquivos ao server para serem compilados; a compilação do projeto selecionado, que envia apenas os arquivos do projeto selecionado na janela do

Gerenciador de Projetos que não contenham o flag de compilado ao server; a compilação em Batch, na qual o usuário pode selecionar quais os projetos que desejará compilar com quais

configurações de compilação.


Todas as mensagens de compilação geradas, como também algumas outras mensagens genéricas geradas pelo AP5 IDE, são enviadas para a área de mensagens (figura 15) que se encontra na base da janela principal do AP5 IDE.

O processo de compilação consiste em selecionar a configuração desejada no combo de configurações existente na barra de ferramentas do AP5 IDE, conectar-se ao server, enviar os arquivos de definições, enviar os arquivos para a compilação e encerrar a conexão com o server. Se algum erro ocorrer a compilação será interrompida. O usuário também pode interromper a compilação clicando no botão Cancelar que aparece na barra de status juntamente com uma barra de percentual concluído.

Configurações de um Grupo de Projetos

As configurações são utilizadas para definir qual o Environment será utilizado na compilação dos projetos e na execução do AP5 Remote. Se não existir ao menos uma configuração, não será possível a compilação. A Janela de Configurações (figura 16), que pode ser acessada através do botão direito do mouse sobre o Gerenciador de Projetos ou no menu Projetos, é utilizada para a manutenção das configurações do grupo de projetos..

Os botões Adicionar, Remover e Editar permitem ao usuário criar novas configurações, alterar informações ou remover configurações existentes. Não há limite para a criação de configurações. Quando for efetuada a compilação, o AP5 IDE irá exibir na área de mensagens a configuração que estará utilizando. A configuração selecionada será utilizada para a compilação de todo o grupo de projetos.

A configuração default é a selecionada no combo existente na barra de ferramentas do AP5 IDE. É a configuração que será utilizada para a compilação (exceto a compilação em batch) e para a execução do AP5 Remote.


Figura 15 - A área de mensagens do AP5 IDE com uma mensagem de erro de compilação

Figura 16 - A janela de seleção e manutenção de Configurações de Compilação

Figura 17 - Edição de uma configuração, onde pode-se identificar o repositório utilizado e eventuais definições utilizadas no código.

Todos os arquivos compilados são registrados em um repositório de programas no AP5. É através das configurações do Grupo de Projetos que o AP5 Server identifica qual será o repositório de compilação e registro dos arquivos de programas (veja figura 17). Criando configurações diferentes, o usuário do AP5 pode compilar em diferentes Environments, ou seja, compilar para diferentes idiomas, bases de dados, etc. Os environments são seções criadas nos arquivos de configuração do AP5 Server (veja documentação do AP5 Server para maiores detalhes) que lhe permitirão não só identificar o repositório correto para armazenar os programas compilados, como para enviar as definições corretas na compilação (como por exemplo, a definição em linha de comando /dTOP que é enviada quando um programa é compilado para TopConnect). Ou seja, para criar diferentes configurações o administrador deve ter criado as seções de configuração corretamente no arquivo de configuração do AP5 Server, identificando, por exemplo, o idioma, a versão e a interface. Depois de criadas, estas seções podem ser utilizadas para a compilação e execução do AP5 Remote através do AP5 IDE simplesmente identificando o nome da seção no campo Environment da configuração.

Também é através das configurações onde o usuário pode incluir definições próprias que identificarão blocos de compilação condicional dentro do código dos fontes (uso de diretivas #IFDEF ou #IFNDEF). Tais definições devem ser adicionadas no campo Parâmetros exatamente como seriam enviadas na linha de comando. Estas definições serão adicionadas aquelas já definidas pelo AP5 Server de acordo com o Environment utilizado.

O usuário também pode utilizar a Compilação em Batch (figura 18), escolhendo os projetos e as configurações que deseja compilar. Nesta janela, os projetos e as configurações existentes são cruzados, de modo que um mesmo projeto pode ser compilado utilizando mais de uma configuração. Assim, pode-se manter versões dos programas em Top Connect e em DBF ou em Inglês e Português, já que de acordo com o Environment informado nas configurações, o AP5 Server irá manter os APO's em repositórios diferentes.

Na janela de Compilação em Batch, o usuário pode marcar os projetos e configurações desejados e clicar no botão Compilar para compilá-los. A diferença entre este botão e o botão Recompilar, é que a recompilação ignora o flag de já compilado nos arquivos contidos nos projetos selecionados, fazendo com que todos sejam compilados.

Para a compilação, nenhum usuário poderá estar trabalhando no repositório configurado. O AP5 tentará abrir o repositório para uso exclusivo e uma mensagem de erro será retornada caso algum usuário esteja trabalhando com o repositório.

A compilação é efetuada no AP5 Server, e este retornará o resultado da compilação ao AP5 IDE. Para a compilação, são necessários os seguintes arquivos (que são mantidos

em um diretório na máquina onde o AP5 Server está instalado. O diretório deve ser indicado na chave INCLUDEPATH do environment definido no INI do AP5 Server): SET.CH, PROTDEF.CH, PROTHEUS.CH, RWMAKE.CH, PRCONST.CH, SIGAWIN.CH, STD.CH, STDWIN.CH e PRTOPDEF.CH, TOPDEF.CH, TOPCONN.CH (se o programa for para o ambiente SQL).

A linguagem ADVPL foi criada seguindo o padrão xBase para Windows utilizando os recursos criados pela Microsiga desde versões anteriores do Siga Advanced. Desse modo, o AP5 IDE procura compatibilizar ao máximo todos os Rdmakes que os usuários de versões anteriores tenham criado. Para isso existe o Assistente de Conversão de Código que será detalhado mais a frente. Uma dessas mudanças importantes é que todos os programas de usuários devem começar com USER FUNCTION <nome do arquivo> (caso contrário um erro de compilação ocorrerá). Isso se deve porque o produto


Figura 18 - A janela de Compilação em Batch

Siga Advanced na versão 5.07 é todo criado utilizando-se a linguagem ADVPL. Como os usuários também poderão utilizar-se desta linguagem para criar suas rotinas específicas, se todos se utilizassem da cláusula FUNCTION poderia ocorrer de alguma nova versão do Siga Advanced conter funções que por coincidência tivessem o mesmo nome de alguma função criada por um usuário. Isto ocasionaria a substituição das funções do usuário pelas funções criadas pela Microsiga em uma eventual atualização de versão. Desse modo, é proibido ao usuário utilizar-se de funções comuns (sem a cláusula USER). Para o uso interno, a Microsiga dispõe de uma chave de autorização que é fornecida através do menu Autorização, permitindo assim que funções comuns sejam utilizadas.

Diferentemente do RDMAKE, a linguagem ADVPL não é interpretada. É executada do mesmo modo tanto para as rotinas criadas pela Microsiga como para as rotinas criadas pelo usuário. Assim não há mais diferenças de velocidade de execução entre os códigos e todos os recursos da linguagem estão disponíveis para os usuários.

Os arquivos compilados são gerados com a extensão APO (Advanced Protheus Object) e mantidos em um repositório. Estes são arquivos binários que serão executados pelo Server. O AP5 Server iniciará a execução a partir de um arquivo inicial. Desse modo, não existe mais o conceito de módulo, a execução será efetuada a partir deste programa inicial (por exemplo SIGACON, o Siga Advanced Contábil), abrindo os arquivos e carregando as funções de acordo com o menu do usuário.

Muito importante: Nesta versão, os arquivos de definições (extensão CH) que forem adicionados no Gerenciador de Projetos ainda não estão sendo enviados ao servidor e devem ser colocados em um diretório no servidor que esteja indicado na chave INCLUDEPATH do Environment definido no INI do AP5 Server.


Utilizando o Debugger do AP5 IDE

Além de um editor de código, o AP5 IDE é uma ferramenta de Debug. Ou seja, permite ao usuário executar passo-a-passo suas rotinas para encontrar e remover erros de lógica. Como em outras ferramentas de Debug, no AP5 IDE o usuário encontra janelas de Watch, janelas de informações com o conteúdo de variáveis, pilha de chamadas, break points existentes, etc. E com todos esses recursos, fica muito mais fácil ao usuário depurar seus códigos, inclusive em pontos de entrada do sistema Siga Advanced 5.07. A execução do AP5 Remote é a mesma, exceto pelo fato de que é efetuada através do AP5 IDE. Quando o AP5 Remote é executado, uma conexão é aberta através do IDE, sendo encerrada somente quando a execução do AP5 Remote é terminada (através do próprio AP5 Remote, ou forçada dentro do IDE).

Os Comandos de Debug

O menu Executar (figura 19), contem todos os comandos utilizados para debugar rotinas no AP5 IDE. Este comando executa o AP5 Remote, inicialmente pelo programa inicial ou quando em processo de debug, a partir do ponto atual. A execução é normal como se a rotina estivesse sendo executada diretamente (sem o Siga Advanced

Protheus IDE). O processamento poderá parar quando um break point for encontrado ou quando o usuário interrompê-lo.O programa inicial deve ser informado no combo de seleção existente na barra de ferramentas do AP5 IDE, como exibido na figura 20. Se por acaso o programa inicial não for informado, o AP5 Remote questionará o usuário pelo nome do programa inicial quando for executado.Geralmente o processo de debug consiste em adicionar um break point a rotina desejada, executar o AP5 Remote através do AP5 IDE e executar o sistema até o momento em que o break point seja encontrado. Então, o usuário utiliza-se dos comandos de execução passo-a-passo para acompanhar a execução da rotina criada. Pode-se também executar o AP5 Remote e acionar o comando Pausa quando a execução chegar na rotina desejada. A execução do comando Pausa também pode ser efetuada através da combinação de teclas ALT+D efetuada no AP5 Remote em execução.

Para a execução passo-a-passo, o AP5 localiza os arquivos de código fonte e posiciona o cursor na linha em execução de modo que o usuário possa acompanhar a execução de suas rotinas. Para isso deve-se utilizar os comandos Percorre Linha, Pula Linha, Executar até o cursor ou os comandos de animação. O comando Percorre Linha executa linha por linha do código, entrando nas chamadas de funções. Ou seja, a execução deste comando sobre uma linha que contenha uma chamada de função fará com que o processo de debug linha-a-linha continue no código da função e o usuário terá que percorrer todo o código da mesma para retornar ao ponto original. Ao contrário, a execução do comando Pula Linha em uma linha que contenha uma chamada de função, fará com que o código da função seja executado normalmente (sem que o código da função seja executado linha-a-linha) e o processo de debug continuará da linha seguinte.


Figura 19 - O menu Executar, com as opções para debug de rotinas.

Figura 20 - Combo para escolha do programa inicial. Pode-se escolher um dos módulos do Siga Advanced ou digitar o nome do programa inicial desejado.

Para que o processo de debug seja efetuado, o AP5 IDE precisará localizar os arquivos onde as linhas executadas se encontram, abri-los para o usuário e posicionar o cursor nas linhas corretas. Por isso, o usuário deve configurar corretamente os diretórios de localização de arquivos (como visto em Configurando o AP5 IDE). Se um arquivo não for localizado, o AP5 IDE questionará o usuário por sua localização a menos que tenha sido configurado para que os arquivos não encontrados sejam ignorados. Os arquivos não encontrados terão seu código executado normalmente até que uma linha válida seja encontrada ou que a rotina termine.

O comando Pausa, faz com que o processamento que esteja executando normalmente (após o comando Executar) entre em modo de debug, permitindo a continuação em passo-a-passo. O comando Pára Execução, finaliza a execução do AP5 Remote, encerrando-o. O AP5 Remote é literalmente derrubado e a conexão com o Server é encerrada. Pode ser utilizado, por exemplo, quando determinada rotina está em loop de execução.

A animação é uma ferramenta que permite ao usuário executar linha-a-linha do código de uma forma automatizada, sem necessitar acionar o comando Percorre Linha para todas as linhas do código. Ao acionar o comando Animação, o AP5 IDE iniciará a execução automática do comando Percorre Linha a uma velocidade inicial. Todas as informações são atualizadas e o usuário pode acompanhar o processamento, aumentar ou diminuir a velocidade ou parar a animação.

O usuário também pode adicionar break points (pontos de parada) ao código. Os pontos de parada indicam linhas do código que farão com que o AP5 IDE entre em modo de debug exatamente como se o comando Percorrer Linha tivesse sido acionado, assim que a execução do código no AP5 Remote atingir a linha marcada. O acionamento do comando Liga/Desliga Ponto de Parada, marca ou desmarca a linha onde o cursor está posicionado no arquivo corrente. Por comodidade, os pontos de parada são gravados pelo AP5 IDE quando este é encerrado, de modo que não é necessário remarcá-los na próxima execução. Pode-se definir condições para a parada em um break point, porém a definição destas condições e outros detalhes serão explicados mais a frente na seção que trata sobre a janela de exibição dos break points existentes.

Por fim, o comando Atualiza, força uma atualização de todas as janelas de informações do AP5 IDE. Todas as expressões ou variáveis são reavaliadas no AP5 Server.

A execução dos comandos de debug é efetuada através da troca de mensagens entre o AP5 IDE e o AP5 Server. Portanto, quando o AP5 Remote estiver sendo executado (e conseqüentemente o controle da execução está com o Server, não com o IDE), a execução de um comando, por exemplo o comando Para Execução, pode não ser efetuada instantaneamente, aguardando que alguma linha do código do AP5 Remote seja processada. Ou seja, se o AP5 Remote estiver parado (por exemplo, aguardando uma intervenção do

usuário para digitar um texto qualquer ou pressionar um botão) o comando não será executado até que algum processamento seja efetuado (por exemplo, quando o usuário clicar no botão ou a validação de uma caixa de edição for acionada).

Enquanto o AP5 IDE está em processo de debug, o usuário pode obter o valor de variáveis simplesmente passando o ponteiro do mouse sobre o nome da variável desejada. Se o conteúdo da variável for diferente de nulo ou espaços em branco ele será exibido em um hint abaixo da linha onde a palavra se encontra. Para avaliar expressões, o usuário pode selecionar o texto de toda a expressão e mover o ponteiro do mouse sobre a expressão selecionada. Pode-se também saber em que arquivo uma função se encontra utilizando o mesmo recurso, contanto que o mapa de objetos (que será detalhado mais a frente) já tenha sido obtido. Este recurso deve ser utilizado com cautela, pois se um comando for selecionado e o ponteiro do mouse passado sobre a seleção, tal comando será executado e pode influenciar no processo de debug.

Durante o processo de debug, o AP5 IDE indicará através de imagens na borda esquerda dos arquivos algumas informações. São utilizados os seguintes símbolos:

Indica um break point na linha onde a imagem se encontra;

Indica o ponto de execução, ou seja, a linha do arquivo corrente é a linha em execuçãono processo de debug. Este mesmo símbolo na cor cinza indica pontos por onde aexecução passou em outros arquivos, quando o processo de debug entra nas chamadas


de funções.

As Janelas de Inspeção do AP5 IDE

O AP5 IDE contém diversas janelas para inspeção do ambiente de execução durante o processo de debug. Assim, o usuário pode acompanhar o valor de variáveis, verificar os break points existentes, a pilha de chamada das funções, etc. Estas janelas podem ser acessadas através do menu Visualizar (figura21).

A Janela de Break Points

A janela de Break Points (figura 22) exibe todos os break points adicionados ao código. Nesta janela são exibidos o nome do arquivo, a linha onde o break point se encontra e a condição de execução. São três os tipos de break points existentes. O break point comum contém apenas o nome do arquivo e a linha onde deve parar o processamento e pode ser adicionado através do comando Liga/Desliga Ponto de Parada do AP5 IDE,ou através do menu acionado pelo botão direito do mouse sobre a janela de BreakPoints. Este tipo de break point pode também ter uma condição de parada. Isto significa que o processamento somente irá parar neste ponto se a condição informada for satisfeita. Para informar uma condição, o usuário deve primeiro adicionar um break point e depois editá-lo através do menu acionado pelo botão direito do mouse. Existe também um break point chamado de break point condicional. Ele não contém nome de arquivo ou linha, pois a parada é efetuada na primeira linha de código onde a condição informada seja satisfeita. Este tipo de break point

somente pode ser adicionado através do menu acionado pelo botão direito do mouse na opção Adicionar (figura 23). Note que os break points adicionados a uma linha de código, pararão somente quando a linha for encontrada, sendo que o processamento poderá seguir normalmente nas linhas seguintes. Ao contrário, um break point condicional fará com que o processamento páre (ou seja, entre em modo de debug) enquanto a condição for satisfeita. Portanto poderá ser necessário remover um break point condicional depois que a condição for atingida pela primeira vez, para poder continuar com o processamento normalmente.


Figura 21 - O menu Visualizar com os comandos para exibição das janelas de inspeção.

Figura 22 - A janela de Break Points com o menu acionado pelo pressionamento do botão direito do mouse.

Figura 23 - Adicionando um break point condicional

A janela de Pilha de Chamadas

A janela de Pilha de Chamadas (figura 24) contém informações sobre a seqüência de chamadas das funções executadas pela rotina em processo de debug no AP5 IDE. Em ordem descendente de acordo com as chamadas executadas, a lista contém o número da linha, o nome da função, os parâmetros recebidos e o nome do programa onde a função se encontra registrada no Server.

Algumas chamadas, como de Code Blocks ou chamadas internas do Server, não exibem o nome do programa. Se um duplo clique for efetuado sobre um item da lista, o AP5 IDE irá localizar o arquivo e posicionar o cursor na linha da chamada, recalculando as demais janelas de inspeção de acordo com a função, como será visto mais a

frente no tópico sobre as janelas de inspeção de variáveis. A localização dos arquivos depende também das preferências configuradas pelo usuário, como visto no capítulo Configurando o AP5 IDE. As informações da janela de Pilha de Chamadas somente estão disponíveis durante o processo de debug do AP5 IDE.

A Janela de Watchs

A janela de Watchs (figura 25) é um local onde o usuário pode adicionar expressões para serem avaliadas durante o processo de debug. Pode-se adicionar, remover ou editar as expressões através do menu acionado pelo botão direito do mouse sobre a janela de Watchs. Como todas as expressões são avaliadas no Server no momento em que são adicionadas e durante o processo de debug, quando não se estiver em processo de debug só será possível a exclusão de expressões. Por comodidade, as expressões adicionadas são gravadas quando o AP5 IDE é encerrado.

São três as colunas de informações exibidas na janela de Watchs. A coluna Expressão contém a expressão adicionada e as colunas Tipo e Resultado contém respectivamente o tipo de dado e o resultado referentes à avaliação da expressão efetuada no Server.

As expressões de tipo Objeto e Array podem ter seu conteúdo exibido através da expansão, efetuada pelo duplo clique sobre a expressão ou o clique no sinal de expansão (+) no canto esquerdo da mesma (figura 26). Durante o processo de debug, o usuário também pode selecionar o texto no arquivo de código e, através do botão direito do mouse, arrastá-lo para a janela de Watchs, adicionando automaticamente o texto para avaliação.

Semelhante à utilização da janela de Watch, o usuário conta também com a área de comandos do AP5 IDE (figura 27). Na área de comandos o usuário pode digitar expressões (como por exemplo, nome de variáveis, comandos, etc.) que ao se pressionar a tecla <ENTER> serão avaliadas no Server e o resultado será apresentado na linha seguinte. Pode-se também arrastar uma expressão de um arquivo aberto para a área de comandos do mesmo modo que na janela de Watchs.


Figura 24 - A janela de Pilha de Chamadas (Call Stack)

Figura 25 - A janela de Watchs com duas expressões adicionadas.

Figura 26 - A janela de Watchs com uma expressão (resultante em objeto) expandida.

As expressões informadas tanto na janela de Watchs como na área de comandos do AP5 IDE são avaliadas no Server. Portanto, o uso de comandos é permitido e pode influenciar na execução dos programas (por exemplo, a digitação do comando SKIP moverá o ponteiro na tabela ativa). Porém, uma expressão digitada na área de comandos somente é avaliada uma vez (quando o usuário pressiona a tecla <ENTER>) ao contrário do que ocorre na janela de Watchs, onde a expressão é avaliada a cada passo do processo de debug (quando as informações são atualizadas). Portanto deve-se evitar utilizar comandos como parte de uma expressão de Watch.

Importante: Cuidado na avaliação de expressões lógicas. O operador de igualdade simples (=) também é um operador de atribuição. Portanto, executar lLeft = .T. atribuirá o valor verdadeiro (.T.) à variável lLeft. Ao invés disso, o usuário que desejar avaliar uma expressão lógica, deverá utilizar o operador de exatidão (==) ou utilizar parênteses para envolver toda a expressão. Por exemplo, (lLeft = .T.).

As Janelas de Inspeção de Variáveis

Para inspecionar o valor de variáveis, o AP5 IDE dispõe de janelas diferentes para cada um dos quatro tipos de variáveis: Locais, Privadas, Públicas e Estáticas. As janelas de Inspeção de Variáveis (figura 28) têm as seguintes colunas de informação: Variável, Tipo e Conteúdo. Como a janela de Watchs, as variáveis dos tipos Objeto e Array podem ser expandidas exibindo seu conteúdo.

Não se pode adicionar ou remover variáveis através das janelas de Inspeção, porém pode-se editar o conteúdo das variáveis ou dos elementos de um Array ou Objeto, através do menu de opções acionado com o botão direito do mouse quando o cursor estiver sobre a variável desejada.

As janelas de Inspeção de Variáveis somente terão conteúdo exibido enquanto o AP5 IDE estiver em processo de Debug.

A Janela de Inspeção de Tabelas e Campos

Como as janelas de Inspeção de Variáveis, o AP5 IDE mantém uma janela de Inspeção de Tabelas de Dados (figura 29). Nesta janela


Figura 27 - Área de Comandos na parte inferior da janela do AP5 IDE

Figura 28 - Janela de variáveis privadas - uma das janelas de Inspeção de Variáveis.

são exibidos todos os arquivos abertos até o momento do processo de debug. Cada arquivo pode ser expandido, exibindo assim seus índices e todos os campos do registro do arquivo onde se encontra o ponteiro. São três as colunas de informações exibidas: Objeto, Tipo e Conteúdo. Na coluna Conteúdo, são exibidas as informações de acordo com o tipo de objeto exibido.

Para as tabelas, são exibidos o Alias, o filtro utilizado, o número do registro onde o ponteiro está posicionado (Recno), o número total de registros e a ordem do índice ativo. A tabela que é a área atualmente selecionada na execução (o retorno da função Alias( ) ) é indicada com dois asteriscos (**).Para os índices, é exibida a chave de indexação (o retorno da função IndexKey( ) ) e o índice ativo é marcado com dois asteriscos (**).Para os campos, é exibido o seu conteúdo para o registro posicionado pelo cursor, exatamente como as variáveis nas outras janelas de inspeção.

Os itens da janela de Watchs e as variáveis das janelas de Inspeção de Variáveis Locais e Estáticas são exibidos de acordo com a Pilha de Chamadas. Se um duplo clique for efetuado sobre uma função na pilha de chamadas, as janelas serão atualizadas com a situação das expressões e variáveis no momento da execução daquela função. Isto permite ao usuário verificar as mudanças ocorridas em variáveis em todos os momentos de execução das suas rotinas. No entanto, quando um passo de debug é efetuado (por

exemplo, com o comando Percorrer Linha), as informações são reavaliadas para a situação atual, ou seja, a última chamada de função efetuada (primeiro item na lista da Pilha de Chamadas).

Em todas as janelas de Inspeção, seja Watchs, Tabelas ou Variáveis, existe uma barra de rolagem na base que permite ao usuário visualizar todo o texto da coluna Conteúdo (ou Resultado no caso da janela de Watchs) "rolando" o texto que seja maior do que o tamanho exibido da janela.

Para facilitar a visualização, as janelas de inspeção se utilizam de imagens que indicam o tipo de dado visualizado. Essas imagens (cuja legenda também pode ser visualizada através do acionamento do botão direito do mouse sobre cada janela) são:

Indicador de variável do tipo Caracter, Numérico, Data ou Memo

Indicador de variável do tipo Lógico com valor Falso

Indicador de variável do tipo Lógico com valor Verdadeiro

Indicador de variável do tipo Array

Indicador de variável do tipo Objeto

Indicador de Tabela de Dados

Indicador de Índice

Indicador de Campo

O Inspetor de Objetos

O Inspetor de Objetos (figura 30) exibe todas as funções registradas no Server. O usuário não precisa estar em processo de debug para obter do Server o mapa de objetos. Ao acionar a visualização através do item Inspetor de Objetos no menu Visualizar ou ao acionar a opção Atualizar no menu acionado pelo botão direito do mouse, o


Figura 29 - Janela de Inspeção de Tabelas de Dados

Figura 30 - A janela do Inspetor de Objetos

Inspetor de Objetos irá conectar-se ao Server e obter o mapa de objetos. O usuário pode optar por exibir o mapa em duas ordens diferentes: Por Programa e Por Função.

Exibindo Por Programa, as funções registradas serão agrupadas pelo nome do programa na qual foi criada ao ser registrada no Server. Caso contrário, uma lista de funções sem agrupamento será exibida. Ao executar um duplo clique sobre o nome de uma função (ou executar o comando Abrir no menu acionado pelo botão direito do mouse), o AP5 IDE tentará abrir o arquivo e posicionar o cursor na linha onde a função se encontra. Pode-se também localizar funções dentro do mapa, selecionando a opção Localizar Função no menu acionado pelo botão direito do mouse. Se a função for localizada, o cursor será posicionado sobre o nó da mesma na árvore montada no mapa de objetos.

Os objetos são os APO's (Advanced Protheus Object) registrados em repositórios no Server. São todas as rotinas e funções compiladas e registradas. Desse modo, ao obter o mapa de objetos, será necessário indicar uma das configurações existentes no Gerenciador de Projetos, como visto na compilação ou na execução do AP5 Remote através do AP5 IDE. Do mesmo modo, se nenhuma configuração for criada, o AP5 IDE irá considerar que os

objetos devem ser obtidos do repositório oficial.

Se não for possível conectar-se ao Server para a obtenção do mapa de objetos, o AP5 IDE não exibirá a janela do Inspetor de Objetos. Sempre que um arquivo é compilado, podem haver mudanças nos objetos registrados no Server. A atualização do mapa de objetos não é efetuada automaticamente, ficando a cargo da necessidade do usuário.

Para facilitar a visualização, o Mapa de Objetos conta com a seguinte lista de imagens indicadoras dos objetos:

Indicador de Arquivo

Indicador de Função

Indicador de impossibilidade para o AP5 de abrir o arquivo (arquivo não encontrado)

Como outros processamentos que requerem conexão ao Server (por exemplo, a compilação já detalhada anteriormente), durante a obtenção do mapa de objetos, o AP5 IDE exibe uma barra de percentual de conclusão acompanhada de um botão para o cancelamento no lugar da barra de tatus de sua janela principal (figura 31). O usuário pode cancelar a obtenção do mapa de objetos clicando no botão Cancelar desta barra.


Figura 31 - Barra de progresso de processamentos do AP5 IDE com o botão para cancelamento.

Controlando Versões de Arquivos Através do AP5 IDE

Os Softwares para Controle de Versões de Arquivos

O AP5 IDE pode ser integrado a um software para gerenciamento de versões de arquivos de código, permitindo ao usuário efetuar a reserva, a confirmação, a obtenção de últimas versões de arquivos, etc., diretamente de dentro do ambiente de desenvolvimento. Os softwares de controle de versão trabalham com uma base de dados dos arquivos que é mantida em um servidor específico e os usuários através de uma aplicação client deste software obtém cópias locais dos arquivos para poder alterá-los, testá-los e então enviar as cópias com as novas implementações para substituir as cópias existentes na base de dados do servidor. É claro que apenas um usuário pode alterar um arquivo por vez e por isso o arquivo deve ser reservado antes de poder ser alterado. Para evitar confusões entre as cópias locais e as cópias mantidas no servidor, os softwares de controle de versão geralmente trabalham atribuindo o atributo de somente leitura (Read Only) aos arquivos locais, de modo que o usuário não os poderá alterar a não ser que uma reserva seja efetuada antes. Este é o mesmo conceito utilizado pelo AP5 IDE para permitir a alteração ou efetuar a reserva automática de um arquivo.

O Controle de Versões Através do AP5 IDE

Como visto no capítulo Configurando o AP5 IDE, o primeiro passo para a utilização do Controle de Versão Integrado é a configuração das linhas de comando para execução das ações do software controlador de versão. A execução destas ações são efetuadas através da execução de macros no AP5 IDE que enviam as linhas de comando configuradas ao software controlador de versão. As macros utilizadas para o controle de versão são: $VERSION_CHECK_OUT, $VERSION_CHECK_IN, $VERSION_GET_LAST, $VERSION_ADD_FILE, $VERSION_REMOVE_FILE, $VERSION_UNDO_CHECK_OUT, $VERSION_ASK_FOR_COMMENT e $SYSTEM_USER_ACCESS. Para maiores detalhes sobre as macros existentes no AP5 IDE, verifique a Tabela de Macros ao final desta documentação.

A Reserva Automática de um Arquivo

Quando o AP5 IDE está configurado para utilizar o controle de versão, o usuário será questionado sobre a reserva assim que ocorrer a primeira tentativa de alteração em um arquivo com o atributo de somente leitura. Se optar por reservá-lo, o AP5 IDE irá então executar a macro para reserva de arquivo ($VERSION_CHECK_OUT). Se o usuário optar por não reservá-lo, o atributo de somente leitura permanecerá na cópia local do arquivo e conseqüentemente o AP5 IDE não permitirá que nele sejam efetuadas alterações.

Executando Outras Macros de Controle de Versão

As macros de controle de versão também podem ser executadas através da barra de ferramentas de controle de versão (figura 32) que é exibida automaticamente quando o uso de controle de versão é habilitado nas configurações de preferências do AP5 IDE.Através do ambiente do AP5 IDE, o usuário pode:

Obter a última versão de um arquivo, ou seja, o software de controle de versão gravará no diretório onde o arquivo se encontra uma cópia local com a última versão mantida em sua base de dados e nesta cópia local colocará o atributo de somente leitura;

Reservar um arquivo, o que também fará com que a última versão seja trazida para a cópia local, porém o atributo de somente leitura será removido permitindo que o usuário efetue as alterações necessárias;

Confirmar as alterações em um arquivo reservado, ou seja, a cópia local será enviada ao server e o arquivo não mais ficará reservado para o usuário. Conseqüentemente, o atributo de somente leitura será atribuído novamente à copia local;


Figura 32 - A barra de ferramentas para execução das macros de controle de versão.

Desfazer uma reserva efetuada, o que fará com que a reserva na base de dados do software controlador de versão seja desfeita e o atributo de somente leitura seja atribuído novamente ao arquivo;

Adicionar ou remover arquivos da base de dados, ou seja, através do AP5 IDE o usuário pode adicionar arquivos para que tenha a versão controlada pelo software controlador de versão ou remover um arquivo para que não mais tenha sua versão controlada por tal software.

Nas linhas de comando para o controle de versão, por default são adicionadas, quando o usuário as configura, as macros especiais $VERSION_ASK_FOR_COMMENT e $SYSTEM_USER_ACCESS, que respectivamente obtém

do usuário o comentário e o nome do usuário e senha para as operações a serem efetuadas no servidor de versões (figura 33). Dependendo do modo que o software de controle de versão utilizado trabalha, o usuário pode customizar estas linhas de comando e até remover a execução destas macros.

O responsável pela remoção ou atribuição do atributo de somente leitura é o software controlador de versão. Portanto, após a execução da macro para reserva do arquivo, o AP5 IDE irá esperar que o atributo de somente leitura seja removido do arquivo. Caso este atributo não seja removido dentro de um intervalo de tempo de cinco segundos (por exemplo, se a reserva do arquivo ainda não teve tempo de ser efetuada pelo software controlador de versão ou mesmo se a execução da linha de comando falhou ou não foi possível reservar o arquivo pois o mesmo está reservado para outro usuário) será exibida uma mensagem questionando o usuário se o IDE deve aguardar mais cinco segundos pelo término da reserva do arquivo. Se o usuário não permitir que o IDE aguarde mais cinco segundos e o arquivo permanecer com o atributo de somente leitura o arquivo será fechado por segurança (garantindo que uma eventual cópia local obtida do servidor cujo processo de reserva terminou posteriormente não seja sobrescrita por uma versão com informações incorretas que poderia estar sendo mantida aberta no IDE).

Após a execução de macros como a de reserva de arquivo ou a de obtenção da última versão que tem alterações efetuadas pelo software controlador de versão na cópia local do arquivo, o AP5 IDE irá reabrir o arquivo para carregar as eventuais diferenças. Portanto, antes da execução de tais macros, caso o arquivo contenha modificações não gravadas, o usuário será questionado sobre a continuação da execução da macro.

A estrutura de pastas do projeto na base de dados do software de controle de versão deve ser a mesma estrutura dos diretórios dos arquivos trabalhados. Este conceito foi implantado para facilitar a execução das macros automaticamente pois o path dos arquivos é informado na linha de comando. Entretanto, isto é possível de ser alterado, simplesmente modificando as linhas de comandos informadas na janela de preferências (por exemplo, informando um nome de projeto fixo) de acordo com a sintaxe de linha de comando do software utilizado. Note que alguns softwares controladores de versão, como o Visual Source Safe da Microsoft, permitem ao usuário criar diferentes bancos de dados para armazenamento dos projetos mesmo que isso não seja aconselhável pelo próprio fabricante. Para a execução das macros de controle de versão, o AP5 IDE funcionará corretamente com apenas um banco de dados para armazenagem.

Para a execução de qualquer um dos comandos de controle de versão, o usuário deve ter os direitos necessários cadastrados no software de controle de versão utilizado.


Figura 33 - A caixa de diálogo para digitação da senha exibida pela macro $SYSTEM_USER_ACCESS durante a execução da macro para reserva de arquivo

Muito importante: Caso o usuário deseje efetuar testes locais, e desse modo remover manualmente (ou mesmo através de opções do software de controle de versão utilizadas nas linhas de comando das macros) o atributo de somente leitura, a execução automática do pedido de reserva não será efetuada pelo AP5 IDE e as cópias locais (mesmo que não estejam reservadas ou não sejam a versão correta mantida no servidor de controle de versão) poderão sempre ser editadas no AP5 IDE. Assim, o controle das reservas e confirmações dos arquivos será totalmente do usuário pela execução através dos botões na barra de ferramentas de controle de versão ou diretamente em uma versão client do software controlador de versão. Note que neste caso o usuário deve verificar sempre se o arquivo está corretamente reservado através do software de controle de versão, pois não há garantias de que, por exemplo, uma linha de comando executada através do AP5 IDE foi executada com sucesso e a versão do arquivo que o usuário está editando é a última.Do mesmo modo, se o software de controle de versão utilizado não trabalhar com o atributo de somente leitura nos arquivos, apenas as execuções manuais das macros serão efetuadas no AP5 IDE e é extremamente aconselhável neste caso que as operações de reserva, confirmação, etc. sejam efetuadas sempre através da versão client do software de controle de versão.


Utilizando os Assistentes do AP5 IDE

Através do menu Ferramentas (figura 34) o usuário tem acesso aos assistentes do AP5 IDE e também as ferramentas customizadas que serão detalhadas mais a frente. O AP5 IDE disponibiliza o Assistente de Geração de Código e o Assistente de Conversão.

O Assistente de Geração de Código

O Assistente de Geração de Código do AP5 IDE (figura 35) permite a criação de rotinas básicas através de informações definidas pelo usuário. O assistente cria rotinas específicas com o código básico para o tipo de rotina desejada, facilitando ao usuário pois ele deverá somente incluir a lógica principal de acordo com a sua necessidade. O escopo do programa, com as funções em ADVPL, são montados pelo assistente. Os tipos de rotinas que são criados pelo Assistente de Geração de Código são rotinas de relatórios, rotinas de cadastro, rotinas para geração e importação de arquivo texto e rotinas de processamento genérico.

Para a geração do escopo do programa, o Assistente solicita informações como o arquivo principal, os parâmetros utilizados, títulos de relatórios ou browsers, etc. (por exemplo, figura 36).


Figura 34 - O Menu Ferramentas.

Figura 35 - O Assistente de Geração de Código

Figura 36 – Informações necessárias ao Assistente de Geração de Código para a geração do escopo do programa.

O Assistente de Conversão de Código

Os antigos Rdmakes mantidos pelos usuários continuam compatíveis na versão do AP5. Porém, algumas alterações são necessárias para o correto funcionamento destes programas. Para auxiliar na adaptação dos Rdmakes, o AP5 IDE contém um Assistente de Conversão de Código.

Selecionando os Arquivos

Acionando a opção Assistente de Conversão do menu Ferramentas, o Assistente iniciará de sua tela para seleção de arquivos para conversão (figura 37).Através dos botões ao lado direito da lista, o usuário pode adicionar, remover ou limpar a lista de arquivos para a conversão. Após um ou mais arquivos terem sido adicionados a lista, o botão Avançar será disponibilizado para que o processo continue. Selecionando Avançar, o processo de compatibilização se iniciará (figura 38).

Convertendo os Arquivos

Após o término do processo de conversão o botão Avançar se tornará novamente disponível.

O Assistente de Conversão não efetuará diretamente as alterações nos arquivos selecionados para conversão. Utilizará uma cópia em memória de cada arquivo onde efetuará as mudanças necessárias.

Na tela seguinte o Assistente questionará o usuário pelo diretório no qual deverá gravar os arquivos convertidos (figura 39).

Diretório para Gravação dos Arquivos Convertidos

Nesta tela o usuário poderá também selecionar quais os arquivos que não deseja gravar e removê-los da lista de arquivos convertidos. Todos os arquivos da lista serão gravados com o nome original no diretório informado.


Figura 37 - Seleção de arquivos para conversão no Assistente de Conversão de Código

Figura 38 - O Assistente em processo de conversão dos arquivos

Portanto, é aconselhável fornecer um diretório diferente do diretório dos arquivos originais para que os mesmos não sejam substituídos.Seguirá uma tela de processo da gravação dos arquivos e então a tela de finalização da conversão (figura 40) será exibida. Neste momento os arquivos convertidos já se encontram gravados no diretório informado.

Criação de Projeto e Compilação Automáticos

O Assistente de Conversão do AP5 IDE também poderá criar automaticamente um grupo de projetos (conforme descrito em capítulo anterior) com todos os arquivos convertidos. Para isso basta selecionar a opção Criar um Novo Projeto e fornecer o nome do arquivo. O arquivo será criado no mesmo diretório onde os arquivos convertidos foram gravados. O Assistente também poderá compilar automaticamente o grupo de projetos criado, bastando que o usuário selecione a opção Compilar Todos os Arquivos.

Ao se pressionar o botão Finalizar, o assistente irá então executar as opções selecionadas pelo usuário. Caso não seja possível criar o grupo de projetos, ou compilar os arquivos (por exemplo, se não for possível conectar ao Server) o usuário será avisado sem qualquer interferência nos arquivos convertidos gravados no diretório informado anteriormente.

Como já detalhado anteriormente, os códigos criados por usuários do Siga Advanced deverão utilizar a cláusula USER FUNCTION <nome do programa>, garantindo assim a unicidade das funções criadas. Isto também permite que a função EXECBLOCK e as opções de menus iniciadas com o caracter de código ASCII 35 (#) sejam executadas normalmente. A inclusão da cláusula USER FUNCTION é uma das alterações efetuadas pelo Assistente de Conversão.

Nos antigos Rdmakes, todas as variáveis eram criadas como Private no escopo do sistema. Assim, uma variável criada em uma função chamada pela rotina principal, permanecia durante toda a execução do Rdmake. Como agora o código não é mais interpretado, as variáveis Private permanecem durante toda a execução até a finalização da rotina que a criou. Então, por motivos de compatibilização, todas as variáveis serão declaradas no início da rotina convertida.

Finalmente, por ser um código interpretado o RDMAKE utilizava-se da função EXECUTE para executar funções nas ações de botões ou em outras ocasiões. Como o usuário tem a sua disposição todas características da linguagem ADVPL, como por exemplo uso de parâmetros e retorno de valores em funções, as chamadas das funções EXECUTE(<nome da função>) são substituídas pela chamada da própria função nos programas convertidos.

Juntamente com estas alterações, será incluída nas rotinas específicas convertidas a cláusula #INCLUDE "RWMAKE.CH" para manter a compatibilidade dos comandos utilizados no Rdmake e todas as cláusulas #INCLUDE ou #DEFINE já existentes na rotina específica serão movidas para o início do programa.


Figura 39 - Seleção do diretório para gravação dos arquivos convertidos.

Figura 40 - A tela de finalização da conversão, onde o usuário pode criar um grupo de projetos e compilar os arquivos automaticamente.

Tabela de Macros

As Macros implementadas no AP5 IDE podem ser utilizadas para automatizar ações ou ferramentas. No menu Ferramentas, qualquer ferramenta adicionada pode utilizar nos parâmetros ou no diretório inicial uma ou mais macros. Basta informar no texto o nome da macro. Por exemplo, pode-se utilizar macros na inclusão de uma ferramenta que permita editar o arquivo corrente no NOTEPAD do Windows:NOTEPAD.EXE $SOURCE_NAME.Além dessa utilização, a macro $VERSION_CHECK_IN pode ser executada automaticamente durante o processamento do AP5 IDE.

Abaixo encontram-se detalhadas as macros suportadas no AP5 IDE.

Nome Descrição$$ Retorna o caracter "$".$IDE_PATH Retorna o path de execução do AP5 IDE.$INPUT_TEXT(cTit,cMsg,cDefault) Exibe a mensagem informada em cMsg em um diálogo com título cTit,

permitindo a digitação de um texto. Retorna o texto digitado caso o diálogo seja confirmado ou o texto em cDefault caso o diálogo seja cancelado.

$SOURCE_NAME Retorna o nome completo (path e nome) do arquivo corrente. Se nenhum arquivo estiver aberto retorna vazio ("").

$SOURCE_NAME_NO_DRIVE Retorna o nome completo sem a letra do drive do arquivo corrente. Se nenhum arquivo estiver aberto retorna vazio ("").

$SOURCE_SHORT_NAME Retorna somente o nome do arquivo corrente (sem path ou letra do drive). Se nenhum arquivo estiver aberto retorna vazio ("").

$SOURCE_CURSOR_LINE Retorna a linha onde o cursor está posicionado no arquivo corrente. Se nenhum arquivo estiver aberto retorna "00".

$SOURCE_CURSOR_COLUMN Retorna a coluna onde o cursor está posicionado no arquivo corrente. Se nenhum arquivo estiver aberto retorna "00".

$SOURCE_CURSOR_WORD Retorna a palavra que se encontra onde o cursor está posicionado no arquivo corrente. Se nenhum arquivo estiver aberto retorna vazio (""). Considera como palavra todo e qualquer texto entre os delimitadores.

$SOURCE_EXECUTION_LINE Retorna a linha de execução no arquivo corrente. Se nenhum arquivo estiver aberto ou o AP5 IDE Não estiver em modo de debug, retorna "00".

$SOURCE_PATH Retorna o path do arquivo corrente. Se nenhum arquivo estiver aberto retorna vazio ("").

$SOURCE_EXT Retorna a extensão do arquivo corrente. Se nenhum arquivo estiver aberto retorna vazio ("").

$SOURCE_DRIVE Retorna a letra do drive do arquivo corrente. Se nenhum arquivo estiver aberto retorna vazio ("").

$SOURCE_SYSTEM_DATE Retorna a data do sistema no padrão dd/mm/yyyy.$SOURCE_SYSTEM_TIME Retorna a hora do sistema no padrão hh:mm:ss.$SYSTEM_USER_NAME Retorna o nome do login do usuário na rede. Se o usuário não estiver

logado ou não houver uma rede, retorna vazio ("").$SYSTEM_USER_ACCESS Exibe uma caixa de diálogo para identificação por ID e senha,

retornando-os separados por uma vírgula (;) ou vazio ("") se a caixa de diálogo for cancelada.

$VERSION_ADD_FILE Adiciona o arquivo corrente ao servidor de controle de versão , através da execução da linha de comando informada nas preferências. Esta macro só tem funcionalidade quando o uso de controle de versão estiver habilitado no AP5 IDE. Note que a estrutura de pastas do projeto no Controlador de Versão deve ser a mesma estrutura de diretórios onde o arquivo se encontra.


$VERSION_ASK_FOR_COMMENT Exibe uma caixa de diálogo para a digitação do comentário para as operações de reserva, confirmação, etc. de controle de versão. Esta macro é utilizada automaticamente pelas macros que executam ações do controlador de versão.

$VERSION_CHECK_OUT Reserva o arquivo corrente para alteração no Controlador de Versão, através da execução da linha de comando informada nas preferências. Esta macro só tem funcionalidade quando o uso de controle de versão estiver habilitado no AP5 IDE. Note que a estrutura de pastas do projeto no Controlador de Versão deve ser a mesma estrutura de diretórios onde o arquivo se encontra. Após reservar o fonte, o arquivo é reaberto para carregar eventuais modificações.

$VERSION_CHECK_IN Confirma as alterações no arquivo corrente, levando-as para o servidor do controle de versão e desfaz a reserva efetuada, através da execução da linha de comando informada nas preferências. Esta macro só tem funcionalidade quando o uso de controle de versão estiver habilitado no AP5 IDE. Note que a estrutura de pastas do projeto no Controlador de Versão deve ser a mesma estrutura de diretórios onde o arquivo se encontra.

$VERSION_GET_LAST Obtém a última versão do arquivo corrente no controlador de versão. Esta macro só tem funcionalidade quando o uso de controle de versão estiver habilitado no AP5 IDE. Após a execução do comando o arquivo é reaberto para carregar eventuais modificações. Note que a estrutura de pastas do projeto no Controlador de Versão deve ser a mesma estrutura de diretórios onde o arquivo se encontra.

$VERSION_REMOVE_FILE Remove o arquivo corrente do controlador de versão. Esta macro só tem funcionalidade quando o uso de controle de versão estiver habilitado no AP5 IDE. Note que a estrutura de pastas do projeto no Controlador de Versão deve ser a mesma estrutura de diretórios onde o arquivo se encontra.

$VERSION_UNDO_CHECK_OUT Desfaz a última reserva efetuada para o arquivo corrente no controlador de versão. Esta macro só tem funcionalidade quando o uso de controle de versão estiver habilitado no AP5 IDE. Note que a estrutura de pastas do projeto no Controlador de Versão deve ser a mesma estrutura de diretórios onde o arquivo se encontra.


GlossárioExpressão DefiniçãoADVPL Advanced Program Language - Linguagem de programação desenvolvida pela

Microsiga Software S.A.Alias Alias de um arquivo é um "apelido" dado a um arquivo aberto, de modo que para

selecionar a área de trabalho e poder efetuar alterações ou pesquisas, o usuário pode se referir ao arquivo através deste apelido. No Siga Advanced, os arquivos têm como padrão os Alias referentes às três primeiras letras de seu nome, por exemplo SB1.

AP5 Remote Programa do AP5 que faz a interface com o usuário, através da comunicação com o AP5 Server.

Aplicação MDI Multiple Document Interface (Interface de Documentos Múltiplos). É uma aplicação cuja interface consiste de uma janela principal que pode conter múltiplas janelas filhas, ou documentos. Os títulos das janelas filhas combinam com o título da janela pai quando a janela filha é maximizada.

Break Points Pontos de parada marcados nas linhas do código de um programa que indicam pontos onde o processamento deve entrar em modo de debug quando forem alcançados.

Buffer de Edição É uma cópia do arquivo aberto no AP5 IDE mantida em memória para permitir a edição do mesmo. Essa cópia é carregada quando o arquivo é aberto e gravada quando o arquivo é salvo.

Debug Processo de depuração de erros através da execução linha-a-linha do código, com a ajuda de inspetores de ambiente que exibem o conteúdo de variáveis, campos, etc.

Debugger Programa que encontra e elimina erros de programação (bugs).Delimitadores Delimitadores são caracteres especiais ou de pontuação utilizados para separar as

palavras do código. Por exemplo, o texto "IF !EOF()" contém duas palavras: "IF" e "EOF". A separação das palavras é necessária para a Diferenciação de Sintaxe. Abaixo está a lista de delimitadores de texto considerados no AP5 IDE.Caracter de Tabulação (Código ASC II #9)Caracter de Line Feed (Código ASC II #10)Caracter de Carriage Return (Código ASC II #13)Caracter de Espaço (Código ASC II #32)Caracter de Ponto (Código ASC II #46)Caracter de Vírgula (Código ASC II #44)Caracter de Dois-Pontos (Código ASC II #58)Caracter de Ponto-e-Vírgula (Código ASC II #59)Caracter de Abertura de Chaves (Código ASC II #123)Caracter de Fechamento de Chaves (Código ASC II #125)Caracter de Abertura de Colchetes (Código ASC II #91)Caracter de Fechamento de Colchetes (Código ASC II #93)Caracter de Abertura de Parênteses (Código ASC II #40)Caracter de Fechamento de Parênteses (Código ASC II #41)Caracter de Sinal de Igual (Código ASC II #61)Caracter de Sinal de Adição (Código ASC II #43)Caracter de Sinal de Subtração (Código ASC II #45)Caracter de Sinal de Multiplicação (Código ASC II #*42)Caracter de Sinal de Divisão (Código ASC II #47)Caracter de Barra Invertida (Código ASC II #92)Caracter de Sinal de Maior (Código ASC II #62)Caracter de Sinal de Menor (Código ASC II #60)Caracter de Sinal de Percentual (Código ASC II #37)Caracter de Sinal de Arroba (Código ASC II #64)Caracter de Exclamação (Código ASC II #33)Caracter de Diferença (Código ASC II #35)Caracter de Macro Substituição (Código ASC II #38)Caracter de Cifrão (Código ASC II #36)

Derrubar Client Finaliza a execução do AP5 Remote. A finalização do AP5 Remote somente será


efetuada assim que alguma linha de código for executada. Por exemplo, se o AP5 Remote estiver em estado de espera (aguardando por uma digitação do usuário), a finalização pedida no IDE somente será efetuada assim que algum código no AP5 Remote seja executado (por exemplo, na validação do texto digitado pelo usuário).

Diferenciação de Sintaxe

Diferenciação através de cores do texto do código de um programa, visando facilitar a identificação de erros de digitação e melhorar o aspecto visual. Geralmente são diferenciados texto comum de palavras reservadas, números ou strings.

Identação É o alinhamento das linhas de texto, através da inclusão de tabulações, segundo a estrutura lógica do programa visando facilitar a leitura do código. Por exemplo, abaixo estão demonstradas linhas de código sem e com identação de texto:

if i < 10for x := i to 10grava()next xendif

if i < 10 for x := i to 10 grava() next xendif

Executar Executa o AP5 Remote normalmente, mantendo o IDE em estado de espera. Desse modo, o IDE somente entrará em modo de debug em uma das seguintes situações:1. um break point for encontrado;2. o usuário selecionar o comando pause no IDE;3. um break point condicional for satisfeito;4. o usuário pressionar no AP5 Remote a combinação de teclas ALT+D.O modo de execução também se encerra se o usuário finalizar o AP5 Remote.

Gutter Área nas margens de uma janela utilizada para a exibição de informações, como por exemplo a área onde ficam marcados os ícones de break points ou a área da régua de números de linhas nas janelas de documentos do AP5 IDE.

IDE Integrated Development Environment (Ambiente de Desenvolvimento Integrado). É uma aplicação onde todo o desenvolvimento, execução, depuração e correção de procedimentos pode ser desenvolvido.

Pausar Parada na execução do AP5 Remote ou na execução de uma animação. A parada do AP5 Remote somente será executada assim que alguma linha de código for executada. Por exemplo, se o AP5 Remote estiver em estado de espera (aguardando por uma digitação do usuário), a pausa efetuada no IDE somente será efetuada assim que algum código no AP5 Remote seja executado (por exemplo, na validação do texto digitado pelo usuário).

Percorrer Linha Execução linha por linha do código, entrando no código de funções.Programas Registrados São todos os programas compilados através do Advanced Protheus IDE, que são

mantidos em diferentes repositórios no Advanced Protheus Server, de acordo com opção do Administrador.

Ponto de Entrada Conceito implementado desde as versões anteriores do sistema de ERP Siga Advanced. É uma rotina de nome fixo e criada pelo usuário. O sistema Siga Advanced checa a existência desta rotina em determinados pontos do código e a executa se for encontrada, permitindo assim que o usuário customize processos fechados. Na versão 5.07, o usuário pode debugar estas rotinas chamadas automaticamente através do AP5 IDE (por exemplo, adicionando break points).

Pular Linha Execução linha por linha do código, sem entrar no código das funções.RDMAKE Linguagem interpretada criada pela Microsiga Software S.A. utilizada no sistema de

ERP Siga Advanced até a versão x.07.Seguir Até Retorno Execução em modo normal do AP5 Remote até o momento em que a linha em


execução seja a linha onde o cursor está posicionado. Para isso, o Advanced Protheus IDE coloca um break point temporário na linha onde o cursor está posicionado.

Server Serviço do AP5 que se encarrega de executar as rotinas dos programas registrados e controlar o acesso dos usuários. Comunica-se com o AP5 Remote para permitir a interface com o usuário.

String Cadeia de caracteres formadora de um texto qualquer, compreendida entre aspas duplas (") ou aspas simples ('), como por exemplo "AP5".

Variáveis Estáticas Variáveis definidas com instância estática, ou seja, poderão ser visualizadas ou alteradas por qualquer rotina dentro do mesmo programa.

Variáveis Locais Variáveis definidas com instância local, ou seja, poderão ser visualizadas ou alteradas somente dentro da rotina que as declarou.

Variáveis Privadas Variáveis definidas com instância privada, ou seja, poderão ser visualizadas ou alteradas apenas pela rotina que as declarou e pelas rotinas chamadas por esta.

Variáveis Públicas Variáveis definidas com instância pública, ou seja, poderão ser visualizadas ou alteradas por qualquer rotina dos programas registrados.

Watchs Janela de inspeção onde expressões digitadas pelo usuário podem ser avaliadas no AP5 Server durante o processo de debug.


Protheus IDE

Documents

Transcript of Protheus IDE