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

Sumário
AP5 IDE.......................................................................................................................................................1
Documentação e Guia do Usuário..............................................................................................1
CopyRight © 1999 Microsiga Software S.A................................................................................1
Sumário........................................................................................................................................2
O AP5 IDE...................................................................................................................................4
Configurando o AP5 IDE............................................................................................................5
Configurações do Debugger...............................................................................................................5
Definindo o Padrão de Teclas de Atalho.........................................................................................................5
Definindo o Número de Arquivos na Lista de Recentemente Abertos...........................................................6
Utilizando a Régua com o Número de Linhas................................................................................................6
Definindo a Localização de Arquivos.............................................................................................................6
Ignorando Arquivos Não Encontrados............................................................................................................6
Configurações de Código....................................................................................................................7
Elementos de Texto.........................................................................................................................................7
Definindo o Estilo do Texto............................................................................................................................7
Definindo a Cor do Texto................................................................................................................................7
Definindo a Cor de Fundo do Texto................................................................................................................7
Desabilitando a Diferenciação de Sintaxe.......................................................................................................7
Configurações de Controle de Versão...............................................................................................8
Utilizando o Controle de Versão.....................................................................................................................8
Software Controlador de Versão.....................................................................................................................8
Path Inicial do Software Controlador de Versão.............................................................................................8
Linha de Comando para Obtenção da Última Versão.....................................................................................9
Linha de Comando para Reservar Arquivo.....................................................................................................9
Linha de Comando para Cancelar Reserva......................................................................................................9
Linha de Comando para Confirmar Arquivo...................................................................................................9
Linha de Comando para Adicionar Arquivo...................................................................................................9
Linha de Comando para Remover Arquivo.....................................................................................................9
Utilizando o AP5 IDE................................................................................................................10
A Edição de Arquivos.......................................................................................................................10
Criando e Editando Arquivos........................................................................................................................10
Recursos de Edição........................................................................................................................................11
Modificações de Texto..........................................................................................................................11
Inserção de Texto em um Arquivo........................................................................................................12
Localização e Substituição de Texto.....................................................................................................12
Utilizando Book Marks..........................................................................................................................14
Grupos de Projetos e a Compilação de Arquivos...........................................................................14
Trabalhando com Grupos de Projetos............................................................................................................14
Compilando Arquivos de Código-Fonte........................................................................................................15
Configurações de um Grupo de Projetos.......................................................................................................16
Utilizando o Debugger do AP5 IDE.................................................................................................19
Os Comandos de Debug................................................................................................................................19
As Janelas de Inspeção do AP5 IDE..............................................................................................................21
A Janela de Break Points.......................................................................................................................21
A janela de Pilha de Chamadas.............................................................................................................22
A Janela de Watchs................................................................................................................................22

As Janelas de Inspeção de Variáveis.....................................................................................................23
A Janela de Inspeção de Tabelas e Campos..........................................................................................23
O Inspetor de Objetos............................................................................................................................24
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...................................................................................26
A Reserva Automática de um Arquivo..........................................................................................................26
Executando 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..............................................................................................30
Selecionando os Arquivos.............................................................................................................................30
Convertendo os Arquivos..............................................................................................................................30
Diretório para Gravação dos Arquivos Convertidos.....................................................................................30
Criaçã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 4

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
Figura 1 - A pasta Debugger da janela de Preferências do AP5 IDE 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:
FiveWin
Percorrer Linha F8 Seguir até o Retorno F7
Pular Linha F10 Localizar Ctrl+L
Executar F5 Localizar Próximo F3
Adicionar Break Point F9 Ir para a linha "n" Ctrl+G
Visual C++
Percorrer Linha F11 Seguir até o Retorno Ctrl+F10
Pular Linha F10 Localizar Ctrl+F
Delphi
Percorrer Linha F7 Seguir até o Retorno F4
Pular Linha F8 Localizar Ctrl+F

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 Figura 2 - A pasta Código da janela de Preferências do AP5 IDE
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.

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.
Figura 3 - A pasta Controle de Versão da janela de Preferências do AP5

IDE
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 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 Arquivos

O 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
Figura 5 - Os itens do menu Arquivo 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. Figura 6 - Diferenciação de Sintaxe em um arquivo aberto no AP5 IDE,
Para finalizar a execução do AP5 IDE, o usuárioutilizando o fonte MS
pode escolher LineDraw.
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

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 Figura 7 - Os itens do menu Editar
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>)

<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 Figura 8 - Pasta Localizar da janela de localização do AP5 IDE.
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 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.
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.
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. Figura 11 - Janela de substituição, com as mesmas opções de
pesquisa da localização simples.
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

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).
Figura 12 - Linhas marcadas com
Book Marks
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.
Figura 13 - O menu 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
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.
Figura 15 - A área de mensagens do AP5 IDE com uma mensagem de erro de compilação
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.. Figura 16 - A janela de seleção e manutenção de
Configurações de Compilação
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 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.
Figura 18 - A janela de Compilação em Batch
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

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.
Figura 19 - O menu Executar, com as
opções para debug de rotinas.
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
Figura 20 - Combo para escolha do programa inicial. Pode-se
linha seguinte.
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ção
no processo de debug. Este mesmo símbolo na cor cinza indica pontos por onde a
execuçã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).
Figura 21 - O menu Visualizar com os comandos para

exibição das janelas de inspeção.
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, Figura 22 - A janela de Break Points com o menu acionado pelo
ou através do menu acionado pelo botão pressionamento do botão direito do mouse.
direito do mouse sobre a janela de Break
Points. 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
Figura 23 - Adicionando um break point condicional continuar com o processamento normalmente.

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.
Figura 24 - A janela de Pilha de Chamadas (Call Stack)
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.
Figura 25 - A janela de Watchs com duas

expressões adicionadas.
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.
Figura 26 - A janela de Watchs com uma

expressão (resultante em objeto) expandida.
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 27 - Área de Comandos na parte inferior da janela do AP5 IDE
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.
Figura 28 - Janela de variáveis privadas - uma das

janelas de Inspeção de Variáveis.
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

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.
Figura 29 - Janela de Inspeção de Tabelas de Dados
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 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.
Figura 31 - Barra de progresso de processamentos do AP5 IDE com o botão para

cancelamento.
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.

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 Figura 32 - A barra de
última versão mantida em sua base de dados e nesta cópia local colocará o ferramentas para execução das
atributo de somente leitura; macros de controle de versão.
 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;

 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.
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
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.

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.
Figura 34 - O Menu Ferramentas.
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 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
Figura 37 - Seleção de arquivos para conversão no compatibilização se iniciará (figura 38).
Assistente de Conversão de Código
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).
Figura 38 - O Assistente em processo de conversão
dos arquivos
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.

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
Figura 39 - Seleção do diretório para gravação dos então a tela de finalização da conversão (figura 40) será
arquivos convertidos. 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.
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.
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.

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ário
Expressão Definição
ADVPL 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 Diferenciação através de cores do texto do código de um programa, visando facilitar a
Sintaxe 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 < 10
for x := i to 10
grava()
next x
endif
if i < 10
for x := i to 10
grava()
next x
endif
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

Caricato da

Informazioni sul documento

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Protheus IDE

Caricato da

Copyright:

Formati disponibili

AP5 IDE

Documentação e Guia do Usuário

CopyRight © 1999 Microsiga Software S.A.

AP5 IDE – Documentação e Guia do Usuário

AP5 IDE – Documentação e Guia do Usuário

AP5 IDE – Documentação e Guia do Usuário

AP5 IDE – Documentação e Guia do Usuário 4

Definindo o Padrão de Teclas de Atalho

AP5 IDE – Documentação e Guia do Usuário 5

Definindo o Número de Undo's

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

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

Definindo a Localização de Arquivos

Ignorando Arquivos Não Encontrados

AP5 IDE – Documentação e Guia do Usuário 6

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

Definindo o Estilo do Texto

Definindo a Cor do Texto

Definindo a Cor de Fundo do Texto

Desabilitando a Diferenciação de Sintaxe

AP5 IDE – Documentação e Guia do Usuário 7

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

Utilizando o Controle de Versão

O campo Software indica o caminho

Path Inicial do Software

O campo Iniciar Em indica o path

AP5 IDE – Documentação e Guia do Usuário 8

Linha de Comando para Reservar Arquivo

Linha de Comando para Cancelar Reserva

Linha de Comando para Confirmar Arquivo

Linha de Comando para Adicionar Arquivo

Linha de Comando para Remover Arquivo

AP5 IDE – Documentação e Guia do Usuário 9

Criando e Editando Arquivos

A gravação dos arquivos é efetuada pelos itens Salvar e Salvar Como.

Ao contrário, a opção Salvar Como sempre questiona o usuário por um

A opção Escolha de Fonte permite ao

AP5 IDE – Documentação e Guia do Usuário 10

O menu Editar (figura 7) contém todas as opções

Modificações de Texto Figura 7 - Os itens do menu Editar

A identação modifica as tabulações do código de maneira a tornar mais fácil a

AP5 IDE – Documentação e Guia do Usuário 11

Inserção de Texto em um Arquivo

Localização e Substituição de Texto

É possível localizar textos no arquivo corrente

A pasta Localizar em Arquivos (figura 9)

Para substituir todas as ocorrências o usuário deve

AP5 IDE – Documentação e Guia do Usuário 13

Utilizando Book Marks

A localização simples e a substituição somente estão disponíveis quando ao menos um

Tanto na janela de localização como na janela de substituição, os campos da expressão a

Grupos de Projetos e a Compilação de Arquivos

Figura 13 - O menu Projetos

Trabalhando com Grupos de Projetos

O menu Projetos (figura 13) exibe as opções para se trabalhar

Compilando Arquivos de Código-Fonte

AP5 IDE – Documentação e Guia do Usuário 15

O processo de compilação consiste em selecionar a configuração desejada no combo de configurações existente na

As configurações são utilizadas para definir qual o

Os botões Adicionar, Remover e Editar

A configuração default é a selecionada no

AP5 IDE – Documentação e Guia do Usuário 16

Na janela de Compilação em Batch, o

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