Aula 1/7 - Programando em Autolisp

Introdução
por R.C. Ruschel, DCC-FEC-UNICAMP, Agosto 1997

Interfaces do AutoCAD:

• Além da interação pela linha de comando e por menus o AutoCAD R13 permite:
o executar um conjunto de comandos por meio de command-scripting
o a programação pelo usuário utilizando-se:
 a linguagem de programação AutoLISP ou
 a linguagem C através do ADS (AutoCAD Developing System)
• A forma de programação depende:
o das necessidades da aplicação (desempenho, custo)
o da experiência de programação da equipe envolvida

AutoLisp:

• O AutoLisp é baseado na linguagem de programação LISP (List Processing)

o de aprendizado simples porém poderosa.
• O AutoCAD tem um interpretador de Lisp embutido, permitindo a digitação de expressões/funções
AutoLisp na linha de comando e sua interpretação automática.
• O AutoCAD inclue rotinas AutoLisp bastante úteis nos sub-diretórios sample e support.

Aplicações em AutoLisp:

• São armazenadas em arquivos ASCII com extensão .lsp.

• Devem ser carregadas para o ambiente do AutoCAD para serem executadas.
• Como carregar:
o na linha de comando
o pelo menu Tools/Applications ...
o de forma automática incluíndo-a no arquivo acad.lsp

ADS - AutoCAD Developing System:

• Ambiente de programação baseado na linguagem C.

• Aplicações desenvolvidas no ADS se comunicam com o AutoCAD via AutoLisp.
o Todas funções básicas em ADS fazem uma chamada para uma função equivalente em
AutoLisp.

ADS x AutoLisp:

• A escolha ADS x AutoLisp depende:

o da experência do programador
o do desempenho desejado para a aplicação
 aplicações em ADS são + rápidas e utilizam menos memória
o do desempenho do processo de desenvolvimento da applicação
 AutoLisp é recomendado para prototipagem e aplicações onde o custo do
desenvolvimento e manutenção é mais importante que o desempenho da aplicação.
o da portabilidade desejada para a aplicação
 Aplicações em AutoLisp são mais portáteis. Dependem apenas do AutoCAD para a
plataforma desejada.
  Aplicações em ADS dependem do AutoCAD, da versão da linguagem C e do
ambiente de desenvolvimento.

Lisp:

• A LP Lisp é:
o da mesma época que o Fortran
o diferente de outras LPs, i.e., dados e programas são tratados da mesma forma (tudo como
listas) e são colodados no mesmo espaço de memória do computador.
o interpretada, i.e.,toda vez que o programa é executado o código fonte é avaliado.
o muito utilizada na programação da área de inteligência artificial.

Lisp utiliza a notação infixa (operador seguido dos operandos):

1 + 2 ----------> (+ 1 2)
Listas - composição:

• inicia com "(", termina com ")" e é composta por átomos, que podem ser:
o um número interio: -32.768 a 32.767
o um número real: -4.932 a 4.932 onde e: -307 a 307
o uma cadeia de caracteres (string): "Ola", "Insira um ponto:"
o um símbolo: nome de função interna ou definida pelo usuário
o uma variável: um símbolo que representa um nome de dado
o um nil: valor nulo (vazio)
o um ponteiro para arquivo (file descriptor): nome de arquivo
o uma sub-rotina (subr): nome de funções internas e externas do AutoLisp
o um nome de entidade: código numérico associado ao objeto numa sessão de trabalho
o conjunto de seleção: conjunto de objetos selecionados

Listas - Exemplos:
Lista de dados:
(2.0 3.5 7.6)
("paola" (11 06 1996) 3.150 51)
Lista de programa (primeiro elemento é um nome de função ou uma subr):
(setq A 21) ;setq é uma subr, A é um símbolo (nome de variável)
(list 2 3 4) ;list é uma subr
(defun vistalatdir ()(command "vpoint" "1,0,0")) ; defun e command são
subrs
(vistalatdir) ;vistalatdir é um símbolo (nome de função)
Avaliando expressões em Lisp:

• O interpretador do Lisp é denominado avaliador.

• Toda a entrada para o Lisp é processada por meio do avaliador.
• Tudo dentro do AutoLisp em relação ao avaliador retorna um valor como resultado, i.e.:
o qdo um elemento de dado é apresentado ao avaliador, o valor atribuido ao elemento é
retornado.
o qdo um símbolo é apresentado, o valor da ligação atual do símbolo é retornado.
o qdo uma lista de programa, é apresentada, essa é executada e o valor final da execução é
retornado.

Avaliando Listas de programa:

• Se o primeiro elemento da lista for o nome de uma subr ou uma função definida, a subr ou função é
executada; o restante da lista é usado como parâmetros para a função ou subr.
• Se o primeiro elemento da lista não for uma função ou subr, obtém-se uma mensagem de erro: "bad
function" (função ruim).
Exemplos de avaliação de listas de programa:
(list 1 2 3) ;constrói uma lista de 3 números inteiros
;retorna (1 2 3)
(2.0 3.0 6.6) ;retorna erro:bad function
(setq a 1.0) ;retorna o valor 1.0 atribuído a variável a
(set 'a 1.0) ;idem mas usando o símbolo '
(set (quote a) 1.0);idem mas usando a subr quote

Obs: a subr quote é empregada para acessar o nome da referência (não o valor) de um símbolo. Portanto, o
2o. exemplo para ser processado como um lista de programa deveria ser:

(quote (2.0 3.0 6.6)) ou '(2.0 3.0 6.6)

AutoLisp na linha de comando do AutoCAD:

• É possível avaliar expressões em AutoLisp e até funções na linha de comando do AutoCAD.

• Este recurso é muito utilizado para experimentação e testes.
• Basta digitar na linha de comando a expressão ou função desejada, e.g.:
• Command: (setq A 2.0)
• 2.0
• Command: (setq B 3.0)
• 3.0
• Command: (setq C (+ A B))
• 5.0
• Command: !C
• 5.0
• Command: (setq p1 (list 1 2))
• (1 2)
• Command: (setq p2 (list 10 20))
• (10 20)
• Command: (command "line" p1 p2 "")
• line From point:
• to point:
• to point:
• Command: nil
• Command:(defun vistalatdir ()(command "vpoint" "1,0,0"))
• VISTALATDIR
• Command:(vistalatdir)
Desenvolvendo programas em AutoLisp - sem um ambiente de programação:

• Utiliza-se simultaneamente dois programas o AutoCAD e um editor de texto simples (e.g. Edit ou
NotePad do Windows).
o Entra-se no AutoCAD
o Chama-se o editor de texto utilizando o comando EDIT
o Edita-se as funções que compõem o programa num arquivo com extensão LSP (e.g.
programa1.lsp). Salva edição e sai do editor (automaticamente retornando para o AutoCAD).
o Carrega-se o arquivo no AutoCAD.
o Executa-se funções contidas no arquivo com (nome-da-função) ou nome-da-função

Arquivo acad.pgp:

• Para fazer com que o comando EDIT chame o editor de texto diferente do edit do windows é
necessário alterar uma linha do arquivo r13\com\support\acad.pgp:

Linha original:
EDIT,EDIT,0, File to edit: ,4
Nova linha:
EDIT,c:\windows\notepad, 0, File to edit: ,4
 • O subdiretório onde o notepad.exe está localizado pode variar. Portanto, verifique no seu
microcomputador o subdiretório correto.
• A mesma observação vale para a localização do arquivo acad.pgp.

Carregando programas AutoLisp no AutoCAD:

• Na linha de comando digitar (load "unidade-de-disco:\\sub-diretório\\nome-do-promaga-com-

extensão"), e.g.:

Command: (load "c:\\trab\\programa1.lsp")

• No pull-down menu Tools/Applications indicar arquivo a ser carregado procurando sua localização
com auxílio do botton File e depois carrega-lo acionando Load.

Exemplo - isomets.lsp:

• Conteúdo do arquivo isomets.lsp:

• ;;;Vista isometrica lat-dir, fundo, por-cima
• (defun c:iso1()
• (command "vpoint" "1,1,1"))
• ;;;Vista isometrica lat-esq, fundo, por-cima
• (defun c:iso2()
• (command "vpoint" "-1,1,1"))
• ;;;Vista isometrica lat-dir, frente, por-cima
• (defun c:iso3()
• (command "vpoint" "1,-1,1"))
• Carregando o arquivo isomets.lsp e executando funções:
• Command: (load "c:\\trab\\isomets.lsp")
• ISO3
• Command: iso1
• vpoint Rotate/ <0.0000 0.0000 1.0000>: 1,1,1 Regenerating drawing
• Command: nil
Exemplo - media.lsp:

• Conteúdo do arquivo media.lsp

• ;;;Programa principal
• (defun c:mediatestes()
• (setq t1(getreal "\nNota teste-1: "))
• (setq t2(getreal "\nNota teste-2: "))
• (setq nota (soma-e-divide))
• (princ "\nMedia dos testes = ")
• (princ nota) (princ))
• ;;;funcao soma-e-divide
• (defun soma-e-divide()
• (/ (+ t1 t2) 3.0))
• Carregando o arquivo media.lsp e executando função mediatestes:
• Command: (load "c:\\trab\\media.lsp")
• SOMA-E-DIVIDE
• Command: mediatestes
• Nota teste-1: 5.0
• Nota teste-2: 7.0
• Media dos testes = 6.0
• Command:
Homework:

• Ler o capítulo 1 de (Gaál, 1997) ou capítulos 1 e 2 de (Kramer&Kramer, 1995).

• Faça os seguintes exercícios propostos por (Gaál, 1997):
 1. Crie uma rotina que aplique um offset de 3 unidades numa entidade e altere em seguida o
layer ao qual ela pertence para OFFLINES. Suponha que o layer já exista.
2. Crie um bloco qualquer (interno ao desenho). A seguir, crie uma rotina que insira este bloco
rapidamente, com as escala x e y constantes e rotação 0, explodindo-o em seguida. O usuário
deverá somente informar a posição em que será inserido o bloco.

Última atualização em 13/8/1997 por RCR.