4a IDE

Inteligência Protheus
Ferramenta de
Trabalho IDE
Página 1 de 41
IDE – Ambiente de
desenvolvimento
integrado
Página 2 de 41
Sumário
O IDE .............................................................................................. 5
Configurando o IDE ........................................................................ 5
Configurações do Debugger ................................................................... 6
Definindo o Padrão de Teclas de Atalho .............................................................6
Definindo o Número de Arquivos na Lista de Recentemente Abertos ......................7
Utilizando a Régua com o Número de Linhas .....................................................7
Definindo a Localização de Arquivos..................................................................7
Ignorando Arquivos Não Encontrados................................................................7
Configurações de Código ....................................................................... 8
Elementos de Texto........................................................................................8
Definindo o Estilo do Texto ..............................................................................8
Definindo a Cor do Texto.................................................................................8
Definindo a Cor de Fundo do Texto ...................................................................8
Desabilitando a Diferenciação de Sintaxe...........................................................8
Configurações de Controle de Versão .................................................... 9
Utilizando o Controle de Versão........................................................................9
Software Controlador de Versão ..................................................................... 10
Path Inicial do Software Controlador de Versão ................................................ 10
Linha de Comando para Obtenção da Última Versão.......................................... 10
Linha de Comando para Reservar Arquivo........................................................ 10
Linha de Comando para Cancelar Reserva ....................................................... 10
Linha de Comando para Confirmar Arquivo ...................................................... 11
Linha de Comando para Adicionar Arquivo ....................................................... 11
Linha de Comando para Remover Arquivo........................................................ 11
Utilizando o IDE............................................................................ 12
A Edição de Arquivos ............................................................................12
Criando e Editando Arquivos .......................................................................... 12
Recursos de Edição ...................................................................................... 13
Modificações de Texto ............................................................................. 14
Inserção de Texto em um Arquivo............................................................. 14
Localização e Substituição de Texto........................................................... 14
Utilizando Book Marks ............................................................................. 16
Grupos de Projetos e a Compilação de Arquivos ...................................17
Trabalhando com Grupos de Projetos .............................................................. 17
Compilando Arquivos de Código-Fonte ............................................................ 19
Configurações de um Grupo de Projetos .......................................................... 19
Utilizando o Debugger do IDE...............................................................22
Os Comandos de Debug ................................................................................ 22
As Janelas de Inspeção do IDE....................................................................... 24
A Janela de Break Points.......................................................................... 25
A janela de Pilha de Chamadas ................................................................. 25
A Janela de Watchs................................................................................. 26
As Janelas de Inspeção de Variáveis.......................................................... 27
A Janela de Inspeção de Tabelas e Campos ................................................ 28
O Inspetor de Objetos ............................................................................. 29
Página 3 de 41
Controlando Versões de Arquivos Através do IDE........................ 30

Os Softwares para Controle de Versões de Arquivos.............................30
O Controle de Versões Através do IDE ..................................................30
A Reserva Automática de um Arquivo ............................................................. 31
Executando Outras Macros de Controle de Versão............................................. 31
Utilizando os Assistentes do IDE .................................................. 33

O Assistente de Geração de Código.......................................................33
O Assistente de Conversão de Código ...................................................34
Selecionando os Arquivos .............................................................................. 34
Convertendo os Arquivos .............................................................................. 34
Diretório para Gravação dos Arquivos Convertidos ............................................ 34
Criação de Projeto e Compilação Automáticos .................................................. 35
Tabela de Macros .......................................................................... 36

Glossário ...................................................................................... 38
Página 4 de 41
O IDE
O 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 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 IDE
Antes de iniciar a utilização do
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 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 IDE, são
mantidas no arquivo chamado
Figura 1 - A pasta Debugger da janela de Preferências do IDE xxxIDE.INI que se encontra no
mesmo diretório de execução
do IDE.
IDE – Ambiente de desenvolvimento integrado 5

Configurações do Debugger
A pasta de configurações do debugger (figura 1), exibe as opções básicas para o
processamento do 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 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 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 F9 Ir para a linha "n" Ctrl+G
Point
Visual C++
Percorrer Linha F11 Seguir até o Retorno Ctrl+F10
Pular Linha F10 Localizar Ctrl+F
Point
Delphi
Percorrer Linha F7 Seguir até o Retorno F4
Pular Linha F8 Localizar Ctrl+F
Point
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 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 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 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 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 IDE. Aqui você
pode habilitar ou
desabilitar a diferenciação
de sintaxe bem como
configurar as cores para
cada elemento de texto
que pode ser diferenciado.
Elementos de Texto Figura 2 - A pasta Código da janela de Preferências do IDE
Os elementos de texto são tipos de expressões que devido a sua finalidade são
classificados em grupos separados. Como por exemplo, palavras reservadas ao
compilador, strings de caracteres, números, etc. Nesta lista são apresentados os
diferentes elementos de texto que permitem a diferenciação de sintaxe no 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 IDE não se utilizará da diferenciação de sintaxe no código

dos arquivos abertos. Apesar de que o uso diferenciação de sintaxe não consuma muitos
recursos, o atualização das janelas pode ficar mais rápida com esse recurso desabilitado.

Desabilitando a diferenciação, as cores de todo o texto serão aquelas definidas no

Windows da estação.
Para a alteração da fonte do texto, utilize a opção Escolha de Fonte no menu

Arquivo. A fonte não pode ser diferenciada para os elementos de texto do
código. Apenas o estilo e as cores.
Configurações de Controle de Versão
A pasta de configurações de
Controle de Versão (figura
3), exibe as opções para a
integração de um software
de controle de versão ao
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 IDE
ou pela requisição do
usuário através dos botões
da barra de ferramentas de
controle de versão.
Figura 3 - A pasta Controle de Versão da janela de Preferências do
IDE
Utilizando o Controle de Versão
A opção Utiliza Controle de Versão indica que será utilizado um software de controle de
versão para controlar a reserva e a alteração de arquivos de código-fonte. Ao acionar esta
opção uma janela com os softwares controladores de versão compatíveis (figura 4) será
apresentada para que o usuário escolha aquele que esteja utilizando. A confirmação desta
janela traz nos campos das linhas de comando as sintaxes utilizadas pelo software
escolhido sugeridas. Caso o software utilizado não se encontre na lista de softwares
compatíveis, o usuário deverá consultar a documentação que o acompanha e fornecer
manualmente as sintaxes para as linhas de comandos.

Software Controlador
de Versão
O campo Software indica o
caminho para o software que
receberá as linhas de
comando enviadas pelo IDE
para as ações de controle de
versão.
Path Inicial do
Software Controlador
de Versão
O campo Iniciar Em indica o
path onde o software
controlador de versão será
iniciado quando receber as
linhas de comando.
Figura 4 - Seleção de um software de controle de versão compatível. A

confirmação do diálogo preenche os campos de linhas de comando de
acordo com as sintaxes do software escolhido.
Linha de Comando para Obtenção da Última Versão
O campo Última Versão indica os parâmetros passados para o Software Controlador de

Versão para realizar uma obtenção da última versão do arquivo de código aberto no
momento. Pode-se utilizar macros para obtenção do nome do arquivo corrente, path, etc.
Veja a Tabela de Macros para informações das macros disponíveis no 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 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
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
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 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 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 IDE.

Utilizando o IDE
A Edição de Arquivos
O 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
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 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 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.
Figura 5 - Os itens do menu Arquivo
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 IDE está preparado para tentar detectar a existência
desse arquivo no diretório de seu executável e instalá-lo no ambiente do usuário assim
que for iniciado.

Para finalizar a execução do 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
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
IDE irá questioná-lo para
encerrar a sessão de Figura 6 - Diferenciação de Sintaxe em um arquivo aberto no IDE,
debug antes de finalizar. utilizando o fonte MS LineDraw.
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 IDE sem que uma sessão de debug
tenha sido encerrada, o 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 IDE). Porém, a finalização do
Remote nem sempre é imediata visto que o controle do envio das mensagens
pode não estar com o IDE no momento da finalização. Isto pode acarretar na
finalização do IDE sem que o Remote seja finalizado, ou seja, o processo de
execução do 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 IDE pode
armazenar é configurável, como já foi detalhado no
tópico Configurando o IDE.
Figura 7 - Os itens do menu Editar

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 IDE não é capaz de
identar arquivos que contenham a linha de código do comando IF dessa
maneira:
If(<Expressão>)
<Comando>
Endif
Isso se deve ao fato de que o comando IF seguido de um parênteses é

confundido com a função IF: IF(<Expressão>,<Comando1>,<Comando2>) que
não é um indicador de início de bloco de controle de fluxo, ou seja, não termina
com um ENDIF. Isto é facilmente corrigido incluindo-se um caracter de espaço
entre o comando e o sinal de parênteses:
If (<Expressão>)
<Comando>
Endif
Se o 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 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 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 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 IDE

move o cursor até sua localização e
marca o texto encontrado, fechando a
janela de localização de texto. Pode-se
utilizar a opção Repetir Procura para
continuar localizando a expressão com
as mesmas configurações sem
precisar abrir a janela de localização
novamente.
A pasta Localizar em Arquivos (figura

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

do 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 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 IDE irá
substituir apenas a primeira
ocorrência da expressão
encontrada.
Figura 10 - Janela com os resultados da localização. Um duplo clique

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

de pesquisa da localização simples.
A rotina de substituição, como a rotina de localização de expressões, também marca as
ocorrências encontradas. Porém, para facilitar a visualização, o IDE tenta posicionar a
caixa de diálogo que questiona o usuário sobre a substituição das ocorrências de modo a
permitir a visualização do texto marcado de um modo que a caixa de diálogo esteja
totalmente visível. Caso não seja possível posicioná-la de modo que fique totalmente
visível e que seja possível visualizar o texto, a caixa de diálogo será
centralizada.
Utilizando Book Marks
Este é recurso de edição bastante útil que não se encontra disponível

através dos menus ou botões das barras de ferramentas. Um book mark é
um ponto marcado em uma linha que permite a rápida localização e
posicionamento do cursor, permitindo ao usuário marcar pontos
importantes no código para poder voltar o posicionamento do cursor no
local marcado através de uma combinação de teclas. Para adicionar ou
remover um book mark em uma linha de código, o usuário deve
Figura 12 - Linhas marcadas
IDE – Ambiente de desenvolvimento integrado com Book Marks 16
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 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 XXXIDE.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 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 IDE que
tais arquivos são enviados e compilados no Server. Para
isso, foi criado o conceito de Grupo de Projetos.
Figura 13 - O menu Projetos
Trabalhando com Grupos de Projetos
O menu Projetos (figura 13) exibe as opções para

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

com diversos arquivos de código e de definições
estruturados em diferentes projetos e pastas

O único meio de compilar um arquivo de código-fonte através do 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 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 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 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 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 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 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 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 IDE, são enviadas para a área de mensagens (figura 15) que se
encontra na base da janela principal do IDE.
Figura 15 - A área de mensagens do IDE com uma mensagem de erro de compilação
O processo de compilação consiste em selecionar a configuração desejada no combo de

configurações existente na barra de ferramentas do 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 Remote. Se não existir ao menos uma
configuração, não será possível a
compilação. A Janela de Configurações
(figura 16), que pode ser acessada
através do botão direito do mouse sobre o
Gerenciador de Projetos ou no menu
Projetos, é utilizada para a manutenção
das configurações do grupo de projetos..
Figura 16 - A janela de seleção e manutenção

de Configurações de Compilação

Os botões Adicionar, Remover e Editar permitem ao usuário criar novas configurações,

alterar informações ou remover configurações existentes. Não há limite para a criação de
configurações. Quando for efetuada
a compilação, o 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 IDE. É a
configuração que será utilizada para
a compilação (exceto a compilação
em batch) e para a execução do
Remote.
Figura 17 - Edição de uma configuração, onde pode-se identificar

o repositório utilizado e eventuais definições utilizadas no código.
Todos os arquivos compilados são registrados em um repositório de programas no

Protheus. É através das configurações do Grupo de Projetos que o 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 Protheus 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 Server (veja
documentação do 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 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 Remote através do 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 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 Server irá manter os APO's em repositórios
diferentes.

Na janela de Compilação em Batch, o usuário pode marcar os projetos e configurações

desejados e clicar no botão
Compilar para compilá-los. A
diferença entre este botão e o
botão Recompilar, é que a
recompilação ignora o flag de já
compilado nos arquivos contidos
nos projetos selecionados,
fazendo com que todos sejam
compilados.
Figura 18 - A janela de Compilação em Batch
Para a compilação, nenhum usuário poderá estar trabalhando no repositório

configurado. O IDE 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 Server, e este retornará o resultado da compilação

ao 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 Server está instalado. O diretório
deve ser indicado na chave INCLUDEPATH do environment definido no INI do
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 IDE procura compatibilizar ao máximo todos os Rdmakes que os
usuários de versões anteriores tenham criado. Para isso existe o Assistente de
Conversão de Código que será detalhado mais a frente. Uma dessas mudanças
importantes é que todos os programas de usuários devem começar com USER
FUNCTION <nome do arquivo> (caso contrário um erro de compilação
ocorrerá). Isso se deve porque o produto Siga Advanced na versão 5.07 é todo
criado utilizando-se a linguagem ADVPL. Como os usuários também poderão
utilizar-se desta linguagem para criar suas rotinas específicas, se todos se
utilizassem da cláusula FUNCTION poderia ocorrer de alguma nova versão do
Siga Advanced conter funções que por coincidência tivessem o mesmo nome de
alguma função criada por um usuário. Isto ocasionaria a substituição das
funções do usuário pelas funções criadas pela Microsiga em uma eventual
atualização de versão. Desse modo, é proibido ao usuário utilizar-se de funções
comuns (sem a cláusula USER). Para o uso interno, a Microsiga dispõe de uma
chave de autorização que é fornecida através do menu Autorização, permitindo
assim que funções comuns sejam utilizadas.
Diferentemente do RDMAKE, a linguagem ADVPL não é interpretada. É

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

Os arquivos compilados são gerados com a extensão APO (Advanced Protheus

Object) e mantidos em um repositório. Estes são arquivos binários que serão
executados pelo Server. O 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 Server.
Utilizando o Debugger do IDE

Além de um editor de código, o 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 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
Remote é a mesma, exceto pelo fato de que é efetuada através do IDE. Quando o Remote
é executado, uma conexão é aberta através do IDE, sendo encerrada somente quando a
execução do Remote é terminada (através do próprio 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 IDE. Este comando executa o 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 IDE, como
exibido na figura 20. Se por acaso o programa inicial
não for informado, o 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 Remote
através do 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 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
Remote em execução.
Figura 19 - O menu Executar, com
as opções para debug de rotinas.
Para a execução passo-a-passo, o IDE 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.
Para que o processo de debug seja efetuado, o 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 IDE). Se um arquivo
não for localizado, o 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. 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.
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 Remote, encerrando-o.
O 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 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 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 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 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
IDE. Todas as expressões ou variáveis são reavaliadas no Server.
A execução dos comandos de debug é efetuada através da troca de mensagens

entre o IDE e o Server. Portanto, quando o 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 Remote
seja processada. Ou seja, se o 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 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 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 IDE
O IDE contém diversas janelas para

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

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

A Janela de Break Points
A janela de Break Points (figura 22) exibe todos os break points adicionados ao código.
Nesta janela são exibidos o
nome do arquivo, a linha
onde o break point se
encontra e a condição de
execução. São três os tipos
de break points existentes.
O break point comum
contém apenas o nome do
arquivo e a linha onde deve
parar o processamento e
pode ser adicionado através
do comando Liga/Desliga
Ponto de Parada do IDE, Figura 22 - A janela de Break Points com o menu acionado pelo
ou através do menu acionado pelo botão pressionamento do botão direito do mouse.
direito do mouse sobre a janela de Break
Points. Este tipo de break point pode também ter uma condição de parada. Isto significa
que o processamento somente irá parar neste ponto se a condição informada for
satisfeita. Para informar uma condição, o usuário deve primeiro adicionar um break point
e depois editá-lo através do menu acionado pelo botão direito do mouse. Existe também
um break point chamado de break point condicional. Ele não contém nome de arquivo ou
linha, pois a parada é efetuada na primeira linha de código onde a condição informada
seja satisfeita. Este tipo de break point somente pode ser adicionado através do menu
acionado pelo botão direito do mouse na opção Adicionar (figura 23). Note que os break
points adicionados a uma linha de código, pararão somente quando a linha for encontrada,
sendo que o processamento poderá
seguir normalmente nas linhas
seguintes. Ao contrário, um break point
condicional fará com que o
processamento páre (ou seja, entre em
modo de debug) enquanto a condição
for satisfeita. Portanto poderá ser
necessário remover um break point
condicional depois que a condição for
atingida pela primeira vez, para poder
continuar com o processamento
normalmente.
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 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 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 IDE. As informações
da janela de Pilha de Chamadas
somente estão disponíveis durante
o processo de debug do IDE.
Figura 24 - A janela de Pilha de Chamadas (Call Stack)
A Janela de Watchs
A janela de Watchs (figura 25) é um local onde o

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

duas expressões adicionadas.
São três as colunas de informações exibidas na janela de Watchs. A coluna Expressão

contém a expressão adicionada e as colunas Tipo e Resultado contém respectivamente o
tipo de dado e o resultado referentes à avaliação da
expressão efetuada no Server.
As expressões de tipo Objeto e Array podem ter seu

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

expressão (resultante em objeto) expandida.

Semelhante à utilização da janela de Watch, o usuário conta também com a área de

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

do 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 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

Figura 28 - Janela de variáveis privadas - uma
das janelas de Inspeção de Variáveis.
terão conteúdo exibido enquanto o IDE estiver em processo de Debug.
A Janela de Inspeção de Tabelas e Campos
Como as janelas de Inspeção de Variáveis, o IDE mantém uma janela de Inspeção de

Tabelas de Dados (figura 29). Nesta janela são exibidos todos os arquivos abertos até o
momento do processo de debug. Cada arquivo pode ser expandido, exibindo assim seus
índices e todos os campos do registro do arquivo onde se encontra o ponteiro. São três as
colunas de informações exibidas: Objeto, Tipo e Conteúdo. Na coluna Conteúdo, são
exibidas as informações de acordo com o tipo de objeto exibido.
Para as tabelas, são exibidos o Alias, o filtro utilizado, o número do registro onde o
ponteiro está posicionado (Recno),
o número total de registros e a
ordem do índice ativo. A tabela que
é a área atualmente selecionada na
execução (o retorno da função
Alias( ) ) é indicada com dois
asteriscos (**).
Para os índices, é exibida a chave
de indexação (o retorno da função
IndexKey( ) ) e o índice ativo é
marcado com dois asteriscos (**).
Para os campos, é exibido o seu
conteúdo para o registro
posicionado pelo cursor,
exatamente como as variáveis nas
outras janelas de inspeção.
Figura 29 - Janela de Inspeção de Tabelas de Dados
Os itens da janela de Watchs e as variáveis das janelas de Inspeção de

Variáveis Locais e Estáticas são exibidos de acordo com a Pilha de Chamadas.
Se um duplo clique for efetuado sobre uma função na pilha de chamadas, as
janelas serão atualizadas com a situação das expressões e variáveis no
momento da execução daquela função. Isto permite ao usuário verificar as
mudanças ocorridas em variáveis em todos os momentos de execução das suas
rotinas. No entanto, quando um passo de debug é efetuado (por exemplo, com
o comando Percorrer Linha), as informações são reavaliadas para a situação
atual, ou seja, a última chamada de função efetuada (primeiro item na lista da
Pilha de Chamadas).
Em todas as janelas de Inspeção, seja Watchs, Tabelas ou Variáveis, existe uma

barra de rolagem na base que permite ao usuário visualizar todo o texto da
coluna Conteúdo (ou Resultado no caso da janela de Watchs) "rolando" o texto
que seja maior do que o tamanho exibido da janela.
Para facilitar a visualização, as janelas de inspeção se utilizam de imagens que

indicam o tipo de dado visualizado. Essas imagens (cuja legenda também pode
ser visualizada através do acionamento do botão direito do mouse sobre cada
janela) são:

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

Indicador de variável do tipo Lógico com valor Falso
Indicador de variável do tipo Lógico com valor Verdadeiro
Indicador de variável do tipo Array
Indicador de variável do tipo Objeto
Indicador de Tabela de Dados
Indicador de Índice
Indicador de Campo
O Inspetor de Objetos
O Inspetor de Objetos (figura 30) exibe todas as funções registradas no Server. O usuário
não precisa estar em
processo de debug para
obter do Server o mapa
de objetos. Ao acionar a
visualização através do
item Inspetor de Objetos
no menu Visualizar ou ao
acionar a opção Atualizar
no menu acionado pelo
botão direito do mouse, o
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. Figura 30 - A janela do Inspetor de Objetos
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 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 Remote através do
IDE. Do mesmo modo, se nenhuma configuração for criada, o IDE irá considerar que os
objetos devem
ser obtidos do
repositório
oficial.
Figura 31 - Barra de progresso de processamentos do IDE com o botão para
cancelamento.

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

o 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 IDE 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 IDE exibe uma barra de percentual de conclusão acompanhada de um
botão para o cancelamento no lugar da barra de tatus de sua janela principal
(figura 31). O usuário pode cancelar a obtenção do mapa de objetos clicando no
botão Cancelar desta barra.
Controlando Versões de Arquivos Através do IDE
Os Softwares para Controle de Versões de

Arquivos
O 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 IDE para permitir a alteração ou
efetuar a reserva automática de um arquivo.
O Controle de Versões Através do IDE

Como visto no capítulo Configurando o 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 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 IDE, verifique a Tabela de Macros ao final desta documentação.
A Reserva Automática de um Arquivo
Quando o 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 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 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 IDE.
Através do ambiente do IDE, o usuário pode:
9 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
Figura 32 - A barra de
atributo de somente leitura;
ferramentas para execução
9 Reservar um arquivo, o que também fará com que a das macros de controle de
última versão seja trazida para a cópia local, porém o versão.
atributo de somente leitura será removido permitindo que
o usuário efetue as alterações necessárias;
9 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;
9 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;
9 Adicionar ou remover arquivos da base de dados, ou seja, através do 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
Figura 33 - A caixa de diálogo para digitação da senha efetuadas no servidor de versões (figura 33).
exibida pela macro $SYSTEM_USER_ACCESS
durante a execução da macro para reserva de arquivo
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 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 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 IDE funcionará
corretamente com apenas um banco de dados para armazenagem.
Para a execução de qualquer um dos comandos de controle de versão, o usuário

deve ter os direitos necessários cadastrados no software de controle de versão
utilizado.
Muito importante: Caso o usuário deseje efetuar testes locais, e desse modo
remover manualmente (ou mesmo através de opções do software de controle de
versão utilizadas nas linhas de comando das macros) o atributo de somente
leitura, a execução automática do pedido de reserva não será efetuada pelo 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 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 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 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 IDE
Através do menu Ferramentas (figura 34) o usuário tem acesso

aos assistentes do IDE e também as ferramentas customizadas
que serão detalhadas mais a frente. O IDE disponibiliza o
Assistente de Geração de Código e o Assistente de Conversão.
Figura 34 - O Menu Ferramentas.
O Assistente de Geração de Código

O Assistente de Geração de Código do 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
Figura 35 - O Assistente de Geração de Código

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
Figura 36 – Informações necessárias ao Assistente de browsers, etc. (por exemplo, figura 36).
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
Protheus. Porém, algumas alterações são necessárias para o correto funcionamento destes
programas. Para auxiliar na adaptação dos Rdmakes, o 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).
Figura 37 - Seleção de arquivos para conversão no

Assistente de Conversão de Código
Convertendo os Arquivos
Após o término do processo de conversão

o botão Avançar se tornará novamente
disponível.
O Assistente de Conversão não efetuará

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

o usuário pelo diretório no qual deverá
gravar os arquivos convertidos (figura 39). Figura 38 - O Assistente em processo de conversão
dos arquivos
Diretório para Gravação dos Arquivos Convertidos

Nesta tela o usuário poderá também
selecionar quais os arquivos que não deseja

gravar e removê-los da lista de arquivos

convertidos. Todos os arquivos da lista
serão gravados com o nome original no
diretório informado. Portanto, é
aconselhável fornecer um diretório
diferente do diretório dos arquivos
originais para que os mesmos não sejam
substituídos.
Seguirá uma tela de processo da gravação
dos arquivos e 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
Figura 39 - Seleção do diretório para gravação informado.
dos arquivos convertidos.
Criação de Projeto e Compilação Automáticos
O Assistente de Conversão do IDE também

poderá criar automaticamente um grupo de
projetos (conforme descrito em capítulo
anterior) com todos os arquivos
convertidos. Para isso basta selecionar a
opção Criar um Novo Projeto e fornecer o
nome do arquivo. O arquivo será criado no
mesmo diretório onde os arquivos
convertidos foram gravados. O Assistente
também poderá compilar automaticamente
o grupo de projetos criado, bastando que o
usuário selecione a opção Compilar Todos
os Arquivos. Figura 40 - A tela de finalização da conversão,
onde o usuário pode criar um grupo de projetos
e compilar os arquivos automaticamente.
Ao se pressionar o botão Finalizar, o assistente irá então executar as opções selecionadas
pelo usuário. Caso não seja possível criar o grupo de projetos, ou compilar os arquivos
(por exemplo, se não for possível conectar ao Server) o usuário será avisado sem
qualquer interferência nos arquivos convertidos gravados no diretório informado
anteriormente.
Como já detalhado anteriormente, os códigos criados por usuários do Siga

Advanced deverão utilizar a cláusula USER FUNCTION <nome do programa>,
garantindo assim a unicidade das funções criadas. Isto também permite que a
função EXECBLOCK e as opções de menus iniciadas com o caracter de código
ASCII 35 (#) sejam executadas normalmente. A inclusão da cláusula USER
FUNCTION é uma das alterações efetuadas pelo Assistente de Conversão.
Nos antigos Rdmakes, todas as variáveis eram criadas como Private no escopo do
sistema. Assim, uma variável criada em uma função chamada pela rotina
principal, permanecia durante toda a execução do Rdmake. Como agora o código
não é mais interpretado, as variáveis Private permanecem durante toda a
execução até a finalização da rotina que a criou. Então, por motivos de

compatibilização, todas as variáveis serão declaradas no início da rotina

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

EXECUTE para executar funções nas ações de botões ou em outras ocasiões.
Como o usuário tem a sua disposição todas características da linguagem ADVPL,
como por exemplo uso de parâmetros e retorno de valores em funções, as
chamadas das funções EXECUTE(<nome da função>) são substituídas pela
chamada da própria função nos programas convertidos.
Juntamente com estas alterações, será incluída nas rotinas específicas

convertidas a cláusula #INCLUDE "RWMAKE.CH" para manter a compatibilidade
dos comandos utilizados no Rdmake e todas as cláusulas #INCLUDE ou #DEFINE
já existentes na rotina específica serão movidas para o início do programa.
Tabela de Macros
As Macros implementadas no 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 IDE.
Abaixo encontram-se detalhadas as macros suportadas no IDE.
Nome Descrição
$$ Retorna o caracter "$".
$IDE_PATH Retorna o path de execução do IDE.
$INPUT_TEXT(cTit,cMsg,cDefa Exibe a mensagem informada em cMsg em um diálogo
ult) 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 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 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_COMMEN Exibe uma caixa de diálogo para a digitação do
T 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
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
$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

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 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
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.
Remote Programa do Protheus que faz a interface com o usuário, através da
comunicação com o 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 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 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 Remote. A finalização do Remote somente
será efetuada assim que alguma linha de código for executada. Por
exemplo, se o 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 Remote seja executado (por
exemplo, na validação do texto digitado pelo usuário).
Diferenciação de Diferenciação através de cores do texto do código de um programa,
Sintaxe 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 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 Remote a combinação de teclas ALT+D.
O modo de execução também se encerra se o usuário finalizar o
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 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 Remote ou na execução de uma animação. A
parada do Remote somente será executada assim que alguma linha
de código for executada. Por exemplo, se o 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 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 São todos os programas compilados através do Advanced Protheus
Registrados 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 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 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 Protheus que se encarrega de executar as rotinas dos
programas registrados e controlar o acesso dos usuários. Comunica-
se com o 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
"PROTHEUS".

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 Server durante o processo de debug.

4a IDE

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

4a IDE

Încărcat de

Drepturi de autor:

Formate disponibile

Inteligência Protheus

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

Utilizando os Assistentes do IDE .................................................. 33

Tabela de Macros .......................................................................... 36

O IDE é um ambiente de desenvolvimento integrado que acompanha o Advanced

IDE – Ambiente de desenvolvimento integrado 5

Definindo o Padrão de Teclas de Atalho

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

IDE – Ambiente de desenvolvimento integrado 6

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

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

Definindo a Localização de Arquivos

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

Ignorando Arquivos Não Encontrados

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

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

IDE – Ambiente de desenvolvimento integrado 7

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

Definindo o Estilo do Texto

Definindo a Cor do Texto

Definindo a Cor de Fundo do Texto

Desabilitando a Diferenciação de Sintaxe

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

IDE – Ambiente de desenvolvimento integrado 8

Desabilitando a diferenciação, as cores de todo o texto serão aquelas definidas no

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

Configurações de Controle de Versão

Utilizando o Controle de Versão

IDE – Ambiente de desenvolvimento integrado 9

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

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

Linha de Comando para Reservar Arquivo

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

Linha de Comando para Cancelar Reserva

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

IDE – Ambiente de desenvolvimento integrado 10

Linha de Comando para Confirmar Arquivo

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

Linha de Comando para Adicionar Arquivo

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

Linha de Comando para Remover Arquivo

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

IDE – Ambiente de desenvolvimento integrado 11

Criando e Editando Arquivos

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

IDE – Ambiente de desenvolvimento integrado 12

Para o envio de um arquivo via e-mail o usuário deve ter instalado e

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

IDE – Ambiente de desenvolvimento integrado 13

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

Isso se deve ao fato de que o comando IF seguido de um parênteses é

Se o IDE encontrar uma linha como a descrita anteriormente simplesmente

Inserção de Texto em um Arquivo

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

Localização e Substituição de Texto

É possível localizar textos no arquivo corrente ou realizar uma pesquisa em mais de um

IDE – Ambiente de desenvolvimento integrado 14

Assim que o texto é localizado, o IDE

A pasta Localizar em Arquivos (figura

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