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

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

O Inspetor de Objetos ...........................................................................................................................25

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



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

O Controle de Versões Através do AP5 IDE ................................................................................... 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

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


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.



Configurando o AP5 IDE

Antes de iniciar a utilização do AP5

IDE, deve-se configurá-lo para um

melhor aproveitamento de seus

recursos. Na opção de preferências,

encontrada no menu Arquivo, item

Preferências, são definidas as

informações que influenciam no

comportamento do AP5 IDE. Ao

acionar este item do menu, a janela de

Preferências é exibida, contendo

informações divididas em três pastas.

Todas as informações das preferências

bem como as diversas informações

armazenadas pelo AP5 IDE, são

mantidas no arquivo chamado

AP5IDE.INI que se encontra no mesmo

diretório de execução do IDE.

Configurações do Debugger

A pasta de configurações do debugger (figura 1), exibe as opções básicas para o processamento do AP5 IDE em

modo de debug e do editor. Aqui são definidas as configurações para a localização dos arquivos de código fonte

durante o processo de debug, se o AP5 IDE deve ignorar automaticamente os arquivos não encontrados, o

tamanho da tabulação, do número de Undo's, etc.

Definindo o Padrão de Teclas de Atalho

O padrão de teclas utilizado identifica quais serão as teclas para o acionamento das principais funções de debug do

AP5 IDE. Os padrões possíveis são os mesmos utilizados pelas linguagens de programação FiveWin, Visual C++

e Delphi, tornando fácil a assimilação para usuários de algumas destas ferramentas. Para cada um dos padrões

utilizados, as combinações de teclas para o acionamento das ações de debug serão:

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 Executar F5 Localizar Próximo F3 Adicionar Break Point F9 Ir para a linha "n" Ctrl+G Delphi

Percorrer Linha F7 Seguir até o Retorno F4 Pular Linha F8 Localizar Ctrl+F Executar F9 Localizar Próximo F3 Adicionar Break Point F5 Ir para a linha "n" Ctrl+G

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



Definindo a Tabulação O campo Tabulação indica o número de caracteres que serão usados para cada tecla de tabulação (código ASC II

#9), na identação do código.

Definindo o Número de Undo's

O campo de Número Máximo de Undo's indica o número máximo de modificações no texto que o AP5 IDE irá

armazenar para permitir o Undo e/ou Redo. As ações são armazenadas de modo que assim que é atingido o limite

estabelecido as últimas ações passam a ser descartadas a cada nova ação. Os Undo's e Redo's são mantidos por arquivo, e são resetados quando o arquivo é salvo. Indicando zero (0), o

armazenamento máximo torna-se infinito (dependente apenas da memória disponível).

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

O campo Arquivos na Lista de Recentemente Abertos indica o número máximo de arquivos que serão mantidos na

lista de recentemente abertos, que se encontra no final do menu Arquivo, para possibilitar a abertura rápida dos

mesmos. Indicando zero (0), não será mantida uma lista dos arquivos recentemente abertos.

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

A opção Exibir Régua com o Número de Linhas indica se o AP5 IDE deve exibir uma régua com os números das

linhas em um novo gutter na margem esquerda de cada arquivo aberto, para facilitar a localização visual do

usuário.

Definindo a Localização de Arquivos

Quando em processo de debug, especificamente durante os comandos de Percorrer Linha e Pular Linha, a

execução é feita linha-a-linha do código. Para isso, o AP5 IDE localiza os arquivos de código fonte, abre-os e

posiciona o cursor na linha em execução. Para os arquivos não encontrados, o IDE questionará o usuário por seu

caminho. Se não forem encontrados, não poderão ser abertos para o posicionamento da linha e serão colocados em

uma lista de arquivos ignorados (até que o IDE seja reinicializado). Para facilitar a localização, pode-se digitar

neste campo uma lista de paths onde os arquivos devem ser procurados. Os paths devem ser separados com o sinal

de ponto-e-vírgula (;).

Ignorando Arquivos Não Encontrados

Quando em processo de debug, especificamente durante os comandos de Percorrer Linha e Pular Linha, a

execução é feita inha-a-linha do código. Para isso, o AP5 IDE localiza os arquivos de código fonte, abre-os e

posiciona o cursor na linha em execução. Porém se não for possível encontrar o arquivo de código fonte, o IDE

questionará o usuário pelo caminho onde o arquivo pode ser encontrado. Se o usuário realmente não tiver o

arquivo e cancelar a localização do mesmo, o IDE não o questionará mais (até que o IDE seja reinicializado). Para

evitar que seja questionado a cada arquivo não encontrado, pode-se marcar esta opção. Assim todos os arquivos

não encontrados serão adicionados automaticamente à lista de arquivos ignorados.

Note que os break points eventualmente contidos em um fonte não encontrado não farão com que o

processamento pare. Do mesmo modo, executando o comando Percorrer Linha sobre uma função

que esteja em um arquivo de código-fonte não encontrado, fará com que a função seja normalmente

executada e a parada volte a ocorrer somente na próxima linha, depois do retorno da função.



Configurações de Código

A pasta de configurações do

código (figura 2), exibe as opções

para controle da diferenciação de

sintaxe no editor do AP5 IDE.

Aqui você pode habilitar ou

desabilitar a diferenciação de

sintaxe bem como configurar as

cores para cada elemento de texto

que pode ser diferenciado.

Elementos de Texto

Os elementos de texto são tipos de expressões que devido a sua finalidade são classificados em grupos separados.

Como por exemplo, palavras reservadas ao compilador, strings de caracteres, números, etc. Nesta lista são

apresentados os diferentes elementos de texto que permitem a diferenciação de sintaxe no AP5 IDE. O elemento

deve ser selecionado nesta lista para que se possa configurar suas cores e estilo. Todas as demais configurações

nesta mesma pasta serão, então, relacionadas com o elemento atualmente selecionado.

Definindo o Estilo do Texto

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

elementos.

Definindo a Cor do Texto

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

elementos.

Definindo a Cor de Fundo do Texto

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

elementos.

Desabilitando a Diferenciação de Sintaxe

Selecionando-se esta opção, o AP5 IDE não se utilizará da diferenciação de sintaxe no código dos arquivos

abertos. Apesar de que o uso diferenciação de sintaxe não consuma muitos recursos, o atualização das janelas

pode ficar mais rápida com esse recurso desabilitado. Desabilitando a diferenciação, as cores de todo o texto serão

aquelas definidas no Windows da estação.

Para a alteração da fonte do texto, utilize a opção Escolha de Fonte no menu Arquivo. A fonte não

pode ser diferenciada para os elementos de texto do código. Apenas o estilo e as cores.

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



Configurações de Controle de Versão

A pasta de configurações de

Controle de Versão (figura 3), exibe

as opções para a integração de um

software de controle de versão ao

AP5 IDE. Nesta pasta são definidos

os comandos básicos para

acionamento do software

controlador de versão através de

linha de comando. Estes comandos

podem ser acionados

automaticamente pelo AP5 IDE ou

pela requisição do usuário através

dos botões da barra de ferramentas

de controle de versão.

Utilizando o Controle de Versão

A opção Utiliza Controle de Versão indica que será utilizado um software de controle de versão para controlar a

reserva e a alteração de arquivos de código-fonte. Ao acionar esta opção uma janela com os softwares

controladores de versão compatíveis (figura 4) será apresentada para que o usuário escolha aquele que esteja

utilizando. A confirmação desta janela traz nos campos das linhas de comando as sintaxes utilizadas pelo software

escolhido sugeridas. Caso o software utilizado não se encontre na lista de softwares compatíveis, o usuário deverá

consultar a documentação que o acompanha e fornecer manualmente as sintaxes para as linhas de comandos.

Software Controlador de Versão

O campo Software indica o caminho

para o software que receberá as linhas

de comando enviadas pelo AP5 IDE

para as ações de controle de versão.

Path Inicial do Software Controlador de Versão

O campo Iniciar Em indica o path

onde o software controlador de versão

será iniciado quando receber as linhas

de comando.

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

AP5 IDE

Figura 4 - Seleção de um software de controle de versão compatível. A

confirmação do diálogo preenche os campos de linhas de comando de

acordo com as sintaxes do software escolhido.



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

O campo Última Versão indica os parâmetros passados para o Software Controlador de Versão para realizar uma

obtenção da última versão do arquivo de código aberto no momento. Pode-se utilizar macros para obtenção do

nome do arquivo corrente, path, etc. Veja a Tabela de Macros para informações das macros disponíveis no AP5

IDE.

Linha de Comando para Reservar Arquivo

O campo Reservar indica os parâmetros passados para o Software Controlador de Versão para realizar a reserva

do arquivo de código fonte aberto no momento. Pode-se utilizar macros para a obtenção do nome do arquivo

corrente, path, etc. Veja a Tabela de Macros para informações das macros disponíveis no AP5 IDE.

Note que apesar desta linha de comando poder ser acessada através da barra de ferramentas, não se

deve fugir de seu objetivo (reservar o arquivo aberto no servidor de arquivos), pois quando o uso de

controle de versão está habilitado no AP5 IDE, esta linha de comando é executada automaticamente no

momento que alguma alteração está prestes a ser efetuada em um arquivo. Caso necessite executar algo

diferente, utilize-se das ferramentas no menu Ferramentas.

Linha de Comando para Cancelar Reserva

O campo Cancelar indica os parâmetros passados para o Software Controlador de Versão para realizar o

cancelamento da última reserva efetuada pelo usuário, do arquivo de código aberto no momento. Pode-se utilizar

macros para obtenção do nome do arquivo corrente, path, etc. Veja a Tabela de Macros para informações das

macros disponíveis no AP5 IDE.

Linha de Comando para Confirmar Arquivo

O campo Confirmar indica os parâmetros passados para o Software Controlador de Versão para realizar a

confirmação do arquivo de código fonte aberto no momento. Pode-se utilizar macros para obtenção do nome do

arquivo corrente, path, etc. Veja a Tabela de Macros para informações das macros disponíveis no AP5 IDE.

Linha de Comando para Adicionar Arquivo

O campo Adicionar indica os parâmetros passados para o Software Controlador de Versão para adicionar o

arquivo de código fonte aberto no momento no controle de versão. Pode-se utilizar macros para a obtenção do

nome do arquivo corrente, path, etc. Veja a Tabela de Macros para informações das macros disponíveis no AP5

IDE.

Linha de Comando para Remover Arquivo

O campo Remover indica os parâmetros passados para o Software Controlador de Versão para remover o arquivo

de código fonte aberto no momento do controlador de versão. Pode-se utilizar macros para a obtenção do nome do

arquivo corrente, path, etc. Veja a Tabela de Macros para informações das macros disponíveis no AP5 IDE.



Utilizando o AP5 IDE

A Edição de Arquivos

O AP5 IDE suporta a edição de arquivos no formato texto, sendo que as extensões padrões são PRW, PRX e PRG.

Todos os arquivos gravados pelo IDE, são gravados contendo como finalizadores de linha os caracteres de código

ASC II 10 e 13 (LF e CR). Através das opções dos menus o usuário tem um controle amplo da formatação do

texto, com facilidades de cópia e edição de múltiplos arquivos como uma aplicação MDI.

Criando e Editando 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

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 5 - Os itens do menu Arquivo

Figura 6 - Diferenciação de Sintaxe em um arquivo aberto no AP5 IDE,

utilizando o fonte MS LineDraw.



Para finalizar a execução do AP5 IDE, o usuário pode escolher a opção Sair, utilizar a combinação de teclas

Alt+F4 ou clicar no ícone em forma de x na barra de títulos da janela principal. Ao finalizar, o AP5 IDE grava

todas as informações das preferências bem como informações do ambiente do usuário (como janelas abertas,

posicionamento, etc.). Porém, se o usuário estiver com uma sessão de debug em progresso, o AP5 IDE irá

questioná-lo para encerrar a sessão de debug antes de finalizar.

Para o envio de um arquivo via e-mail o usuário deve ter instalado e configurado em sua máquina um

cliente de e-mail como por exemplo o Microsoft Outlook. O arquivo físico, ou seja, a cópia gravada

no disco será enviado como um "attachment" via e-mail. Portanto qualquer alteração efetuada no

buffer de edição que não tenha sido gravada não constará do "attachment" no e-mail.

Muito importante: Se o usuário finalizar o AP5 IDE sem que uma sessão de debug tenha sido

encerrada, o AP5 IDE irá tentar encerrar esta sessão antes de finalizar enviando ao Server o comando

Derrubar Client (que será detalhado mais a frente no tópico sobre Utilização do Debug do AP5 IDE).

Porém, a finalização do AP5 Remote nem sempre é imediata visto que o controle do envio das

mensagens pode não estar com o AP5 IDE no momento da finalização. Isto pode acarretar na

finalização do AP5 IDE sem que o AP5 Remote seja finalizado, ou seja, o processo de execução do

AP5 Remote ficará preso na memória da estação.

Recursos de Edição

O menu Editar (figura 7) contém todas as opções necessárias para a

edição e formatação dos textos nos arquivos abertos. Contem os

recursos de Copiar, Recortar e Colar blocos de texto utilizando-se

da área de transferência, permitindo também que textos copiados de

outros arquivos de código-fonte sejam copiados para arquivos

abertos. Possui também os recursos de Desfazer e Refazer ações, ou

seja, as modificações efetuadas no texto podem ser desfeitas até o

limite inicial da abertura ou da última gravação do arquivo e refeitas

até o limite do número de ações armazenadas. O número de ações

que o AP5 IDE pode armazenar é configurável, como já foi

detalhado no tópico Configurando o AP5 IDE.

Modificações de Texto

No item Texto, existem opções para transformar o texto selecionado para caracteres maiúsculos ou minúsculos e

até mesmo uma opção para identar o arquivo.

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

e do encerramento das estruturas de controle de fluxo (como IF-ENDIF, WHILE-ENDDO, etc.).

Porém a identação não faz o papel do compilador, avaliando as expressões. Por esse motivo, o AP5

IDE não é capaz de identar arquivos que contenham a linha de código do comando IF dessa maneira:

If(<Expressão>)

<Comando>

Endif

Isso se deve ao fato de que o comando IF seguido de um parênteses é confundido com a função IF:

IF(<Expressão>,<Comando1>,<Comando2>) que não é um indicador de início de bloco de

controle de fluxo, ou seja, não termina com um ENDIF. Isto é facilmente corrigido incluindo-se um

caracter de espaço entre o comando e o sinal de parênteses:

If (<Expressão>)

<Comando>

Endif

Figura 7 - Os itens do menu Editar



Se o AP5 IDE encontrar uma linha como a descrita anteriormente simplesmente exibirá uma

mensagem de erro na identação, exibindo a linha onde tal erro foi encontrado, e cancelará o processo

de identação. O usuário também pode cancelar o processo de identação clicando no botão Cancela

que aparece na barra de status do AP5 IDE. Em qualquer um dos casos, quando a identação é

cancelada, o código não é alterado.

Inserção de Texto em um Arquivo

Existem também opções para inserir caracteres ASC II e os comentários padronizados para documentação no

código, utilizando a fonte configurada. Também no menu Editar se encontram as opções de navegação no código.

São as opções para posicionamento do cursor em determinado número de linha e posicionamento do cursor na

linha em execução (somente quando o AP5 IDE estiver com uma sessão de debug aberta) no arquivo selecionado.

A opção Localizar exibe a janela de localização de texto.

Localização e Substituição de Texto

É possível localizar textos no arquivo corrente

ou realizar uma pesquisa em mais de um

arquivo, estando ele aberto ou não no AP5

IDE. A pasta Localizar (figura 8) pesquisa por

expressões no arquivo corrente. Pode-se

pesquisar acima ou abaixo da posição do

cursor. Ainda pode-se indicar se a pesquisa

deve considerar a coincidência dos caracteres,

ou seja, encontrar exatamente a expressão

fornecida, ou ignorar as diferenças entre

caracteres maiúsculos ou minúsculos. Para isso

o usuário deve marcar a caixa Coincidir

Maiúsc./Minúsc. Pode-se também indicar se a

expressão deve ser localizada em qualquer

lugar do texto ou somente se for uma palavra

inteira. Uma palavra inteira é o texto

considerado entre dois delimitadores.

Assim que o texto é localizado, o AP5 IDE move o cursor até sua localização e marca o texto encontrado,

fechando a janela de localização de texto. Pode-se utilizar a opção Repetir Procura para continuar localizando a

expressão com as mesmas configurações sem precisar abrir a janela de localização novamente.

A pasta Localizar em Arquivos (figura 9)

permite uma pesquisa mais ampla com todas

as opções da localização detalhada

anteriormente. Pode-se localizar expressões

em arquivos de um diretório, pode-se

localizar expressões em todos os arquivos

abertos e pode-se localizar expressões em

todos os arquivos do grupo de projetos aberto

(a utilização de grupos de projetos será

detalhada no tópico Criação de Grupos de

Projetos e Compilação de Arquivos). Porém

os resultados da pesquisa serão exibidos na

Janela de Resultados da Localização em

Arquivos (figura 10).

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

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

AP5 IDE.



Nesta pasta as opções de direção são substituídas pelas opções de localização, ou seja, onde a pesquisa deve ser

efetuada. Se o usuário optar por pesquisar em um diretório, o quadro de opções Diretório de Pesquisa será

habilitado, permitindo ao usuário digitar no campo Máscara de Pesquisa o diretório e a máscara de arquivos que

deseja pesquisar (por exemplo, C:\FONTES\*.PRX). A máscara padrão de pesquisa é *.PR?. Se o usuário desejar

utilizar uma máscara diferente (por exemplo, pesquisar em arquivos texto com extensão TXT), deverá selecionar a

caixa Usa Caracteres Curinga que nesta pasta está habilitada.

Se o path informado juntamente com a máscara não for informado, será considerado o path atual. Se o path for

inválido, não haverá erros emitidos ao usuário. Apenas nenhuma ocorrência da expressão será encontrada. Se o

usuário desejar pesquisar a mesma máscara nos subdiretórios, deverá marcar a opção Pesquisar Subdiretórios. A

seleção da opção Repetir Procura não vale para a localização em arquivos. Se for requisita a pesquisa será feita

como uma localização comum no arquivo aberto.

Durante a localização em arquivos, uma janela de localização é exibida. Pressionando-se a tecla <ESC> ou

fechando-se esta janela a pesquisa é interrompida. Após a finalização da localização em arquivos, basta efetuar um

duplo clique em qualquer uma das ocorrências encontradas para que o arquivo seja editado e o cursor posicionado

na linha da ocorrência. Diferentemente da localização simples, esta não traz o texto selecionado no editor do AP5

IDE.

A opção Substituir (figura 11) funciona

exatamente como a localização simples,

porém substituindo as expressões

encontradas por uma expressão definida

pelo usuário. Tem as mesmas opções de

pesquisa e um campo para a digitação da

expressão a ser substituída. Pressionando

o botão OK o AP5 IDE irá substituir

apenas a primeira ocorrência da expressão

encontrada.

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

pressionar o botão Tudo. O AP5 IDE não perguntará

ao usuário se deve substituir as expressões a menos

que a caixa Perguntar Antes de Substituir seja

selecionada. Nesse caso, para cada uma das

expressões encontradas, será exibido um diálogo

perguntando ao usuário se deseja substituir a

expressão com os botões Sim, Não, Cancela e Tudo.

O botão Sim, substitui a ocorrência e continua a

pesquisa, o botão Não não substitui a ocorrência e

continua a pesquisa, o botão Cancela finaliza a

pesquisa mantendo as substituições até então

efetuadas e o botão Tudo termina de substituir todas

as ocorrências sem questionar o usuário.

A rotina de substituição, como a rotina de localização de expressões, também marca as ocorrências encontradas.

Porém, para facilitar a visualização, o AP5 IDE tenta posicionar a caixa de diálogo que questiona o usuário sobre

a substituição das ocorrências de modo a permitir a visualização do texto marcado de um modo que a caixa de

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.

Figura 10 - Janela com os resultados da localização. Um duplo clique

abre o arquivo para edição posicionando na linha onde a expressão foi

encontrada.

Figura 11 - Janela de substituição, com as mesmas opções

de pesquisa da localização simples.



Utilizando Book Marks

Este é recurso de edição bastante útil que não se encontra disponível através dos menus ou

botões das barras de ferramentas. Um book mark é um ponto marcado em uma linha que

permite a rápida localização e posicionamento do cursor, permitindo ao usuário marcar

pontos importantes no código para poder voltar o posicionamento do cursor no local

marcado através de uma combinação de teclas. Para adicionar ou remover um book mark

em uma linha de código, o usuário deve posicionar o cursor sobre a linha desejada e utilizar

a combinação de teclas CTRL+SHIFT+<n>, onde n é um número de 0 a 9. Pode-se manter

apenas 10 book marks por arquivo. Para localizar um book mark, o usuário deve utilizar a

combinação de teclas CTRL+<n>. Os book marks existentes são indicados na borda

esquerda dos arquivos através de imagens contendo o número do book mark (figura 12).

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

encontra aberto no AP5 IDE. Caso contrário, somente a localização em arquivos se encontrará

disponível.

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

da expressão a substituir são listas "drop-down", ou seja, acumulam as últimas 50 expressões

digitadas. Essas informações também são gravadas no arquivo AP5IDE.INI que é mantido no

diretório de instalação do Windows da estação.

Grupos de Projetos e a Compilação de Arquivos

Como um ambiente integrado, o AP5 IDE é o portal de entrada para as

rotinas específicas. Além de permitir a criação e edição dos arquivos de

código-fonte, é através do AP5 IDE que tais arquivos são enviados e

compilados no AP5 Server. Para isso, foi criado o conceito de Grupo de

Projetos.

Trabalhando com Grupos de Projetos

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

com grupos de projetos, compilação de arquivos, etc. Um grupo

de projetos é uma coleção de projetos e pastas que mantém listas

de arquivos de código (extensões *.PR?) e de definições

(extensão *.CH) e também as configurações de compilação. Os

grupos de projetos são editados através da janela do Gerenciador

de Projetos (figura 14). Utilizando as opções do menu Projetos

pode-se criar novos grupos, editá-los e gravá-los. A extensão

padrão para a gravação dos grupos de projetos é .PRJ.

Figura 14 - A janela do Gerenciador de Projetos,

com diversos arquivos de código e de definições

estruturados em diferentes projetos e pastas

Figura 13 - O menu Projetos

Figura 12 - Linhas marcadas

com Book Marks



O único meio de compilar um arquivo de código-fonte através do AP5 IDE é utilizando um grupo de projetos. Os

arquivos devem ser adicionados a pastas criadas para cada projeto. A divisão dos arquivos em projetos e pastas

organiza o trabalho, pois os arquivos podem ser divididos de acordo com a utilização, com um título explanatório

em seu projeto ou pasta. A edição dos projetos, ou seja, a criação de novas pastas, novos projetos, renomeação,

adicionamento de arquivos, edição das configurações, etc., é efetuada através do clique do botão direito do mouse

sobre qualquer área da janela do gerenciador de projetos. Pode-se também editar os arquivos através do duplo

clique do mouse ou do pressionamento da tecla <ENTER> sobre um arquivo na lista.

No menu acionado pelo botão direito do mouse ainda existem duas opções para importação e exportação do

Grupo de Projetos de/para um arquivo texto. Isto permite ao usuário manter cópias de segurança de grupos de

projetos longos, de modo que se ocorrer algum problema no arquivo binário onde os projetos são mantidos, as

informações possam ser facilmente restauradas do arquivo texto formatado.

Adicionar um arquivo em uma pasta significa adicionar o nome do arquivo em uma lista, e não

adicionar o arquivo propriamente dito ao projeto. Para qualquer tratamento com o arquivo, o AP5

IDE irá localizá-lo no path gravado. Assim os arquivos podem ser mantidos em outros diretórios que

não o da execução do sistema. O Gerenciador de Projetos utiliza os seguintes ícones de imagens para

indicar situações nos arquivos mantidos na lista:

Quando o arquivo for compilado com sucesso, o AP5 IDE indicará através deste ícone. Quando

o grupo de projetos é gravado, um flag de compilado é gravado para o arquivo. Isto é necessário para

evitar a recompilação do arquivo até que o mesmo seja alterado ou que o usuário acione o comando

"Compilar Tudo".

Quando houver alterações no arquivo, o AP5 IDE indicará através deste ícone. A identificação

de alteração é efetuada através da data e hora do arquivo que é mantida no arquivo de grupo de

projetos desde sua última gravação. Desse modo, o AP5 IDE somente identificará que o arquivo teve

modificações quando o mesmo for gravado. Ou seja, alterações efetuadas no buffer de edição do

arquivo que não forem gravadas, não serão consideradas na gravação. O AP5 IDE sempre compilará o

arquivo encontrado no path indicado no Gerenciador de Projetos. Quando o arquivo é indicado como

modificado, o flag de compilado (se existir) será removido para indicar que o arquivo deve ser

recompilado.

Se o arquivo não for encontrado no path indicado no Gerenciador de Projetos, o AP5 IDE

indicará através deste ícone. Isto pode acontecer, por exemplo, se o arquivo for deletado do diretório

sem ser removido do projeto em que se encontra.

A reavaliação do status dos arquivos (que poderá exibir os ícones acima) é efetuada sempre que

possível nas principais operações referentes ao Gerenciador de Projetos. Por exemplo, quando um

arquivo é adicionado ou removido, quando o nome de um projeto ou pasta é modificado, quando uma

pasta ou um projeto é criado ou removido, quando um projeto é compilado, quando um arquivo

contido no Gerenciador de Projetos é gravado, etc. Desse modo, por exemplo a deleção de um arquivo

não exibirá o ícone de não encontrado imediatamente, e sim após a realização da reavaliação do

status.

Compilando Arquivos de Código-Fonte

Para a compilação, o AP5 IDE não poderá estar em modo de debug. Existem três opções de compilação:

a compilação de tudo, que ignora o flag de compilado nos arquivos, simplesmente enviando novamente todos

os arquivos ao server para serem compilados;

a compilação do projeto selecionado, que envia apenas os arquivos do projeto selecionado na janela do

Gerenciador de Projetos que não contenham o flag de compilado ao server;

a compilação em Batch, na qual o usuário pode selecionar quais os projetos que desejará compilar com quais

configurações de compilação.



Todas as mensagens de compilação geradas, como também algumas outras mensagens genéricas geradas pelo

AP5 IDE, são enviadas para a área de mensagens (figura 15) que se encontra na base da janela principal do AP5

IDE.

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

barra de ferramentas do AP5 IDE, conectar-se ao server, enviar os arquivos de definições, enviar os arquivos para

a compilação e encerrar a conexão com o server. Se algum erro ocorrer a compilação será interrompida. O usuário

também pode interromper a compilação clicando no botão Cancelar que aparece na barra de status juntamente

com uma barra de percentual concluído.

Configurações de um Grupo de Projetos

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

Environment será utilizado na compilação dos

projetos e na execução do AP5 Remote. Se não existir

ao menos uma configuração, não será possível a

compilação. A Janela de Configurações (figura 16),

que pode ser acessada através do botão direito do

mouse sobre o Gerenciador de Projetos ou no menu

Projetos, é utilizada para a manutenção das

configurações do grupo de projetos..

Os botões Adicionar, Remover e Editar

permitem ao usuário criar novas configurações,

alterar informações ou remover configurações

existentes. Não há limite para a criação de

configurações. Quando for efetuada a

compilação, o AP5 IDE irá exibir na área de

mensagens a configuração que estará utilizando.

A configuração selecionada será utilizada para a

compilação de todo o grupo de projetos.

A configuração default é a selecionada no

combo existente na barra de ferramentas do

AP5 IDE. É a configuração que será utilizada

para a compilação (exceto a compilação em

batch) e para a execução do AP5 Remote.

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

Figura 16 - A janela de seleção e manutenção

de Configurações de Compilação

Figura 17 - Edição de uma configuração, onde pode-se identificar

o repositório utilizado e eventuais definições utilizadas no código.



Todos os arquivos compilados são registrados em um repositório de programas no AP5. É através das

configurações do Grupo de Projetos que o AP5 Server identifica qual será o repositório de compilação e registro

dos arquivos de programas (veja figura 17). Criando configurações diferentes, o usuário do AP5 pode compilar em

diferentes Environments, ou seja, compilar para diferentes idiomas, bases de dados, etc. Os environments são

seções criadas nos arquivos de configuração do AP5 Server (veja documentação do AP5 Server para maiores

detalhes) que lhe permitirão não só identificar o repositório correto para armazenar os programas compilados,

como para enviar as definições corretas na compilação (como por exemplo, a definição em linha de comando

/dTOP que é enviada quando um programa é compilado para TopConnect). Ou seja, para criar diferentes

configurações o administrador deve ter criado as seções de configuração corretamente no arquivo de configuração

do AP5 Server, identificando, por exemplo, o idioma, a versão e a interface. Depois de criadas, estas seções

podem ser utilizadas para a compilação e execução do AP5 Remote através do AP5 IDE simplesmente

identificando o nome da seção no campo Environment da configuração.

Também é através das configurações onde o usuário pode incluir definições próprias que identificarão blocos de

compilação condicional dentro do código dos fontes (uso de diretivas #IFDEF ou #IFNDEF). Tais definições

devem ser adicionadas no campo Parâmetros exatamente como seriam enviadas na linha de comando. Estas

definições serão adicionadas aquelas já definidas pelo AP5 Server de acordo com o Environment utilizado.

O usuário também pode utilizar a Compilação em Batch (figura 18), escolhendo os projetos e as configurações

que deseja compilar. Nesta janela, os projetos e as configurações existentes são cruzados, de modo que um mesmo

projeto pode ser compilado utilizando mais de uma configuração. Assim, pode-se manter versões dos programas

em Top Connect e em DBF ou em Inglês e Português, já que de acordo com o Environment informado nas

configurações, o AP5 Server irá manter os APO's em repositórios diferentes.

Na janela de Compilação em Batch, o

usuário pode marcar os projetos e

configurações desejados e clicar no botão

Compilar para compilá-los. A diferença

entre este botão e o botão Recompilar, é

que a recompilação ignora o flag de já

compilado nos arquivos contidos nos

projetos selecionados, fazendo com que

todos sejam compilados.

Para a compilação, nenhum usuário poderá estar trabalhando no repositório configurado. O AP5

tentará abrir o repositório para uso exclusivo e uma mensagem de erro será retornada caso algum

usuário esteja trabalhando com o repositório.

A compilação é efetuada no AP5 Server, e este retornará o resultado da compilação ao AP5 IDE. Para

a compilação, são necessários os seguintes arquivos (que são mantidos em um diretório na máquina

onde o AP5 Server está instalado. O diretório deve ser indicado na chave INCLUDEPATH do

environment definido no INI do AP5 Server): SET.CH, PROTDEF.CH, PROTHEUS.CH,

RWMAKE.CH, PRCONST.CH, SIGAWIN.CH, STD.CH, STDWIN.CH e PRTOPDEF.CH,

TOPDEF.CH, TOPCONN.CH (se o programa for para o ambiente SQL).

A linguagem ADVPL foi criada seguindo o padrão xBase para Windows utilizando os recursos

criados pela Microsiga desde versões anteriores do Siga Advanced. Desse modo, o AP5 IDE procura

compatibilizar ao máximo todos os Rdmakes que os usuários de versões anteriores tenham criado.

Para isso existe o Assistente de Conversão de Código que será detalhado mais a frente. Uma dessas

mudanças importantes é que todos os programas de usuários devem começar com USER FUNCTION

<nome do arquivo> (caso contrário um erro de compilação ocorrerá). Isso se deve porque o produto

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



Siga Advanced na versão 5.07 é todo criado utilizando-se a linguagem ADVPL. Como os usuários

também poderão utilizar-se desta linguagem para criar suas rotinas específicas, se todos se

utilizassem da cláusula FUNCTION poderia ocorrer de alguma nova versão do Siga Advanced conter

funções que por coincidência tivessem o mesmo nome de alguma função criada por um usuário. Isto

ocasionaria a substituição das funções do usuário pelas funções criadas pela Microsiga em uma

eventual atualização de versão. Desse modo, é proibido ao usuário utilizar-se de funções comuns

(sem a cláusula USER). Para o uso interno, a Microsiga dispõe de uma chave de autorização que é

fornecida através do menu Autorização, permitindo assim que funções comuns sejam utilizadas.

Diferentemente do RDMAKE, a linguagem ADVPL não é interpretada. É executada do mesmo modo

tanto para as rotinas criadas pela Microsiga como para as rotinas criadas pelo usuário. Assim não há

mais diferenças de velocidade de execução entre os códigos e todos os recursos da linguagem estão

disponíveis para os usuários.

Os arquivos compilados são gerados com a extensão APO (Advanced Protheus Object) e mantidos

em um repositório. Estes são arquivos binários que serão executados pelo Server. O AP5 Server

iniciará a execução a partir de um arquivo inicial. Desse modo, não existe mais o conceito de módulo,

a execução será efetuada a partir deste programa inicial (por exemplo SIGACON, o Siga Advanced

Contábil), abrindo os arquivos e carregando as funções de acordo com o menu do usuário.

Muito importante: Nesta versão, os arquivos de definições (extensão CH) que forem adicionados no

Gerenciador de Projetos ainda não estão sendo enviados ao servidor e devem ser colocados em um

diretório no servidor que esteja indicado na chave INCLUDEPATH do Environment definido no INI

do AP5 Server.



Utilizando o Debugger do AP5 IDE

Além de um editor de código, o AP5 IDE é uma ferramenta de Debug. Ou seja, permite ao usuário executar passo-

a-passo suas rotinas para encontrar e remover erros de lógica. Como em outras ferramentas de Debug, no AP5

IDE o usuário encontra janelas de Watch, janelas de informações com o conteúdo de variáveis, pilha de chamadas,

break points existentes, etc. E com todos esses recursos, fica muito mais fácil ao usuário depurar seus códigos,

inclusive em pontos de entrada do sistema Siga Advanced 5.07. A execução do AP5 Remote é a mesma, exceto

pelo fato de que é efetuada através do AP5 IDE. Quando o AP5 Remote é executado, uma conexão é aberta

através do IDE, sendo encerrada somente quando a execução do AP5 Remote é terminada (através do próprio AP5

Remote, ou forçada dentro do IDE).

Os Comandos de Debug

O menu Executar (figura 19), contem todos os comandos utilizados para debugar rotinas no AP5 IDE. Este

comando executa o AP5 Remote, inicialmente pelo programa inicial ou quando em processo de debug, a partir do

ponto atual. A execução é normal como se a rotina estivesse sendo executada diretamente (sem o Siga Advanced

Protheus IDE). O processamento poderá parar quando um break

point for encontrado ou quando o usuário interrompê-lo.

O programa inicial deve ser informado no combo de seleção

existente na barra de ferramentas do AP5 IDE, como exibido na

figura 20. Se por acaso o programa inicial não for informado, o AP5

Remote questionará o usuário pelo nome do programa inicial quando

for executado.

Geralmente o processo de debug consiste em adicionar um break

point a rotina desejada, executar o AP5 Remote através do AP5 IDE

e executar o sistema até o momento em que o break point seja

encontrado. Então, o usuário utiliza-se dos comandos de execução

passo-a-passo para acompanhar a execução da rotina criada. Pode-se

também executar o AP5 Remote e acionar o comando Pausa quando

a execução chegar na rotina desejada. A execução do comando

Pausa também pode ser efetuada através da combinação de teclas

ALT+D efetuada no AP5 Remote em execução.

Para a execução passo-a-passo, o AP5 localiza os arquivos de código fonte e posiciona o cursor na linha em

execução de modo que o usuário possa acompanhar a execução de suas rotinas. Para isso deve-se utilizar os

comandos Percorre Linha, Pula Linha, Executar até o cursor ou os comandos de animação. O comando Percorre

Linha executa linha por linha do código, entrando nas chamadas de funções. Ou seja, a execução deste comando

sobre uma linha que contenha uma chamada

de função fará com que o processo de debug

linha-a-linha continue no código da função e

o usuário terá que percorrer todo o código da

mesma para retornar ao ponto original. Ao

contrário, a execução do comando Pula

Linha em uma linha que contenha uma

chamada de função, fará com que o código

da função seja executado normalmente (sem

que o código da função seja executado linha-

a-linha) e o processo de debug continuará da

linha seguinte.

Figura 19 - O menu Executar, com

as opções para debug de rotinas.

Figura 20 - Combo para escolha do programa inicial. Pode-

se escolher um dos módulos do Siga Advanced ou digitar o

nome do programa inicial desejado.



Para que o processo de debug seja efetuado, o AP5 IDE precisará localizar os arquivos onde as linhas executadas

se encontram, abri-los para o usuário e posicionar o cursor nas linhas corretas. Por isso, o usuário deve configurar

corretamente os diretórios de localização de arquivos (como visto em Configurando o AP5 IDE). Se um arquivo

não for localizado, o AP5 IDE questionará o usuário por sua localização a menos que tenha sido configurado para

que os arquivos não encontrados sejam ignorados. Os arquivos não encontrados terão seu código executado

normalmente até que uma linha válida seja encontrada ou que a rotina termine.

O comando Pausa, faz com que o processamento que esteja executando normalmente (após o comando Executar)

entre em modo de debug, permitindo a continuação em passo-a-passo. O comando Pára Execução, finaliza a

execução do AP5 Remote, encerrando-o. O AP5 Remote é literalmente derrubado e a conexão com o Server é

encerrada. Pode ser utilizado, por exemplo, quando determinada rotina está em loop de execução.

A animação é uma ferramenta que permite ao usuário executar linha-a-linha do código de uma forma

automatizada, sem necessitar acionar o comando Percorre Linha para todas as linhas do código. Ao acionar o

comando Animação, o AP5 IDE iniciará a execução automática do comando Percorre Linha a uma velocidade

inicial. Todas as informações são atualizadas e o usuário pode acompanhar o processamento, aumentar ou

diminuir a velocidade ou parar a animação.

O usuário também pode adicionar break points (pontos de parada) ao código. Os pontos de parada indicam linhas

do código que farão com que o AP5 IDE entre em modo de debug exatamente como se o comando Percorrer

Linha tivesse sido acionado, assim que a execução do código no AP5 Remote atingir a linha marcada. O

acionamento do comando Liga/Desliga Ponto de Parada, marca ou desmarca a linha onde o cursor está

posicionado no arquivo corrente. Por comodidade, os pontos de parada são gravados pelo AP5 IDE quando este é

encerrado, de modo que não é necessário remarcá-los na próxima execução. Pode-se definir condições para a

parada em um break point, porém a definição destas condições e outros detalhes serão explicados mais a frente na

seção que trata sobre a janela de exibição dos break points existentes.

Por fim, o comando Atualiza, força uma atualização de todas as janelas de informações do AP5 IDE. Todas as

expressões ou variáveis são reavaliadas no AP5 Server.

A execução dos comandos de debug é efetuada através da troca de mensagens entre o AP5 IDE e o

AP5 Server. Portanto, quando o AP5 Remote estiver sendo executado (e conseqüentemente o controle

da execução está com o Server, não com o IDE), a execução de um comando, por exemplo o comando

Para Execução, pode não ser efetuada instantaneamente, aguardando que alguma linha do código do

AP5 Remote seja processada. Ou seja, se o AP5 Remote estiver parado (por exemplo, aguardando uma

intervenção do usuário para digitar um texto qualquer ou pressionar um botão) o comando não será

executado até que algum processamento seja efetuado (por exemplo, quando o usuário clicar no botão

ou a validação de uma caixa de edição for acionada).

Enquanto o AP5 IDE está em processo de debug, o usuário pode obter o valor de variáveis

simplesmente passando o ponteiro do mouse sobre o nome da variável desejada. Se o conteúdo da

variável for diferente de nulo ou espaços em branco ele será exibido em um hint abaixo da linha onde a

palavra se encontra. Para avaliar expressões, o usuário pode selecionar o texto de toda a expressão e

mover o ponteiro do mouse sobre a expressão selecionada. Pode-se também saber em que arquivo uma

função se encontra utilizando o mesmo recurso, contanto que o mapa de objetos (que será detalhado

mais a frente) já tenha sido obtido. Este recurso deve ser utilizado com cautela, pois se um comando for

selecionado e o ponteiro do mouse passado sobre a seleção, tal comando será executado e pode

influenciar no processo de debug.

Durante o processo de debug, o AP5 IDE indicará através de imagens na borda esquerda dos arquivos

algumas informações. São utilizados os seguintes símbolos:

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

Indica o ponto de execução, ou seja, a linha do arquivo corrente é a linha em execuçã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).

A Janela de Break Points

A janela de Break Points (figura 22)

exibe todos os break points

adicionados ao código. Nesta janela

são exibidos o nome do arquivo, a

linha onde o break point se encontra

e a condição de execução. São três

os tipos de break points existentes.

O break point comum contém

apenas o nome do arquivo e a linha

onde deve parar o processamento e

pode ser adicionado através do

comando Liga/Desliga Ponto de

Parada do AP5 IDE,

ou através do menu acionado pelo botão

direito do mouse sobre a janela de 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

continuar com o processamento normalmente.

Figura 21 - O menu Visualizar com os comandos para

exibição das janelas de inspeção.

Figura 22 - A janela de Break Points com o menu acionado pelo

pressionamento do botão direito do mouse.

Figura 23 - Adicionando um break point condicional



A janela de Pilha de Chamadas

A janela de Pilha de Chamadas (figura 24) contém informações sobre a seqüência de chamadas das funções

executadas pela rotina em processo de debug no AP5 IDE. Em ordem descendente de acordo com as chamadas

executadas, a lista contém o número da linha, o nome da função, os parâmetros recebidos e o nome do programa

onde a função se encontra registrada no Server.

Algumas chamadas, como de Code Blocks ou chamadas internas do Server, não exibem o nome do programa. Se

um duplo clique for efetuado sobre um item da lista, o AP5 IDE irá localizar o arquivo e posicionar o cursor na

linha da chamada, recalculando as demais janelas de inspeção de acordo com a função, como será visto mais a

frente no tópico sobre as janelas de

inspeção de variáveis. A localização dos

arquivos depende também das preferências

configuradas pelo usuário, como visto no

capítulo Configurando o AP5 IDE. As

informações da janela de Pilha de

Chamadas somente estão disponíveis

durante o processo de debug do AP5 IDE.

A Janela de Watchs

A janela de Watchs (figura 25) é um local onde o usuário pode

adicionar expressões para serem avaliadas durante o processo de

debug. Pode-se adicionar, remover ou editar as expressões através do

menu acionado pelo botão direito do mouse sobre a janela de Watchs.

Como todas as expressões são avaliadas no Server no momento em

que são adicionadas e durante o processo de debug, quando não se

estiver em processo de debug só será possível a exclusão de

expressões. Por comodidade, as expressões adicionadas são gravadas

quando o AP5 IDE é encerrado.

São três as colunas de informações exibidas na janela de Watchs. A

coluna Expressão contém a expressão adicionada e as colunas Tipo e

Resultado contém respectivamente o tipo de dado e o resultado

referentes à avaliação da expressão efetuada no Server.

As expressões de tipo Objeto e Array podem ter seu conteúdo

exibido através da expansão, efetuada pelo duplo clique sobre a

expressão ou o clique no sinal de expansão (+) no canto esquerdo da

mesma (figura 26). Durante o processo de debug, o usuário também

pode selecionar o texto no arquivo de código e, através do botão

direito do mouse, arrastá-lo para a janela de Watchs, adicionando

automaticamente o texto para avaliação.

Semelhante à utilização da janela de Watch, o usuário conta também com a área de comandos do AP5 IDE (figura

27). Na área de comandos o usuário pode digitar expressões (como por exemplo, nome de variáveis, comandos,

etc.) que ao se pressionar a tecla <ENTER> serão avaliadas no Server e o resultado será apresentado na linha

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

Figura 25 - A janela de Watchs com

duas expressões adicionadas.

Figura 26 - A janela de Watchs com uma

expressão (resultante em objeto) expandida.



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.

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 27 - Área de Comandos na parte inferior da janela do AP5 IDE

Figura 28 - Janela de variáveis privadas - uma

das janelas de Inspeção de Variáveis.



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.

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

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



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

Inspetor de Objetos irá conectar-

se ao Server e obter o mapa de

objetos. O usuário pode optar

por exibir o mapa em duas

ordens diferentes: Por

Programa e Por Função.

Exibindo Por Programa, as funções registradas serão agrupadas pelo nome do programa na qual foi criada ao ser

registrada no Server. Caso contrário, uma lista de funções sem agrupamento será exibida. Ao executar um duplo

clique sobre o nome de uma função (ou executar o comando Abrir no menu acionado pelo botão direito do

mouse), o AP5 IDE tentará abrir o arquivo e posicionar o cursor na linha onde a função se encontra. Pode-se

também localizar funções dentro do mapa, selecionando a opção Localizar Função no menu acionado pelo botão

direito do mouse. Se a função for localizada, o cursor será posicionado sobre o nó da mesma na árvore montada no

mapa de objetos.

Os objetos são os APO's (Advanced Protheus Object) registrados em repositórios no Server. São todas as rotinas e

funções compiladas e registradas. Desse modo, ao obter o mapa de objetos, será necessário indicar uma das

configurações existentes no Gerenciador de Projetos, como visto na compilação ou na execução do AP5 Remote

através do AP5 IDE. Do mesmo modo, se nenhuma configuração for criada, o AP5 IDE irá considerar que os

objetos devem ser

obtidos do

repositório oficial.

Se não for possível conectar-se ao Server para a obtenção do mapa de objetos, o AP5 IDE não exibirá

a janela do Inspetor de Objetos. Sempre que um arquivo é compilado, podem haver mudanças nos

objetos registrados no Server. A atualização do mapa de objetos não é efetuada automaticamente,

ficando a cargo da necessidade do usuário.

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

dos objetos:

Indicador de Arquivo

Indicador de Função

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

Como outros processamentos que requerem conexão ao Server (por exemplo, a compilação já

detalhada anteriormente), durante a obtenção do mapa de objetos, o AP5 IDE exibe uma barra de

percentual de conclusão acompanhada de um botão para o cancelamento no lugar da barra de tatus de

sua janela principal (figura 31). O usuário pode cancelar a obtenção do mapa de objetos clicando no

botão Cancelar desta barra.

Figura 30 - A janela do Inspetor de Objetos

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

cancelamento.



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

Os Softwares para Controle de Versões de Arquivos

O AP5 IDE pode ser integrado a um software para gerenciamento de versões de arquivos de código, permitindo ao

usuário efetuar a reserva, a confirmação, a obtenção de últimas versões de arquivos, etc., diretamente de dentro do

ambiente de desenvolvimento. Os softwares de controle de versão trabalham com uma base de dados dos arquivos

que é mantida em um servidor específico e os usuários através de uma aplicação client deste software obtém

cópias locais dos arquivos para poder alterá-los, testá-los e então enviar as cópias com as novas implementações

para substituir as cópias existentes na base de dados do servidor. É claro que apenas um usuário pode alterar um

arquivo por vez e por isso o arquivo deve ser reservado antes de poder ser alterado. Para evitar confusões entre as

cópias locais e as cópias mantidas no servidor, os softwares de controle de versão geralmente trabalham atribuindo

o atributo de somente leitura (Read Only) aos arquivos locais, de modo que o usuário não os poderá alterar a não

ser que uma reserva seja efetuada antes. Este é o mesmo conceito utilizado pelo AP5 IDE para permitir a alteração

ou efetuar a reserva automática de um arquivo.

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

Como visto no capítulo Configurando o AP5 IDE, o primeiro passo para a utilização do Controle de Versão

Integrado é a configuração das linhas de comando para execução das ações do software controlador de versão. A

execução destas ações são efetuadas através da execução de macros no AP5 IDE que enviam as linhas de

comando configuradas ao software controlador de versão. As macros utilizadas para o controle de versão são:

$VERSION_CHECK_OUT, $VERSION_CHECK_IN, $VERSION_GET_LAST, $VERSION_ADD_FILE,

$VERSION_REMOVE_FILE, $VERSION_UNDO_CHECK_OUT, $VERSION_ASK_FOR_COMMENT e

$SYSTEM_USER_ACCESS. Para maiores detalhes sobre as macros existentes no AP5 IDE, verifique a Tabela de

Macros ao final desta documentação.

A Reserva Automática de um Arquivo

Quando o AP5 IDE está configurado para utilizar o controle de versão, o usuário será questionado sobre a reserva

assim que ocorrer a primeira tentativa de alteração em um arquivo com o atributo de somente leitura. Se optar por

reservá-lo, o AP5 IDE irá então executar a macro para reserva de arquivo ($VERSION_CHECK_OUT). Se o

usuário optar por não reservá-lo, o atributo de somente leitura permanecerá na cópia local do arquivo e

conseqüentemente o AP5 IDE não permitirá que nele sejam efetuadas alterações.

Executando Outras Macros de Controle de Versão

As macros de controle de versão também podem ser executadas através da barra de ferramentas de controle de

versão (figura 32) que é exibida automaticamente quando o uso de controle de versão é habilitado nas

configurações de preferências do AP5 IDE.

Através do ambiente do AP5 IDE, o usuário pode:

Obter a última versão de um arquivo, ou seja, o software de controle de

versão gravará no diretório onde o arquivo se encontra uma cópia local

com a última versão mantida em sua base de dados e nesta cópia local

colocará o atributo de somente leitura;

Reservar um arquivo, o que também fará com que a última versão seja

trazida para a cópia local, porém o atributo de somente leitura será

removido permitindo que o usuário efetue as alterações necessárias;

Confirmar as alterações em um arquivo reservado, ou seja, a cópia local será enviada ao server e o arquivo

não mais ficará reservado para o usuário. Conseqüentemente, o atributo de somente leitura será atribuído

novamente à copia local;

Figura 32 - A barra de

ferramentas para execução

das macros de controle de

versão.



Desfazer uma reserva efetuada, o que fará com que a reserva na base de dados do software controlador de

versão seja desfeita e o atributo de somente leitura seja atribuído novamente ao arquivo;

Adicionar ou remover arquivos da base de dados, ou seja, através do AP5 IDE o usuário pode adicionar

arquivos para que tenha a versão controlada pelo software controlador de versão ou remover um arquivo para

que não mais tenha sua versão controlada por tal software.

Nas linhas de comando para o controle de versão, por default são adicionadas, quando o usuário as configura, as

macros especiais $VERSION_ASK_FOR_COMMENT e $SYSTEM_USER_ACCESS, que respectivamente obtém

do usuário o comentário e o nome do usuário e senha para

as operações a serem efetuadas no servidor de versões

(figura 33). Dependendo do modo que o software de

controle de versão utilizado trabalha, o usuário pode

customizar estas linhas de comando e até remover a

execução destas macros.

O responsável pela remoção ou atribuição do atributo de somente leitura é o software controlador de

versão. Portanto, após a execução da macro para reserva do arquivo, o AP5 IDE irá esperar que o

atributo de somente leitura seja removido do arquivo. Caso este atributo não seja removido dentro de

um intervalo de tempo de cinco segundos (por exemplo, se a reserva do arquivo ainda não teve tempo

de ser efetuada pelo software controlador de versão ou mesmo se a execução da linha de comando

falhou ou não foi possível reservar o arquivo pois o mesmo está reservado para outro usuário) será

exibida uma mensagem questionando o usuário se o IDE deve aguardar mais cinco segundos pelo

término da reserva do arquivo. Se o usuário não permitir que o IDE aguarde mais cinco segundos e o

arquivo permanecer com o atributo de somente leitura o arquivo será fechado por segurança

(garantindo que uma eventual cópia local obtida do servidor cujo processo de reserva terminou

posteriormente não seja sobrescrita por uma versão com informações incorretas que poderia estar

sendo mantida aberta no IDE).

Após a execução de macros como a de reserva de arquivo ou a de obtenção da última versão que tem

alterações efetuadas pelo software controlador de versão na cópia local do arquivo, o AP5 IDE irá

reabrir o arquivo para carregar as eventuais diferenças. Portanto, antes da execução de tais macros,

caso o arquivo contenha modificações não gravadas, o usuário será questionado sobre a continuação da

execução da macro.

A estrutura de pastas do projeto na base de dados do software de controle de versão deve ser a mesma

estrutura dos diretórios dos arquivos trabalhados. Este conceito foi implantado para facilitar a execução

das macros automaticamente pois o path dos arquivos é informado na linha de comando. Entretanto,

isto é possível de ser alterado, simplesmente modificando as linhas de comandos informadas na janela

de preferências (por exemplo, informando um nome de projeto fixo) de acordo com a sintaxe de linha

de comando do software utilizado. Note que alguns softwares controladores de versão, como o Visual

Source Safe da Microsoft, permitem ao usuário criar diferentes bancos de dados para armazenamento

dos projetos mesmo que isso não seja aconselhável pelo próprio fabricante. Para a execução das

macros de controle de versão, o AP5 IDE funcionará corretamente com apenas um banco de dados

para armazenagem.

Para a execução de qualquer um dos comandos de controle de versão, o usuário deve ter os direitos

necessários cadastrados no software de controle de versão utilizado.

Figura 33 - A caixa de diálogo para digitação da senha

exibida pela macro $SYSTEM_USER_ACCESS

durante a execução da macro para reserva de arquivo



Muito importante: Caso o usuário deseje efetuar testes locais, e desse modo remover manualmente

(ou mesmo através de opções do software de controle de versão utilizadas nas linhas de comando das

macros) o atributo de somente leitura, a execução automática do pedido de reserva não será efetuada

pelo AP5 IDE e as cópias locais (mesmo que não estejam reservadas ou não sejam a versão correta

mantida no servidor de controle de versão) poderão sempre ser editadas no AP5 IDE. Assim, o controle

das reservas e confirmações dos arquivos será totalmente do usuário pela execução através dos botões

na barra de ferramentas de controle de versão ou diretamente em uma versão client do software

controlador de versão. Note que neste caso o usuário deve verificar sempre se o arquivo está

corretamente reservado através do software de controle de versão, pois não há garantias de que, por

exemplo, uma linha de comando executada através do AP5 IDE foi executada com sucesso e a versão

do arquivo que o usuário está editando é a última.

Do mesmo modo, se o software de controle de versão utilizado não trabalhar com o atributo de

somente leitura nos arquivos, apenas as execuções manuais das macros serão efetuadas no AP5 IDE e é

extremamente aconselhável neste caso que as operações de reserva, confirmação, etc. sejam efetuadas

sempre através da versão client do software de controle de versão.



Utilizando os Assistentes do AP5 IDE

Através do menu Ferramentas (figura 34) o usuário tem acesso aos assistentes do

AP5 IDE e também as ferramentas customizadas que serão detalhadas mais a

frente. O AP5 IDE disponibiliza o Assistente de Geração de Código e o Assistente

de Conversão.

O Assistente de Geração de Código

O Assistente de Geração de Código do AP5 IDE

(figura 35) permite a criação de rotinas básicas

através de informações definidas pelo usuário. O

assistente cria rotinas específicas com o código

básico para o tipo de rotina desejada, facilitando ao

usuário pois ele deverá somente incluir a lógica

principal de acordo com a sua necessidade. O

escopo do programa, com as funções em ADVPL,

são montados pelo assistente. Os tipos de rotinas

que são criados pelo Assistente de Geração de

Código são rotinas de relatórios, rotinas de cadastro,

rotinas para geração e importação de arquivo texto e

rotinas de processamento genérico.

Para a geração do escopo do programa, o Assistente solicita informações como o arquivo principal, os parâmetros

utilizados, títulos de relatórios ou browsers, etc. (por exemplo, figura 36).

Figura 34 - O Menu Ferramentas.

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

Figura 36 – Informações necessárias ao Assistente de

Geração de Código para a geração do escopo do programa.



O Assistente de Conversão de Código

Os antigos Rdmakes mantidos pelos usuários continuam compatíveis na versão do AP5. Porém, algumas

alterações são necessárias para o correto funcionamento destes programas. Para auxiliar na adaptação dos

Rdmakes, o AP5 IDE contém um Assistente de Conversão de Código.

Selecionando os Arquivos

Acionando a opção Assistente de Conversão do

menu Ferramentas, o Assistente iniciará de sua tela

para seleção de arquivos para conversão (figura

37).

Através dos botões ao lado direito da lista, o

usuário pode adicionar, remover ou limpar a lista de

arquivos para a conversão. Após um ou mais

arquivos terem sido adicionados a lista, o botão

Avançar será disponibilizado para que o processo

continue. Selecionando Avançar, o processo de

compatibilização se iniciará (figura 38).

Convertendo os Arquivos

Após o término do processo de conversão o botão

Avançar se tornará novamente disponível.

O Assistente de Conversão não efetuará diretamente

as alterações nos arquivos selecionados para

conversão. Utilizará uma cópia em memória de cada

arquivo onde efetuará as mudanças necessárias.

Na tela seguinte o Assistente questionará o usuário

pelo diretório no qual deverá gravar os arquivos

convertidos (figura 39).

Diretório para Gravação dos Arquivos Convertidos

Nesta tela o usuário poderá também selecionar quais os

arquivos que não deseja gravar e removê-los da lista de

arquivos convertidos. Todos os arquivos da lista serão

gravados com o nome original no diretório informado.

Portanto, é aconselhável fornecer um diretório diferente

do diretório dos arquivos originais para que os mesmos

não sejam substituídos.

Seguirá uma tela de processo da gravação dos arquivos

e então a tela de finalização da conversão (figura 40)

será exibida. Neste momento os arquivos convertidos já

se encontram gravados no diretório informado.

Figura 37 - Seleção de arquivos para conversão no

Assistente de Conversão de Código

Figura 38 - O Assistente em processo de conversão

dos arquivos

Figura 39 - Seleção do diretório para gravação

dos arquivos convertidos.



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

O Assistente de Conversão do AP5 IDE também poderá

criar automaticamente um grupo de projetos (conforme

descrito em capítulo anterior) com todos os arquivos

convertidos. Para isso basta selecionar a opção Criar

um Novo Projeto e fornecer o nome do arquivo. O

arquivo será criado no mesmo diretório onde os

arquivos convertidos foram gravados. O Assistente

também poderá compilar automaticamente o grupo de

projetos criado, bastando que o usuário selecione a

opção Compilar Todos os Arquivos.

Ao se pressionar o botão Finalizar, o assistente irá então executar as opções selecionadas pelo usuário. Caso não

seja possível criar o grupo de projetos, ou compilar os arquivos (por exemplo, se não for possível conectar ao

Server) o usuário será avisado sem qualquer interferência nos arquivos convertidos gravados no diretório

informado anteriormente.

Como já detalhado anteriormente, os códigos criados por usuários do Siga Advanced deverão utilizar a

cláusula USER FUNCTION <nome do programa>, garantindo assim a unicidade das funções criadas.

Isto também permite que a função EXECBLOCK e as opções de menus iniciadas com o caracter de

código ASCII 35 (#) sejam executadas normalmente. A inclusão da cláusula USER FUNCTION é uma

das alterações efetuadas pelo Assistente de Conversão.

Nos antigos Rdmakes, todas as variáveis eram criadas como Private no escopo do sistema. Assim, uma

variável criada em uma função chamada pela rotina principal, permanecia durante toda a execução do

Rdmake. Como agora o código não é mais interpretado, as variáveis Private permanecem durante toda

a execução até a finalização da rotina que a criou. Então, por motivos de compatibilização, todas as

variáveis serão declaradas no início da rotina convertida.

Finalmente, por ser um código interpretado o RDMAKE utilizava-se da função EXECUTE para

executar funções nas ações de botões ou em outras ocasiões. Como o usuário tem a sua disposição

todas características da linguagem ADVPL, como por exemplo uso de parâmetros e retorno de valores

em funções, as chamadas das funções EXECUTE(<nome da função>) são substituídas pela chamada da

própria função nos programas convertidos.

Juntamente com estas alterações, será incluída nas rotinas específicas convertidas a cláusula

#INCLUDE "RWMAKE.CH" para manter a compatibilidade dos comandos utilizados no Rdmake e

todas as cláusulas #INCLUDE ou #DEFINE já existentes na rotina específica serão movidas para o

início do programa.

Figura 40 - A tela de finalização da conversão,

onde o usuário pode criar um grupo de projetos

e compilar os arquivos automaticamente.



Tabela de Macros

As Macros implementadas no AP5 IDE podem ser utilizadas para automatizar ações ou ferramentas. No menu

Ferramentas, qualquer ferramenta adicionada pode utilizar nos parâmetros ou no diretório inicial uma ou mais

macros. Basta informar no texto o nome da macro. Por exemplo, pode-se utilizar macros na inclusão de uma

ferramenta que permita editar o arquivo corrente no NOTEPAD do Windows:

NOTEPAD.EXE $SOURCE_NAME.

Além dessa utilização, a macro $VERSION_CHECK_IN pode ser executada automaticamente durante o

processamento do AP5 IDE.

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

Nome Descrição

$$ Retorna o caracter "$".

$IDE_PATH Retorna o path de execução do AP5 IDE.

$INPUT_TEXT(cTit,cMsg,cDefault) Exibe a mensagem informada em cMsg em um diálogo com título cTit,

permitindo a digitação de um texto. Retorna o texto digitado caso o

diálogo seja confirmado ou o texto em cDefault caso o diálogo seja

cancelado.

$SOURCE_NAME Retorna o nome completo (path e nome) do arquivo corrente. Se nenhum

arquivo estiver aberto retorna vazio ("").

$SOURCE_NAME_NO_DRIVE Retorna o nome completo sem a letra do drive do arquivo corrente. Se

nenhum arquivo estiver aberto retorna vazio ("").

$SOURCE_SHORT_NAME Retorna somente o nome do arquivo corrente (sem path ou letra do

drive). Se nenhum arquivo estiver aberto retorna vazio ("").

$SOURCE_CURSOR_LINE Retorna a linha onde o cursor está posicionado no arquivo corrente. Se

nenhum arquivo estiver aberto retorna "00".

$SOURCE_CURSOR_COLUMN Retorna a coluna onde o cursor está posicionado no arquivo corrente. Se

nenhum arquivo estiver aberto retorna "00".

$SOURCE_CURSOR_WORD Retorna a palavra que se encontra onde o cursor está posicionado no

arquivo corrente. Se nenhum arquivo estiver aberto retorna vazio ("").

Considera como palavra todo e qualquer texto entre os delimitadores.

$SOURCE_EXECUTION_LINE Retorna a linha de execução no arquivo corrente. Se nenhum arquivo

estiver aberto ou o AP5 IDE Não estiver em modo de debug, retorna

"00".

$SOURCE_PATH Retorna o path do arquivo corrente. Se nenhum arquivo estiver aberto

retorna vazio ("").

$SOURCE_EXT Retorna a extensão do arquivo corrente. Se nenhum arquivo estiver

aberto retorna vazio ("").

$SOURCE_DRIVE Retorna a letra do drive do arquivo corrente. Se nenhum arquivo estiver

aberto retorna vazio ("").

$SOURCE_SYSTEM_DATE Retorna a data do sistema no padrão dd/mm/yyyy.

$SOURCE_SYSTEM_TIME Retorna a hora do sistema no padrão hh:mm:ss.

$SYSTEM_USER_NAME Retorna o nome do login do usuário na rede. Se o usuário não estiver

logado ou não houver uma rede, retorna vazio ("").

$SYSTEM_USER_ACCESS Exibe uma caixa de diálogo para identificação por ID e senha,

retornando-os separados por uma vírgula (;) ou vazio ("") se a caixa de

diálogo for cancelada.

$VERSION_ADD_FILE Adiciona o arquivo corrente ao servidor de controle de versão , através

da execução da linha de comando informada nas preferências. Esta

macro só tem funcionalidade quando o uso de controle de versão estiver

habilitado no AP5 IDE. Note que a estrutura de pastas do projeto no

Controlador de Versão deve ser a mesma estrutura de diretórios onde o

arquivo se encontra.



$VERSION_ASK_FOR_COMMENT Exibe uma caixa de diálogo para a digitação do comentário para as

operações de reserva, confirmação, etc. de controle de versão. Esta

macro é utilizada automaticamente pelas macros que executam ações do

controlador de versão.

$VERSION_CHECK_OUT Reserva o arquivo corrente para alteração no Controlador de Versão,

através da execução da linha de comando informada nas preferências.

Esta macro só tem funcionalidade quando o uso de controle de versão

estiver habilitado no AP5 IDE. Note que a estrutura de pastas do projeto

no Controlador de Versão deve ser a mesma estrutura de diretórios onde

o arquivo se encontra. Após reservar o fonte, o arquivo é reaberto para

carregar eventuais modificações.

$VERSION_CHECK_IN Confirma as alterações no arquivo corrente, levando-as para o servidor

do controle de versão e desfaz a reserva efetuada, através da execução da

linha de comando informada nas preferências. Esta macro só tem

funcionalidade quando o uso de controle de versão estiver habilitado no

AP5 IDE. Note que a estrutura de pastas do projeto no Controlador de

Versão deve ser a mesma estrutura de diretórios onde o arquivo se

encontra.

$VERSION_GET_LAST Obtém a última versão do arquivo corrente no controlador de versão.

Esta macro só tem funcionalidade quando o uso de controle de versão

estiver habilitado no AP5 IDE. Após a execução do comando o arquivo é

reaberto para carregar eventuais modificações. Note que a estrutura de

pastas do projeto no Controlador de Versão deve ser a mesma estrutura

de diretórios onde o arquivo se encontra.

$VERSION_REMOVE_FILE Remove o arquivo corrente do controlador de versão. Esta macro só tem

funcionalidade quando o uso de controle de versão estiver habilitado no

AP5 IDE. Note que a estrutura de pastas do projeto no Controlador de

Versão deve ser a mesma estrutura de diretórios onde o arquivo se

encontra.

$VERSION_UNDO_CHECK_OUT Desfaz a última reserva efetuada para o arquivo corrente no controlador

de versão. Esta macro só tem funcionalidade quando o uso de controle

de versão estiver habilitado no AP5 IDE. Note que a estrutura de pastas

do projeto no Controlador de Versão deve ser a mesma estrutura de

diretórios onde o arquivo se encontra.



Glossá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

Sintaxe

Diferenciação através de cores do texto do código de um programa, visando facilitar a

identificação de erros de digitação e melhorar o aspecto visual. Geralmente são

diferenciados texto comum de palavras reservadas, números ou strings.

Identação É o alinhamento das linhas de texto, através da inclusão de tabulações, segundo a

estrutura lógica do programa visando facilitar a leitura do código. Por exemplo, abaixo

estão demonstradas linhas de código sem e com identação de texto:

if i < 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

Documents

Transcript of Protheus IDE