LISP Romana PDF

AutoLISP
Introducere
AutoLISP-ul este un limbaj de programare pentru AutoCAD. Acest curs
oferă cursantului posibilitatea de a-şi însuşi cunoştinţe practice de lucru în
AutoLISP prin cursuri şi texte care explică structura şi sintaxa limbajului şi
relaţia acestuia cu AutoCAD-ul. Prin exerciţii aplicative la teoria de
programare şi exemple concrete cursantul îşi completează aceste cunoştinţe.
Acest curs reprezintă o culegere de texte şi un ghid pentru un curs

AutoLISP pe o perioada de 3 zile, oferit de Autodesk, Inc. Training
Department. La exerciţiile de proiectare se adaugă lecţii suplimentare şi
discuţii la obiect. Acest curs poate fi folosit individual atunci cînd este în
combinaţie cu o dischetă ce conţine fişierele necesare pentru rezolvarea
exerciţiilor.
Acest curs este bazat pe o versiune AutoLISP ce poate fi găsită pe toate

platformele pe care este implementat AutoCAD R12.
Obiective
La sfîrşitul acestui curs, cursantul va fi capabil să înţeleagă sintaxa
AutoLISP, o varietate de funcţii standard şi procesul de evaluare Lisp.
Cursantul va putea folosi AutoLISP-ul pentru:
• Utilizarea comenzilor AutoCAD prin intermediul funcţiilor
de bază AutoLISP.
• Crearea de noi funcţii AutoLISP.
• Crearea de noi funcţii AutoCAD pe baza limbajului
AutoLISP.
• Corectarea şi modificarea entităţilor din baza de date a
AutoCAD-ului.
• Citirea şi scrierea în fişiere cu texte ASCII cu ajutorul
limbajului AutoLISP.
• Combinarea programelor de tip AutoLISP cu fişierele
AutoCAD de tip script.
50099176.doc R.2.1 9/21/2011 ATC. Iasi •1

AUTODESK, INC.
Cuprins
Acest material cuprinde subiectele prezentate mai jos. Explicarea acestor
subiecte reprezintă conţinutul principal al capitolelor de mai jos.
Introducere.....................................................................................................1
Generalităţi.....................................................................................................3
Expresii simbolice..........................................................................................7
Atomi şi liste................................................................................................13
Evaluări .......................................................................................................21
Expresii simbol AutoLISP fară comenzi AutoCAD....................................35
Tipuri de date numerice...............................................................................41
Puncte AutoCAD şi liste AutoLISP.............................................................47
Prelucrare de liste.........................................................................................57
Comenzi AutoCAD şi liste AutoLISP.........................................................71
Selecţie interactivă de puncte.......................................................................79
Funcţii..........................................................................................................87
Funcţii care acţionează ca şi comenzi AutoCAD........................................97
Fişiere de programare AutoLISP...............................................................101
Funcţia C....................................................................................................105
Teste logice şi condiţionale........................................................................113
Bucle de program.......................................................................................123
Operaţii cu şiruri........................................................................................131
Acces la entităţi..........................................................................................139
Liste asociate entităţilor.............................................................................147
Modificarea unei entităţi............................................................................155
Selectarea grafică a unei entităţi................................................................165
Tratarea erorilor.........................................................................................171
Operaţii cu fişiere.......................................................................................175
..........................................................................................................................
Seturi de selecţie........................................................................................193
Tabele şi nume de obiecte..........................................................................203
Fişiere script şi AutoLISP..........................................................................211
Accesul la entităţi simple şi la polilinii......................................................217
Accesul la entităţi simple şi la blocuri.......................................................221
•2
AUTODESK, INC. TRAINING LECTII DE BAZA AUTOLISP
Crearea entităţilor cu funcţia entmake.......................................................225

Crearea poliliniilor şi a definitiilor de bloc cu funcţia entmake ...............227
Tratarea şirurilor........................................................................................231
Tratarea entităţilor......................................................................................243
50099176.doc R.2.1 9/21/2011 •3

AUTODESK, INC.
Generalităţi despre AutoLISP

Ce este AutoLISP-ul ?
AutoLISP-ul este un dialect al limbajului de programare Lisp utilizat
pentru completarea posibilităţilor de proiectare în AutoCAD.
Lisp este un acronim pentru list processing (in alte texte, list
programming. Este un limbaj de programare superior foarte cunoscut
pentru aplicaţiile lui în domeniul sistemelor specializate, inteligenţă
artificială, programare pe bază de reguli şi AutoCAD.
Lisp este unul dintre limbajele de programare cele mai vechi. Ca şi

FORTRAN, primele implementări ale limbajului Lisp datează din anii 60.
Multe sublimbaje ale limbajului Lisp există în prezent, incluzînd Common
Lisp, Franz Lisp, Mu Lisp şi X Lisp.
Limbajul Lisp are multe caracteristici care se adresează atît profesioniştilor

cît şi amatorilor.
• AutoLISP are o sintaxă simplă, precisă. Procesul de evaluare
şi sintaxa folosită pentru crearea expresiilor Lisp sunt uşor
de învăţat.
• Este un interpretor aşa încît rezultatele obţinute din calcule
pot fi vizualizate interactiv într-o sesiune AutoCAD.
• AutoLISP interacţionează direct cu AutoCAD fără să
necesite programe de sprijin extern, cum ar fi compilatorul.
• Programele AutoLISP sînt uşor de înţeles şi modificat.
• AutoLISP-ul este capabil de iteraţie şi recursivitate.
Funcţiile pot utiliza instrucţiuni condiţionale şi de start
standard şi pot fi definite în aşa fel încît o funcţie apeleaza la
recursiune .
• AutoLISP-ul încurajează programatorul să scrie funcţii
simple,structurate şi să combine aceste funcţii cu scopul de a
crea programe complexe dar uşor de înţeles.
Pentru cei ce sînt interesaţi să lucreze cu programe AutoLISP le
recomandăm următoarele cărţi:
Common LISP: A Gentle Introduction to Symbolic Computing de David S.

Touretzky; LISP de Winston & Horn Looking at LISP de Tony Hasemer
Common LispCraft de Robert Wilensky AutoLISP Programmer's
Reference Manual.
Ce poate face AutoLISP-ul ?

AutoLISP-ul este o sculă puternică. Poate fi folosit pentru a adapta
AutoCAD-ul la orice fel de aplicaţii, făcînd astfel AutoCAD-ul mai sensibil
la modul de lucru. Multe dintre cele mai complicate aplicaţii proiectate
pentru AutoCAD folosesc pe scară largă limbajul de programare AutoLISP.
•4
AutoLISP poate crea subrutine şi macrouri puternice. Subrutinele

AutoLISP pot fi alcătuite din comenzi AutoCAD şi funcţii AutoLISP şi pot
automatiza operaţii complexe în cadrul AutoCAD-ului.
Subrutinele AutoLISP pot crea noi funcţii AutoLISP şi noi comenzi

AutoCAD care pot fi folosite în linia de comandă sau în cadrul fişierelor
script şi menu-urilor AutoLISP.
Cum încărcăm AutoLISP-ul ?

AutoLISP-ul este o componentă standard a AutoCAD-ului, portabilă pe
toate maşinile de calcul. Interpretorul AutoLISP se încarcă automat la
fiecare sesiune AutoCAD.
AutoLISP operează în cadrul editorului grafic AutoCAD. Interpretorul stă

în "umbră" în timpul unei sesiuni de interpretare grafică aşteptînd să
evalueze o expresie simbolică introdusă în linia de comandă a AutoCAD-
lui.
AutoLISP-ul este disponibil numai în cadrul editorului grafic.
Ce trebuie să ştim pentru a folosi AutoLISP-ul ?

• Cunoştinte temeinice de lucru cu AutoCAD.
Trebuie de asemenea să aveţi cunoştinţe despre:
• Fişiere script.
• Menu-uri utilizator.
În unele cazuri este mai simplu şi mai uşor să optimizaţi o secventă de
desenare cu un fişier script sau cu un menu de bază decît să folosiţi un
program AutoLISP.
Ce editor de text ar trebui folosit ?

Este nevoie de un editor de text ASCII pentru a crea fişiere program
AutoLISP pe baza acestui manual.
Fişierele de text ASCII pot fi întîlnite sub denumirea de fişiere

"programmer", "non-document" sau "unformatted".
Versiunea MS-DOS® 5.0 a apărut cu un editor de text simplu numit EDIT.

Dacă folosiţi versiunea DOS 386 a AutoCAD-ului din acest manual este
posibil să doriţi să folosiţi acest editor.
Aplicaţia NOTEPAD din Microsoft® WindowsTM este un editor de text

ASCII aşa cum este aplicaţia Text Editor din Sun Mycrosystems®
SPARCTM din Open WindowsTM.
Există o varietate de editoare de text gratuite şi care circulă liber pentru

AutoCAD şi AutoLISP în cadrul Forumului CompuServe AutoCAD (GO
50099176.doc R.2.1 9/21/2011 •5

AUTODESK, INC.
ACAD). Orice editor profesional de programare este o unealtă bună cu care

se pot scrie fişiere program AutoLISP.
Hardware pentru AutoLISP şi necesarul de memorie

Computerul dumneavoastră trebuie să aibă hardware-ul şi memoria cerută
de AutoCAD pentru a putea folosi AutoLISP-ul. Manualele AutoCAD
Interface şi Installation And Performance Guide prezintă cerinţele specifice
fiecărei platforme.
Lansarea în execuţie
Lansaţi editorul grafic AutoCAD înainte de a lansa orice altă comanda. Va
trebui să introduceţi s-expresiile AutoLISP din linia de comandă.
Vă sugerăm să lansaţi sesiunea de editare grafică ori de cîte ori utilizaţi

acest manual.
•6
Expresii simbolice
Expresiile simbolice sînt instrucţiuni de bază ale limbajului AutoLISP.
Obiective
În acest capitol veţi învăţa:
• Cum să creaţi o expresie simbolică
• Cum recunoaşte AutoCAD-ul expresiile simbolice
• Cum să folosiţi expresiile simbolice în cadrul comenzilor
AutoCAD
• Cum să aflaţi valoarea unei expresii simbolice
Instrucţiuni în AutoLISP
În principal LISP-ul procesează listele: el procesează şi evaluează listele

de obiecte. AutoLISP-ul procesează liste cunoscute ca expresii simbolice,
în cadrul AutoCAD-ului.
Listele sînt principalul mijloc de construire a expresiilor simbolice în

AutoLISP. O expresie simbolică din AutoLISP poate fi comparată cu o
propoziţie în limba engleză.
O expresie simbolică sau o s-expresie are întotdeauna o anumită valoare.

Funcţia principală a LISP-ului este să determine valoarea unei s-expresii.
De fiecare dată cînd lansăm o s-expresie interpretorului LISP (de obicei sub
forma unei liste, el va evalua acea expresie şi ne va da rezultatul. Acest
rezultat se numeşte valoarea expresiei.
O expresie simbolică sau o s-expresie reprezintă pur şi simplu o

instrucţiune în LISP.
S-expresiile în AutoLISP sînt construite prin încadrarea unei secvenţe

valide de caractere între paranteze. Caracterul paranteză stînga sau ( se
numeşte paranteză deschisă şi caracterul paranteză dreapta sau ) se numeşte
paranteză închisă. În mod obişnuit aceste caractere sînt denumite deschis şi
închis.
Parantezele dintr-o s-expresie trebuie să fie echilibrate. Oricărei paranteze

deschise trebuie sa-i corespundă una închisă.
Obs. Cea mai frecventă greşeală în AutoLISP este neînchiderea

parantezelor. Editoarele de text profesionale au această caracteristică de a
găsi parantezele corespondente cu un minim de efort.
50099176.doc R.2.1 9/21/2011 •7

AUTODESK, INC.
Cum recunoaşte AutoCAD-ul o s-expresie

AutoCAD-ul recunoaşte o s-expresie AutoLISP printr-o paranteză deschisă.
Dacă găseşte o astfel de paranteză, AutoCAD-ul transferă intrarea
utilizatorului către interpretorul AutoLISP şi aşteaptă rezultatul. AutoCAD
afişează rezultatul s-expresiei.
Command: (+ 1 2)
(+ 1 2)
AutoCAD AutoLISP
3
3
Command:
Figura 1. Diagrama de comunicatie dintre AutoCAD si AutoLISP
Exemplu
Pe linia de comandă a AutoCAD-ului înscrieţi s-expresiile în coloana din
stînga a tabelului care urmează. Comparaţi rezultatele date de AutoCAD cu
rezultatele care se află în coloana din dreapta a tabelului.
Command:(+12)
3
Command:
S-expresii Rezultate
(+ 1 2) 3
(- 2 1) 1
(/ 4 2) 2
(* 4 2) 8
Tabelul 1. Rezultatele expresiilor simbolice
S-expresiile şi comenzile AutoCAD

S-expresiile pot fi introduse ca intrare la comenzi AutoCAD. AutoCAD-ul
va recunoaşte parantezele deschise, va transfera intrarea interpretorului
AutoLISP şi va aştepta rezultatul.
•8
AutoCAD-ul tipăreşte rezultatul intrării s-expresiilor pe linia de comandă.

AutoCAD-ul foloseşte rezultatul unei s-expresii introduse, drept intrare la
comanda curentă.
Command:array
last
polar
5,5
(/ 360 15)
(/ 360 15)
AutoCAD 24
AutoLISP
Command:array
last
polar
5,5
20
Figura 2. Cum AutoCAD-ul si AutoLISP-ul comunica intr-o comanda AutoCAD
50099176.doc R.2.1 9/21/2011 •9

AUTODESK, INC.
Exemplu
În comanda "polar array" care urmează, împărţind 360 de grade la 15 se
determină numărul de obiecte de creat, de exemplu se crează un obiect la
fiecare 15 grade de rotaţie.
Introduceţi comenzile.
Command: line
From point: 5,5
To point: 5,8
To point: Enter
Command: array
Select objects: last
1 found
Select objects: Enter
Rectangular or Polar array (R/P): p
Center point of array: 5,5
Number of items: (/ 360 15)
Angle to fill (+=ccw, -=cw) <360>:Enter
Rotate objects as they are copied? <Y>Enter
Figura 3. Expresia (/360 15) genereaza un array de 24 linii
Caracterul semnul exclamării

AutoCAD-ul analizează intrarea utilizatorului în linia de comandă cautînd
un alt caracter AutoLISP asociat: semnul exclamarii sau !. Acest caracter
este denumit în mod frecvent bang. Dacă semnul exclamarii este primul
caracter, AutoCAD-ul transferă intrarea către interpretorul AutoLISP şi
aşteaptă rezultatul.
Orice s-expresie validă poate urma după semnul exclamării.

Command: !(+ 12)
•10
Caracterul "bang" este deseori folosit pentru a cere AutoLISP-ului valoarea

unui simbol. În acest caz, simbolul nu trebuie să se afle între paranteze.
Command: !pi
Exemplu
pieste un simbol predefinit în AutoLISP. Extrageţi valoarea simbolului pi
pe linia de comandă AutoCAD.
Command: !pi
3.14159
Command:
Recapitulare
• S-expresiile sînt expresii AutoLISP valide aflate între

paranteze.
• AutoCAD-ul caută două caractere speciale: parantezele
deschise sau open şi semnul exclamării sau bang.
• Open indică AutoCAD-ului că urmează o s-expresie.
• Bang indică AutoCAD-ului că urmează o s-expresie sau un
simbol.
• S-expresiile şi caracterul bang pot fi folosite în linia de
comandă sau în cadrul comenzilor AutoCAD.
• Caracterul bang poate precede S-expresiile sau simbolurile.
50099176.doc R.2.1 9/21/2011 •11

AUTODESK, INC.
Această pagină a fost lăsată liberă în mod intenţionat.
•12
Atomi şi liste
Există două mari categorii de tipuri de date în AutoLISP: atomi şi liste.
Atomii sînt obiecte simple. Listele sînt obiecte complexe. Acest capitol
defineşte atomii şi listele.
Obiective
În acest capitol se va studia:

• Diferenţa dintre atomi şi liste
• Componentele unei liste
• Cum să recunoaştem un raport de erori AutoLISP
• Natura obiectului AutoLISP nil
Atomi
Un atom este cel mai simplu tip de date din Lisp. Un atom poate fi un
număr întreg
1
un număr real
4587.993401
un şir de caractere
''A String Of Pearls''
o funcţie AutoLISP predefinită
+
un simbol
XYZ
sau oricare alt tip de obiecte existente în tabelul 3-1.
50099176.doc R.2.1 9/21/2011 •13

AUTODESK, INC.
Tipuri de atomi Exemple Tip de data

AutoLISP
simbol pi,x,mid_pt SYM
sir "Hello, world." STR
intreg 1,32767,-32768 INT
numar real 1.0,45.678,-876543.21 REAL
descriptor de fisier <File: #a82> FILE
nume entitate AutoCAD <Entity name: 6000001a> ENAME
set de selectie AutoCAD <Selection set: 1> PICKSET
subr (functie interna) <Subr: #1e32> SUBR
subr externa (Functia ADS) <Ext. Subr: 1 #3a970498> EXSUBR
Tabelul 2. Exemple de atomi din AutoLISP si tipul de date al acestora
Există o regulă simplă pentru a afla dacă un obiect este un atom sau o listă.
Dacă obiectul nu se află între paranteze atunci este un atom; dacă da, atunci
este o listă.
Liste
Listele sînt s- expresii complexe formate din atomi şi/sau alte liste. Listele
necesită sintaxe simple dar riguroase.
• O listă trebuie să se afle între paranteze.
• Pentru orice listă care poate fi evaluată, primul termen din
cadrul listei respective trebuie să fie o funcţie.
• Obiectele din cadrul listei trebuie separate prin cel puţin un
spaţiu.
Iată cîteva exemple de liste. Observaţi că fiecare obiect este separat printr-
un spaţiu de celelalte obiecte din cadrul listei.
(+ 1 2 )
(- 4 2 )
(x y z )
(1.0 1.0 0.0 )
Despre evaluarea listelor vom vorbi puţin mai tîrziu.
Elementele unei liste

Atomii şi listele pot fi combinate sub formă de liste. În următoarele patru
exemple am introdus trei atomi într-o listă. Fiecare atom este un element al
listei.
Exemplu
Această listă are trei elemente: numerele reale 1.0, 1.0 şi 0.0
•14
(1.0 1.0 0.0)

Această listă are trei elemente: funcţia de adunare + (funcţie internă), nr.
întreg 1 şi nr. întreg 3.
(+ 1 3)
Această listă are trei elemente: funcţia de adunare +, nr. întreg 1 şi listă
(+ 2 3)
(+ 1 (+ 2 3 ))
Figura 4. Lista de trei elemente: doi atomi si o lista
Exemplu
Această listă are trei elemente: funcţia de adunare +, lista (+ 1(+ 2 3)) şi
lista (+ 4 5).
(+ (+ 1 (+ 2 3)) (+ 4 5))
Figura 5. Lista de trei elemente: un atom si doua liste.
Ceea ce este încadrat între paranteze reprezintă o listă.
O listă se compune dintr-o paranteză de deschidere urmată de zero sau

de mai multe obiecte care pot fi atomi sau liste după care urmează o
paranteză de închidere.
50099176.doc R.2.1 9/21/2011 •15

AUTODESK, INC.
Condiţii de eroare
Cînd introduceţi s-expresii în linia de comandă AutoCAD, interpretorul
AutoLISP vă va spune dacă aţi introdus o expresie neechilibrată. O
expresie neechilibrată are mai multe paranteze deschise decît închise.
Iată o expresie neechilibrată. Îi lipseşte o paranteză închisă.

Command: (+ 1 (+ 2 3)
1>
AutoLISP-ul semnalizează o expresie neechilibrată printr-un mesaj special.
n>
unde n este numărul de paranteze închise care lipsesc.
Sînt două modalităţi de rezolvare în cazul condiţiilor de eroare: completaţi

numărul corect de paranteze închise sau apăsaţi Ctrl-C pentru a anula
expresia şi a ne reîntoarce în linia de comandă.
Notă Este de asemenea posibil să vedeţi acest mesaj cînd un şir este
neechilibrat. Un şir neechilibrat are ghilimele duble la un capăt şi simple la
celălalt.
Particularităţile obiectului nil

Toate obiectele din AutoLISP sînt atomi sau liste. Atomii şi listele se
exclud mutual. Un atom nu este niciodată listă şi o listă nu este niciodată
atom.
Excepţia o face obiectul nil.
Obiectul nil este "lista goală". Prin convenţie nil este şi atom şi listă. nil
poate fi exprimat în două moduri: 0 sau nil;.
nil este echivalentul AutoLISP pentru fals. Multe funcţii în AutoLISP

testează dacă o condiţie este adevarată sau falsă, de exemplu dacă valoarea
unui număr este mai mare decît 0. De cîte ori un test de condiţie este fals,
AutoLISP-ul va returna obiectul nil ca fiind valoarea testului.
nil este singurul obiect din AutoLISP corespunzator lui "fals"; de aceea
orice altă valoare returnată de un test de condiţie trebuie să corespundă lui
"adevărat".
•16
Recapitulare
• Cele două mari clase de obiecte din AutoLISP sînt atomii şi
listele.
• Există cîteva tipuri diferite de atomi.
• Atomii sînt obiecte care nu sînt încadrate între paranteze.
• Listele sînt întodeauna încadrate între paranteze
• Obiectele conţinute într-o listă constituie elementele unei
liste
• Elementele unei liste pot fi atomi sau liste
• Elementele unei liste sînt separate între ele de cel puţin un
spaţiu
• AutoLISP detectează expresiile neechilibrate
• nil este şi atom şi listă
• nil este lista goală
• nil este returnat de testele de condiţie pentru a indica "fals"
50099176.doc R.2.1 9/21/2011 •17

AUTODESK, INC.
EXERCITIUL 1: ATOMI SI LISTE
În acest exerciţiu veţi:

• Recapitula ce aţi înţeles despre atomi şi liste
• Determina dacă un obiect este atom sau listă
• Folosi AutoLISP pentru a afla valoarea diferitelor obiecte
Partea I
1. Determinaţi dacă obiectul este atom sau listă.
2. Completaţi rezultatul evaluării în căsuţa corespunzatoare.
Tabelul 3. Determinarea naturii obiectului
Obiecte Atomi Liste
73.5
"0,0"
(1.0 2.0 3.0)
"String"
("String")
()
•18
Partea a II-a
1. Găsiţi valoarea acestui atom în linia de comandă AutoCAD
2. Tipăriţi "!" urmat de un atom
3. Scrieţi răspunsul în coloana din dreapta:
Exemplu
Command: !4.5
Atomi Valori
4.5
"text"
17
setq
xyz
nil
Tabelul 4. Determinarea valorii atomului
Partea a III-a
1. Determinaţi numărul de elemente conţinut de fiecare listă.
2. Scrieţi răspunsul în coloana din dreapta.
Lista Numar de elemente
(1.0 2.0 3.0)
(+ 1 2)
(+ 1 (+ 2 3))
(+ 1 2 (+ 3 4) 5)
(+ 1 (+ 2 (+ 3 4)) 5)
()
Tabelul 5. Determinarea numarului de elemente din lista
50099176.doc R.2.1 9/21/2011 •19

AUTODESK, INC.
Această pagină este lăsată liberă în mod intenţionat.
•20
Evaluarea
Evaluarea este procesul prin care AutoLISP-ul determină valoarea unui
obiect. Evaluarea se aplică şi la atomi şi la liste.
Fiecare obiect din AutoLISP are o valoare. Prin evaluarea unui obiect,
AutoLISP-ul determină valoarea acestuia.
Obiective
În acest capitol veţi studia:
• Procesul evaluării
• Cum returnează AutoLISP-ul o valoare
• Cum evaluează AutoLISP-ul atomi şi liste
• Cum se folosesc funcţiile aritmetice de bază în AutoLISP
• Cum se anulează evaluarea unui obiect
• Cum leagă AutoLISP-ul o valoare de o variabilă
Returnarea valorii
Cînd transmiteţi un obiect spre evaluare AutoLISP-ului, acesta îi determină
valoarea şi o returnează. Într-un exemplu anterior, folosind caracterul "!",
AutoLISP-ul a evaluat obiectul pi şi a returnat valoarea AutoCAD-ului.
AutoCAD-ul a tipărit valoarea returnată în zona liniei de comandă.
Command: !pi
3.14159 <- valoare returnata
Într-un exemplu anterior folosind comanda ARRAY, AutoLISP-ul a evaluat

lista (/ 360 15) şi a returnat valoarea 24 AutoCAD-ului. AutoCAD-ul a
folosit valoarea returnată la intrare în comanda ARRAY.
Number of items: (/ 360 15)
50099176.doc R.2.1 9/21/2011 •21

AUTODESK, INC.
Figura 6. AutoLISP returneaza valoarea expresiei in linia de comanda AutoCAD.
Evaluarea atomilor
Atomii sînt obiecte simple şi sînt evaluaţi folosind reguli simple potrivit
tipului lor de date. Majoritatea atomilor se autoevaluează. Numerele întregi,
numerele reale, şirurile, se autoevaluează la valoarea pe care o au. Modul în
care se evaluează un simbol nu poate fi discutat decît după ce învăţam cum
se leagă o listă.
Tip de atom Exemplu Regula de Valoare
evaluare
Intreg 1 Valoarea este 1

nr. insusi
Real 4.5 Valoarea este 4.5

nr. insusi
Sir "text" Valoarea este "text"

nr. insusi
Simbol x Legarea curenta Ultima asignare

Tabelul 6. Reguli de evaluare a atomilor
Evaluarea listelor
Evaluarea unei liste poate fi facută într-unul din aceste două moduri: se ia
lista ca atare sau se evaluează. În funcţie de natura listei, metodele dau
rezultate diferite,de exemplu, valori diferite.
•22
Dacă o listă este luată ca atare, atunci valoarea ei este lista însăşi. Acest
lucru va fi mai clar după explicarea funcţiei quote mai tîrziu în această
lecţie.
Dacă o listă urmează a fi evaluată de AutoLISP, atunci trebuie respectată

regula sintactică.
• Pentru orice listă care poate fi evaluată, primul element din
cadrul listei trebuie să fie o funcţie.
Listele sînt evaluate potrivit instrucţiunilor referitoare la primul element al
listei. Dacă primul element este numele unei subrutine interne AutoLISP
sau funcţii, restul de elemente ale listei sînt transferate funcţiei ca
argumente formale şi sînt evaluate de către funcţie.
Funcţiile sînt fie funcţii interne AutoLISP, fie subrutine, aşa cum sînt cele
prezentate în capitolul 4 al manualului AutoLISP Programmer’s Reference
Manual, fie funcţii externe definite de utilizator sau exsubr definite de
aplicaţii ADS, sau funcţii AutoLISP definite de utilizator.
Cum evaluează AutoLISP-ul o listă

Vom folosi o listă simplă pentru a ilustra procesul de evaluare a unei liste.
Aceasta este o listă formată din trei elemente: funcţia + numerele întregi 1
şi 2.
(+ 1 2)
Etapa I: Analiza primului element

Primul element al unei liste pe care AutoLISP-ul o poate evalua trebuie
să fie o funcţie.
AutoLISP-ul verifică primul element al listei unde se aşteaptă să găsească o

funcţie. Dacă primul element al listei pe care AutoLISP-ul încearcă să o
evalueze nu este o funcţie, acesta va da naştere unei erori.
Elementele care urmează după o funcţie în cadrul unei liste sînt

argumentele funcţiei; adică ele reprezintă datele asupra cărora funcţia
operează.
Etapa a II-a: Evaluarea funcţiei

AutoLISP evaluează funcţia. O funcţie evaluează un set de instrucţiuni care
sugerează AutoCAD-ului cum să acţioneze mai departe.
Funcţia + evaluează un set de instrucţiuni pentru AutoLISP. Dacă ar fi să

exprimăm în cuvinte aceste instrucţiuni, am putea spune: găsiţi valoarea
fiecărui element din această listă. Care sînt argumentele funcţiei? Puneţi
toate valorile la un loc şi returnaţi rezultatul ca fiind valoarea întregii liste.
50099176.doc R.2.1 9/21/2011 •23

AUTODESK, INC.
Etapa a III-a: Continuarea instrucţiunilor funcţiei

(.. 1 ..)
Urmărind instrucţiunile din funcţia +, AutoLISP-ul găseşte valoarea

următorului element din listă: numărul întreg 1. Numerele întregi se
evaluează pe sine. Astfel AutoLISP-ul memorează valoarea 1 în stiva
programului, de exemplu o introduce într-o locaţie de memorie temporară.
(.. .. 2)
Conţinînd cu instrucţiunile de la funcţia +, AutoLISP-ul verifică dacă mai

sînt şi alte elemente în listă. Mai există un element: numărul întreg 2.
AutoLISP-ul îi pastrează valoarea în stivă.
Etapa a IV-a: Returnarea valorii funcţiei

Nemaigăsind alte elemente în listă, de exemplu argumente la funcţie,
AutoLISP-ul îşi termină instrucţiunile de la funcţia + prin adăugarea
valorilor argumentelor 1 şi 2 şi prin returnarea numărului întreg 3 ca fiind
valoarea listei.
Command: (+ 1 2)
3
Command:
Un exemplu mai complex

AutoLISP evaluează elementele dintr-o listă de la stînga la dreapta.
În multe cazuri ar fi convenabil pentru noi să urmăm procesul de evaluare

din interior spre exterior decît de la dreapta spre stînga. Rezultatele sînt de
obicei aceleaşi şi adesea este mai uşor pentru noi să citim coduri AutoLISP
cu un grad de imbricare mai mare, lucrînd din interior în exterior. Dar nu
acesta este modul în care AutoLISP-ul evaluează o listă. Întotdeauna
lucrează de la stînga la dreapta.
Consideraţi această listă formată din trei elemente: (+ 1 (+ 2 3))

• Funcţia +
• Atomul 1
• Lista (+ 2 3)
•24
Figura 7. Evaluarea unei liste complexe
AutoLISP-ul evaluează această listă folosind exact aceeaşi metodă ca în

exemplul anterior.
(+ ..
AutoLISP-ul caută primul element al listei aşteptînd să găsească o funcţie şi

apoi o evaluează. Funcţia returnează valoarea ei ca un set de instrucţiuni
pentru AutoLISP.
(.. 1 ..
Urmînd instrucţiunile funcţiei +, AutoLISP-ul află valoarea celui de al

doilea element al listei, de ex. primul argument la funcţia +: atomul 1. Apoi
îi memorează valoarea şi continuă.
(.. .. (+ 2 3) ..
AutoLISP-ul găseşte valoarea celui de al treilea element al listei, cum ar fi

al doilea argument la funcţia +.
Al treilea element este el însuşi o listă. Cum află AutoLISP-ul valoarea

unei liste? Prin evaluare. Cum evaluează AutoLISP-ul o listă?
(.. .. (+ ..
Mai întîi evaluează funcţia + şi îi primeşte instrucţiunile

( .. .. (.. 2 ..
(.. .. (.. .. 3) ..
Apoi găseşte valoarea argumentelor 2 şi 3. Terminîndu-i instrucţiunile de la

funcţia + din cadrul listei (+ 2 3), AutoLISP-ul adaugă valorile şi returnează
rezultatul care în acest caz este nr. întreg 5.
Nemaigăsind alte elemente în listă, AutoLISP-ul termină instrucţiunile de

la funcţia + în lista principală prin adăugarea valorii celor două elemente la
un loc şi returnînd valoarea 6.
50099176.doc R.2.1 9/21/2011 •25

AUTODESK, INC.
Funcţii aritmetice
AutoLISP-ul include funcţii interne pentru operaţii aritmetice ca: adunarea,
scăderea, înmulţirea şi împărţirea
• + funcţia de adunare
• - funcţia de scădere
• * funcţia de înmulţire
• / funcţia de împărţire
•26
Exemple
Expresii aritmetice S-expresii AutoLISP
1+2 (+ 1 2)
2-1 (- 2 1)
2*4 (* 2 4)
4/2 (/ 4 2)
Tabelul 7. Aritmetica AutoLISP
Ordinea argumentelor în funcţiile de adunare şi de înmulţire nu are

importanţă. Este însă importantă pentru scădere şi împărţire.
Fig. 8 Ordinea argumentelor in functia de scadere
În cazul scăderii, valoarea celui de al doilea argument este scăzută din

valoarea primului argument şi rezultatul returnat este valoarea listei.
Fig. 9 Ordinea argumentelor in functia de impartire
În cazul împărţirii, valoarea celui de al doilea argument este divizorul

valorii primului argument.
Iată cîteva exemple complexe.
50099176.doc R.2.1 9/21/2011 •27

AUTODESK, INC.
Exemple
Expresii aritmetice S-expresii AutoLISP
1 + (2 - 3) (+ 1 (- 2 3))
(4 + 2) - 1 (- (+ 4 2) 1)
4*4/2 (/ (* 4 4) 2)
4/2*3 (* 3 (/ 4 2))
Tabelul 8. Exemple complexe de expresii aritmetice
Recapitulare
• AutoLISP-ul determină valoarea unui obiect prin evaluare.
• AutoLISP-ul returnează valoarea fiecărui obiect pe care il
evaluează.
• Majoritatea atomilor se evaluează pe sine.
• Simbolurile se evaluează prin legare sau atribuire.
• Listele sînt evaluate printr-un proces standard.
• Primul element al oricarei liste ce poate fi evaluată trebuie
să fie o funcţie.
• AutoLISP-ul are funcţii standard pentru operaţii aritmetice.
•28
EXERCITIUL 2: LISTE SI ARITMETICA LISTELOR

• Consolida cunoştinţele despre procesul de evaluare
• Începe scrierea expresiilor AutoLISP folosind listele
• Transforma expresiile aritmetice în expresii AutoLISP
• Transforma expresiile AutoLISP în expresii aritmetice
Partea I
1. Folosiţi funcţia +, -, /, şi *.
2. Transformaţi expresiile aritmetice în expresii AutoLISP.
3. Scrieţi răspunsurile în coloana din dreapta.
Exemplu
Expresia în notaţia aritmetică standard:
1+2
Expresia în AutoLISP:
(+12)
Expresii aritmetice S-expresii
3 + 10 + 5
20 * 15
16 - 10
15 / 3
5 + (10 * 2)
(5 + 10) * 2
Tabelul 9. Traducerea expresiilor aritmetice
50099176.doc R.2.1 9/21/2011 •29

AUTODESK, INC.
Partea a II-a
1. Transformaţi s-expresiile în expresii aritmetice
2. Scrieţi răspunsurile în coloana din dreapta
Exemplu
Expresia în notaţia aritmetică standard
(2 * 5) / (7 - 2)
Expresia în AutoLISP
(/ (* 2 5) (- 7 2))
s-expresii expresii aritmerice
(+ 2 (+ 5 4) (- 4 2))
(- 5 (+ 4 (- 3 2)))
(/ 8 (- (/ 6 2) 1))
(* 2 (/ (+ 2 4) 3))
(- 5 (/ 6 (+ 1 2)))
(+ (/ (* 2 3) (- 4 2)) 1)
Tabelul 10. Traducerea expresiilor AutoLISP
•30
Liste neevaluate
Valoarea unei liste poate fi determinată în unul din aceste două moduri: se
evaluează lista sau se consideră lista ca atare.
Funcţia AutoLISP quote este folosită pentru a returna o listă sau un atom
neevaluat, adică la valoarea ca listă.
Folosiţi quote ca fiind primul element într-o listă şi adăugaţi un singur

argument. Valoarea listei va fi valoarea neevaluată a celui de al doilea
element al listei, adică argumentul la quote.
Exemplu
Această expresie returnează lista (1.0 2.0 3.0) neevaluată.
Command: (quote (1.0 2.0 3.0))
(1.0 2.0 3.0)
Ce s-ar întîmpla dacă AutoLISP-ului i s-ar cere să evalueze lista?
De ce?
Command: (1.0 2.0 3.0)
?
Operaţia de legare a două obiecte

Legarea este procesul prin care o valoare este atribuită unui simbol definit
de utilizator sau unei variabile. În AutoLISP, spunem că la un simbol sau la
o variabilă se leagă o valoare. Aceasta înseamnă în limbajul BASIC că o
valoare este egală de o variabilă sau că o valoare este atribuită unei
variabile.
Funcţia AutoLISP setq se foloseşte pentru a lega un simbol sau o variabilă

de o valoare.
Exemplu
Această expresie leagă simbolul x de valoarea 4.5.
Command: (setq x 4.5)
4.5
Command: !x
4.5
50099176.doc R.2.1 9/21/2011 •31

AUTODESK, INC.
În BASIC, aceeaşi operaţie ar putea fi exprimată astfel:
LET x = 4.5
Cum funcţionează funcţia setq

Valoarea funcţiei setq este un set de instrucţiuni pentru AutoLISP.
Aceste instrucţiuni ar putea fi exprimate astfel: Luaţi primul argument ca

atare. Nu-l evaluaţi. Găsiţi valoarea celui de al doilea argument. Legaţi
primul argument de valoarea celui de al doilea argument. Returnaţi
valoarea legării ca fiind valoarea listei.
Exemplu
Notaţi returnarea valorii acestei expresii. Valoarea listei este valoarea
legăturii stabilite pentru simbolul x de către funcţia setq.
4.5
Recapitulare
• Funcţia quote suprimă procesul de evaluare.
• Legarea este procesul de atribuire a unei valori la o
variabilă.
• Functia setq este folosită pentru a lega o variabilă de o
valoare.
•32
EXERCITIUL 3: EVALUAREA LISTELOR SI LEGAREA VARIABILELOR

• Consolida cunoştinţele despre procesul de evaluare
• Determina dacă o listă poate fi evaluată fără erori
• Consolida cunoştinţele despre procesul de legare
• Folosi funcţia setq pentru a lega variabile de valori, adică
veţi atribui valori variabilelor
Partea I
1. Determinaţi dacă o listă poate fi evaluată sau trebuie considerată
ca atare.
2. Puneţi un semn în coloana corespunzătoare
Tabelul 11. Determinarea situatiei in care o lista poate fi evaluata
s-expresii Evaluari? Numai fata
valorii?
(+ 1 2)
(+ 1 (+ 2 3))
(1.0 2.0 3.0)
(quote (1.0 2.0

3.0))
(setq x 4.5)
(setq y (1.0 2.0

3.0))
(y (1 2))
50099176.doc R.2.1 9/21/2011 •33

AUTODESK, INC.
Partea a II-a
1. Legaţi variabila x de valorile din tabel

2. Folosiţi funcţia setq şi funcţia quote dacă este necesar
3. Verificaţi valoarea variabilei folosind "bang" pentru a-i afla
legarea curentă.
Exemplu
Command: (setq x 1)
1
Command: !x
1
Command:(setq x (+ 1 2 3))
6
Command: !x
6
Command: (setq x (quote (4 (+ 5 6)))

(4 (+ 5 6))
Command:!x
(4 (+ 5 6))
Valoare pentru
x
4.5
"text"
(1.0 2.0 3.0)
(+ 1 2 3)
(1 (+ 2 3))
Tabelul 12. Legarea lui x unor valori diferite
•34
50099176.doc R.2.1 9/21/2011 •35

AUTODESK, INC.
S-expresii AutoLISP în cadrul comenzilor AutoCAD

S-expresiile AutoLISP pot fi folosite în cadrul comenzilor AutoCAD.
Obiective
• Cum să folosiţi AutoLISP-ul în cadrul comenzilor AutoCAD
• Cum să returnaţi o valoare din AutoLISP către o comandă
AutoCAD
Returnarea unei valori în linia de comandă

Valoarea unei expresii AutoLISP este trecută din AutoLISP în AutoCAD
ca răspuns la linia AutoCAD în acţiune.
Dacă linia de comandă este în acţiune, valoarea unei expresii este pur şi
simplu tiparită în zona liniei de comandă.
Command: (setq x (+ 4 6))
10
Command: !x
10
Această expresie returnează valoarea divizării rădăcinii pătrate numărului
50 prin numărul real 9.
Command: (/ (sqrt 50.0) 9.0)
0.78567
Această expresie returnează valoarea multiplicării rezultatului obţinut prin
adunarea lui 2.5 cu 6.3 de 24.0.
Command: (* (+ 2.5 6.3) 24.0)
211.2
Returnarea unei valori la o comandă AutoCAD

Dacă o comandă AutoCAD este în acţiune, atunci evaluarea unei expresii
AutoLISP returnează valoarea expresiei în AutoCAD. Valoarea devine
răspunsul la linia curentă a comenzii AutoCAD.
În acest exemplu, comanda ARRAY recepţionează ca număr de repetiţii ale

funcţiei, rezultatul unei expresii AutoLISP pentru care 6.0 se divide la 0.35;
cu alte cuvinte, nu ştim dinainte cîte repetiţii cuprinde unitatea 0.35 la o
distantă de 6.0 unitaţi, deci rugăm AutoLISP-ul să calculeze valoarea
pentru noi şi să returneze răspunsul AutoCAD-ului.Deoarece comanda din
ARRAY acceptă numai numere întregi şi nu numere reale, vom folosi
funcţia AutoLISP fix pentru a rotunji cel mai apropiat număr întreg.
•36
Exemplu
Începeţi un desen nou.
Tipăriţi comenzile şi expresiile care urmează.
Command: (/ 6.0 0.35)

17.1429
Command: (fix 17.1429)
17
Command: (fix (/ 6.0 0.35))
17
Command: line
From point: 1,1
To point: 5,5
To point: Enter
Command: array
Select objects: I
Rectangular or Polar array (R/P): r
Number of rows (-) <1>: 1
Number of columns (III) <1>: (fix (/ 6.0 0.35))
Distance between columns: 0.35
AutoCAD crează 17 elemente în array.
Trebuie avut în vedere faptul că o expresie AutoLISP a fost folosită

interactiv, în mijlocul unei comenzi AutoCAD, pentru a calcula o valoare
(în acest caz un număr întreg) care ulterior este dată automat comenzii în
acel punct special la secvenţa de cerere a comenzii.
50099176.doc R.2.1 9/21/2011 •37

AUTODESK, INC.
În exemplul urmator, AutoLISP-ul calculează mărimea razei unei racordări.
Exemplu
Tipăriţi expresiile şi comenzile care urmează.
Mărimea razei unei racordări este stabilită la 2.24.

Command: line
From point: 1,1
To point: 5,5
To point: Enter
Command: line
From point: 10,1
To point: 6,5
To point: Enter
Command: fillet
Polyline/Radius/<Select two lines>: r
Enter fillet radius <1.0>: (/ 28.0 12.5)
Command: fillet
Polyline/Radius/<Select two lines>: pick first line
Select second object: pick second line
Figura 10. Doua linii cu o racordare la o raza de (/28.0 12.5) sau 2.24
Recapitulare
• S-expresiile pot fi folosite ca răspunsuri la cererile de
comandă AutoCAD.
• AutoLISP returnează valoarea unei s-expresii folosite în
cadrul unei comenzi AutoCAD la cererea comenzii.
•38
EXERCITIUL 4: EXPRESII AUTOLISP IN CADRUL COMENZILOR AUTOCAD

• Folosi funcţii aritmetice şi funcţia setq pentru a crea valori şi
legături simbol
• Folosi valorile şi simbolurile ca răspunsuri la cererile de
comandă AutoCAD
Instrucţiuni
1. Începeţi un desen nou.
2. Desenaţi un arc cu un unghi inclus de 1 radian.
3. Desenaţi două cercuri concentrice: unul cu o rază de două treimi pi
şi unul cu o rază la jumătate din această valoare.
4. Amplasaţi arcul în jurul centrului cercurilor.
5. Fixaţi cîte o copie la fiecare 15 grade de rotaţie.
Command: arc
Center/<Start point>: 5,5
Center/End/<Second point>: c
Center: 3,5
Angle/Length of chord/<End point>: a
Included angle: (/ 180 pi)
Command: (setq x (* pi (/ 2.0 3.0)))
2.0944
Command: circle
3P/2P/TTR/<Center point>: 5,5
Diameter/<Radius>: !x
Command: circle
Diameter/<Radius>: (/ x 2)
50099176.doc R.2.1 9/21/2011 •39

AUTODESK, INC.
Command: (setq x (/ 360 15))

24
Command: array
Select objects: pick the arc
1 found
Rectangular or Polar array (R/P): p
Number of items: !x
Rotate objects as they are copied? <Y>Enter
Figura 11. Array completat
•40
50099176.doc R.2.1 9/21/2011 •41

AUTODESK, INC.
Tipuri de date numerice

AutoLISP-ul are două tipuri de date numerice: numere întregi şi numere
reale. Funcţia type returnează tipurile de date ale unui obiect.
Obiective
• Diferenţele dintre cele două tipuri de date numerice
• Cum să determinaţi tipul de date al unui obiect
Determinarea tipului de date ale unui obiect

Funcţia AutoLISP type se foloseşte pentru a determina tipul de date al unui
obiect. type cere un argument şi returnează un simbol care indică tipul de
date al argumentului.
De exemplu, această expresie returnează tipul de date al numărului real 1.0

Command: (type 1.0)
REAL
Numere reale
AutoLISP-ul reprezintă numerele reale în virgulă mobilă, dublă precizie cu
cel puţin 14 zecimale. Nu există tipuri de date care să reprezinte numere
cu simplă precizie în AutoLISP. Toate numerele reale sînt cu dublă precizie
şi ele sînt reprezentate în AutoLISP în aceeaşi manieră ca în AutoCAD.
Numerele reale sînt numere introduse cu punct zecimal, de exemplu 4.5 sau
123.456.
4.5
Pentru valori cuprinse între 1.0 şi -1.0, zero trebuie să preceadă punctul
zecimal, de exemplu, 0.45 sau 0.123 sau -0.876.
0.123
Precizia afişării si precizia internă

Precizia implicită a afişării unui număr real în AutoLISP este de 5
zecimale. Reprezentarea internă este întotdeauna menţinută cu cel puţin 14
zecimale semnificative de precizie.
•42
Dacă este necesară afişarea sau tipărirea valorii unui număr real cu o
precizie mai mare decît precizia de afişare a AutoLISP-ului, numărul real
poate fi transformat într-un şir cu ajutorul funcţiei AutoLISP rtos şi apoi
afişat sau tipărit cu precizia de afişare dorită.
rtos cere pînă la 3 argumente: un număr real, un număr întreg care

reprezintă unul dintre sistemele de unitaţi AutoCAD şi numărul de zecimale
pentru şirul care va fi returnat.
Exemplu
Introduceţi expresiile care urmează.
Legaţi simbolul x de numărul real 4.5

4.5
Verificaţi-i valoarea şi tipul de date
Command: !x
4.5
Command: (type x)
Folosiţi funcţia rtos pentru a vizualiza valoarea lui x ca număr zecimal cu o
precizie de 8 zecimale.
Command: (rtos x 2 8)
"4.50000000"
Numere întregi
Numerele întregi sînt numere introduse fără punct zecimal. Numerele
întregi în AutoLISP sînt numere întregi cu semn pe 32 biţi cuprinse între
2.147.483.648 şi +2.147.483.647. Deşi AutoLISP-ul foloseşte valori de 32
biţi, cele transferate între AutoLISP şi AutoCAD sînt limitate la valori de
16 biţi, de exemplu nu se poate transfera o valoare mai mică de -32.768 sau
mai mare de +32.767 în AutoCAD. Dacă folosiţi o valoare care depăşeste
aceste limite, puteţi folosi funcţia float pentru a o transforma într-un număr
real înainte de a o transfera în AutoCAD.
50099176.doc R.2.1 9/21/2011 •43

AUTODESK, INC.
Exemplu
Legaţi simbolul x de un număr întreg cu valoarea de 65535.

Command: (setq x 64435)
65535
Verificaţi-i valoarea şi tipul de date.
Command: !x
65535
Command: (float x)
65535.0
Command: (fix (float x))
65535
Command: (type x)
INT
Folosiţi funcţiile float şi fix pentru a returna valoarea lui x cu tipuri de date
diferite şi folosiţi funcţia rtos pentru a imprima valoarea cu un format de
zece zecimale.
Command: (type (float x))
REAL
Command: (type (fix (float x)))
INT
Command: (rtos (float x) 2 10)
"65535.0000000000"
Conversia automată a numerelor întregi

AutoLISP-ul va converti numerele întregi în numere reale ori de cîte ori va
întîlni ambele tipuri de date ca argumente la funcţie.
Dacă două numere întregi sînt folosite ca argumente la funcţia de adunare

+, valoarea returnată a expresiei este un număr întreg; totuşi, dacă
argumentele sînt un număr real şi un număr întreg, valoarea returnată este
exprimată printr-un număr real.
Exemplu
Această expresie returnează un număr întreg.
•44
Command: (+ 1 2)
3
Command: (type (+ 1 2))
INT
Această expresie returnează un număr real.
Command: (+ 1.0 2)
3.0
Command: (type (+ 1.0 2)
REAL
Recapitulare
• AutoLISP-ul are două tipuri de date numerice: numere

întregi şi numere reale.
• Numerele întregi au valori de 32 biţi în AutoLISP.
• Numai numerele întregi cu valori de 16 biţi pot fi transferate
între AutoLISP şi AutoCAD.
• Numerele reale sînt numere zecimale cu dublă precizie.
• Numerele reale sînt reţinute cu cel puţin 14 zecimale de
precizie.
• AutoLISP-ul va converti un număr întreg într-un număr real
cînd le întîlneşte pe amîndouă în cadrul aceleiaşi expresii.
• Un număr real trebuie întotdeauna să aibă o cifră care
precede punctul zecimal.
• Funcţia type returnează tipul de date al unui obiect.
• Funcţia fix transformă un număr real într-un număr întreg.
• Funcţia float transformă un număr întreg într-un număr real.
50099176.doc R.2.1 9/21/2011 •45

AUTODESK, INC.
EXERCITIUL 5: FOLOSIREA NUMERELOR INTREGI SI REALE

• Consolida cunoştinţele despre tipurile de date ale numerelor
întregi şi reale.
• Folosi funcţia setq pentru a lega variabile de valori cu tipuri
de date numerice diferite.
• Determina valoarea returnată şi tipul de date numerice ale
unei expresii AutoLISP
Partea I
1.Legaţi simbolurile de valori diferite.
2.Introduceţi s-expresia corespunzatoare în linia de comandă AutoCAD.
simbol valoare
a 1
b 2
c 3
x 1.0
y 2.0
z 4.5
Tabelul 13. Legarea variabilelor de valori numerice.
•46
Partea aII-a
1.Determinaţi valoarea returnată şi tipul de date pentru fiecare expresie.
2.Scrieţi răspunsurile în coloanele corespunzatoare
3.Trebuie mai întîi să efectuaţi prima parte a acestui exerciţiu.
expresia-s returnarea valorii tip de data pentru

valoarea returnata
(+ 1 2)
(+ 1 2.0)
(+ 1.0 2.0)
(+ a b)
(+ a y)
(+ y z)
(fix x)
(float a)
(fix z)
(float (fix z))
(fix (+ (float a) (float b)))
(/ x y)
(fix (/ x y))
(float (fix (/ x y)))
(+ (fix (/ a y)) (fix (float a)))
Tabelul 14. Valorile returnate si tipurile de date numerice ale expresiilor.
50099176.doc R.2.1 9/21/2011 •47

AUTODESK, INC.
Puncte AutoCAD şi liste AutoLISP

AutoCAD-ul foloseşte coordonatele carteziene pentru a descrie punctele
2- şi 3-dimensionale. AutoLISP-ul reprezintă un punct sub forma unei liste
de numere reale.
Obiective
• Cum reprezintă AutoLISP-ul puncte
• Cum să construiţi o listă care reprezintă un punct folosind
atît constante cît şi variabile.
Puncte AutoCAD
Un punct 3-dimensional este format din trei numere, fiecare avînd o valoare
independentă care corespunde unei distanţe de la originea sistemului de
coordonate de-a lungul axelor X, Y şi Z. Imaginaţi-vă punctul 3-D sub
forma a trei cutii, fiecare conţinînd un număr real.
Figura 12. Punct 3-d reprezentat prin trei coordonate
Luaţi, de exemplu, punctul 3-D 1,2,3. AutoCAD-ul are o gamă largă de

operatori pentru a descrie acest punct: Introducerea în coordonate absolute,
relative şi polare, agăţarea de obiecte, filtre de coordonate etc. Dar
reprezentarea internă a punctului se reduce la o asociere între trei numere
reale.
Figura 13. Valori de-a lungul axelor de coordonate.
•48
AutoLISP-ul reprezintă un punct AutoCAD 3-D sub forma unei liste

formate din trei numere reale, unde primul element este valoarea
coordonatei X, al doilea valoarea Y şi al treilea valoarea Z.
Punctul 1,2,3 exprimat sub forma unui obiect AutoLISP este (1.0 2.0 3.0)
Figura 14. Lsta AutoLISP sub forma unui punct AutoCAD
Construirea listelor de coordonate ale punctelor

Rezultatul unei încercări de a crea un obiect AutoLISP, recunoscut de
AutoCAD ca punct 3-D, este clar: o listă formată din trei numere reale.
Cum se poate construi o astfel de listă?
Există două funcţii pentru construirea acestor obiecte: quote şi list.
Construirea punctelor cu funcţia quote

Aşa cum aţi observat mai devreme, funcţia quote impiedică procesul de
evaluare pentru singurul ei argument şi returnează acest argument
neevaluat.
Construirea unei liste formată din trei numere reale este un proces simplu
cu ajutorul funcţiei quote. De exemplu, expresia (quote (1.0 2.0 3.0)
returnează valoarea (1.0 2.0 3.0), o reprezentare AutoLISP validă a unui
punct AutoCAD.
50099176.doc R.2.1 9/21/2011 •49

AUTODESK, INC.
Exemplu
Introduceţi expresiile care urmează. Creaţi două liste formate din cîte trei
numere reale şi folosiţi listele în linia de comandă AutoCAD.
Command: (setq pt1 (quote (1.0 1.0 1.0)))
(1.0 1.0 0.0)
Command: !pt1
(1.0 1.0 0.0)
Command: (setq pt2 (quote (5.0 5.0 0.0)))
(5.0 5.0 0.0)
Command: !pt2
(5.0 5.0 0.0)
Command: line
From point: !pt1
To point: !pt2
To point: Enter
pt2 (5.0 5.0 0.0)
pt1 (1.0 1.0 0.0)
Figura 15. Linie de la pt1 la pt2
Construirea punctelor cu funcţia list

Valoarea returnată a funcţiei list este o listă formată din valorile
argumentelor funcţiei. Funcţia poate primi oricîte argumente doriţi.
evaluează fiecare argument, unul după altul şi le memorează valoarea

list
temporar. Cînd funcţia list îşi epuizează argumentele îşi compune valorile
argumentelor din elemente în cadrul unei liste şi returnează lista.
•50
Exemplu
În timp ce lucraţi, nu uitaţi că numerele reale se evaluează pe sine, de

exemplu, Command: !4.5 returnează 4.5.
Folosiţi funcţia list pentru a returna o listă formată din trei numere reale.
Command: (list 1.0 2.0 3.0)
(1.0 2.0 3.0)
Folosiţi funcţia setq pentru a lega simbolul pt la o listă cu trei numere reale.
Command: (setq pt (list 1.0 2.0 3.0))
(1.0 2.0 3.0)
Command: !pt
(1.0 2.0 3.0)
Folosiţi simbolul pt ca intrare la comanda AutoCAD ID şi verificaţi dacă
AutoCAD-ul recunoaşte valoarea simbolului ca punct valid 3-D.
Command: id
Point: !pt
X=1.0000 Y=2.0000 Z=3.0000
Command:
Figura 16. Valoare returnata de functia list
50099176.doc R.2.1 9/21/2011 •51

AUTODESK, INC.
Construirea punctelor din variabile cu funcţia list

Deoarece funcţia list îşi evaluează argumentele, puteţi folosi simboluri sau
variabile ca argumente ale funcţiei list pe/sau în loc de numere reale.
Să admitem că aveţi trei variabile x, y şi z care sînt legate de numerele reale

1.0, 2.0 şi 3.0.
Figura 17.Legarea variabilelor de numere reale cu functia setq
Atunci expresia (list x y z) va returna aceeaşi valoare ca şi expresia (list

1.0 2.0 3.0)
Figura 18. Valoare returnata de functia list
•52
Exemplu
Legaţi simbolurile x, y şi z de trei numere reale

1.0
Command !x:
1.0
Command: (setq y 2.0)
2.0
Command: !y
2.0
Command: (setq z 3.0)
3.0
Command: !z
3.0
Folosiţi variabilele ca argumente la funcţia list.
Command: (list x y z)
(1.0 2.0 3.0)
Memoraţi lista într-o variabilă numită pt şi folosiţi-o în cadrul comenzii
AutoCAD.
Command: (setq pt (list x y z))
(1.0 2.0 3.0)
Command: !pt
(1.0 2.0 3.0)
Command: id
Point: !pt
X=1.0000 Y=2.0000 Z=3.0000
Command:
50099176.doc R.2.1 9/21/2011 •53

AUTODESK, INC.
Recapitulare
• AutoCAD-ul foloseşte sistemul de coordonate carteziene 3-
D pentru a specifica punctele.
• Un punct AutoCAD este reprezentat în AutoLISP sub forma
unei liste de numere reale.
• AutoLISP-ul reprezintă un punct AutoCAD 2-D sub forma
unei liste formată din două numere reale.
• Un punct AutoCAD 3-D este reprezentat sub forma unei
liste cu trei numere reale.
• Funcţia quote poate construi o listă de numere din constante.
• Funcţia list poate construi o listă de numere din constante
sau din variabile.
•54
EXERCITIUL 6: UTILIZAREA LISTELOR DE NUMERE CA PUNCTE AUTOCAD

• Consolida cunoştinţele despre relaţia dintre listele
AutoLISP formate din două sau trei numere reale şi punctele
AutoCAD.
• Lega variabile pentru a reprezenta coordonatele unui punct.
• Crea liste ale variabilelor coordonatelor pentru a reprezenta
puncte.
• Folosi liste ca răspunsuri la cererile de comandă AutoCAD.
Partea I
1. Introduceţi expresiile în coloana din stînga.
2. Scrieţi valoarea returnată a fiecarei expresii în coloana din mijloc.
3. Dacă o legatură simbol apare în cadrul expresiei, scrieţi-i valoarea
în coloana din dreapta.
Expresia Valoarea expresiei Simbol de atribuire
(setq x 1.0) 1.0 x = 1.0
(setq y 2.0)
(setq z 0.0)
(list 1.0 2.0 0.0)
(list x y z)
(setq pt1 (list x y z))
!pt1
(quote (5.0 6.0 0.0))
(setq pt2 (quote (5.0 6.0 0.0)))
!pt2
(quote (x y z))
(setq notapoint (quote (x y z)))
!notapoint
Tabelul 15. Crearea punctelor din liste de numere
50099176.doc R.2.1 9/21/2011 •55

AUTODESK, INC.
Partea a II-a
1. În acelaşi desen din partea I introduceţi expresiile care urmează.
2. Creaţi o Linie şi un Cerc folosind variabilele legate de liste
formate din numere reale aşa cum sînt punctele pentru comenzile
AutoCAD.
3. Legaturile simbol se bazează pe partea I a acestui exerciţiu.
Command: line
From point: !pt1
To point: !pt2
To point: Enter
Command: circle
3P/2P/TTR/<center point>: 2p
First point on diameter: !pt1
Second point on diameter: !pt2
5,6,0
1,2,0
Figura 19. Linie si cerc folosind variabilele pt1 si pt2
•56
50099176.doc R.2.1 9/21/2011 •57

AUTODESK, INC.
Separarea listelor
Avînd instrucţiuni pentru construirea listelor - funcţiile list şi quote - ne-ar fi
de folos să avem şi cîteva instrucţiuni pentru separarea listelor.
Dacă am avea un set instrucţiuni pentru extragerea fiecărui element dintr-o

listă, atunci am putea realiza mult mai uşor programe AutoLISP.
• Desenaţi un dreptunghi cunoscînd numai coordonatele
colţurilor opuse.
• Găsiţi punctul de mijloc dintre oricare ar fi două puncte ( nu
numai punctele finale ) ale unei linii sau ale unui cerc.
• Determinaţi dacă un punct se află într-o anumită regiune 2-D
sau 3-D a unui sistem de coordonate carteziane.
De vreme ce acest lucru necesită mai mult decît abilitatea de a separa liste,
separarea listelor este o cerinţă fundamentală în această operaţie.
Obiective
• Cum sînt reprezentate listele în memoria computerului sub
forma unui arbore binar.
• Cum sînt listele reprezentate grafic.
• Cum să folosiţi funcţiile car şi edr pentru separarea listelor.
• Cum să separaţi liste care reprezintă puncte în AutoCAD şi
cum să specificaţi puncte prin crearea unor liste noi bazate
pe punctele existente.
Structura internă a unei liste

O listă AutoLISP este reprezentată în memoria computerului sub forma
unui arbore binar. Orice punct de pe arborele binar unde poate apărea o
ramificaţie se numeşte nod. Nodul este una din unităţile fundamentale
pentru stocarea memoriei în AutoLISP.
Primul nod de sus al unui arbore binar se numeşte nodul radacină.
•58
Structura unei liste AutoLISP este desfăcută nod cu nod, începînd de la

nodul rădăcină. Fiecare nod se desface în două ramificaţii reprezentînd
diferite părţi ale listei: primul element al listei şi lista cu primul element
îndepărtat.
Figura 20. Nodul radacina si primul set de ramificatii pentru o lista.
De exemplu prima ramificaţie a listei (1.0 2.0 3.0) ar putea fi reprezentată

astfel.
(1.0 2.0 3.0)
1.0 (2.0 3.0)

Figura 21. Nodul radacina si primul set de ramificatii pentru lista (1.0 2.0 3.0)
50099176.doc R.2.1 9/21/2011 •59

AUTODESK, INC.
Subdivizarea de-a lungul ramificaţiei arborelui continuă pînă ce partea

dreaptă a ramificaţiei se termină cu lista goală sau nil.
(1.0 2.0 3.0)
1.0 (2.0 3.0)
2.0 (3.0)
3.0 ()
Figura 22. Arbore binar complet pentru lista (1.0 2.0 3.0)
AutoLISP-ul are apelative speciale pentru cele două parţi ale ramificaţiei
listei. Primul element al listei se numeşte car-ul listei. Lista fără primul ei
element se numeşte cdr-ul listei. Ramificaţia stîngă este partea car a listei
iar ramificaţia dreaptă este partea cdr.
Figura 23. Partile car si cdr de la nodul radacina al listei.
•60
Reprezentarea unei liste cu trei elemente atomice prin car şi cdr, căreia îi
este atribuit simbolul x, ar arăta după cum urmează. Dacă o listă formată
din unul sau mai multe elemente se află la oricare din nodurile arborelui,
este urmată de o ramificaţie. Partea stîngă a ramificaţiei este car-ul listei la
care se referă nodul iar partea dreaptă este cdr-ul listei la care se referă
nodul.
Figura 24. Reprezentarea completa a unei liste cu trei atomi ca elemente cu car
si cdr.
Să combinăm graficul care reprezintă arborele binar pentru valorile

simbolului pt, care este legat de lista (1.0 2.0 3.0) cu ramificaţiile car şi cdr
ale arborelui.
Figura 25. Grafic combinat pentru simbolul pt, legat de lista (1.0 2.0 3.0).
50099176.doc R.2.1 9/21/2011 •61

AUTODESK, INC.
Recapitulare
• Listele sînt reprezentate în memorie sub forma unui arbore
binar.
• Primul element al listei este car-ul listei.
• Lista după ce primul element este îndepărtat reprezintă cdr-
ul listei.
• Funcţiile car şi cdr formează ramificaţiile car şi cdr ale listei.
• O ramificaţie cdr a unui arbore binar se termină în nil sau
lista goală.
•62
EXERCITIUL 7: GRAFUL VALORILOR INTR-UN ARBORE BINAR

• Consolida cunoştinţele despre reprezentarea listelor în
memorie.
• Completa un grafic a valorilor unei liste, reprezentat sub
forma unui arbore binar.
Instrucţiuni
1. Terminaţi graful complet al unui arbore binar pentru variabila
alst.
2. alst este legată de lista (8.0 3.0 0.0).
3. Arătaţi valoarea fiecarui nod din grafic.
(8.0 3.0 0.0)
8.0 ?
? ?
? ?
Figura 26. Completarea grafului binar
50099176.doc R.2.1 9/21/2011 •63

AUTODESK, INC.
EXERCITIUL 8: GRAFUL EXPRESIILOR INTR-UN ARBORE BINAR

• Consolida cunoştinţele despre separarea listelor şi
restabilirea elementelor lor individuale.
• Completa un grafic al expresiilor care restabilesc elementele
unei liste, grafic reprezentat sub forma unui arbore binar.
Instrucţiuni
1. Terminaţi graficul complet al unui arbore binar pentru variabila
xlst.
2. xlst este legată de lista (1.0 (2.0 3.0) 4.0).
3. Arătaţi valoarea fiecărui nod din grafic
4. Arătaţi expresia care restabileşte fiecare valoare din grafic.
5. Marcaţi ramificaţiile car şi cdr ale unui arbore.
6. Observaţi că elementele acestei liste sînt formate din doi atomi şi o
listă.
xlst
(1.0 (2.0 3.0) 4.0)
1.0 ((2.0 3.0) 4.0)

(car xlst) (cdr xlst)
(2.0 3.0) ?
(car (cdr xlst)) (cdr (cdr xlst))
? ? ? ?
(car (car (cdr xlst))) ? ? ?
? ?
? ?
Figura 27. Completarea graficul binar
•64
Funcţiile car si cdr
Funcţiile car şi cdr sînt funcţii non-destructive. Nici una dintre ele nu
afectează legarea argumentului ei ceea ce este un mod curios de a spune
despre (car x) că poate returna o valoare diferită de x dar nu va schimba
valoarea lui x.
car
Funcţia car returnează primul element al listei. Singurul argument al
funcţiei car trebuie să fie o listă, iar lista trebuie să aibă unul sau mai multe
elemente.
Exemplu
Introduceţi expresia care urmează. Legaţi variabila pt la o listă cu trei
numere reale. Folosiţi funcţia car pentru a returna coordonata x în listă
(primul element) şi legaţi variabila x de acea valoare.
(1.0 2.0 0.0)
Command: !pt
(1.0 2.0 0.0)
Command: (car pt)

1.0
Command: (setq x (car pt))

1.0
Command: !x
1.0
Command: !pt
(1.0 2.0 0.0)
cdr
Funcţia cdr returnează o listă şi elementele ei cu excepţia primului element;
cu alte cuvinte îndepărtează primul element al listei în afara valorii lui
returnate.
50099176.doc R.2.1 9/21/2011 •65

AUTODESK, INC.
Exemplu
Legaţi variabila pt de o listă cu trei numere reale.

(1.0 2.0 0.0)
Command: !pt
(1.0 2.0 0.0)
Folosiţi funcţia cdr pentru a returna o listă fără primul element şi legaţi
variabila yzlst de acea valoare.
Command: (cdr pt)
(2.0 0.0)
Command: (setq yzlst (cdr pt))

(2.0 0.0)
Command: !lyzlst
(2.0 0.0)
Command: !pt
(1.0 2.0 0.0)
Construirea unui dreptunghi cunoscînd colţurile opuse

În figurile care urmează cunoaştem două puncte din colţurile unui
dreptunghi. Celelalte două puncte se calculează prin combinarea
cordonatelor X şi Y ale punctelor cunoscute în diverse moduri pentru a
forma noi perechi de coordonate.
Figura 28. Valorile X si Y pentru colturile unui dreptunghi.
•66
Această pagină este lăsată liberă în mod intenţionat
50099176.doc R.2.1 9/21/2011 •67

AUTODESK, INC.
Figura care urmează reprezintă coordonatele punctelor în funcţie de variabilele X şi Y.
X1,Y1 X2,Y1
X1,Y2 X2,Y2
0,0
Figura 29. Valorile X,Y pentru colturile dreptunghiului
Consideraţi că două variabile sînt legate de cele două liste formate din
numere reale.
(setq pt1 (list 1.0 5.0 0.0))
(setq pt2 (list 10.0 1.0 0.0))
Acest tabel arată funcţiile necesare pentru returnarea valorilor X, Y şi Z din
fiecare punct.
coordinate pt1 pt2
X (car pt1) (car pt2)
Y (car (cdr pt1)) (car (cdr pt2))
Z (car (cdr (cdr pt1))) (car (cdr (cdr pt2)))
Tabelul 16. Expresiile folosite pentru returnarea coordonatelor X, Y si Z.
•68
Figura următoare exprimă punctele de coordonate sub forma de expresii

AutopLISP, bazate pe cunoaşterea a două puncte pt1 şi pt2. Pentru a
simplifica lucrurile, acestea sînt tratate ca puncte 2-dimensionale.
pt1 (list (car pt2) (car (cdr pt1)))
(list (car pt1) (car (cdr pt2))) pt2
0,0
Figura 30. Calcularea colturilor unui dreptunghi
50099176.doc R.2.1 9/21/2011 •69

AUTODESK, INC.
Exemplu
Folosiţi funcţia list pentru a le combina în alte două puncte ale

dreptunghiului.
Command: (setq pt1 (list 1.0 5.0))
(1.0 5.0)
Command: !pt1
(1.0 5.0)

(10.0 1.0)
Command: !pt3
(10.0 1.0)
Folosiţi funcţiile car şi cdr pentru a extrage valorile X şi Y ale punctelor
cunoscute.
Command: (car pt1)
1.0
Command: (car (cdr pt3))

1.0
Command: (list (car pt1) (car (cdr pt3)))

(1.0 1.0)
Command: (setq pt2 (list (car pt1) (car (cdr pt3))))

(1.0 1.0)
Command: !pt2
(1.0 1.0)
Command: (car pt3)

10.0
Command: (car (cdr pt1))

5.0
Command: (list (car pt3) (car (cdr pt1)))

(10.0 5.0)
•70
Command: (setq pt4 (list (car pt3) (car (cdr pt1))))

(10.0 5.0)
Command: !pt4
(10.0 5.0)
Desenaţi dreptunghiul folosind linia de comandă AutoCAD.
Punctele sînt 2-dimensionale. Linia de comandă AutoCAD va completa

automat valoarea Z a punctului bazată pe valoarea curentă a inălţimii
(elevation).
Command: line
From point: !pt1
To point: !pt2
To point: !pt3
To point: !pt4
To point: close
pt1 pt4
1,5 10,5
pt2 pt3
1,1 10,1
0,0
Figura 31. Localizarea colturilor unui dreptunghi
Recapitulare
• Funcţia car returnează primul element al unei listei.
• Funcţia cdr returnează o listă cu excepţia primului element.
• Există funcţii standard la care se face apel pentru stabilirea
componentelor X, Y şi Z ale unui punct reprezentat printr-o
listă.
50099176.doc R.2.1 9/21/2011 •71

AUTODESK, INC.
EXERCITIUL 9: LUCRUL CU LISTE DE PUNCTE

• Consolida cunoştinţele despre funcţii care separă liste şi
funcţii care crează liste.
• Crea puncte formate din liste şi le veţi lega de variabile.
• Crea puncte formate din liste bazate pe valorile X şi Y din
alte puncte formate din liste.
Matematica problemei
Două puncte 2-dimensionale şi punctul care se află la mijlocul distanţei
dintre ele pot fi exprimate logic în funcţie de X şi Y după cum urmează.
pt1 = pt1x, pt1y

pt2 = pt2x, pt2y
midpt = mptx, mpty
Valorile X şi Y ale lui mpt pot fi exprimate aritmetic după cum urmează.
mptx = (pt1x + pt2x)/2

mpty = (pt1y + pt2y)/2
Instrucţiuni
Scrieţi un set de expresii AutoLISP care execută urmatoarele comenzi în
ordine
1. Legaţi o variabilă pt1 de lista formată din două numere reale 1.5
şi 8.9.
2. Legaţi o variabilă pt2 de o listă formată din două numere reale
7.8 şi 3.2.
3. Scrieţi un set de expresii care leagă variabila midpt de punctul
care se află la mijlocul distanţei dintre punctele pt1 şi pt2.
După ce aţi verificat expresiile în editorul AutoCAD scrieţi-le mai jos.
•72
Comenzi AutoCAD si AutoLISP

Comenzile AutoCAD pot fi chemate direct din AutoLISP, s-expresiile
AutoLISP pot fi folosite ca răspunsuri la cererile de comandă.
Obiective
• Cum să chemaţi o comandă AutoCAD direct din AutoLISP.
• Cum să folosiţi şirul AutoLISP, s-expresiile constante şi
variabile ca răspunsuri la cererile de comandă.
• Sintaxa funcţiei AutoLISP command.
• Cum să evitaţi lucrul cînd traduceţi un program folosind
comenzile în limba engleză indiferent de versiunea
AutoCAD.
Funcţia command
Funcţia command apelează funcţiile AutoCAD din AutoLISP. Funcţia
command acceptă un argument de tip şir care trebuie să fie numele unei
comenzi AutoCAD şi oricare alte argumente opţionale care ar fi în mod
normal introduse în linia de comandă.
În cazurile în care este nevoie de un return ca răspuns la o comandă, şirul ""

este folosit ca argument. Aceasta este reprezentarea AutoLISP a şirului
nul pe care AutoCAD-ul o interpretează ca un return în cadrul funcţiei
apelative command.
Funcţia command acceptă şiruri şi variabile AutoLISP ca argumente. De

exemplu aceste trei seturi de expresii trasează aceeaşi entitate Line.
Folosirea argumentelor de tip şir
Command: (command "line" "1,1" "5,5" "")

nil
Folosirea argumentelor constante
Command: (command "line” (quote (1.0 1.0)) (quote (5.0 5.0)) "")
nil
Folosirea argumentelor variabile
Command: (setq pt1 (list 1.0 1.0) pt2 (list 5.0 5.0))
(5.0 5.0)
Command: (command "line" pt1 pt2"")

nil
50099176.doc R.2.1 9/21/2011 •73

AUTODESK, INC.
Efecte secundare
Funcţia command returnează întotdeauna nil. Efectul secundar al unei
expresii command este mult mai interesant decît valoarea returnată. Un efect
secundar al unei expresii AutoLISP reprezintă o schimbare în starea
programului care se produce datorită unei funcţii de apelare. Efectul
secundar al apelării unei funcţii setq este pentru a crea un nou simbol de
legatură sau pentru a atribui o valoare la o variabilă. Efectul secundar al
apelării unei funcţii command este de a realiza o comandă AutoCAD care
modifică fişierul grafic într-un anume fel.
Exemplu
Legaţi două variabile de două puncte 2-dimensionale.

(1.0 1.0)

(5.0 5.0)
Apelaţi la comanda LINE şi folosiţi variabilele ca argumente.
Command: (command "line" pt1 pt2 "")
nil
5,5
1,1
Figura 32. Linie de la 1.1 la 5.5
•74
Exemplu
Folosiţi variabilele pt1 şi pt2 de la exerciţiul anterior ca puncte reprezentînd

centrele a două cercuri şi ca puncte finale ale diametrului unui cerc.
Command: circle
3P/2P/TTR/<center point>: !pt1
Diameter/<Radius>: 0.5
Command: (command "circle" pt2 0.5)
Command: (command "circle" "2p" pt1 pt2)
Figura 33. Cercuri definite de pt1 si pt2
50099176.doc R.2.1 9/21/2011 •75

AUTODESK, INC.
Exemplu
Folosiţi valorile lui pt1 şi pt2 de la exerciţiul anterior.
Desenaţi două arce folosind pt1 şi pt2 ca puncte finale şi o valoare a razei de
3.5.
Command: arc
Center/<Start point>: !pt1
Center/End/<Second point>: e
End point: !pt2
Angle/Direction/Radius/<Center point>: r
Radius: 3.5
Command:(comand”arc” pt2 ”e” pt1 ”r” 3.5)
Figura 34. Arce definite de pt1 si pt2
•76
Globalizarea comenzilor
Toate versiunile AutoCAD-ului vor accepta comenzile şi opţiunile din
limbajul american şi englezesc indiferent de versiunea limbii sursă. Acest
lucru permite utilizatorului să scrie o aplicaţie AutoLISP care poate fi
folosită în toate versiunile de limbaj ale AutoCAD-ului fără a traduce
funcţiile command în limba sursă.
Fiecare versiune AutoCAD tradusă într-o anumită limbă pastrează un menu

de opţiuni şi comenzi din limba sursă. De exemplu versiunea germană
AutoCAD pastrează un menu de opţiuni şi comenzi în limba germană astfel
încit cei care o folosesc îşi pot introduce comenzile în germană. Toate
versiunile AutoCAD indiferent de limba sursă păstreză un menu de opţiuni
şi comenzi în engleza americană împreună cu un menu în limba sursă.
Pentru a folosi versiunea englezească a comenzilor şi opţiunilor AutoCAD,

prefaţati şirul cu un caracter “subliniere” sau cu "_". De exemplu acesta
este modul în care se apelează la linia de comandă în toate versiunile
AutoCAD.
Command: (command "_line" "1.1" "5.1" "1.5" "_c")
Recapitulare
• Functia command permite apelarea comenzilor AutoCAD din
AutoLISP.
• Şirul nul sau "" este tratat ca un return de către funcţia command.
• Expresiile AutoLISP sînt acceptate ca răspunsuri la cererile de

comandă AutoCAD în cadrul funcţiei command.
• Argumentele funcţiei command sînt numele comenzii AutoCAD

urmate de răspunsurile la cererile de comandă.
• Caracterul subliniere poate fi prefaţat în cadrul unei instrucţiuni

de tip command în engleza americană şi va funcţiona în toate versiunile de
limbaj ale AutoCAD-ului.
50099176.doc R.2.1 9/21/2011 •77

AUTODESK, INC.
EXERCITIUL 10: TRANSFORMAREA COMENZILOR IN AUTOLISP

• Transforma comenzile AutoCAD script în expresii
AutoLISP.
• Scrie expresiile.
• Testa expresiile în editorul AutoCAD.
Instrucţiuni
2. Transformaţi comenzile şi cererile AutoCAD în expresii ale
funcţiei command. Scrieţi răspunsurile în coloana din dreapta.
3. Testaţi expresiile în editorul AutoCAD.
Comenzi si cereri Expresii AutoLISP
Command: line (command "line" "1,1" "5,5" "")

From point: 1,1 or
To point: 5,5
To point: ENTER (command "line" '(1.0 1.0) '(5.0 5.0) "")
Command: circle
Diameter/<Radius>: 0.5
Command: circle
3P/2P/TTR/<Center point>: 2p
First point on diameter: 1,1
Second point on diameter: 5,5
Command: arc
Center/<Start point>: 2,1
Center/End/<Second point>: c
Center: 1,1
Angle/Length of chord/<End point>: l
Length of chord: 1.414
Tabelul 17. Traducerea comenzilor in AutoLISP
•78
EXERCITIUL 11: APELUL COMENZII POLYLINE DIN AUTOLISP
În acest exerciţiu:
• Veţi folosi AutoLISP-ul pentru a executa o comandă
AutoCAD şi pentru a desena o nouă entitate.
• Veţi apela comanda AutoCAD PLINE din AutoLISP.
• Veţi scrie un set de expresii AutoLISP pentru a desena o
polilinie rectangulară.
Instrucţiuni
2. Creaţi urmatoarele legaturi de variabile în AutoCAD:
(setq pt1 (list 1.0 1.0 0.0))
(setq pt3 (list 11.0 8.0 0.0))
3. Folosiţi variabilele pt1 şi pt3.

4. Scrieţi un set de expresii ce vor desena un dreptunghi, folosind
comanda "Polyline" opţiunea 2-D închisă de la punctul 1,1 la 11,1
la 11,8 la 1,8, folosind variabilele pt1 şi pt3.
5. Folosiţi funcţiile car, cdr, list şi command dacă este nevoie.
6. Testaţi expresiile în AutoCAD.
7. Scrieţi-le mai jos.
50099176.doc R.2.1 9/21/2011 •79

AUTODESK, INC.
•80
Selecţia interactivă a punctelor

AutoLISP-ul dispune de funcţii care opresc evaluarea unei expresii şi
permit utilizatorului să stocheze puncte şi distanţe folosind metodele
standard AutoCAD de specificare a acestor valori. Punctul sau distanţa
devine valoarea returnată a expresiei.
Obiective
• Cum să cereţi informaţii utilizatorului în cadrul unui
program AutoLISP.
• Cum să cereţi coordonatele unui punct utilizatorului.
• Cum să cereţi o distanţă utilizatorului.
• Cum să cereţi utilizatorului valoarea pe care o doriţi.
• Cum să folosiţi puncte şi distanţe de la utilizator în cadrul
funcţiilor AutoLISP command şi comenzilor AutoCAD.
Puncte si distanţe
Funcţia getpoint permite utilizatorului să selecteze un punct folosind orice
metode standard AutoCAD de selectare a punctelor: selectare grafică,
coordonate absolute, relative sau relative polare, agăţarea obiectelor, filtre
de coordonate sau accesarea ultimului punct.
Funcţia getdist permite utilizatorului să specifice o distantă prin introducerea

valorii sau selecţiond două puncte. Este acelaşi mecanism folosit de fiecare
comandă AutoCAD care cere utilizatorului o distanţă.
getpoint
Funcţia getpoint foloseşte serviciile AutoCAD pentru a permite utilizatorului
să introducă un punct. Punctul selectat de utilizator reprezintă valoarea
returnată a expresiei. AutoLISP-ul returnează punctul sub forma unei liste
formată din trei numere reale: valorile coordonatelor X, Y şi Z.
Command:(getpoint)
1,1,0
(1.01.00.0)
Funcţia getpoint este folosită pentru a obţine un punct de la utilizator în
cadrul unei expresii AutoLISP. De exemplu ar putea fi nevoie să cereţi
utilizatorului din cadrul unui program AutoLISP, puncte care vor fi folosite
apoi ca puncte finale ale unei linii.
50099176.doc R.2.1 9/21/2011 •81

AUTODESK, INC.
Command: (setq pt1 (getpoint))

1,1
(1.0 1.0 0.0)

5,5
(5.0 5.0 0.0)
Command: (command ”line” pt1 pt2 “”)
Deoarece toate serviciile AutoCAD de specificare a punctelor sînt

disponibile în timpul apelării funcţiei getpoint, nu sînteţi constrîns să
introduceţi coordonatele exacte ale punctului.
<pick a point with the mouse>
<list of three reals returned>
<pick a point with the mouse>
<list of three reals returned>
Command: (command “line “ pt1 pt2 “”)
Exemplu
Introduceţi expresiile care urmează. Legaţi variabilele pt1 şi pt2 de puncte
pe care le selectaţi cu mouse-ul în cadrul unei funcţii de apelare getpoint şi
folosiţi variabilele într-o comanda LINE.
Command: ( setq pt1 (getpoint))
pick a point
pick a point
Command: (command “line” pt1 pt2””)
Exemplu
Introduceţi expresiile care urmează. Legaţi variabila pt1 de un punct pe care
îl selectaţi cu mouse-ul şi variabila pt2 de un punct descris de coordonatele
polare relative. Folosiţi variabilele în linia de comandă.
Command: (setq pt1 (getpoint ))
pick a point
@2<45
•82
Command: (command “line” pt1 pt2” “)
Exemplu
Introduceţi expresiile care urmează. Legaţi variabila pt1 de un punct pe care
îl selectaţi cu mouse-ul în cadrul unei funcţii de apelare getpoint şi folosiţi
variabila într-o comandă CIRCLE.
pick a point
Command: (command “circle” pt1 0.5)
getdist
Funcţia getdist cere utilizatorului două puncte. Valoarea returnată este un
număr real: distanţa 3-D între două puncte.
Command: (setq dst1 (getdist))
Second point: 2,2
1.41421
Command: !dst1
1. 41421
Funcţia getdist primeşte un argument opţional, punctul de bază de la care
se măsoară distanţa. În acest caz funcţia cere utilizatorului un singur punct.
Command: (setq pt1 (list 1.0 1.0 0.0))

(1.0 1.0 0.0)
Command: (setq dst1 (getdist pt1))
2,2
1.41421
Command: !dst1
1.41421
50099176.doc R.2.1 9/21/2011 •83

AUTODESK, INC.
Figura 35. Functia getdist “drag” din punctul initial 1,1,0
Exemplu
Introduceţi expresiile care urmează. Legaţi variabila pt1 de un punct
folosind coordonatele absolute şi variabila rad de distanţa dintre două
puncte pe care o selectaţi cu mouse-ul. Folosiţi variabila în comanda
CIRCLE .
5,5
(5.0 5.0 0.0)
Command: (setq rad (getdist))
pick two points
Command: (command “circle” pt1 rad)
Exemplu
Introduceţi expresiile care urmează. Legaţi variabila cen de un punct pe care
îl selectaţi cu mouse-ul. Legaţi variabila rad de distanţa dintre cen şi un
punct pe care îl selectaţi cu mouse-ul. Folosiţi variabilele în comanda
CIRCLE .
Command: (setq cen (getpoint))
pick a point
Command: (setq rad (getdist cen))
pick a point
Command: (command “circle” cen rad)
•84
Dialog cu utilizatorul
Funcţiile getpoint şi getdist primesc şi argumente opţionale: un şir de text
care este afişat în zona liniei de comandă ca o cerere pentru utilizator.
Command: (getpoint “Point:”)

Point: 1,1
(1.0 1.0 0.0)
Dacă getdist cere două puncte, se cere automat al doilea punct "Second
point:".
Command: (getdist “From point:”)

From poin: 1,1
(1.0 1.0 0.0)
Second point: 2,2
1.41421
Deoarece getdist primeşte două cereri opţionale, ordinea şi tipul de date în

acest caz sînt importante. Dacă primul argument al funcţiei getdist este un
şir, acesta reprezintă o cerere. Dacă primul argument este un punct, atunci
se poate proceda la cererea celui de-al doilea argument.
Command: (getdist (quote (1.0 1.0 0.0)) “To point:”)

To point: 2,2
1.41421
Recapitulare
• Funcţia getpoint returnează un punct de la utilizator.

• Funcţia getdist returnează o distanţă dată sub forma unui
număr real de la utilizator.
• Ambele funcţii primesc argumente opţionale pentru
utilizator.
• Utilizatorul poate aplica oricare dintre metodele AutoCAD
de specificare a punctelor şi distanţelor la o cerere AutoLISP
pentru un punct sau o distanţă.
50099176.doc R.2.1 9/21/2011 •85

AUTODESK, INC.
EXERCITIUL 12: CEREREA SI FOLOSIREA PUNCTELOR DE LA UTILIZATOR

• Scrie expresiile care cer utilizatorului puncte şi distanţe.
• Scrie comenzile de desenare în AutoCAD.
Partea I
Instrucţiuni
Scrieţi un set de expresii. Testaţi-le în editorul AutoCAD apoi scrieţi-le mai
jos.
1. Cereţi utilizatorului patru puncte.
2. Atribuiţi-le variabilelor pt1 prin pt4.
3. Trasaţi o polilinie 2-D închisă între cele patru puncte.
Partea a II-a
Instrucţiuni
jos.
1. Cereţi utilizatorului un punct centru şi atribuiţi valoarea unei
variabile numite cen.
2. Cereţi utilizatorului distanţa de la variabila cen şi atribuiţi valoarea
unei variabile numite rad.
3. Desenaţi un cerc cu centrul cen şi raza rad.
•86
Partea a III-a
Instrucţiuni
jos.
1. Cereţi utilizatorului două puncte.
2. Atribuiţi-le variabilelor pt1 şi pt2.
3. Desenaţi o polilinie 2-D închisă.
4. Folosiţi pt1 şi pt2 pentru colţurile opuse ale poliliniei.
5. Calculaţi celelalte două puncte din pt1 şi pt2 folosind funcţiile car,
cdr şi list.
50099176.doc R.2.1 9/21/2011 •87

AUTODESK, INC.
•88
Funcţii
Pe lîngă funcţiile interne, AutoLISP-ul permite crearea funcţiilor definite
de utilizator, adică funcţii ale caror seturi de instrucţiuni şi nume au fost
definite.
Obiective
• Definiţia funcţiei AutoLISP.
• Cum să creaţi propriile funcţii AutoLISP.
• Sintaxa funcţiei defun.
• Cum să trimiteţi argumente unei funcţii.
• Cum returnează funcţia o valoare.
Funcţiile si evaluarea listelor

Consideraţi procesul de evaluare al unei expresii tipice care foloseşte o
funcţie internă AutoLISP.
(setq x 10)
AutoLISP-ul evaluează primul element unde se aşteaptă să gasescă o

funcţie. Aici găseşte subprogramul setq şi reface legătura. Legarea lui setq
reprezintă un set de instrucţiuni care arată cum trebuie facută procesarea.
AutoLISP-ul evaluează argumentele lui setq în ordine şi termină prin
aplicarea instrucţiunilor de procesare la valoarea argumentelor.
Rezultatul în acest caz este o valoare returnată, 10, pentru expresie şi un

efect secundar al variabilei x care este legată de 10.
setqeste un subprogram şi instrucţiunile lui au fost predefinite în AutoLISP.

Utilizatorul nu le poate schimba. Totuşi este posibilă crearea unor noi
funcţii care să execute orice instrucţiuni de procesare dorite de utilizator.
Legături noi se crează prin folosirea subprogramului defun care este funcţia
de definire.
50099176.doc R.2.1 9/21/2011 •89

AUTODESK, INC.
Sintaxa funcţiei defun

Sintaxa funcţiei defun este puţin diferită de cea a celorlalte funcţii folosite
pînă acum.
(defun <sym name> (<arg list> / <local var>) <expr> ...)
defun cere obligatoriu două argumente şi un număr variabil de argumente

care urmează după primele două.
Argumentele funcţiei defun

Primul argument al funcţiei este numele noii funcţii de definit. Folosiţi un
nume nou pe care l-aţi creat, de preferinţă unul care descrie acţiunile
funcţiei.
ATEN}IE Nu folosiţi niciodată numele unei funcţii sau a unui simbol

construite intern deoarece acesta se va suprapune peste definiţia originală şi
îl va face inaccesibil pînă lansaţi AutoLISP-ul în cadrul unei noi sesiuni
AutoCAD.
În acest exemplu, primul argument al funcţiei defun este numele simbol

myfun care devine numele funcţiei definite de utilizator.
(defun myfun (<arg list> / <local var>) <expr> ...)
Al doilea argument cerut de defun este o listă de argumente cerute şi

variabile locale. Cele două tipuri de argumente sînt separate de o linie.
Acum este suficient să folosiţi o listă goală.
Exemplul este extins pentru a include lista argumentelor cerute şi a

variabilelor locale.
(defun MYFUN ( ) <expr> ... )
Argumentele care urmează după argumentele cerute sînt expresii de evaluat
cînd se execută funcţia definită de utilizator. Ele reprezintă instrucţiunile de
procesare care vor fi executate cînd funcţia va fi apelată.
Returnarea valorii unei funcţii

Valoarea returnată a funcţiei definite de utilizator este valoarea ultimei
expresii din corpul definiţiei funcţiei.
•90
În următoarele exemple, expresiile vor fi adăugate corpului funcţiei myfun.

Seturi diferite de expresii vor da înţelesuri diferite funcţiei myfun precum şi
valori returnate diferite.
În acest exemplu myfun adaugă două numere şi returnează răspunsul.

(defun myfun ( )
(+ 1 2 )
)
Exemplu
Introduceţi expresiile care urmează. Definiţi funcţia myfun apoi apelaţi-o.
Command: (defun myfun () (+1 2 ))

MYFUN
Command: (myfun)
3
Exemplu
myfun va returna radacina patrată a lui 624, rotunjită pîna la cel mai apropiat
număr întreg.
Command: (defun myfun () (fix (sqrt 624.0))

MYFUN
Command: (myfun)
24
Exemplu
myfun va returna distanţa dintre două puncte alese de utilizator.
Command: (defun myfun () (getdist “From point: “))
MYFUN
Command: (myfun)
From point: pick a point
Second point: pick a point
50099176.doc R.2.1 9/21/2011 •91

AUTODESK, INC.
În cele trei exemple pe care le-aţi parcurs, valoarea returnată a funcţiei

myfun este valoarea returnată a ultimei expresii din corpul definiţiei.
Figura 36.Corp de expresii pentru o definitie a functiei
Expresii multiple pot fi introduse în corpul definiţiei funcţiei. Valoarea

returnată a funcţiei este valoarea returnată a ultimei expresii din corpul
definiţiei.
În acest exemplu valoarea returnată a funcţiei myfun este valoarea expresiei

(+3 4)
Command: (defun myfun () (+1 2) (+3 4))
MYFUN
Command: (myfun)
7
Figura 37.Ultima expresie din corp este valoarea returnata a functiei.
•92
Argumentele unei funcţii

(defun myfun (<arg list> / <local var>) <expr>... )
Lista argumentelor cerute dintr-o expresie defun vă permite să adăugaţi

argumente la funcţiile de apelare.
În acest exemplu funcţia myfun este definită cu un singur argument solicitat:

simbolul x. x este folosit în cadrul expresiei din corpul definiţiei funcţiei
myfun: (* x 10). Orice valoare se utilizează ca argument la myfun, aceasta va
deveni automat valoarea lui x din corpul expresiei (* x 10).
Command: (defun myfun (x) (* x 10))

MYFUN
10
Command: (myfun 1)
20
Command: (myfun 2)
Command:
Figura 38. Valoarea argumentului se afla in corpul de expresii al functiei.
50099176.doc R.2.1 9/21/2011 •93

AUTODESK, INC.
Exemplu
Introduceţi expresiile care urmează. Creaţi o funcţie numită add-one care
solicită un argument. Adăugaţi unu la valoarea lui şi returnaţi. Folosiţi
funcţia cu două valori diferite
.
Command: (defun add-one (x) (+ x 1))
ADD-ONE
Command: (add-one 1)
2
Command: (add-one 4)
5
Exemplu
Introduceţi expresiile care urmează. Creaţi o funcţie numită dtr care cere un
argument exprimat în grade şi returnează valoarea transformată în radiani.
Folosiţi funcţia cu trei valori diferite.
Formula aritmetică pentru transformarea gradelor în radiani pentru valoarea

d este:
(d / 180) * pi
Command: (defun dtr (d) (* pi (/ d 180.0)))

DTR
Command: (dtr 180)
3.14159
Command: (dtr 360)
6.28319
Command: (dtr 90)
1.5708
Exemplu
Introduceţi expresiile care urmează. Creaţi o funcţie care se numeşte add-two
care cere două argumente, adaugă valorile lor şi returnează. Folosiţi funcţia
cu două seturi de valori diferite.
Command: (defun add-two (x y) (+x y))

ADD-TWO
Command: (add-two 1 2)
3
Command: (add-two 4 5)
9
•94
Recapitulare
• Noile funcţii externe sînt create cu ajutorul funcţiei defun.

• Toate funcţiile returnează o valoare .
• Funcţiile sînt definite fără argumente sau cu un număr fix de
argumente solicitate .
• Argumentele unei funcţii sînt evaluate oriunde s-ar afla în
corpul definiţiei funcţiei.
50099176.doc R.2.1 9/21/2011 •95

AUTODESK, INC.
EXERCITIUL 13: DEFINREA UNOR NOI FUNCTII
Trebuie să completaţi partea a III-a a acestui exerciţiu. Se vor face

referiri la această parte în exerciţiile care urmează.

• Consolida cunoştinţele despre cum sînt create funcţiile
definite de utilizator.
• Scrie funcţii cu argumente solicitate.
• Scrie o funcţie care apelează o comandă AutoCAD.
Partea I
Instrucţiuni
1. Creaţi o funcţie numită times-two.

2. Funcţia solicită două argumente.
3. Funcţia multiplică cele două argumente şi returnează valoarea.
4. Testaţi-o în AutoCAD.
5. Scrieţi-o mai jos.
Partea a II-a
Instrucţiuni
1. Creaţi o funcţie numită rtd.
2. Funcţia solicită un argument.
3. Funcţia transformă valoarea argumentului din radiani în grade şi
returnează valoarea.
Formula aritmetică de transformare din radiani în grade pentru valoarea r
este:
(r / pi) * 180
•96
Partea a III-a
Instrucţiuni
1. Creaţi o funcţie numită rectangle.
2. Funcţia nu cere argumente.
3. Cereţi utilizatorului două puncte şi memoraţi-le sub formă de
variabile.
4. Trasaţi o polilinie 2-D închisa folosind punctele pentru colţurile
opuse.
5. Calculaţi celelalte două puncte cu ajutorul funcţiilor car, cdr şi list.
50099176.doc R.2.1 9/21/2011 •97

AUTODESK, INC.
Această pagină a fost lăsată liberă intenţionat.
•98
Funcţii care acţionează sub formă de comenzi AutoCAD

O funcţie definită de utilizator poate apela o funcţie AutoLISP command în
cadrul corpului definiţiei ei. Apelarea ei apare utilizatorului sub forma unei
comenzi AutoCAD, o comandă ce poate fi apelată fără ca aceasta să se afle
între paranteze.
Obiective
• Cum să transformaţi o funcţie AutoLISP definită de
utilizator într-o nouă comandă AutoCAD.
• Cum să folosiţi simbolul pause în cadrul funcţiilor de tip
command .
• Cum să obţineţi valoarea unei variabile de sistem în
AutoLISP.
O noua comandă ZOOM

Pentru a ilustra unele puncte sensibile ale definirii funcţiilor şi comenzilor
AutoCAD vom crea o funcţie simplă şi utilă care combină comanda ZOOM
cu opţiunea Center, schimbînd factorul de afişare cu 2.
Consideraţi cererile pentru o operaţie ZOOM CENTER.

Command: zoom
All/Center/Dynamic/Extens/Left/Previous/Vmax/Window/<Scale(X/XP>:
Center point:
Magnification or Heigh<current>:
Avem nevoie de două valori pentru această funcţie: noul punct centru şi
factorul curent de afişare multiplicat cu 2. Vom obţine cele două puncte de
la utilizator prin suspendarea evoluţiei funcţiei şi vom obţine factorul de
afişare prin setarea variabilei de sistem VIEWSIZE.
Simbolul "pause"
Putem obţine un punct de la utilizator prin legarea unei variabile cu setq şi
getpoint şi transferarea variabilei către comanda ZOOM.
(setq pt (getpoint “Center point: “))

(command “zoom” “c” pt ...)
Putem suspenda cererile de comandă care vin din AutoCAD pentru a
permite utilizatorului să răspundă direct.
50099176.doc R.2.1 9/21/2011 •99

AUTODESK, INC.
(command “zoom” “c” pause ...)

Simbolul special AutoLISP pause este folosit ca argument pentru funcţiile
tip command. pause suspendă evaluarea expresiei şi permite utilizatorului să
raspundă în linia de comandă unde este introdus (în cazul ilustrat mai sus,
cererea pentru un nou punct de centru pentru afişare).
Variabile de sistem AutoCAD

Funcţia AutoLISP getvar are un singur argument: numele unei variabile de
sistem exprimată sub forma unui şir, adică între ghilimele. Funcţia
returnează valoarea variabilei de sistem.
În acest exemplu funcţia getvar returnează valoarea variabilei de sistem

VIEWSIZE .
Command: (getvar “viewsize”)
Funcţia ZPLUS
Avem toate instrucţiunile necesare pentru definirea funcţiei noastre.
• O modalitate de a suspenda comanda ZOOM şi de a permite
utilizatorului să selecteze un nou punct de centru.
• O modalitate de a obţine factorul de afişare curent zoom.
Exemplu
Introduceţi expresiile care urmează. Creaţi o nouă funcţie numită zplus şi
folosiţi-o. zplus va afişa noul punct de centru pe care îl selectaţi cu factorul
2. defun zp
Command: (defun zplus() )
1> (setq zplus-height (*0.5 (getvar “viewsize”)))
1> (command “zoom” “c” pause zplus-height))
ZPLUS
Command: (zplus)
All/Center/Dynamic/Extens/Left/Previous/Vmax/Windows/<Scale(X/XP)>:
Center point: pick a point 4.
Magnification or Heigh<9.0000>:4.5.000000000
Command: nil
Command:
Funcţia C:ZPLUS
O sintaxă specială pentru numele funcţiei definite de utilizator ne permite
să apelăm funcţia sub o formă prescurtată fără să folosim paranteze.
Această funcţie apare mai curînd sub forma unei comenzi AutoCAD decît
sub forma unei funcţii.
•100
Dacă numele unei funcţii începe cu litera C:, atunci funcţia poate fi apelată
fie sub forma unei funcţii sau sub forma unei comenzi.
Dacă numele unei funcţii începe cu caracterul C:, funcţia poate fi apelată pe
linia de comandă fie ca o funcţie, fie ca o comandă.
În acest exemplu, funcţia c:zplus este apelată ca o funcţie şi ca o comandă.
Exemplu
Introduceţi expresiile care urmează. Definiţi funcţia c:zplus şi apelaţi-o în
ambele moduri, ca o funcţie şi ca o comandă.
Command: (defunc: zplus ()
1> (setq zplus-height (* 0.5 (getvar "viewsize")))
1> (command "zoom" "c" pause zplus-height))
C:ZPLUS
Command: (c:zplus)
All/Center/Dynamic/Extents/Left/Previous/Vmax/Window/<Scale(X/XP)>:c
Center point: pick a point
Magnification or Height <2.250000>: 1125000000000
Command: nil
Command:zplus
All/Center/Dynamic/Extents/Left/Previous/Vmax/Window/<Scale(X/XP)>:
c Center point: pick a point
Magnification or Height <9.0000>: 4.5000000000
Command:nil
Command:
Recapitulare
• Simbolul pause permite utilizatorului să răspundă la o cerere

dintr-o comandă AutoCAD apelată de funcţia AutoLISP de
tip command.
• Funcţia getvar stabileşte valoarea variabilei de sistem.
• Prefaţînd numele unei funcţii definită de utilizator cu C: se
crează o nouă comandă AutoCAD
50099176.doc R.2.1 9/21/2011 •101

AUTODESK, INC.
EXERCITIUL 14: CREAREA DE NOI COMENZI AUTOCAD
Trebuie să completaţi partea I a acestui exerciţiu, deoarece se vor face

referiri la această parte şi în alte exerciţii.

• Crea comenzi noi în AutoCAD din funcţii AutoLISP.
• Modifica o funcţie existentă dintr-un exerciţiu anterior şi o
veţi transforma într-o comandă.
Partea I
1. Modificaţi funcţia rectangle din partea a III-a a exerciţiului 11-1.

2. Definiţi funcţia ca c:rectangle.
3. Scrieţi funcţia mai jos.
Partea a II-a
1. Definiţi o funcţie numită c:zminus.
2. Aceasta trebuie să facă aceleaşi lucruri ca şi funcţia c:zplus, dar
schimbaţi factorul de afişare de la 2 la 1/2.
3. Scrieţi funcţia mai jos.
•102
Fişierele program AutoLISP

Puteţi crea funcţii definite de utilizator introducînd codul corespunzător în
linia de comandă. Pentru definirea funcţiilor şi pentru succesiuni complexe
de s-expresii este adesea mult mai eficient să folosiţi un editor de text şi să
scrieţi funcţiile sau expresiile într-un fişier de tip text cu o extensie .lsp.
Codul din fişier poate fi încărcat în editorul grafic cu ajutorul funcţiei
AutoLISP load.
Obiective
• Cum să scrieti fişiere text care conţin programe AutoLISP.
• Cum să încarcaţi fişierele program AutoLISP în editorul
grafic AutoCAD.
• Cum lucrează funcţia AutoLISP load.
• Cum să recunoaşteţi cele mai frecvente mesaje de erori în
timpul incărcării.
Evaluarea la încărcarea fişierului
Funcţia load citeşte pe rînd expresiile dintr-un fişier şi evaluează fiecare

expresie în parte. Valoarea returnată de funcţia load este valoarea ultimei
expresii care a fost evaluată.
Funcţia load cere un singur argument de tip şir: numele fişierului .lsp de
încărcat.
(load “filename”).
Dacă adăugaţi codul pentru funcţia c:rectangle la numele unui fişier
rectang.lsp puteţi încărca fişierul într-o sesiune de editare grafică fără să
reintroduceţi întreaga definiţie a funcţiei
NOTĂ • Funcţia AutoLISP load este diferită de comanda AutoCAD LOAD.
50099176.doc R.2.1 9/21/2011 •103

AUTODESK, INC.
Căutarea fişierului
AutoLISP-ul va căuta fişierul rectang.lsp în directorul curent împreună cu
alte directoare menţionate în specificarea de cale a bibliotecii AutoCAD-
ului. Dacă găseşte fişierul, îl va încărca în editor.
Pentru lista de directoare aflate în specificarea de cale a bibliotecii

AutoCAD consultaţi descrierea funcţiei findfile în capitolul 4 din AutoLISP
Programmer's Reference Manual.
Mesaje de eroare la încărcare

Dacă AutoLISP-ul afişează un mesaj de eroare la încărcarea fişierului,
trebuie să editaţi fişierul şi să corectaţi eroarea.
Lista erorilor AutoLISP şi a cauzelor acestora se află în Appendix D din

AutoLISP Programmer's Reference Manual. O listă succintă a erorilor pe
care este posibil să le întîlniţi la încărcare este dată mai jos. Majoritatea
mesajelor indică erori tipice de programare AutoLISP cum ar fi:
• Ortografierea greşită a funcţiilor sau a numelor simbol
• Tipuri greşite de argumente la funcţie
• Paranteze neîmperecheate
• Ghilimele neîmperecheate
Mesaje de eroare Explicatii
can't open file for input -- LOAD failed Fisierul numit in Functia load nu poate fi
gasit., sau utilizatorul nu are acces sa
citeasca fisierul.
extra right paren S-a detectat una sau mai multe paranteze
dreapta in plus.
insufficient string space Nu exista spatiu suficient pentru a aranja sirul

text specificat, de obicei datorita ghilimelelor
neimperecheate.
malformed list O lista citita dintr-un fisier s-a terminat

prematur. Cea mai frecventa cauza este
imperecherea gresita a parantezelor sau a
ghilimeleor..
Tabelul 18. Mesaje de eroare la incarcare
•104
Recapitulare
• Programele AutoLISP pot fi stocate în fişiere text externe.

• Fişierele AutoLISP au extensia .lsp.
• Funcţia load încarcă un program AutoLISP în AutoCAD.
• AutoLISP-ul vă atrage atenţia printr-un mesaj de eroare dacă
are o problemă la încărcarea fişierului.
50099176.doc R.2.1 9/21/2011 •105

AUTODESK, INC.
EXERCITIUL 15: INCARCAREA UNUI FISIER SURSA AUTOLISP

• Crea un fişier program AutoLISP.
• Încărca fişierul în editorul grafic .
• Folosi comanda definită de fişier.
Instrucţiuni
1. Folosiţi editorul text pe staţia dvs. de lucru. Rugaţi instructorul să

vă ajute să configuraţi editorul de text în sistemul dvs.
2. Creaţi un fişier de text numit rectang.lsp.
3. Salvaţi fişierul în directorul de lucru.
4. Încărcaţi fişierul în editorul grafic.
5. Folosiţi comanda RECTANGLE.
(defun c:rectangle ()
(setq pt1 (getpoint "ănFirst corner: "))
(setq pt3 (getpoint "ănOther corner: "))
(command
"_.pline"
pt1
(list (car pt1) (car (cdr pt3)))
pt3
"c"
)
)
Command: (load "rectang")
C:RECTANGLE
Command: rectangle
First corner:
•106
Sugestii de programare optimă a funcţiilor C:

Acest capitol tratează o serie de aspecte referitoare la interfaţa şi operaţiile
interne ale funcţiilor C:, dar aceste rezultate pot fi aplicate la orice definiţie
a unei funcţii nu numai la cele a căror nume începe cu C:.
Obiective
• Cum se întrerupe execuţia unei funcţii definite de utilizator.
• Cum să anulaţi afişarea cererilor de comandă AutoCAD în
timpul executării unei comenzi AutoLISP.
• Conceptul de alocare şi de variabile locale şi globale.
• Diferenţa dintre variabilele locale şi globale.
• Cum să declaraţi şi să folosiţi variabilele locale în cadrul
definiţiei funcţiei.
Returnarea şirului vid de la o funcţie C:

Valoarea ultimei expresii din corpul de expresii care urmează după
argumentele cerute şi variabilele locale din definiţia unei funcţii este
întotdeauna returnată ca valoarea funcţiei. Cred că aţi observat că funcţia
c:rectangle returnează nil. Acest lucru este evident deoarece o funcţie de
apelare de tip command este ultima expresie din corpul definiţiei funcţiei
c:rectangle şi funcţia de tip command returnează întotdeauna nil.
Funcţia AutoLISP prin1 va vizualiza un şir vid pe ecran dacă prin1 este
ultima expresie din definiţia funcţiei. De exemplu, această versiune
modificată a comenzii RECTANGLE nu vizualizează nil la cererea de
comandă după ce aceasta a fost executată.
50099176.doc R.2.1 9/21/2011 •107

AUTODESK, INC.
( defun c:rectangle ()
(command
"_.pline"
pt1
pt3
"c"
)
(prin1)
)
Anularea afişării cererilor de comandă AutoCAD

Implicit AutoCAD-ul dublează toate comenzile şi opţiunile în zona liniei
de comandă, incluzind şi pe cele emise de un program AutoLISP.
Variabila de sistem CMDECHO poate suprima această "comandă dublă".
În această versiune modificată a funcţiei c:rectangle , CMDECHO este setată pe

off la startul rutinei iar la ieşire este setată pe on.
(defun c:rectangle ()
(setq old_cmdecho (getvar "CMDECHO"))
(setvar "CMDECHO" 0)
(command "pline"
pt1
pt3
"c"
)
(setvar "CMDECHO" old_cmdecho)
(prin1)
)
Alocarea: Moduri de legare a unei variabile

AutoLISP-ul foloseşte o schemă dinamică de alocare. Alocarea unei
variabile este determinată în timpul funcţionării de ordinea apelării funcţiei
şi de declaraţiile de variabilă.
Variabilele sînt legate în două moduri: global şi local
O variabilă globală este o variabilă a cărei legare (sau atribuire a unei

valori) a fost făcută cu ajutorul funcţiilor set şi setq şi nedeclarată locală în
funcţie. Variabilele globale pot fi vizualizate sub forma de liste pe ecran
folosind funcţia de apelare (familia de atomi 0).
•108
Variabilele globale sînt accesibile tuturor funcţiilor definite de utilizator atît

pentru citire cît şi pentru scriere.Variabilele globale sînt adesea folosite
pentru "comunicare" între programele AutoLISP. De exemplu Programul 1
va seta o condiţie într-o variabilă globală pe care Programul o va verifica
înainte de a acţiona.
O variabilă locală este o variabilă a cărei legare a fost facută cu ajutorul

funcţiilor set şi setq în cadrul unei funcţii a cărei variabilă a fost declarată
locală sau cu ajutorul declaraţiei sub forma unui argument cerut la o
funcţie.
Variabilele locale îşi menţin legătura numai în contextul unei funcţii în

care au fost declarate ca fiind locale. Ele îşi pierd legătura odată cu ieşirea
funcţiei.
Legarea unei variabile globale se poate schimba în cazul alocării unei

funcţii în care o variabilă cu acelaşi nume a fost declarată local. La ieşirea
funcţiei, variabila este legată din nou de valoarea globală originală.
Un set de s-expresii ilustrează aceste concepte.
Exemplu
Citiţi explicaţiile şi introduceţi s-expresiile adecvate.
Mai întîi veţi lega global variabila x de valoarea 1.

Command: (setq x 1)
1
Command: !x
1
Apoi veţi defini o funcţie local_arg care îl declară pe x ca argument. Legarea
lui x se poate schimba local în cadrul alocării funcţiei local_arg şi legarea
globală va fi restabilită la ieşirea funcţiei local_arg .
Command: (defun local_arg (x) (print x) (* x x))
LOCAL_ARG
Command: (local_arg 2)
2
4
Command: !x
1
Apoi veţi defini o funcţie local_var care îl declară pe x ca variabilă locală.
Legarea lui x se poate schimba local în cadrul alocării funcţiei local_var şi
legarea globală va fi restabilită la ieşirea funcţiei local_var.
Command: (defun local_var (/ x) (setq x 3) (print x))
LOCAL_VAR
Command: (local_var)
50099176.doc R.2.1 9/21/2011 •109

AUTODESK, INC.
3
Command: !x
1
Veţi defini apoi o funcţie global_var unde variabila x nu a fost definită nici
ca argument nici ca variabilă locală; de aceea schimbarea în interiorul
legăturii se va face global, în afara alocarii funcţiei global_var.
Command: (defun global_var () (setq x 4) (print x))
GLOBAL_VAR
Command: (global_var)
4
Command: !x
4
Folosirea variabilelor locale

Funcţia c:rectangle a fost pe deplin clarificată. În acest exemplu, variabilele
old_emdecho, pt1 şi pt2 sînt declarate ca fiind locale la funcţie; deci ele nu pot
intra în conflict cu variabilele globale care au acelaşi nume şi nici cu
variabilele cu acelaşi nume care pot fi găsite în cadrul altor funcţii.
(defun c:rectangle (/ old_cmdecho pt1 pt3)

(command "pline"
pt1
pt3
"c"
)
(prin1)
)
Declaraţia variabilelor locale se face de obicei după un program care a fost

verificat şi pus la punct întrucît declaraţia face dificilă sau chiar imposibilă
examinarea valorilor lor în cazul în care funcţia abortează sau face ceva
neaşteptat din cauza unei erori în cod.
Globalizarea variabilelor de sistem

Variabilele de sistem apelate de funcţia AutoLISP setvar nu se traduc
niciodată din limba engleză în limba utilizatorului. Cererile de apelare a
funcţiei setvar funcţionează în toate versiunile AutoCAD-ului fără să
necesite traducerea numelui variabilei de sistem din limba engleză în limba
utilizatorului.
•110
Variabilele de dimensiune se traduc numai în linia de comandă pentru

dimensionare.
Redefinirea comenzii
Puteţi înlocui comenzile AutoCAD existente cu comenzi AutoLISP care au
acelaşi nume.
Utilizatorul poate apela o comandă AutoCAD prin prefaţarea numelui

comenzii prin caracterul punct (.), de exemplu, .LINE, indiferent dacă
comanda a fost nedefinită.
Este bine să prefaţaţi numele unei comenzi apelate de funcţia AutoLISP de

tip command printr-un punct (.) sau prin subliniere (pentru a vă asigura că
funcţioneaza în toate limbile).
Sînt două etape de parcurs pentru înlocuirea comenzii AutoCAD cu o

comandă AutoLISP care are acelaşi nume.
• Folosiţi comanda UNDEFINE pentru a anihila o comandă
AutoCAD pentru sesiunea de editare curentă.
• Creaţi o funcţie AutoLISP care are acelaşi nume ca şi
comanda AutoCAD şi prefaţaţi-o cu c:.
Puteţi redefini o comandă AutoCAD folosind comanda REDEFINE.
Exemplu
Anihilaţi comanda AutoCAD LINE.

Command: undefine
Command name: line
Înlocuiţi-o cu o comandă AutoLISP cu acelaşi nume care desenează o linie
segment. Apelaţi versiunea englezească a comenzii AutoCAD LINE din
cadrul funcţiei AutoLISP.
Command: (defun c: line () (command “._ line “ pause pause “”))
C: LINE
Apelaţi comanda LINE.
50099176.doc R.2.1 9/21/2011 •111

AUTODESK, INC.
Command: line
.- line From point: pick a point
To point pick a point
To point:
Command: nil
Redefiniţi comanda AutoCAD.
Command: redefine
Command name: line
•112
Recapitulare
• Puteţi ieşi dintr-o funcţie apelînd prin1 sau princ care

reprezintă ultima expresie în corpul definitiei funcţiei.
• Variabila de sistem CMDECHO poate suprima afişarea
cererilor de comandă AutoCAD.
• AutoLISP-ul utilizează o schemă dinamică de alocare.
• Variabilele globale sînt accesibile pentru toate funcţiile.
• Variabilele locale sînt accesibile numai în contextul
funcţiilor în care au fost declarate.
• Puteţi folosi variabile locale în cadrul funcţiilor pentru a
evita posibilitatea unor conflicte între variabile cu aceleaşi
nume din alte funcţii.
• Variabilele de sistem apelate de funcţia setvar nu se traduc
niciodată din engleză.
• Comenzile AutoCAD pot fi înlocuite cu comenzi AutoLISP
care au acelaşi nume, folosind comanda UNDEFINE.
• Comanda AutoCAD va fi întotdeauna apelată cînd numele
comenzii este prefaţat printr-un punct; de exemplu .LINE,
indiferent dacă comanda a fost anihilată.
• Prefaţaţi întotdeauna numele unei comenzi cu un punct (.)
sau prin caracterul subliniere ( _ ) în cazul funcţiei de tip
command .
• Prefaţaţi întotdeauna opţiunea de comandă prin caracterul
subliniere ( _ ) în cazul funcţiei de tip command.
50099176.doc R.2.1 9/21/2011 •113

AUTODESK, INC.
EXERCITIUL 16: FUNCTIA DE PROGRAMARE OPTIMA
• Veţi consolida cunoştinţele cu privire la ordonarea
funcţiilor C:, incluzînd ieşirea funcţiilor, dublarea cererii de
comandă şi declaraţia variabilei locale.
• Veţi modifica fişierul rectang.lsp pentru a introduce noi
concepte din acest capitol.
• Veţi crea un nou fişier text cu o funcţie modificată.
Partea I
Etape de lucru
1. Modificaţi fişierul rectang.lsp
2. Adăugaţi funcţia de ieşire imediată.
3. Anulaţi ecoul cererii de comandă.
4. Declaraţi variabilele corespunzătoare ca variabile locale.
5. Încărcaţi, lansaţi şi testaţi programul după ce aţi făcut modificările.
Partea a II-a
Etape de lucru
1. Rescrieţi funcţia c:zplus de la sfîrşitul capitolul 12 într-un
fişier numit zplus.lsp.
2. Folosiţi funcţia getpoint pentru a obţine noul punct de centru a
ecranului.
3. Anulaţi ecoul din opţiunile şi cererile de comandă ZOOM.
4. Declaraţi toate variabilele local.
5. Introduceţi funcţia de ieşire.
6. Încărcaţi, demaraţi şi testaţi programul după ce aţi făcut
modificările.
NOTA • Funcţiile GETxxx nu pot fi folosite în cadrul expresiilor

funcţiilor command; de exemplu, (command "line" (getpoint)) nu este permisă.
•114
Teste logice şi de egalitate

Programele AutoLISP pot face un salt pe baza valorii unei expresii test.
Obiective
• Cum se poate schimba controlul desfăşurarii unui program
pe baza unei expresii test.
• Cum să folosiţi testele de egalitate şi testele logice ca
expresii test.
• Diferenţa dintre simbolul t şi simbolul nil.
• Cum să determinaţi tipul de date al unui obiect.
Ramificarea programului
Aceasta diagrama simplă ilustrează principiul ramificării programului.
Figura 39. Ramificarea programului bazata pe testul de conditie
În această diagramă, dacă valoarea variabilei x este egală cu şirul de tip text
"Hello, world", atunci programul se va ramifica în expresia y şi va continua;
dacă nu , se va ramifica în expresia z şi va continua.
Funcţiile care realizează testele condiţionale sînt folosite pentru ramificaţii
în interiorul programelor AutoLISP. Cele două funcţii de bază pentru
testele condiţionale sînt:
• if
• cond
Unele valori sau seturi de valori sînt testate cu if sau cond iar programul se
ramifică conform rezultatelor testului. AutoLISP-ul dispune de o varietate
de funcţii care testează valorile pe baza anumitor criterii sau unele valori pe
50099176.doc R.2.1 9/21/2011 •115

AUTODESK, INC.
baza celorlalte. În acest capitol ne concentrăm atenţia asupra unora dintre

cele mai utilizate funcţii de acest tip.
• =, >, <
• equal
• and
• or
• not
• logand
t si nil
În AutoLISP, simbolul t este echivalentul pentru "adevărat" în orice test
condiţional. Simbolul nil este echivalentul lui "fals".
Dacă o expresie AutoLISP nu se evaluează, atunci expresia este nil sau

falsă. Dacă o expresie nil este folosită într-un test condiţional, atunci va fi
executată o ramificaţie pentru o condiţie falsă.
Dacă o expresie AutoLISP evaluează orice altceva decît nil, atunci expresia
este t sau adevărată. Dacă o expresie t este folosită într-un test condiţional,
atunci va fi executată ramificaţia pentru o condiţie adevarată.
tşi nil se exclud mutual. Dacă o expresie este t, atunci nu poate fi nil. Dacă
o expresie este nil, atunci nu poate fi t.
•116
EXERCITIUL NR 17: OBIECTELE SI EXPRESIILE POT FI T SAU NIL
• Veţi învăţa să determinaţi dacă valoarea returnată a unei
funcţii este t sau nil.
Instrucţiuni
1. Într-un desen nou, desenaţi o entitate de tip linie.
2. Introduceţi expresiile în coloana din stînga a tabelului.
3. Determinaţi dacă expresiile sînt t sau nil.
4. Verificaţi căsuţa adecvată din tabel.
Expresie t nil
(setq ename (entnext))
!ename
(setq ename (entnext ename))
!ename
(+ 1 2)
(- 1 1)
()
(command "erase" "last" "")
(command "u")
Tabelul 19. Expresiile pot fi t sau nil
50099176.doc R.2.1 9/21/2011 •117

AUTODESK, INC.
Funcţii care testează egalitatea

Funcţia = are două sau mai multe argumente cu orice tip de date. Această
funcţie verifică dacă toate argumentele au valori echivalente. Dacă da,
funcţia returnează t; dacă nu, returnează nil.
De exemplu, această expresie verifică dacă valorile numărului real 4.0 şi

expresia (+ 2.0 2.0) sînt echivalente
Command: (= 4.0 (+ 2.0 2.0))
T
Această expresie verifică dacă 4.0 este echivalent cu expresia (+ 1.5 2.0)
Command: (= 4.0 (+ 1.5 2.0))
nil
Funcţia < verifică dacă primul ei argument este numeric mai mic decît al
doilea argument.
Command: (< 45 50)
T
Funcţia equal este în esenţă aceeaşi cu funcţia =.
Exerciţiu
Legaţi două variabile de valori numerice. Folosiţi variabilele ca argumente
la cîteva funcţii şi verificaţi rezultatele.
Command: (setq x 1)
1

1.5
Verificaţi dacă x este mai mic decît y.

Command: (< x y)
T
Verificaţi dacă x este mai mare decît y.

Command: (> x y)
nil
•118
Verificaţi dacă y este mai mare sau egal cu 1,5.

Command: (>= y 1.5)
T
Verificaţi dacă x este mai mic sau egal cu y.
Command: (<= x y)
T
Verificaţi dacă x nu este egal cu y.

Command: (/= x y)
T
Acest tabel arată funcţiile care verifică egalitatea în AutoLISP.
Functie Test
= Egal cu
/= Nu este egal cu
< Mai mic decit
<= Mai mic sau egal cu
> Mai mare decit
>= Mai mare sau egal cu
minusp Mai mic decit zero
zerop Egal cu zero
equal Egal cu
eq Au aceeasi legatura
Tabelul 20. Functii de egalitate
50099176.doc R.2.1 9/21/2011 •119

AUTODESK, INC.
Funcţii care verifică tipul de date

AutoLISP-ul dispune de cîteva funcţii care verifică tipul de date ale unui
simbol sau expresii.
Functie Test
ATOM Este argumentul un atom?
LISTP Este argumentul o lista?
BOUNDP Este argumentul legat de o valoare?
NULL Este argumentul nil?
NUMBERP Este argumentul un număr?
Tabelul 21. Functii care testeaza tipul de date
Exemplu
Legaţi trei variabile de trei tipuri de date diferite: un simbol, un număr real
şi o listă.
Command: (setq x 'abc)
ABC

1.0
Command: (setq z '(1 2 3))

(1 2 3)
Folosiţi variabilele ca argumente la funcţii care testează tipul de date.
Examinaţi rezultatele funcţiilor.
Sînt aceste variabile atomi?

Command: (atom x)
T
Command: (atom y)
T
Command: (atom z)
nil
Sînt aceste variabile liste?
Command: (listp x)
nil
Command: (listp y)
nil
Command: (listp z)
T
•120
Combinarea funcţiilor type cu funcţiile "="

Puteţi verifica tipul de date al unui obiect în AutoLISP folosind fie funcţia
=, fie funcţia equal cu funcţia type.
Exemplu
Legaţi două variabile cu tipuri de date diferite: un număr întreg şi un număr

real.
Command: (setq x 1)
1

1.5
Folosiţi funcţiile type şi = pentru a verifica tipul lor de date.

Command: (= (type x) 'INT)
T
Command: (equal (type x) 'REAL)

nil
Command: (equal (type y) 'REAL)

T
50099176.doc R.2.1 9/21/2011 •121

AUTODESK, INC.
Funcţii logice
Există cîteva funcţii de test logic în AutoLISP. În acest capitol vom studia
patru dintre cele mai importante funcţii: not, and, or şi logand.
Funcţia not
Funcţia not solicită un argument. Dacă argumentul este nil, atunci expresia
returnează t; dacă nu, aceasta returnează nil.
Funcţia not este o funcţie a cărei valoare returnată este opusul argumentului
ei. Daţi-i nil şi va returna t. Daţi-i t şi va returna nil.
Exemplu
Command: (not nil)
T
Command: (not t)
nil
Funcţia and
Funcţia and solicită unul sau mai multe argumente. Dacă unul dintre
argumente este nil, ea returnează nil. Dacă toate argumentele sînt t , atunci
returnează t.
Funcţia and opreşte procesarea de îndată ce găseşte un argument nil. Unele

programe sînt scrise în acord cu acest comportament. De exemplu, puteţi fi
siguri că programul nu va găsi o instrucţiune într-o listă de argumente ale
funcţiei and dacă nici unul dintre argumentele anterioare nu este nil.
Exemplu
Command: (and 1 2 3)
T
Command: (and 1 2 nil)

nil
Funcţia or
Funcţia or solicită unul sau mai multe argumente. Dacă unul dintre
argumente este t, funcţia returnează t. Dacă toate argumentele sînt nil,
atunci funcţia returnează nil.
Funcţia or opreşte procesarea de îndată ce găseşte un argument t. Unele

programe sînt scrise în conformitate cu acest comportament. De exemplu,
puteţi fi siguri că programul nu va găsi o instrucţiune într-o listă de
argumente ale funcţiei or dacă nici unul dintre argumentele anterioare nu
este t.
•122
Exemplu
Command: (or 1 2 3)
T
Command: (or 1 2 nil)

T
Command: (or nil nil nil)

nil
Funcţia logand
Funcţia logand are două sau mai multe argumente care ar trebui să fie
numere întregi. Funcţia returnează un număr întreg.
Funcţia logand realizează o comparaţie AND bit cu bit a biţilor din

argumentele care sînt numere întregi. Dacă un bit este setat la valoarea
"adevărat" în toate argumentele funcţiei logand, atunci acel bit este setat la
valoarea "adevărat" şi în valoarea returnată.
Numerele întregi 7, 3 şi 15 sînt reprezentate în biţi în tabelul de mai jos.
Intreg 1 bit 2 bit 4 bit 8 bit 16 bit
7 X X X
3 X X
15 X X X X
Tabelul 22. Biti setati la valoarea "adevarat" in trei numere intregi.
Această expresie va returna un număr întreg în care toţi biţii care sînt setaţi
la valoarea "adevărat" în toate cele trei argumente vor fi setaţi la valoarea
"adevărat”. În acest caz, biţii pentru valorile 1 şi 2 vor fi returnaţi ca
"adevărat" de către expresie, deoarece sînt singurii biţi setaţi "adevărat" în
toate cele trei argumente.
Command: (logand 7 15 3)
3
Funcţia logand va fi de folos atunci cînd va fi folosită împreună cu funcţiile

"entity access" mai tîrziu în acest curs, în special cu valorile binare cum ar
fi codurile grupului 70 DXF pentru Polylines şi Block Definitions .
50099176.doc R.2.1 9/21/2011 •123

AUTODESK, INC.
Recapitulare
• Ramificarea unui program depinde de valoarea unui test
condiţional.
• Toate obiectele şi expresiile din AutoLISP sînt t sau nil.
• AutoLISP dispune de o varietate de funcţii care testează
tipul de egalitate şi tipul de date ale obiectelor şi expresiilor.
• Puteţi testa tipul exact de date al unui obiect combinînd
funcţiile type şi =.
• Funcţiile logice not, and şi or verifică dacă una sau mai multe
expresii sînt t sau nil.
• Funcţia logand realizează o comparaţie AND bit cu bit a unei
liste de numere; aceasta funcţie va fi de ajutor în combinaţie cu
funcţiile de tip entity access mai tîrziu.
•124
Expresii test şi expresii condiţionale
Funcţiile de egalitate şi funcţiile logice sînt folosite în

expresii test. Expresiile test sînt folosite în expresii
condiţionale şi iterative formate din funcţii ca if şi while. Ele
verifică dacă există o anumită condiţie şi arată AutoLISP-
ului ce funcţie să execute care depinde de condiţie, sau de
rezultatul testului.
NOTĂ • Orice atom, simbol sau expresie poate fi folosită ca expresie test
deoarece orice obiect în LISP are o valoare: fie nil, fie altceva.
Obiective
• Cum să folosiţi expresiile condiţionale pentru a face salt la
diferite seturi de expresii în cadrul programului AutoLISP
• Sintaxa funcţiilor if şi cond.
• Cum să folosiţi funcţia progn pentru a executa multiple s-
expresii în cadrul funcţiei if.
Expresii condiţionale
Expresiile condiţionale controlează desfăşurarea unui program AutoLISP.

Folosim expresiile test pentru a verifica dacă o anumită condiţie există, iar
rezultatul expresiei test este folosit pentru a comuta expresia condiţională.
Expresia condiţională poate opta pentru execuţia programului în oricare din
cele cîteva direcţii posibile. Fiecare direcţie va avea un set de expresii de
evaluat în AutoLISP.
Cele mai folosite expresii condiţionale în AutoLISP sînt funcţiile if şi cond.
Funcţia if
Funcţia if are două argumente obligatorii şi un al treilea argument care este
opţional.
Dacă valoarea primului argument este t, adică oricare în afară de nil,

AutoLISP-ul evaluează al doilea argument.
Dacă valoarea primului argument este nil, AutoLISP-ul sare peste al doilea
argument. Dacă există cel de-al treilea argument opţional, AutoLISP-ul il
evaluează.
50099176.doc R.2.1 9/21/2011 •125

AUTODESK, INC.
Simplificînd puţin lucrurile, funcţia if ar arăta cam aşa:
(if
(I_return_true)
(do_this)
(else_do_this)
)
Exemplu
Introduceţi expresiile care urmează:
Legaţi variabila x de o valoare a lui 1. Legaţi valoarea lui y bazată pe

valoarea lui x.
Command: (setq x 1)
1
Command: (if (= x 1) (setq y 1) (setq y 0))

1
Command: !y
1
Legaţi variabila x de o valoare a lui 0. Legaţi variabila y bazată pe valoarea
x.
Command: (setq x 0)
0
Command: (if (= x 1) (setq y 1) (setq y 0))

0
Command: !y
0
•126
EXERCITIUL 18: RAMIFICAREA PROGRAMULUI FOLOSIND FUNCTIA IF
În acest exerciţiu :
• Veţi folosi funcţia if.

• Veţi scrie o funcţie pentru a comuta SNAP pe on sau off în
funcţie de setarea curentă.
Etape de lucru
1. Într-un fişier nou, folosiţi editorul de text pentru a crea o funcţie
numită c:snaptog.
2. Introduceţi codul de mai jos.
3. Funcţia ar trebui să comute modul SNAP în funcţie de valoarea
curentă.
(defun c:snaptog (/ snapval)
(setq snapval (getvar "SNAPMODE")) ;get current SNAPMODE
(if
(= 1 snapval) ;if it's on...
(setvar "SNAPMODE" 0) ;turn it off...
(setvar "SNAPMODE" 1) ;otherwise, turn it on
)
(prin1) ;quiet exit
4. Salvaţi funcţia într-un fişier numit snaptog.lsp din directorul student.

5. Încărcaţi fişierul în AutoCAD.
6. Desenaţi cîteva entităţi tip Line şi Circle.
7. Folosiţi SNAPTOG pentru a comuta SNAP pe on sau off cînd desenaţi
entităţile.
NOTĂ • Încercaţi să apelaţi SNAPTOG în cadrul unei comenzi LINE sau

CIRCLE .
50099176.doc R.2.1 9/21/2011 •127

AUTODESK, INC.
Expresii multiple în cadrul funcţiei if.

Funcţia if permite execuţia unei singure expresii după ce a fost evaluată
expresia test.
Puteţi face ca expresii multiple să apară ca o singură expresie la funcţia if

prin amplasarea acestora în cadrul expresiei progn.
Funcţia progn evaluează pe fiecare dintre argumentele sale, pe rînd şi

returnează valoarea ultimului argument. Expresii multiple aflate în cadrul
funcţiei progn apar sub forma unei simple expresii la o funcţie de apelare.
În acest exemplu, dacă variabila x este egala cu 1, atunci valorile vor fi

atribuite ambelor variabile y şi z. Asignarea este realizată de două s-
expresii.
Exemplu
Command: (setq x 1)
1
Command: (if (= x 1) (progn (setq y 2) (setq z 3)) (setq y 0))

3
Command: !y
2
Command: !z
3
•128
EXERCITIUL 19: EXPRESII MULTIPLE IN CADRUL FUNCTIEI IF
• Veţi modifica funcţia existentă de la exerciţiul 18.
• Veţi folosi funcţia progn.
• Veţi executa s-expresii multiple prin apelarea unei funcţii if.
Etape de lucru
1. În editorul de text, deschideţi fişierul snaptog.lsp din directorul
student.
2. Redenumiţi funcţia c:modetog.
3. Cu ajutorul funcţiei progn, adăugaţi codul care comută SNAPMODE şi
GRIDMODE pe baza valorii curente a lui SNAPMODE.
4. Salvaţi fişierul pe disc ca modetog.lsp.
5. Încărcaţi programul modificat în AutoCAD.
6. Testaţi comanda MODETOG.
50099176.doc R.2.1 9/21/2011 •129

AUTODESK, INC.
Funcţia cond
Funcţia cond cere un argument obligatoriu şi un număr oarecare de
argumente opţionale.
Fiecare argument al funcţiei cond poate fi un set de expresii incluse într-o

listă externă.
Funcţia cond evaluează prima expresie în fiecare din listele de argumente,

pe rînd, pînă ce o expresie evaluează "adevărat". Atunci funcţia cond
evaluează expresiile care urmează primei expresii din cadrul argumentului
şi returnează.
Funcţia cond este de preferat funcţiei if ori de cîte ori există mai mult de
două cazuri de testat, adică mai mult de două ramificări în orice punct din
program.
Exemplu
Această definiţie a funcţiei va introduce valori diferite în zona liniei de
comandă, în funcţie de valoarea numerică a variabilei x.
Fiţi atenţi în mod special la modul în care pot fi construite argumentele la

funcţia cond. Prima expresie dintr-un argument este expresia test şi
expresiile care urmează după test vor fi evaluate dacă argumentul test este
adevărat.
Funcţia cond opreşte testarea argumentelor de îndată ce găseşte un argument

a cărui expresie test este adevarată, adică nu este nil.
(defun testx (x)
(cond
(
(= x 0)
(prompt "ănX equals 0.")
)
(
(< x 0)
(prompt "ănX is less than 0.")
)
(
(> x 0)
(prompt "ănX is greater than 0.")
)
)
(prin1)
)
Recapitulare
Funcţia if testează o expresie şi se ramifică spre oricare dintre cele două s-
expresii.
Funcţia progn este folosită pentru a executa s-expresii multiple în cadrul

funcţiei if.
•130
Funcţia cond poate testa mai multe expresii şi poate executa orice număr de
s-expresii într-o ramificaţie dată.
50099176.doc R.2.1 9/21/2011 •131

AUTODESK, INC.
EXERCITIUL 20: UTILIZAREA FUNCTIEI COND PENTRU RAMIFICAREA PROGRAMULUI
• Veţi folosi funcţia cond în cadrul unei funcţii noi.
• Veţi testa o variabilă pentru egalitate numerică.
• Veţi executa toate trei ramificaţiile expresiei cond.
Etape de lucru
1. Creaţi o nouă funcţie într-un nou fişier cu ajutorul editorului de
text.
2. Numiţi această funcţie testx.
3. Funcţia cere un argument obligatoriu.
4. Într-o instrucţiune cond, folosiţi testele de egalitate pentru a vedea
dacă valoarea argumentului este egală, mai mică sau mai mare
decît 0.
5. Dacă este satisfacut un test de egalitate, folosiţi funcţia prompt
pentru a semnaliza utilizatorul.
(prompt "ănX equals 0.")
6. Salvaţi fişierul ca testx.lsp în directorul student.

8. Folosiţi funcţia testx cu valorile argumentelor 0, 1 şi -1.
•132
50099176.doc R.2.1 9/21/2011 •133

AUTODESK, INC.
Bucle de program
Buclele de program reprezintă un concept important pentru orice limbaj de
programare. Buclele permit instrucţiunilor programului să fie executate de
nenumărate ori pe baza valorii unei espresii test.
Obiective
• Cum să folosiţi buclele pentru a repeta un set de expresii.
• Sintaxa funcţiilor repeat şi while.
Explicarea modului de funcţionare a buclelor

O buclă se explică astfel:
" Testaţi o expresie. Dacă expresia este adevărată, atunci executaţi un set de
instrucţiuni ale programului, pe rînd, apoi testaţi expresia din nou. Dacă
este tot adevărată, executaţi toate instrucţiunile programului apoi testaţi din
nou expresia la infini.
Aşa lucrează funcţia while. Funcţia repeat execută un set de expresii de un

număr de ori prestabilit.
Ca exemplu să presupunem că avem un set de expresii pe care vrem să-l

executăm de 5 ori. Este mai înţelept să scrieţi setul de expresii o singură
dată în program şi să folosiţi unele funcţii care să ceară AutoLISP-ului să
repete expresiile de 5 ori decît să scrieţi setul de expresii de 5 ori.
Ca exemplu (si nu unul strălucit) vom construi o funcţie simplă de

numărare folosind funcţia repeat. Funcţia va adăuga numărul întreg 1 la
valoarea unei variabile ori de cîte ori funcţia este apelată şi apoi va tipări
valoarea variabilei în zona liniei de comandă.
•134
Funcţia repeat
Funcţia repeat cere două argumente şi un număr oarecare de argumente
opţionale.
Primul argument trebuie să fie un număr întreg (sau evaluat într-un număr
întreg). Acesta spune funcţiei repeat de cîte ori să execute al doilea
argument pînă la al n -lea argument.
Exemplu
Command: (repeat 3 (prompt "ănHello"))
Hello
Hello
Hellonil
nil de la sfîrşit este valoarea returnată de funcţia repeat.
Exemplu
Expresiile definesc funcţia count.
În funcţia count, după ce variabila num este legată de 0, valoarea lui num este
vizualizată pe monitor şi incrementată cu 1 pînă la un total de 10 ori.
Command: (defun count ()
1> (setq num 0)
1> (repeat 10 (print num) (setq num (1+ num)))
1> (prin1))
COUNT
Folosiţi funcţia count. Aceasta va introduce numerele de la 0 la 9 în zona
liniei de comandă.
Command: (count)
0
1
2
3
4
5
6
7
8
9
50099176.doc R.2.1 9/21/2011 •135

AUTODESK, INC.
O versiune ceva mai interesantă a funcţiei count va ŞTERGE ultimele trei

entitaţi desenate şi care sînt vizibile pe monitor.
Exemplu
Într-un desen nou, desenaţi cel puţin trei (3) entităţi de orice fel.
Command: (defun count () (repeat 3 (command "erase" "l" "")))

COUNT
Folosiţi funcţia count pentru a şterge ultimele entităţi din desen.
Command: (count)
Mai multe despre intrările utilizatorului

Funcţia initget poate reface valorile permise pentru intrarea utilizatorului în
timpul oricărei apelări a funcţiilor de tip GETXXX, de exemplu funcţiile
getpoint şi getdist.
Apelaţi initget care are un număr întreg ca argument şi/sau o listă de cuvinte
cheie acceptabile, imediat după apelarea unei funcţii GETXXX.
Acest exemplu admite numai numere întregi cu excepţia lui 0, ca răspuns la

getint.
(initget (+ 1 2 4))
(setq response (getint "ănEnter an integer: "))
Funcţia getkword reface un cuvînt cheie de la utilizator bazat pe un şir de
cuvinte cheie stabilite de funcţia initget.
Acest exemplu permite utilizatorului să raspundă cu YES sau NO la cererea

de comandă. Un răspuns nul sau un return nu sînt admise.
(initget 1 "Yes No")
(getkword "ănContinue? Yes/No: ")
•136
EXERCITIUL 21: BUCLARE IN PROGRAM
• Veţi consolida cunoştinţele despre bucle de program.
• Veţi consolida cunoştinţele despre funcţia cond.
• Veţi folosi funcţia repeat pentru a executa un set de s-expresii
de un număr stabilit de ori.
• Veţi scrie o funcţie care cere utilizatorului numărul de
buclări de program.
• Veţi folosi instrucţiunea cond în cadrul buclei.
Etape de lucru
1. Începeţi un desen nou în AutoCAD.
2. Desenaţi un Cerc cu centrul în punctul 5,5 şI o rază de o unitate.
3. În editorul text, deschideţi fişierul numit displace.lsp din
directorul student.
4. Creaţi funcţia c:displace . Folosiţi codul în displace.lsp ca bază
pentru funcţie.
5. DISPLACE ar trebui să execute următoarele:
• Să ceară utilizatorului o incrementare a deplasării.
• Să ceară utilizatorului de cîte ori să execute deplasarea.
• Să ceară utilizatorului direcţia de deplasare.
• Să repete codul care restabileşte ultima entitate desenată şi
care este vizualizată pe monitor şi să o deplaseze cu un
increment adecvat de un număr de ori.
continuare pe pagina urmatoare
50099176.doc R.2.1 9/21/2011 •137

AUTODESK, INC.
;No null, zero or negative response allowed

(initget (+ 1 2 4))
(setq increment (getdist "ănIncrement for movement: "))
;No null, zero or negative response allowed

(initget (+ 1 2 4))
(setq number_of_times (getint "ănNumber of times to displace: "))
;No null response allowed, setup keywords for response

(initget 1 "Up Down Right Left")
(setq direction (getkword "ănUp/Down/Left/Right: "))
(repeat number of times (command “MOVE” (entlast)”” (list 0.0 0.0 0.0)
(cond ;match direction of movement...

((= direction "Up") ;based on keyword supplied by user
(command (list 0.0 increment))
)
((= direction "Down")
(command (list 0.0 (- 0.0 increment)))
)
((= direction "Right")
(command (list increment 0.0))
)
((= direction "Left")
(command (list (- 0.0 increment) 0.0))
)
)
(command "") ;second point of displacement...

;for MOVE command prompt
6. Salvaţi fişierul text.

7. Încărcati fişierul în AutoCAD.
8. Activaţi comanda DISPLACE.
•138
Funcţia while
Funcţia repeat este cea mai simplă funcţie de buclare utilă dacă ştiţi exact de
cîte ori trebuie să repetaţi evaluarea grupului de expresii anterioare intrării
buclei.
Totuşi veţi întîlni ocazii cînd veţi dori să repetaţi ceva de un număr
nedefinit de ori; adică numărul de repetiţii nu poate fi determinat înaintea
intrării în buclă.
Într-un astfel de caz, funcţia while vă dă posibilitatea să repetaţi un set de

expresii de cîte ori este necesar pînă ce valoarea unei expresii test se
schimbă.
Exemplu
(setq x 0) ;set initial value for test
(while
(< x 10) ;while x is less than 10...
(print x) ;print value of x...
(setq x (+ 1 x)) ;add 1 to x and then...
) ;go back to test expression
Figura 40. Diagrama buclei functiei while
50099176.doc R.2.1 9/21/2011 •139

AUTODESK, INC.
Pentru a ieşi dintr-o buclă while, valoarea expresiei test trebuie să fie egală
cu nil. De aceea, dacă expresia test este iniţial t, valoarea expresiei test
trebuie să se schimbe ca rezultat al unei atribuiri din cadrul corpului buclei.
Recapitulare
• Buclele repetă un set de expresii.
• Buclele pot repeta de un număr de ori prestabilit sau pînă ce
valoarea expresiei test este nil.
• Funcţia repeat repetă un set de expresii de un număr de ori
stabilit.
• Funcţia while repetă un set de s-expresii pînă ce expresia test
este egală cu nil.
•140
EXERCITIUL 21: UTILIZAREA FUNCTIEI WHILE PENTRU BUCLARE IN PROGAM
• Veţi consolida cunoştinţele despre buclele de program din
AutoLISP.
• Veţi modifica o funcţie existentă de la exerciţiul anterior.
• Veţi crea un program care desenează dreptunghiuri multiple.
• Veţi folosi funcţia while.
Etape de lucru
1. În editorul de text, încărcaţi fişierul rectangle.lsp.
2. Salvaţi fişierul ca mrectang.lsp în directorul student.
3. Faceţi modificări în fişier.
4. Modificaţi funcţia c:rectangle pentru a cere utilizatorului să deseneze

dreptunghiuri multiple în timpul unei singure secvenţe de funcţionare.
5. Plasaţi corpul codului care cere colţurile şi desenează polilinia în cadrul

unei funcţii while.
6. Un răspuns nul, adică un return la cererea "first corner" va termina

funcţia.
7. Numiţi noua funcţie c:mrectangle pentru "dreptunghiuri multiple".
8. Salvaţi fişierul.

10. Activaţi comanda MRECTANGLE.
50099176.doc R.2.1 9/21/2011 •141

AUTODESK, INC.
Şiruri şi tipărirea lor

În AutoLISP, orice serie de caractere alfanumerice aflate între ghilimele
duble reprezintă un şir text. Şirul poate include caractere speciale cum ar fi
*, &, , % şi .
Obiective
• Despre şirurile text şi valorile lor
• Cum să folosiţi caracterele de control în şirurile text.
• Cum să luaţi şiruri text de la utilizator.
• Cum să folosiţi comanda AutoCAD TEXT cu variabile AutoLISP-
ul legate la şiruri text.
• Diferenţele dintre cele şase funcţii de tipărire în AutoLISP.
• Cum să folosiţi funcţiile de tipărire.
Valorile şirurilor text

Şirurile text se evaluează pe sine, adică valoarea unui şir text este şirul în
sine.
Command: !"This is a string"
"This is a string."
Command: (setq x "This is a string.")
"This is a string."
Command: !x
"This is a string."
Caractere de control
Caracterul "ă" precede un caracter de control în cadrul unui şir text.
Caracterul care urmează imediat are o semnificaţie specială.
În următorul tabel găsiţi caracterele de control cunoscute de asemenea şi ca

"escape codes" care sînt recunoscute în cadrul şirurilor AutoLISP.
•142
Cod Semnificatie
ăă ă caracter
ă" " caracter
ăe caracter escape
ăn caracter newline
ăr caracter return
ăt caracter tab
ănnn Caracter al carui cod octal este nnn
Tabelul 2. Caractere de control în şiruri
Funcţia getstring
Funcţia getstring aşteaptă ca utilizatorul să introducă un şir text. Are două
argumente opţionale: suprimă caracterul spaţiu ca şi return şi un şir de la
utilizator.
Dacă primul argument opţional este furnizat şi acesta nu este nil, atunci este
posibil ca şirul să conţină spaţii; primul spaţiu din şir este tratat ca "return".
Exemplu
Legaţi variabila txt de şirul text "single".

Command: (setq txt (getstring "ănEnter text: "))
Enter text: single
"single"
Command: !txt
"single"
Legaţi variabila txt de şirul text în care s-au introdus spaţii.
Command: (setq txt (getstring T "ănEnter text: "))
Enter text: embedded spaces
"embedded spaces"
Command: !txt
"embedded spaces"
50099176.doc R.2.1 9/21/2011 •143

AUTODESK, INC.
Variabila de sistem TEXTEVAL

Dacă variabila de sistem TEXTEVAL este mai mare decît 0, puteţi răspunde
la o cerere de comandă TEXT sau DTEXT cu o variabilă AutoLISP şi
comanda va tipări valoarea asignată variabilei; dacă nu, comanda va tipări
semnul exclamarii şi numele variabilei.
Comanda TEXT va tipări întotdeauna valoarea unei variabile şir atunci cînd
este apelată în cadrul unei funcţii AutoLISP de tip command indiferent de
setarea TEXTVAL.
Comanda DTEXT nu poate fi apelată de funcţia AutoLISP de tip command.
•144
Exemplu
Într-un desen nou introduceţi expresiile care urmează.
Prima comandă TEXT va tipări !txt1. A două comandă TEXT va tipări

Second line. Vezi figura 18-1.
Command: (setq txt1 "First line.")
"First line."
Command: (setq txt2 "Second line.")

"Second line."
Command: text
Justify/Style/<Start point>: 1,5
Height: 0.5
Rotation: 0
Text: !txt1
Command: (setvar "texteval" 1)

1
Command: text
Justify/Style/<Start point>: Enter
Text: !txt2
Figura 41. entitati tip text
50099176.doc R.2.1 9/21/2011 •145

AUTODESK, INC.
Funcţiile de tipărire
Există şase funcţii de tipărire în AutoLISP. Cinci dintre ele tipăresc şiruri
text iar una tipăreşte caractere text. Trei dintre aceste funcţii tipăresc orice
fel de expresii indiferent dacă acestea sînt de tipul şir text. Funcţia pentru
caractere şi patru dintre funcţiile de tip şir pot tipări nu numai într-un fişier
dar şi pe un monitor.
Functia Argumente Descriere
prin1 şexpr şfile-descţţ Tipareste expr si returneaza expr.

Nu interpreteaza caracterele de
control.
princ şexpr şfile-descţţ Tipareste expr si returneaza expr.

Interpreteaza caracterele de control
print şexpr şfile-descţţ La fel ca prin1, si in plus tipareste un

newline inainte de expr si un spatiu
dupa expr.
prompt şmsgţ Tipareste msg pe display si

returneaza nil.
write-char num şfile-descţ Tipareste un caracter ASCII conform

cu argumentul num pentru codul
zecimal ASCII si returneaza
numarul.
write-line string şfile-descţ Tipareste string fara quotes si

returneaza string cu quotes.
Asemanator cu princ.
Table 3. Functii de tiparire
Intrarea şi ieşirea în/şi dintr-un fişier incluzînd şi tipărirea într-un fişier vor
fi discutate mai tîrziu în acest curs.
Funcţia prompt este folosită pentru tipărirea mesajelor destinate

utilizatorului, pe afişaj.
Funcţia print tipăreşte expresii într-o manieră compatibilă cu funcţia load, în

timp ce funcţia princ le tipăreşte într-o manieră compatibilă cu funcţia read-
line. Veţi studia funcţia read-line în capitolul destinat intrării şi ieşirii într-un
fişier mai tîrziu în acest curs.
Funcţiile prin1, princ şi print acceptă orice expresie ca argument şi îi va tipări

valoarea.
Funcţiile prompt şi write-line acceptă numai argumente de tip şir.
•146
Recapitulare
• Şirurile text sînt caractere alfanumerice aflate între
ghilimele duble.
• Caracterele de control din cadrul unui şir de tip text încep
cu un caracter "a".
• Funcţia getstring primeste şiruri interactiv de la utilizator.
• Variabila de sistem TEXTEVAL demonstrează cum comanda
AutoCAD TEXT va tipări o variabilă AutoLISP.
• AutoLISP-ul dispune de o varietate de funcţii de tipărire
pentru diferite întrebuinţări.
50099176.doc R.2.1 9/21/2011 •147

AUTODESK, INC.
EXERCITIUL 22: SIRURI DE TEXT SI FUNCTII DE TIPARIRE
• Veţi consolida cunoştinţele despre şiruri de tip text şi funcţii
de tipărire.
• Veţi obţine două şiruri text interactiv de la utilizator.
• Veţi folosi şirurile de tip text cu patru dintre funcţiile de
tipărire.
Etape de lucru
1. Intoduceţi expresiile care urmează.
2. Legaţi cinci variabile de la a la d de diferite tipuri de date: număr
întreg, listă, şir şi şir care conţine caractere de control.
Command: (setq a 1)
Command:(setq b '(1.0 1.0 0.0))
Command: (setq c (getstring "ănString: "))

String: xyz
"xyz"
Command: (setq d (getstring "ănFile name: "))

File name: ăstudentăx.dwg
"ăăstudentăăx.dwg"
3. Folosiţi variabilele ca argumente la diferite funcţii de tipărire.
4. Scrieţi valorile în casuţele corespunzatoare din tabelul care
urmează.
Variabila prin1 princ print prompt
Tabelul 25. Variabile si functii de tiparire
•148
Această pagină a fost lăsată liberă in mod intenţionat.
50099176.doc R.2.1 9/21/2011 •149

AUTODESK, INC.
Accesul la entităţi
Fiecărei entităţi dintr-o sesiune de editare îi este atribuit un nume de
entitate de către AutoCAD. Numele unei entităţi este un
identificator unic al fiecărei entităţi dintr-un desen. Numele unei
entităţi se poate schimba de la o sesiune de editare la alta, dar
fiecare nume de entitate este unic determinată în timpul unei
sesiuni de editare.
Obiective
• Cum să folosiţi numele de entităţi pentru a stabili şi modifica entităţile

individuale.
• Cum să aflaţi numele ultimei entităţi adăugate la desen.
• Cum să aflaţi numele primei entităţi adăugate la desen.
• Cum se pot trece în revistă numele entităţilor din desen.
• Cum să creaţi noi comenzi AutoCAD care acţionează asupra numelor de
entităţi.
Funcţii de acces la entităţi

Numele de entităţi pot fi stabilite de AutoLISP şi entităţile la care se
referă pot fi modificate de AutoLISP.
În acest capitol veţi folosi funcţiile de acces la entităţi din AutoLISP

pentru a lucra cu entităţi şi grupuri de entităţi.
• Aflaţi o entitate sau un grup de entităţi.
• Activaţi o entitate cu o comandă AutoCAD.
• Examinaţi proprietăţile unei entităţi.
• Modificaţi proprietăţile unei entităţi.
Functii de acces la Descriere

entitati
entlast returneaza numele ultimei entitaţi adaugata

in baza de date
entsel returneaza lista formata din numele entitaţii

si punctul in care a fost selectata entitatea
entnext returneaza prima entitate din baza de date
entnext ename returneaza numele entitaţii in baza de date

dupa argumentul ename
Tabelul 26.Functii de acces a entitatilor
•150
Cum se află numele ultimei entităţi

Introduceţi comenzile şi expresiile care urmează.
Într-un desen nou creaţi o entitate Line.

Command: line
From point: 1,1
To point: 5,5
To point: Enter
Folosiţi funcţia entlast pentru a stabili numele ultimei entităţi adăugate la
desen, adică entitatea Line. (Numărul din numele entităţii poate fi diferit pe
computerul dumneavoastra).
Command: (entlast)
<Entity name: 60000022>
Funcţia entlast stabileşte numele ultimei entităţi principale neştearsă din
desen.
Legaţi variabla numită ename de valoarea returnată de funcţia entlast.

Verificaţi legarea lui ename.
Command: (setq ename (entlast))
Command: !ename
Folosirea numelui unei entităţi intr-o comandă AutoCAD

Numele entităţilor pot fi folosite ca argumente la funcţia de tip command ori
de cîte ori o comandă AutoCAD cere un set de selecţie.
În acest exemplu, numele entităţii Line este furnizat ca argument la

comanda AutoCAD ERASE.Aceasta expresie va şterge entitatea Line.
Command: (command "erase" ename "")
Exemplu
Introduceţi expresiile şi comenzile care urmează. Expresia AutoLISP va
şterge entitatea Line. Comanda U o va restabili.
nil
50099176.doc R.2.1 9/21/2011 •151

AUTODESK, INC.
Command: U
GROUP
Aflarea numelui primei entităţi

Exemplu
Citiţi instrucţiunile şi tipăriţi expresiile cu caractere aldine.
În acelaţi desen, cu ajutorul entităţii Line, creaţi o entitate Circle.

Command: circle
Diameter/<Radius>: 1
5,5
1,1
Figura 42.Entitati tip linie si cerc
Folosiţi funcţia entlast pentru a stabili numele ultimei entităţi adăugată la

desen, entitatea Circle. (Numărul din numele entitaţii poate fi diferit pe
computerul dvs.).
Command: (entlast)
Funcţia entlast stabileşte ultima entitate principală neştearsă din desen; în
acest caz entitatea Circle.
Folosiţi funcţia entnext pentru a extrage numele primei entităţi din baza de
date, adică, entitatea Line.
•152
Legaţi o variabilă numită entname de valoarea returnată de entnext. Verificaţi

legarea lui ename.
Command: (setq ename (entnext))

Command: !ename
Exemplu
Aflaţi numele primei entităţi din desen, entitatea Linie. Stergeţi-o.
Restabiliţi-o cu comanda U.

nil
Command: U
ERASE
Aflaţi numele ultimei entităţi din desen: entitatea Circle. Deplasaţi-o cu o
unitate în directia X pozitivă din poziţia iniţială.
Command: (setq ename (entlast))
Command: (command "move" ename "" "1,0" "")

nil
50099176.doc R.2.1 9/21/2011 •153

AUTODESK, INC.
5,5
1,1
Figura 23. Situatia dupa miscarea cercului cu o unitate in directia X pozitiva
Aduceţi cercul în poziţia iniţială.

Command: U
MOVE
Baleierea bazei de date entitate cu entitate

Funcţia entlast stabileşte numele ultimei entităţi din baza de date. Funcţia
entnext stabileşte numele primei entităţi din baza de date.
Funcţia entnext are un argument opţional: numele unei entităţi. În acest caz
funcţia entnext returnează numele entităţii care urmează după argument în
baza de date.
Dacă nu există nici o entitate care se urmeze după cea din numele
argumentului entitaţii, entnext returnează nil.
De exemplu acest set de expresii vor returna numele celei de a doua entităţi
din baza de date.
Command: (entnext (entnext))

sau
Command: (setq ename1 (entnext))

Command: (setq ename2 (entnext ename1))
•154
Expresia care urmează ar şterge atunci a doua entitate din baza de date.
Command: (command "erase" ename2 "")
Ar fi bine să se poată stabili numele tuturor entităţilor din baza de date, pe
rînd, pentru a le procesa una cîte una. Funcţia entnext poate face acest lucru
cînd este plasată într-o buclă while împreună cu instrucţiunile de procesare
pentru entităţi.
Recapitulare
• Fiecare entitate dintr-un desen are un nume unic de
entitate.
• Numele entităţilor nu se schimbă niciodată în timpul unei
sesiuni de editare grafică, dar se pot schimba pe parcursul
sesiunilor de editare grafică.
• AutoLISP dispune de funcţii care returnează numele
entităţii.
• Funcţia entlast returnează numele ultimei entităţi adăugată la
desen.
• Funcţia entnext returnează numele primei entităţi adăugată la
desen sau numele entităţii care urmează după argumentul
opţional.
• Puteţi folosi entnext şi o buclă while pentru a accesa fiecare
entitate din desen.
• Numele entităţilor pot fi folosite cu comenzi AutoCAD.
50099176.doc R.2.1 9/21/2011 •155

AUTODESK, INC.
EXERCITIUL 23: ACCESAREA NUMELOR DE ENTITATI
• Veţi aprofunda cunoştinţele despre accesarea numelor de
entităţi.
• Veţi crea o comanda MOVEALL care află numele fiecărei
entităţi din baza de date, pe rînd, şi deplasează fiecare
entitate cu o unitate în X pozitiv.
• Veţi folosi funcţiile entnext şi while.
• Veţi folosi numele entităţilor şi comanda AutoCAD MOVE.
Etape de lucru
1. Folosiţi editorul de texte pentru a salva următorul cod în fişierul numit
moveall.lsp.
(defun c:moveall ()
(setq ename (entnext)) ;get first entity
(while
ename ;we have an entity?
(command "._MOVE" ename "" "1,0" "") ;move it
(setq ename (entnext ename)) ;get the next entity
)
(prin1) ;quiet exit
)
2. Desenaţi cîteva entităţi în desenul dvs.

3. Încărcaţi fişierul moveall.lsp.
4. Activaţi comanda MOVEALL.
5. Urmăriţi deplasarea entităţilor, cîte una pe rînd.
Command: (load "moveall")

C:MOVEALL
Command: moveall
•156
EXERCITIUL 24: SCALAREA TUTUROR ENTITATILOR ACCESATE PRIN NUME
• Veţi aprofunda cunoştinţele despre accesarea numelor de
entităţi.
• Veţi modifica funcţia de la exerciţiul 24.
• Veţi folosi funcţiile entnext şi while.
• Veţi crea o comandă care scalează fiecare entitate din desen.
• Veţi tipări numărul de entitaţi scalate folosind un contor în
cadrul unei bucle.
Aceste expresii vor tipări şirul “Scaling entity 1.” în zona liniei de
comandă.
(setq counter 1)
(prompt (strcat "ănScaling entity " (itoa counter) "."))
Etape de lucru
1. Deschideţi fişierul text moveall.lsp.
2. Salvaţi textul într-un nou fişier numit scaleall.lsp.
3. Folosiţi codul din funcţia c:moveall.lsp.
4. Modificaţi c:moveall.
• Numiţi noua funcţie c:scaleall.
• Scalaţi fiecare entitate cu un factor (0.5) relativ faţă de punctul

origine 0,0.
• Adăugaţi codul care tipăreşte în zona liniei de comandă numărul

de entităţi modificate.
Command: scaleall
Scaling entity 1.
Scaling entity 2.
Scaling entity 3.
5. Încărcaţi fişierul scaleall.lsp.
6. Activaţi comanda SCALEALL.
50099176.doc R.2.1 9/21/2011 •157

AUTODESK, INC.
Liste asociate entităţilor

Puteţi folosi numele unei entităţi pentru a extrage toate elementele unei
entităţi. În AutoLISP un astfel de document este reprezentat print-o listă
asociată. Listele asociate cuprind subliste ale listelor obişnuite sau perechi
cu punct.
Obiective
• Formatul unei perechi cu punct sau cum să creaţi o astfel
de pereche.
• Formatul unei liste asociate.
• Cum să extrageţi o listă asociată unei entităţi.
• Cum să examinaţi o lista asociată.
• Cum să determinaţi tipul entităţii din lista asociată.
Perechi cu punct
O pereche cu punct este o formă specială a unei liste. O pereche cu punct
este o listă formată din două elemente a cărei parte cdr din arborele binar se
termină cu ultimul element al listei şi nu cu nil.
Atît listele obişnuite cît şi perechile cu punct sînt folosite în listele asociate
entităţilor pentru a reprezenta grupul de coduri DXF şi valorile asociate
acestora.
Perechile cu punct conţin întotdeauna două elemente. Primul element al
unei perechi cu punct poate fi stabilit la fel ca şi primul element al unei liste
obişnuite: cu funcţia car. Al doilea element al perechii cu punct poate fi
stabilit direct cu funcţia cdr şi acest lucru diferă de modul în care se
stabileşte al doilea element dintr-o listă obişnuită.
Exemplu
Perechea cu punct care conţine cele două elemente 0 şi "Line" arată astfel.
(0 . "LINE")
Ilustraţia care urmează prezintă arborii binari pentru două obiecte similare:
o listă şi o pereche cu punct, ambele conţinînd aceleaşi elemente.
•158
(0 "LINE") (0 . "LINE")
car cdr car cdr
0 ("LINE") 0 "LINE"
car cdr
"LINE" ()
Figura 44. Arbori binari pentru lista obisnuita si pereche cu punct avind elemente
identice.
Funcţia cons
Funcţia cons cere două argumente obligatorii: o valoare care se adaugă şi o
valoare la care se adaugă.
Dacă valoarea care se adaugă este un atom, atunci funcţia cons returnează o
pereche cu punct a celor două elemente.
Dacă valoarea la care se adaugă este o lista, atunci funcţia cons returnează
lista cu primul argument adăugat în capul listei.
Exemplu
Formaţi o listă obişnuită din elementele 0 şi "Line".

Command: (setq xlist (list 0 "LINE"))
(0 "LINE")
Formaţi o pereche cu punct din elementele 0 şi "Line".
Command: (setq xdot (cons 0 "LINE"))
(0 . "LINE")
Extrageţi primul element din listă şi din perechea punct cu car.
Command: (car xlist)
0
50099176.doc R.2.1 9/21/2011 •159

AUTODESK, INC.
Command: (car xdot)

0
Extrageţi cel de-al doilea element din lista normală cu car şi cdr.
Command: (car (cdr xlist))
"LINE"
Extrageţi cel de-al doilea element din listă şi din perechea punct cu car.
Command: (cdr xdot)
"LINE"
Entităţi înregistrate în baza de date şi liste asociate

Modul în care AutoLISP-ul reprezintă o entitate înregistrată în baza de date
pentru o entitate desenată de tip Line de la 1,1 la 5,5 pe Layerul 0 este
prezentat în continuare.
(
(-1 . <Entity name: xxxxxxxx>)
(0 . "LINE")
(8 . "0")
(10 1.0 1.0 0.0)
(11 5.0 5.0 0.0)
(210 0.0 0.0 1.0)
)
Entitatea înregistrată în baza de date este păstrată sub forma unei liste
asociate.
O listă asociată este o listă de liste.
Primul element al fiecărei subliste este tipul acelei liste. Celelalte elemente
reprezintă datele asociate cu codul.
De exemplu, codul din prima sublistă este numărul întreg -1. Data asociată
este numele entităţii. Codul din a două sublistă este numărul întreg 0. Data
asociată este tipul entităţii; în acest caz, o entitate Line.
Semnificaţia codurilor 8,10 şi 11 si datele lor sînt uşor de imaginat ce

reprezintă.
Datele codului 210 sînt reprezentate de sensul pozitiv al axei Z din

sistemul de coordonate care conţine entitatea.
Memorarea si extragerea formatelor

Prin convenţie, datele dintr-o listă asociată entităţii pot fi extrase prin
scoaterea cdr-ului unei subliste. Pentru aceasta, AutoLISP-ul foloseşte
perechi cu punct în cazul sublistelor cu două elemente şi forme normale de
liste în cazul sublistelor cu mai mult de două elemente.
•160
De exemplu, aceste expresii returnează Layerul entităţii Line şi punctul de

start.
Command: (cdr '(8 . "0"))

"0"
Command: (cdr '(10 1.0 1.0 0.0))
(1.0 1.0 0.0)
Coduri de Grup DXF

Codul fiecărei subliste dintr-o listă asociată unei entităţi corespunde unui
cod de grup DXF. Documentaţia despre aceste coduri există în AutoCAD
Release 12 AutoLISP Programmer’s Reference Manual, Appendix B.
Există mici diferenţe între codurile de grup dintr-un fişier DXF şi codurile
de grup returnate într-o listă asociată unei entităţi. În anexa din AutoLISP
Programmer’s Reference Manual găsiţi lista corectă a codurilor de grup
pentru liste asociate entităţilor.
Acestea sînt codurile listelor asociate entităţilor (sau coduri de grup DXF)
pentru entitatea Line.
Cod de group Semnificatie
-1 Numele entitatii
0 Tipul (Line, Circle, Arc, etc.)
8 Layer
10 Punct de start
11 Punct final
210 Directia pozitiva a axei Z de

extruziune
Tabelul 27. Coduri de grup DXF si proprietatile entitaţilor
50099176.doc R.2.1 9/21/2011 •161

AUTODESK, INC.
Extragerea unei entităţi din baza de date cu funcţia entget

Funcţia entget cere un singur argument: numele unei entităţi. Funcţia va
returna înregistrarea entităţii sub forma unei liste asociate.
Exemplu
Începeţi un desen nou şi desenaţi o linie de la 1,1 la 5,5; tipăriţi expresiile
care urmează.
<Entity name: xxxxxxxx>
Command: (setq elist (entget ename))
( (-1 . <Entity name: xxxxxxxx>) (0 . "LINE") (8 . "0") (10 1.0 1.0 0.0) (11
5.0 5.0 0.0) (210 0.0 0.0 1.0))
Command: !elist
5.0 5.0 0.0) (210 0.0 0.0 1.0))
Extragerea datelor dintr-o listă asociată

Funcţia assoc cere două argumente: valoarea unui cod şi o listă asociată.
Dacă funcţia găseşte o pereche pentru cod în lista asociată, atunci
returnează sublista corespunzatoare; dacă nu, returnează nil.
Presupuneţi că variabila elist este legată de lista asociată în cazul entităţii

Line.
Command: (setq elist (entget (entnext)))
5.0 5.0 0.0) (210 0.0 0.0 1.0))
Command: !elist
5.0 5.0 0.0) (210 0.0 0.0 1.0))
Această expresie va returna sublista care descrie layerul entităţii.
Command: (assoc 8 elist)
(8 . "0")
În această expresie, apelăm cdr care returnează layerul entităţii.
Command: (cdr (assoc 8 elist))
"0"
•162
Exemplu
Asiguraţi-vă că variabila elist este legată de lista asociată în cazul entităţii

Line.
Command: !ename

5.0 5.0 0.0) (210 0.0 0.0 1.0))
Command: !elist
5.0 5.0 0.0) (210 0.0 0.0 1.0))
Extrageţi tipul entităţii, Layerul şi punctul de start al sublistei din lista
asociată.
(0 . "LINE")

(8 . "0")

(10 1.0 1.0 0.0)
Apelaţi cdr pentru a extrage tipul entităţii, Layerul şi punctul de start din
subliste.
"LINE"

"0"

(1.0 1.0 0.0)
50099176.doc R.2.1 9/21/2011 •163

AUTODESK, INC.
Recapitulare
• Perechile cu punct au două elemente şi sînt forme speciale de
liste.
• Al doilea element al perechii cu punct este returnat de cdr.
• Perechile cu punct sînt folosite ca liste obişnuite în listele
asociate entităţilor.
• Entităţile înregistrate în baza de date sînt reprezentate în
AutoLISP sub forma de liste asociate.
• O lista asociată este o listă de liste.
• Fiecare sublistă dintr-o listă asociată are două părţi: car şi cdr.
• Partea car a unei liste asociate entităţii este un cod de grup DXF
care desemnează o proprietate a entităţii car este de asemenea
denumit codul sublistei.
• Partea cdr a unei liste asociate entităţii reprezintă valoarea codului
de grup DXF.
• Funcţia assoc returnează o sublista prin căutarea unui cod.
•164
EXERCITIUL 25: UTILIZAREA LISTELOR ASOCIATE ENTITATLOR
• Veţi consolida cunoştinţele despre listele asociate entităţilor.
• Veţi folosi funcţia entget.
• Veţi crea o funcţie care scalează numai entităţile de tip Line
din desen.
Etape de lucru
1. Deschideţi fişierul text scaleall.lsp.
2. Salvaţi textul într-un nou fişier scline.lsp.
3. Schimbaţi numele funcţiei din c:scaleall în c:scline.
4. Modificaţi funcţia ca să scaleze numai entităţile de tip Line din desen.
6. Desenaţi cîteva tipuri de entităţi în desen:.Lines, Circles and Arcs.
7. Incărcaţi fişierul scline.lsp şi activaţi comanda SCLINE. Numai entităţile
de tip Line vor fi scalate cu aceasta comandă.
50099176.doc R.2.1 9/21/2011 •165

AUTODESK, INC.
C:SCALEALL
(defun c:scaleall ()
(setq counter 1) ;initialize counter
(while
(command "._SCALE" ename "" "0,0" "0.5");scale it
(prompt ;tell user which one
(strcat
"ănScaling entity "
(itoa counter)
".ăn"
)
)
(setq counter (1+ counter)) ;increment the counter
)
(prin1) ;quiet exit
)
C:SCLINE
(defun c:scline ()
(while
(if ;if it's a Line...
(=
"LINE"
(cdr (assoc 0 (entget ename)))
)
(progn
(command "._SCALE" ename "" "0,0" "0.5");scale it and...
(strcat
(itoa counter)
".ăn"
)
)
)
)
)
(prin1) ;quiet exit
)
•166
50099176.doc R.2.1 9/21/2011 •167

AUTODESK, INC.
Modificarea unei entităţi

Modificarea unei entităţi cu AutoLISP-ul are loc în două etape.
• Modificaţi lista asociată unei entităţi cu funcţia subst.
• Actualizaţi entitatea prin aplicarea funcţiei entmod la noua
listă asociată.
Obiective
• Cum să modificaţi o listă asociată unei entităţi.
• Cum să actualizaţi înregistrarea unei entităţi într-un desen pe
baza schimbărilor din lista asociată.
Substituirea valorilor intr-o listă asociată

Funcţia subst înlocuieşte un element dintr-o listă. Funcţia cere trei
argumente: valoarea de substituire, valoarea de substituit într-o listă şi o
listă care conţine valoarea de substituit.
Puteţi folosi funcţia subst pentru a înlocui o valoare într-o listă asociată unei
entităţi.
Iată un exemplu care ilustrează modul cum funcţionează funcţia subst. Vom
înlocui numărul 15 cu numărul 16 în lista noastră de pătrate de numere
întregi.
Command: (setq mylist (list 4 9 15))

(4 9 15)
Command: !mylist
(4 9 15)
Command: (subst 16 15 mylist)

(4 9 16)
Command: !mylist
(4 9 15)
Deoarece funcţia subst este non-destructivă, ea nu va afecta legarea
variabilei mylist. În acest exemplu funcţia setq este adăugată expresiei pentru
a schimba legarea.
Command: (setq mylist (subst 16 15 mylist))

(4 9 16)
Command: !mylist
(4 9 16)
•168
Exemplu
Introduceţi comenzile şi expresiile care urmează.
Într-un desen nou, desenaţi o entitate Line de la 1,1 la 5,5.
Command: line
From point: 1,1
To point: 5,5
To point: Enter
Folosiţi funcţia subst pentru a schimba punctul de start al listei asociate
entităţii Line.
Extrageţi sublista pentru punctul de start şi păstraţi-o sub forma unei

variabile.

<Entity name: xxxxxxxx>)

5.0 5.0 0.0) (210 0.0 0.0 1.0))
Command: (setq old_start (assoc 10 elist))

(10 1.0 1.0 0.0)
Înlocuiţi vechiul punct de start cu unul nou de 7.5,2.5,0 şi schimbaţi legarea
variabilei elist.
Command: (setq new_start (list 10 7.5 2.5 0.0))

(10 7.5 2.5 0.0)
Command: (setq elist (subst new_start old_start elist))

5.0 5.0 0.0) (210 0.0 0.0 1.0))

(10 7.5 2.5 0.0)
50099176.doc R.2.1 9/21/2011 •169

AUTODESK, INC.
Actualizarea unei entităţi

Funcţia entmod modifică proprietăţile unei entităţi cerînd AutoCAD-ului să
actualizeze entitatea pe baza modificărilor făcute în lista asociată entităţii.
Funcţia entmod solicită un singur argument : o listă valabilă asociată

entităţii.
Exemplu
Folosiţi funcţia entmod pentru a aplica modificările la entitatea Line pe baza
modificărilor făcute în copia listei asociate.
Command: !elist
((-1 . <Entity name: xxxxxxxx>) (0 . "LINE") (8 . "0") (10 7.5 2.5 0.0) (11
5.0 5.0 0.0) (210 0.0 0.0 1.0))
Command: (entmod elist)

((-1 . <Entity name: xxxxxxxx>) (0 . "LINE") (8 . "0") (10 7.5 2.5 0.0) (11
5.0 5.0 0.0) (210 0.0 0.0 1.0))
Punctul de start al entităţii Line ar trebui să se deplaseze de la 1.0, 1.0, 0.0
la 7.5, 2.5, 0.0.
5,5,0 5,5,0
1,1,0 7.5,2.5,0
Figura 45. Linie inainte si dupa apelarea functiei entmod.
Recapitulare
• O sublistă dintr-o listă asociată poate fi înlocuită cu funcţia
subst.
• Funcţia entmod va actualiza înregistrarea unei entităţi în baza
de date pe baza modificărilor din lista asociată.
•170
EXERCITIUL 26: ACTUALIZAREA INREGISTRARII UNEI ENTITATI
• Veţi aprofunda cunoştinţele despre modificarea entitaţilor şi
despre listele asociate.
• Veţi folosi funcţia entmod.
• Veţi modifica listele asociate tuturor entităţilor Line.
• Veţi actualiza înregistrarea entităţilor acestora.
Etape de lucru
• Deschideti fişierul text scline.lsp.
• Salvaţi textul într-un fişier nou numit modline.lsp.
• Schimbaţi numele funcţiei din c:scline în c:modline.
• Modificaţi funcţia.
• Dacă entitatea este de tip Line, modificaţi-i punctul de capăt
din valoarea curentă în punctul 5.0, 5.0, 0.0.
• Salvaţi fişierul.
• Într-un desen nou, desenaţi cîteva linii şi cercuri în diferite
poziţii.
• Încărcaţi fişierul modline.lsp.
• Activaţi comanda MODLINE.
50099176.doc R.2.1 9/21/2011 •171

AUTODESK, INC.
C:SCLINE
(defun c:scline ()
(while
(=
"LINE"
(cdr (assoc 0 (entget ename)))
)
(progn
(command "._SCALE" ename "" "0,0" "0.5");scale it and...
(strcat
(itoa counter)
".ăn"
)
)
)
)
)
(prin1) ;quiet exit
)
C:MODLINE
(defun c:modline ()
(while
(setq elist (entget ename)) ;get its assoc list
(= "LINE" (cdr (assoc 0 elist)))
(progn
(entmod ;change its end point
(subst '(11 5.0 5.0 0.0) (assoc 11 elist) elist)
)
(strcat
"ănModifying entity "
(itoa counter)
".ăn"
)
)
)
)
)
(prin1) ;quiet exit
)
•172
EXERCITIUL 27: ACTUALIZAREA TUTUROR ENTITATILOR “DIMENSION” INTR-UN DESEN
Acesta este un exerciţiu opţional.
• Veţi aprofunda cunoştinţele despre modificarea entităţilor şi
listele asociate.
• Veţi scrie o funcţie care să modifice toate entitaţile de tip
Dimmension din desen.
Etape de lucru
1. Deschideţi fişierul grafic moddim.dwg în directorul student.
Figura 46. Desenul moddim.dwg.
2. Dimensiunile din acest desen au fost amplasate pe cîteva nivele

diferite. Sarcina dvs. este să scrieţi un program AutoLISP care să caute
toate entităţile Dimension din acest desen şi să le amplasaţi pe nivelul
DIM.
3. Fişierul program AutpLISP moddim.lsp din directorul student conţine
schiţa programului. Deschideţi acest fişier cu editorul de text şi
adăugaţi codul necesar pentru a completa programul.
50099176.doc R.2.1 9/21/2011 •173

AUTODESK, INC.
Selectarea numelui unei entităţi prin selecţie

grafică cu cursorul
Un program AutoLISP poate extrage numele unei entităţi cerînd
utilizatorului să selecteze o entitate.
Obiective
• Cum să extrageţi numele unei entităţi interactiv cu
utilizatorul.
• Cum să folosiţi funcţia entsel.
• Cum să deplasaţi centrul cercului selectat de utilizator.
Funcţia entsel
Funcţia entsel vă cere să selectaţi un singur obiect. Funcţia returnează o
listă cu două obiecte: numele entităţii şi punctul în care a fost selectat; dacă
nu se selectează nimic atunci funcţia returnează nil.
Puteţi extrage numele entităţii din lista returnată de funcţia entsel cu ajutorul
funcţiei car.
Exemplu
Într-un desen nou , desenaţi o linie şi un cerc.
Command: line
From point: 1,1
To point: 5,5
To point: Enter
Command: circle
Diameter/<Radius>: 1
Selectaţi cercul în punctul 5,6,0 ca răspuns la cererea funcţiei entsel şi legaţi
valoarea returnată de variabila epick.
Command: (setq epick (entsel))

Select object: pick circle at 5,6,0
(<Entity name: xxxxxxxx> (5.0 6.0 0.0))
Command: !epick
(<Entity name: xxxxxxxx> (5.0 6.0 0.0))
•174
Extrageţi numele entităţii din lista returnată de funcţia entsel şi păstraţi-l în

variabila ename.
Command: (setq ename (car epick))

Command: !ename
Ştergeţi entitatea Circle.
Command: (command "._erase" ename "")
Recapitulare
• Funcţia entsel extrage o listă a proprietăţilor unui obiect
selectat de utilizator: numele entităţii şi punctul în care a fost
selectat.
• Partea car a unei liste selectate de entsel reprezintă numele
unei entităţi.
50099176.doc R.2.1 9/21/2011 •175

AUTODESK, INC.
EXERCITIUL 28: SELECTAREA SI MODIFICAREA UNUI CERC
• Veţi consolida cunoştinţele despre selecţia interactivă a
entităţilor.
• Veţi crea un program care cere utilizatorului să selecteze o
entitate Circle şi un nou punct de centru care deplasează
centrul cercului
Etape de lucru
1. În editorul de texte, deschideţi fişierul text numit circen.lsp din directorul
student.
2. Adăugaţi codul care face urmatoarele:
• Defineşte funcţia c:circen.
• Cere utilizatorului o entitate cu funcţia entsel.
• Dacă utilizatorul selectează o entitate, codul trimite lista
asociată entităţii ca argument la funcţia circen_mod.
4. Încărcaţi programul în AutoCAD.
5. Verificaţi comanda CIRCEN într-un desen care conţine cel puţin un cerc.
(defun circen_mod (elist)

(if
(/= "CIRCLE" (cdr (assoc 0 elist))) ;is it a circle?
(prompt "ănNot a circle.") ;if not, exit
(progn
(setq old_cen (cdr (assoc 10 elist))) ;get current center
(initget 1) ;no null reponse...
;for getpoint
;get new center

(setq new_cen (getpoint old_cen "ănCenter point: "))
(entmod ;modify the circle

(subst (cons 10 new_cen) (assoc 10 elist) elist)
)
)
)
)
•176
EXERCITIUL 29: PROBLEME OPTIONALE DE ACCES LA ENTITATI
Acestea sînt exerciţii opţionale pe care le puteţi completa în clasă sau în

afara clasei.
Scrieţi un set de definiţii de funcţii.
c:movelast
• Deplasaţi ultima entitate în baza de date.
• Cereţi operatorului punctul de bază şi al doilea punct al
deplasării..
c:printent
• Selectaţi fiecare entitate din desen, una după alta.
• Tipăriţi fiecare tip şi layer ale entităţii în zona liniei de
comandă.
c:red
• Cereţi operatorului să selecteze o entitate.
• Schimbaţi culoarea entităţii în RED (reprezentată într-o listă
asociată de codul de grup 62 şi numărul întreg 1).
• Observaţi că puteţi adăuga o nouă sublistă la lista asociată
în loc să înlocuiţi o listă existentă folosind funcţia entmod. O
sublistă de grup 62 nu este prezentă într-o listă asociată unei
entităţi dacă culoarea entităţii este BYLAYER.
c:chglayer
• Cereţi operatorului să selecteze o entitate.
• Cereţi operatorului numele unui nivel.
• Schimbaţi nivelul entităţii.
50099176.doc R.2.1 9/21/2011 •177

AUTODESK, INC.
Tratarea erorilor
AutoLISP dispune de o metodă pentru tratarea erorilor de program şi de
utilizare.
Obiective
• Cum să folosiţi funcţiile exit şi quit pentru a forţa o eroare
AutoLISP.
• Cum să înlocuiţi rutina implicită AutoLISP de tratare a
erorilor.
• Cum să utilizaţi rutina de tratare a erorilor pentru "a şterge"
un program după ce a fost abortat din cauza unei erori sau
pentru că utilizatorul a anulat programul.
• Cum să folosiţi comanda UNDO în rutina de tratare a
erorilor.
Forţarea unei erori

Funcţiile exit şi quit realizează aceeaşi operaţie, fără argumente.
Funcţiile exit şi quit forţează aplicaţia curentă să se termine prin forţarea

unei erori AutoLISP. Ele returnează şirul "quit/exit abort" şi transferă şirul
funcţiei de tratare a erorilor *error*. După executarea funcţiei de tratare a
erorilor, AutoCAD-ul se întoarce la linia de comandă.
O aplicaţie poate folosi funcţiile exit şi quit în combinaţie cu o funcţie de

tratare a erorilor definită de utilizator pentru a opri propria-i execuţie,
pentru a reface orice valori necesare în AutoCAD şi pentru a prezenta
utilizatorului un mesaj adecvat.
Funcţia *error*
Puteţi fi siguri că poziţionarea unei variabile de sistem sau o anumită
condiţie AutoCAD pot fi restabilite după apariţia unei erori neaşteptate
folosind funcţia *error*. În cadrul acestei funcţii care poate fi definită de
utilizator puteţi evalua condiţiile de eroare, puteţi returna un mesaj adecvat
utilizatorului şi puteti restabili setarea variabilelor AutoCAD.
Parcurgeţi aceste etape pentru a implementa o subrutină de tratare a erorilor

definită de utilizator pentru o comandă.
• Salvaţi definiţia curentă a funcţiei *error*.
Definiţi o nouă funcţie *error* pentru comandă sau funcţie.
Redefiniţi subrutina veche de tratare a erorilor prin comanda exit sau prin
exit dintr-o nouă subrutină de tratare a erorilor.
•178
Redefinirea rutinei de tratare a erorilor ar trebui făcută în contextul unei

comenzi sau a unei funcţii; plasaţi codul pentru a defini o rutină de tratare a
erorilor în cadrul codului pentru comandă.
50099176.doc R.2.1 9/21/2011 •179

AUTODESK, INC.
Exemplu
Acest cod implementează comanda c:rectangle şi propria-i rutină de tratare a
erorilor.
(defun c:rectangle (/ pt1 pt2)
(setq old_error *error*) ;save default error handler
(defun *error* (msg) ;define new error handler

(setvar "CMDECHO" old_cmdecho) ;restore system variable
(if
(/= "Function cancelled" msg) ;no message if user cancels
(if
(= msg "quit / exit abort") ;no message if program
(princ) ;deliberately aborts
(princ (strcat "ănError: " msg));otherwise, print error for user
)
(princ)
)
(setq *error* old_error) ;restore default error handler
(princ) ;quiet exit
)

(command "pline"
pt1
pt3
"c"
)

;if command is successful
(prin1)
)
După cum vedeţi, AutoLISP-ul vă permite să definiţi o funcţie (adică să
apelaţi funcţia defun) în timpul executării unei comenzi sau funcţii definite
de utilizator. Deci rutina de tratare a erorilor pentru funcţia c:rectangle este
definită de îndată ce utilizatorul apelează comanda RECTANGLE dar nu
înainte de asta. Rutina AutoLISP, implicită de tratare a erorilor este
refacută în toate cazurile: cînd comanda ajunge să fie îndeplinită cu succes
sau la capătul rutinei de tratare a erorilor cu comanda specifică.
Această tehnică vă permite să adaptaţi rutina AutoLISP de tratare a erorilor

pentru orice situaţie.
Rutina noastră de tratare a erorilor cu comandă specifică reface

poziţionarea originală a variabilei de sistem CMDECHO în cazul în care
Comanda RECTANGLE întîlneşte o eroare în timpul execuţiei. Variabila
•180
definită de utilizator old_emdecho a fost facută global aşa încît valoarea ei

este accesibilă noii funcţii *error*.
50099176.doc R.2.1 9/21/2011 •181

AUTODESK, INC.
EXERCITIUL 30: DEFINIREA SI UTILIZAREA UNEI NOI SUBRUTINE DE TRATARE A ERORILOR
• Veţi aprofunda cunoştinţele despre modul cum se foloseşte o
rutină de tratare a erorilor.
Etape de lucru
1. Adăugaţi o rutină de tratare a erorilor pentru comanda CIRCEN în
fişierul circen.lsp.
2. Folosiţi exemplul de la c:rectangle ca o bază de la care să porniţi.
4. Activaţi comanda CIRCEN şi anulaţi-o cu Ctrl-C pentru a verifica rutina
de tratare a erorilor.
•182
UNDO şi tratarea erorilor

Pentru a permite utilizatorului să anuleze într-o singură etapă rezultatul
unei comenzi pe bază de AutoLISP, amplasaţi un UNDO MARK la începutul
rutinei.
Puteţi folosi rutina de tratare a erorilor pentru a anula automat rezultatele

unei comenzi pe bază de AutoLISP pînă la punctul unde a intervenit
eroarea, admiţind faptul ca UNDO CONTROL este setat pentru ONE sau ALL.
Variabilele de sistem UNDOCTRL şi UNDOMARKS pot fi examinate de un

program AutoLISP pentru a determina ce acţiune de anulare, dacă există
vreouna, este adecvată pentru sesiunea curentă AutoCAD.
Exemplu
Această definiţie a comenzii RECTANGLE permite utilizatorului să anuleze
rezultatele comenzii într-o singură etapă.
Instrucţiunea if testează dacă UNDO este activată. Dacă da, atunci dă o
comandă UNDO MARK la începutul rutinei.
După ce utilizatorul introduce o comandă RECTANGLE, utilizatorul poate
anula rezultatul comenzii cu comenzile U sau UNDO BACK.

(if
(= 1 (logand 1 (getvar "UNDOCTL")))
(command "._UNDO" "_MARK")
)

(command "._PLINE"
pt1
pt3
"_C"
)
(prin1)
)
50099176.doc R.2.1 9/21/2011 •183

AUTODESK, INC.
Exemplu
Extindem codul UNDO pentru a include rutina de tratare a erorilor. Dacă
rutina este anulată dintr-un motiv oarecare şi UNDO este disponibil,
rezultatul comenzii pînă la punctul de eroare este anulat automat. Se setează
o variabila de condiţie pentru a fi examinată în rutina de tratare a erorilor.
Un UNDO GROUP este activat în comandă şi corelat cu un UNDO END.
NOTA • Fişierul ai_utils.lsp, versiunea 12 din directorul support conţine

cîteva rutine pentru folosirea codului UNDO într-un program AutoLISP.
•184
(setq old_cmdecho (getvar "CMDECHO")) ;store orignal command echo

(setvar "CMDECHO" 0) ;turn off command echo
(command) ;cancel any command în progress
(if
rect_undo_flag ;if the undo flag is t...
(progn
(command "._UNDO" "_END") ;end the group...
(command "._U") ;undo the command...
(setq rect_undo_flag nil) ;and clear the flag
)
)
(setvar "CMDECHO" old_cmdecho) ;restore system variable
(if
(if
(= msg "quit / exit abort") ;no message if program
(princ) ;deliberately aborts
)
(princ)
)
(princ) ;quiet exit
)
(if
(= 1 (logand 1 (getvar "UNDOCTL")));if UNDO is on...
(progn
(command "._UNDO" "_GROUP") ;start an UNDO GROUP...
(setq rect_undo_flag t) ;and set a flag
)
(setq rect_undo_flag nil) ;else, clear the flag
)

(command "pline"
pt1
pt3
"c"
)
(if
rect_undo_flag ;if the flag is set...
(progn
(command "._UNDO" "_END") ;end the UNDO GROUP...
(setq rect_undo_flag nil) ;and clear the flag
)
)
(setvar "CMDECHO" old_cmdecho) ;reset original command echo
50099176.doc R.2.1 9/21/2011 •185

AUTODESK, INC.

;if command is successful
(prin1) ;quiet exit
)
•186
Operaţii cu fişiere
AutoLISP poate citi şi scrie fişiere text de tip ASCII.
Obiective
• Ce este un descriptor de fişier şi cum este folosit.
• Cum să deschideţi un fişier pentru operaţii de citire sau
scriere.
• Cum să scrieţi linii de text într-un fişier deschis.
• Cum să citiţi linii de text dintr-un fişier deschis.
• Cum să descoperiţi sfîrşitul unui fişier text.
• Cum să închideţi un fişier.
Funcţiile fişier I/O

Operaţiile de citire şi scriere într-un fişier sau operaţii I/O într-un fişier se
realizează cu ajutorul a două funcţii: read-line şi write-line. Deschiderea şi
închiderea fişierelor se realizează de asemenea prin două funcţii: open şi
close.
Deschiderea unui fişier

Funcţia open cere două argumente: numele unui fişier ce urmează a fi
deschis şi modul de deschidere a acestuia. Ambele argumente trebuie să fie
şiruri.
Dacă funcţia open reuşeşte, returnează un descriptor de fişier. Dacă eşuează,
returnează nil.
Programul dvs. trebuie să păstreze descriptorul de fişier într-o variabilă!
Dacă nu-l păstraţi, nu veţi putea citi, scrie sau închide fişierul.
Descriptorul de fişier este un argument obligatoriu pentru funcţiile care

scriu în, citesc din/sau închid fişierul.
Există trei tipuri valide de moduri de deschidere a unui fişier. Fiecare
trebuie să fie reprezentat de o literă mică desparţită prin semne de
punctuaţie.
Open mode Descriere
"r" Deschiderea fisierului pentru citire.
"w" Deschiderea fisierului pentru scriere. daca exista un

fisier cu acelasi nume se va produce o
suprascriere.
"a" Deschiderea fisierului pentru adaugare. daca exista

un fisier cu acelasi nume, va fi adaugat la sfirsitul
acestuia.
Tabelul 28. Moduri de a deschide un fişier.
50099176.doc R.2.1 9/21/2011 •187

AUTODESK, INC.
De exemplu, această expresie deschide un fişier numit test.txt. pentru o

operaţie de scriere.
Command: (setq fp (open "test.txt" "w"))
<File: #xxxxx>
Command: !fp
<File: #xxxxx>
Scrierea într-un fişier

Funcţia write-line va scrie un şir de text într-un fişier deschis. Această
funcţie cere două argumente: un şir de tip text şi un descriptor de fişier. Al
doilea argument este opţional; dacă nu este introdus, funcţia write-line va
scrie şirul pe display.
Presupuneţi că variabila fp este legată de un descriptor de fişier valid

returnat prin deschiderea unui fişier pentru o operaţie de scriere.
Aceste expresii scriu două linii de text într-un fişier.
Command: (write-line "First line." fp)

"First line."
Command: (write-line "Second line." fp)

"Second line."
Închiderea unui fişier

Trebuie să închideţi fişierul imediat după operaţii de scriere, citire sau
adăugare. Dacă nu-l inchideţi, resursele sistemului dvs. vor fi limitate, în
particular numărul de handlere de fişiere disponibil.
Funcţia close va închide un fişier deschis. Funcţia cere un argument: un

descriptor de fişier valid. Funcţia returnează nil.
Această expresie va închide fişierul deschis şi în care s-a scris în cele două
exemple anterioare.
Command: (setq fp (close fp))
Deoarece descriptorul de fişier fp nu mai este valid după ce fişierul la care
se referă este închis, de exemplu dacă se seteaza fp la nil este echivalent cu a
închide fişierul. Se eliberează astfel memoria şi se obţine asigurarea că fp
nu poate fi folosit în afara contextului.
Exemplu
Deschideţi un fişier, scrieţi cîteva linii de text în fişier şi închideţi fişierul.

Examinaţi fişierul cu editorul de text după ce a fost închis.
Deschideţi un fişier numit test.txt pentru o operaţie de scriere.

Command: (setq fp (open "test.txt" "w"))
<File: #xxxxx>
•188
Command: !fp
<File: #xxxxx>
Scrieţi cîteva linii de text într-un fişier.
Command: (write-line "Coders" fp)
"Coders"
Command: (write-line "of the" fp)
"of the"
Command: (write-line "Lost Spark" fp)
"Lost Spark"
Închideţi fişierul.
nil
Command: !fp
nil
Deschideţi fişierul test.txt în editorul text şi examinaţi-l. Ar trebui să
conţină trei linii de text.
Coders
of the
Lost Spark
50099176.doc R.2.1 9/21/2011 •189

AUTODESK, INC.
Deschiderea unui fişier pentru o operaţie de citire

Cînd deschideţi un fişier pentru o operaţie de citire, puteţi citi datele din
fişier, linie cu linie. Nu puteţi modifica sau scrie într-un fişier care a fost
deschis pentru o operaţie de citire. (Dacă vreţi să introduceţi date în fişier,
închideţi-l şi redeschideţi-l pentru o operaţie de scriere.)
Funcţia open apelată cu un argumenr "r" returnează un descriptor de fişier

dacă fişierul specificat există; dacă nu, returnează nil.
Funcţia read-line citeşte o linie de text dintr-un fişier. Cere un argument

opţional: un descriptor de fişier valid pentru un fişier care a fost deschis
pentru o operaţie de citire. Dacă argumentul nu este adăugat, funcţia read-
line citeşte intrarea de pe tastatură.
Funcţia read-line returnează o linie de text pe care o citeşte dintr-un fişier.

Funcţia read-line returnează nil dacă ajunge la capătul fişierului.
Funcţia read-line începe cu prima linie de text dintr-un fişier. O apelare

ulterioară a funcţiei read-line va face ca funcţia să citească următoarea linie
de text din fişier şi aşa mai departe.
•190
Exemplu
În acest exemplu se presupune că aţi creat cu succes fişierul text.txt din

exerciţiul anterior.
Deschideţi fişierul test.txt pentru o operaţie de citire.
Command: (setq fp (open "test.txt" "r"))

<File: #XXXX>
Command: !fp
<File: #XXXX>
Citiţi prima, a două şi a treia linie din fişier.
Command: (read-line fp)

“Coders”

"of the"

"Lost Spark"
Încercaţi să citiţi pînă la sfîrşitul fişierului. Funcţia read-line va returna nil.
nil
Închideţi fişierul.
nil
Command: !fp
nil
50099176.doc R.2.1 9/21/2011 •191

AUTODESK, INC.
Recapitulare
• Un descriptor de fişier este un pointer al unui fişier returnat
de funcţia open.
• Un program trebuie să păstreze un descriptor de fişier
pentru a avea acces la fişierul pe care l-a deschis.
• Fişierele pot fi deschise pentru operaţii de citire, scriere şi
adăugare.
• Argumentele pentru modul de deschidere a fişierelor la
funcţia open trebuie să fie litere mici.
• Un fişier poate fi deschis numai pentru o singură operaţie.
• Funcţiile write-line şi read-line scriu şi citesc din fişiere.
• Funcţia read-line returnează nil cînd ajunge la capătul
fişierului.
•192
EXERCITIUL 31: COPIEREA UNUI FISIER TEXT
Aveţi 30 de minute la dispoziţie să terminaţi acest exerciţiu; este un

program vast. Aveţi nevoie de timp ca să revizuiţi şi să înţelegeti codul şi
de asemenea să introduceţi textul sursă.
• Veţi aprofunda cunoştinţele despre fişiere I/O în AutoLISP.
• Veţi crea un program AutoLISP pentru citit fişiere text de
tip ASCII şi pentru copiat fişiere într-un fişier cu nume
diferit.
• Veţi deschide fişiere atît pentru citit cît şi pentru scris.
Instrucţiuni
1. Introduceţi codul care urmează într-un document nou din editorul text.
2. Salvaţi fişierul în directorul student sub numele de copyfile.lsp.
3. Această funcţie foloseţte o rutină de tratare a erorilor cu apelare

asemănătoare cu cea din exerciţiul precedent. Varibilele legate de
descriptoarele de fişier au fost definite global aşa încît rutina de tratare
a erorilor le poate închide dacă este necesar.
4. Încărcaţi copyfile.lsp în AutoCAD.
5. Activaţi comanda COPYFILE.
6. Încercaţi să copiaţi două fişiere text.
7. Depanaţi programul dacă este necesar.
50099176.doc R.2.1 9/21/2011 •193

AUTODESK, INC.
(defun c:copyfile (/ r_fp_name w_fp_name r_fp_line)

; r_fp source file descriptor
; w_fp destination file descriptor
; r_fp_name source file name
; w_fp_name destination file name
; r_fp_line source file text line

(if ;close source file if open
r_fp
(setq r_fp (close r_fp))
)
(if ;close destination file if open
w_fp
(setq w_fp (close w_fp))
)
(if
(if
(= msg "quit / exit abort") ;no message if program deliberately
(princ) ;aborts
)
(princ)
)
(princ) ;quiet exit
)
;get source file from user with dialogue
(setq r_fp_name (getfiled "Select Source File" "" "txt" 0))
;if source file returned, get destination file from user
(if
r_fp_name
(setq w_fp_name (getfiled "Destination File" "" "txt" 1))
)
;check that we got good values for both file names
;exit if not
(if
(or
(not r_fp_name)
(not w_fp_name)
)
(progn
(prompt "ănMust specify both source and destination file.")
(exit)
)
)
•194
;check that file names are different

;exit if not
(if
(= r_fp_name w_fp_name)
(progn
(prompt "ănSource same name as destination file.")
(exit)
)
)
;open source file for read

;exit if it fails
(if
(not (setq r_fp (open r_fp_name "r")))
(progn
(prompt "ănCould not open source file.")
(exit)
)
)
;open destination file for read

;close source file and exit if it fails
(if
(not (setq w_fp (open w_fp_name "w")))
(progn
(prompt "ănCould not open destination file.")
(exit)
)
)
;get first line from source file
(setq r_fp_line (read-line r_fp))
;write source line to destination file and get next...

;source line until end of file is reached
(while
r_fp_line
(write-line r_fp_line w_fp)
(setq r_fp_line (read-line r_fp))
)
;close the source and destination files

(setq w_fp (close w_fp))
;restore original error handler
50099176.doc R.2.1 9/21/2011 •195

AUTODESK, INC.
(setq *error* old_error)
(prin1) ;quiet exit

)
•196
50099176.doc R.2.1 9/21/2011 •197

AUTODESK, INC.
EXERCITIUL32: CITIREA UNUI FISIER TEXT SI CREAREA ENTITATII “TEXT”

Dacă terminaţi cu comanda COPYFILE puteţi continua cu acest exerciţiu
opţional.
Funcţia c:iotext vă arată cum să citiţi un fişier text de pe disc şi să scrieţi

textul sub formă de entitaţi text AutoCAD. Acesta este un subset de
facilităţi inclus în ACAD R 12 din cadrul fişierului asctext.lsp.
Etape de lucru
1. Deschideţi un nou fişier în editorul text.
2. Introduceţi codul care urmează şi salvaţi-l într-un fişier numit iotext.lsp.
4. Activaţi comanda IOTEXT.
Un singur lucru trebuie să schimbaţi: cereţi utilizatorului să pună spaţii

între linii în loc să scaleze mereu înălţimea textului cu 1.5.
•198
; Iotext.lsp
;
; Command function IOTEXT prompts for the name of a text file.
; It reads each line of the file and draws the corresponding Text
; entities în AutoCAD.
;
; It prompts for the height, rotation angle and insertion point
; of the text. Text is always drawn left-justified.
(defun dtr (d) ;convert degrees to radians

(/ (* d pi) 180.0)
)
(defun rtd (r) ;convert radians to degrees

(/ (* r 180.0) pi)
)
(defun C:IOTEXT()
(setq old_cmdecho (getvar "CMDECHO")) ;save old command echo

(setvar "CMDECHO" 0) ;turn off command echo

(if ;close source file if open
io_fp
(setq io_fp (close io_fp))
)
(setvar "CMDECHO" old_cmdecho) ;restore command echo
(if
(if
(princ) ;aborts
)
(princ)
)
(princ) ;quiet exit
)
(setq io_fp_name ;name of text file to read

(getfiled "Select Text File" "" "txt" 0)
)
(if ;if the file dialogue is canceled

(= io_fp_name nil) ;then exit
(exit)
)
50099176.doc R.2.1 9/21/2011 •199

AUTODESK, INC.
•200
(if ;if we can't open file then exit

(not (setq io_fp (open io_fp_name "r")))
(progn
(prompt "ănCan't open file for input.")
(exit)
)
)
(initget 1) ;no null

(setq ;text insertion point
io_ins_pt (getpoint "ănInsertion point: ")
)
(initget (+ 1 2 4)) ;no null, zero, negative #

(setq ;text height
io_txt_ht (getdist io_ins_pt "ănHeight: ")
)
(setq io_txt_rot ;text rotation angle

(getangle io_ins_pt "ănRotation: ")
)
(if ;if null response to rotation

(not io_txt_rot) ;prompt, set it to 0.0
(setq io_txt_rot 0.0)
)
(setq ;set line spacing distance

io_line_spacing (* io_txt_ht 1.5)
)
(setq ;set line spacing angle

io_spacing_rot (- (dtr io_txt_rot) (/ pi 2))
)
(setq io_fp_line (read-line io_fp)) ;read line from file
;while we have a line of text from the file, draw a Text entity
;in AutoCAD. Set the next Text entity insertion point. Get the
;next line of text from the file.
(while
io_fp_line
(command "text" io_ins_pt io_txt_ht io_txt_rot io_fp_line)
(setq io_ins_pt (polar io_ins_pt io_spacing_rot io_line_spacing))
(setq io_fp_line (read-line io_fp))
)
(setq io_fp (close io_fp)) ;close file
(setvar "CMDECHO" old_cmdecho) ;restore command echo

(prin1) ;quiet exit
)
50099176.doc R.2.1 9/21/2011 •201

AUTODESK, INC.
Seturi de selecţie
AutoCAD-ul poate aşeza grupuri de entităţi în seturi de selecţie. Comenzile
AutoCAD şi funcţiile AutoLISP pot acţiona asupra unui set de selecţie şi
facînd aceasta, poate acţiona global asupra grupului de entităţi din setul de
selecţie.
Obiective
În acest capitol veţi învăţa:
• Cum să creaţi un set de selecţie.
• Cum să folosiţi un set de selecţie cu comenzi AutoCAD.
• Cum să creaţi un set de selecţie interactiv, cu fereastră, cu
filtru şi prin selectarea tuturor componentelor dintr-un
desen.
• Cum să aflaţi lungimea numărului de entităţi într-un set de
selecţie.
• Cum să lucraţi cu nume de entităţi într-un set de selecţie.
Note în legătură cu seturile de selecţie

Un set de selecţie în AutoLISP reprezintă un tip unic de date numit
PICKSET, alcătuit dintr-o colecţie de nume de entităţi. Setul de selecţie nu
este o listă.
AutoLISP poate păstra maximum 128 de seturi de selecţie deschise odată

(numărul ar putea fi mai mic pentru un sistem dat).
Legaţi întotdeauna o variabilă de un set de selecţie pe care îl creaţi sau

modificaţi; altfel nu aveţi acces la setul de selecţie şi nici o cale de a elibera
resursele sistemului consumate de setul de selecţie pînă ce nu ieşiti din
AutoCAD.
Cînd aţi terminat cu o variabilă atribuită setului de selecţie, este bine să

setaţi variabila pe nil pentru a elibera resursele folosite de setul de selecţie.
•202
AutoLISP dispune de o varietate de funcţii pentru a crea şi manipula

seturile de selecţie. Acest capitol descrie funcţionalitatea şi arată exemple
de funcţii ssget, sslength şi ssname.
Functia Operatia
ssget Creaza un set de selectie
ssadd Adauga o entitate la un set de selectie
ssdel Sterge o entitate dintr-un set de selectie
sslength Determina numarul de entitati dintr-un set de selectie
ssmemb Verifica daca fiecare entitate este parte a setului de selectie
ssname Extrage numele entitatilor din setul de selectie

Tabelul 29. Functii pentru seturi de selectie
Crearea unui set de selecţie

Funcţia ssget include virtual toate seturile de selecţie interactive, cuprinzînd
metode care sînt disponibile în AutoCAD la mesajul “Select objects:”.
Sintaxa completă şi numărul de aplicaţii ale funcţiei sînt prea complicate
pentru a fi descrise aici în întregime. De aceea ne vom concentra atenţia
asupra cîtorva dintre formele de sintaxă cele mai folosite şi vom lăsa
descrierea completă în seama manualului AutoLISP Programmer’s
Reference Manual.
Sintaxa functiei Operatia
(ssget) “Select objects ´standard:cererea

permite utilizatorului selecţia
interactiva "
(ssget "X") Selecteaza toate entitaţile din

desen
(ssget "W" '(1.0 1.0 0.0) '(11.0 8.0 0.0)) Selecteaza toate entitaţile din
fereastra de la 1,1,0 la 11,8,0
(ssget "X" '((0 . "LINE"))) Selecteaza toate entitaţile Line

din desen
Tabelul 30.Sintaxa si operaţiile functiei ssget.
Exemple de lucru
Deschideţi desenul ssget.dwg în directorul student. Veţi folosi acest desen
pentru următoarele patru exemple care arată cum să folosiţi ssget.
50099176.doc R.2.1 9/21/2011 •203

AUTODESK, INC.
Selecţia interactivă
Funcţia ssget apelată fără argumente va genera cererea standard "select
objects:" în zona liniei de comandă şi va permite utilizatorului să selecteze
obiecte interactiv. Cînd utilizatorul termină procesul de selecţie cu tasta
Return sau Space, funcţia ssget returnează valoarea ei sub forma unui nou
set de selecţie.
Exemplu
Cînd vă aflaţi în desenul ssget.dwg, introduceţi expresiile care urmează.
Folosiţi ssget pentru a cere utilizatorului să selecteze obiecte.

Command: (setq ss1 (ssget))
Select objects: pick several objects
<Selection set: 1>
Verificaţi tipul de date ale variabilei ss1.
Command: !ss1
<Selection-set: 1>
Command: (type ss1)
PICKSET
Folosiţi setul de selecţie pentru care variabila ss1 este legată în cadrul
comenzii AutoCAD.
Command: erase
Select objects: !ss1
Refaceţi obiectele şterse.
Command: oops
•204
Selectarea componentelor dintr-un desen

Funcţia ssget apelată cu un singur argument, şirul "X", va returna un set de
selecţie compus din entităţile componente din desen. Această funcţie
include entităţile care nu sînt afişate pe monitor şi entitaţile de pe layere
care sînt îngheţate şi/sau închise.
Exemplu
Cînd sînteţi în desenul ssget.dwg, introduceţi expresiile care urmează.
Folosiţi funcţia ssget pentru a crea un set de selecţie format din toate
entităţile din desen.
Command: (setq ss1 (ssget "X"))
<Selection set: 2>
Ştergeţi toate obiectele din desen.
Command: (command ".erase" ss1 "")
Command: oops
Selectarea componentelor dintr- o fereastră

Puteţi apela funcţia ssget cu un argument de tip şir care corespunde oricărei
opţiuni standard la cererea "select objects:", opţiuni cum ar fi "W" pentru
entităţile incluse în fereastră, "C" pentru entitaţile care traversează sau sînt
incluse în fereastră şi "F" pentru entităţi care intersectează o polilinie de
selecţie.
Exemplu
Cînd sînteţi în desenul ssget.dwg, introduceţi expresiile care urmează.
Creaţi un set de selecţie din entităţi care aparţin unei ferestre definită de
punctele 6,3,0 şi 11,8,,0.
Command: (setq ss1 (ssget "W" '(6 3 0) '(11 8 0)))
<Selection set: 3>
Ştergeţi toate entităţile care se află în interiorul ferestrei.
Refaceţi toate entităţile şterse.
50099176.doc R.2.1 9/21/2011 •205

AUTODESK, INC.
Selectarea cu filtru
Funcţia ssget vă permite să selectaţi entităţile prin filtru. Puteţi filtra în
acord cu oricare dintre proprietăţile entităţilor care sînt păstrate în coduri de
grup DXF în cadrul listelor asociate entităţilor.
O listă filtru este asemănătoare cu o listă asociată entităţii. Implicit, o

entitate trebuie să corespundă fiecărei proprietăţi din filtru pentru a putea fi
adăugată la setul de selecţie. Există şi alte metode de creare a listelor de tip
filtru.
Comanda AutoCAD FILTER definită de fişierele filter.lsp şi filter.dcl este în

general o interfaţă bazată pe dialog la funcţia ssget şi listele de tip filtru.
Exemplu
Creaţi un set de selecţie format din entităţile de tip Line din desen.
Command: (setq ss1 (ssget "X" '((0 . "LINE"))))
<Selection set: 4>
Ştergeţi toate entităţile de tip Line din desen.
Command: oops
Setaţi variabila ss1 pe nil şi eliberaţi resursele folosite curent de setul de
selecţie.
Command: (setq ss1 nil)
nil
•206
Lungimea unui set de selecţie

Funcţia sslength cere un singur argument: un set de selecţie valid. Funcţia
returnează numărul de nume al entităţilor din setul de selecţie.
Exemplu
Creaţi un set de selecţie din trei (3) entităţi.

Select objects: pick three objects
<Selection set: 5>
Folosiţi funcţia sslength pentru a verifica numărul de entităţi din setul de
selecţie.
Command: (sslength ss1)
3
selecţie.
nil
50099176.doc R.2.1 9/21/2011 •207

AUTODESK, INC.
Numele entităţilor dintr-un set de selecţie

Un set de selecţie este un grup format din nume de entităţi AutoCAD.
Funcţia ssname poate stabili numele oricărei entităţi dintr-un set de selecţie.
Funcţia ssname cere două argumente: un set de selecţie valid şi un număr

întreg. Numărul întreg corespunde unui index 0 al numelui entităţii din
setul de selecţie.
Exemplu
Creaţi un set de selecţie din trei entităţi.

Select objects: pick three objects
<Selection set: 6>
Folosiţi ssname pentru a returna numele fiecărei entităţi din setul de selecţie.
Folosiţi entget pentru a returna lista asociată fiecărei entităţi.

Command: (setq ename (ssname ss1 0))
Command: (entget ename)



selecţie.
nil
•208
Recapitulare
• Grupurile de entităţi pot fi plasate în seturi de selecţie.
• Un set de selecţie în AutoLISP are un tip de date PICKSET. Setul de

selecţie nu este o listă.
• AutoLISP poate menţine 128 de seturi de selecţie deschise în acelaşi

timp.
• Legaţi o variabilă ori de cîte ori creaţi un set de selecţie.
• Eliberaţi întotdeauna resursele folosite de un set de selecţie după

ce aţi terminat de lucrat cu acesta.
• Funcţia ssget poate crea un set de selecţie în diferite moduri.
• Funcţia sslength returnează numărul de entităţi din setul de selecţie.
• Funcţia ssname returnează numele entităţii din setul de selecţie.
50099176.doc R.2.1 9/21/2011 •209

AUTODESK, INC.
EXERCITIUL33: CREAREA INTERACTIVA A SETURILOR DE SELECTIE
• Veţi aprofunda cunoştinţele despre seturile de selecţie din

AutoLISP.
• Veţi folosi funcţia ssget.
• Veţi obţine un set de selecţie interactiv de la utilizator.

• Veţi accesa entităţile dintr-un set de selecţie.
Etape de lucru
1. Deschideţi fişierul grafic moddim.dwg din directorul student.
2. În editorul de text deschideţi fişierul numit chdim.lsp din directorul student.
3. Adăugaţi codul care realizează următoarele:
• Creaţi o funcţie numită c:chdim.
• Cereţi utilizatorului un set de selecţie.
• Exploraţi fiecare entitate din setul de selecţie.
• Transferaţi ficare listă asociată entităţii ca argument la
funcţia chdim_mod.
• Eliberaţi setul de selecţie.
1. Salvaţi fişierul chdim.lsp.
2. Încărcaţi fişierul în AutoCAD şi încercaţi comanda CHDIM.
3. Ieşiţi din desen moddim fără a salva modificările.
4. Dacă aveţi timp vă puteţi modifica programul astfel:
• Adăugaţi o rutină de tratare a erorilor.
• Adăugaţi un dicţionar de date.
• Transformaţi variabilele corespunzătoare mai degrabă în
variabile locale decît în variabile globale.
(defun chdim_mod (elist)

(if ;if entity is a dimension...
(= "DIMENSION" (cdr (assoc 0 elist)))
(entmod ;modify it based on...
(subst
(cons 8 "DIM") ;substituting layer DIM...
(assoc 8 elist) ;for its current layer.
elist
)
)
)
)
•210
EXERCITIUL 34: SETURI DE SELECTIE CU FILTRU
Rezolvaţi acest exerciţiu numai dacă aveţi timp în clasă.
Codul care urmează, implementează o versiune a CHDIM care este din punct
de vedere funcţional echivalentă cu versiunea anterioară. Această versiune
foloseşte un filtru pentru set de selecţie în combinaţie cu o selecţie
interactivă de entităţi cu scopul de a amplasa numai entităţile de tip
dimension în setul de selecţie.
Etape de lucru
2. Creaţi un nou fişier în editorul text numit chdim2.lsp.
3. Introduceţi codul care urmează.
Acest cod crează funcţia c:chdim2. CHDIM2 va cere utilizatorului un set de

selecţie, va filtra toate entităţile cu excepţia entităţilor de tip dimension şi
va schimba entităţile pe layerul DIM.
(defun c:chdim2 ()
;get a selecţion-set from user and filter out all but dimensions
(setq ss (ssget “X”((0 . "DIMENSION"))))
(if ;if no selecţion-set, exit

(not ss)
(exit)
)
;change the layer

(command "._chprop" ss "" "LA" "DIM" "")
(setq ss nil) ;free selecţion-set
(prin1) ;quiet exit

)
4. Salvaţi fişierul chdim2.lsp.
6. Activaţi comanda CHDIM2.
7. Părăsiţi desenul moddim fără să faceţi modificări.
50099176.doc R.2.1 9/21/2011 •211

AUTODESK, INC.
Tabele şi nume de simboluri

Tabelele păstreză lista AutoCAD-ului cu nume de simboluri cum ar fi :
layere, definiţii Block şi tipuri de linii.
Obiective
• Tipuri diferite de tabele într-un fişier grafic AutoCAD.
• Cum să citiţi fiecare intrare într-un tabel AutoCAD.
• Cum să căutaţi o intrare anume într-un tabel AutoCAD.
Tabele într-un desen

AutoCAD are 8 tabele diferite care pot fi accesate de AutoLISP.
• Block
• Dimstyle
• Layer
• Ltype
• Style
• UCS
• View
• Vport
Fiecare tabelă poate fi citită direct din AutoLISP. Fiecare în parte poate fi
accesată secvenţial sau accesată pentru un nume de simbol dat.
Funcţiile AutoLISP care accesează tabelele AutoCAD pot extrage datele

asociate cu o tabelă dar nu pot modifica o tabelă sau datele sale.
Căutarea secvenţială a tabelului layer

Funcţia tblnext scanează un tabel şi returnează o listă asociată care conţine datele
unui obiect denumit din tabel sau returnează nil dacă ultima instrucţiune din tabel
a fost atinsă.
Funcţia tblnext are o sintaxă ciudată. Funcţia cere un argument: un şir care
corespunde unuia dintre numele de tabele AutoCAD. Dacă se adaugă al doilea
argument opţional şi acesta nu este nil, atunci funcţia tblnext returnează primul
nume de simbol din tabel; dacă nu se adaugă argumentul, funcţia returnează
simbolul cerut care îl urmează pe cel returnat prin apelarea anterioară a funcţiei
tblnext.
Exemplu
Această expresie returnează lista asociată pentru prima intrare în tabelul
layer.
•212
Command: (tblnext "LAYER" t)

((0 . "LAYER") (2 . "0") (70 . 0) (62 . 7) (6 . "CONTINUOUS"))
Lista asociată este o listă cu perechi cu punct, a cărei cod este realizat în
acelaşi mod în care sînt realizate codurile pentru liste asociate entităţilor.
Deoarece nu lucrăm cu entităţi individuale, este clar că această listă
asociată nu are un grup -1 reprezentînd un nume de entitate.
Vezi anexa B din AutoLISP Programmer’s Reference Manual, "Block and

Table Group Codes", pentru o descriere completă a codurilor din lista
asociată layerelor.
Exemplu
Dacă un desen ar conţine layerele din tabelul de mai jos, atunci s-expresiile
care urmează ar returna listele asociate arătate mai jos.
Layer Stare Culoare Tipul de linie
0 Dezghetat, On 7 sau alb continuu
DIM Dezghetat, Off 2 sau galben continuu
HIDDEN Inghetat, Off 5 sau albastru ascuns
OBJECT Dezghetat, On 1 sau rosu continuu
Tabelul 31. Lista de layere si proprietati care ilustreaza valorile returnate de

functia tblnext
Command: (tblnext "LAYER" t)
Command: (tblnext "LAYER")

((0 . "LAYER") (2 . "DIM") (70 . 0) (62 . -2) (6 . "CONTINUOUS"))

((0 . "LAYER") (2 . "HIDDEN") (70 . 1) (62 . -5) (6 . "HIDDEN"))

((0 . "LAYER") (2 . "OBJECT") (70 . 0) (62 . 1) (6 . "CONTINUOUS"))

nil
50099176.doc R.2.1 9/21/2011 •213

AUTODESK, INC.
O buclă care returnează listele asociate pentru toate numele de simboluri

dintr-un tabel este uşor de implementat. Acest fragment de cod tipăreşte
lista asociată pentru fiecare nume de simbol din tabelul layer.
(setq tlist (tblnext "LAYER" t))
(while
tlist
(print tlist)
(setq tlist (tblnext "LAYER"))
)
•214
EXERCITIUL 35: CAUTAREA INTR-O TABELA
• Veţi consolida cunoştinţele despre tabele.
• Veţi crea o nouă funcţie care scanează fiecare intrare din tabel.
• Veţi tipări numele fiecărui simbol în tabel.
Etape de lucru
1. Deschideţi desenul moddim.dwg în directorul student.
2. Într-un fişier nou din editorul text, introduceţi codul care urmează.
Acesta implementează funcţia c:tlist.
TLIST cere utilizatorului un cod care corespunde unuia dintre tabelele

AutoCAD iar apoi scanează tabelul secvenţial folosind funcţia tblnext şi
tipăreşte numele fiecărui simbol în tabel.
(defun c:tlist ()
;set up list of keywords for user prompt

(initget "Block Dimstyle LAyer LType Style Ucs View VPort")
(setq ttype ;get table type from user

(getkword "ănBlock/Dimstyle/LAyer/LType/Style/Ucs/View/VPort: ")
)
(if ;if user pressed return, exit

(not ttype)
(exit)
)
(setq tlist (tblnext ttype t)) ;get first entry în table
(while ;while we have a valid entry...

tlist ;in the table...
(print (cdr (assoc 2 tlist))) ;print its name...
(setq tlist (tblnext ttype)) ;get the next entry...
(prin1) ;quiet exit

)
3. Salvaţi fişierul ca tlist.lsp în directorul student.
5. Activaţi comanda TLIST.
50099176.doc R.2.1 9/21/2011 •215

AUTODESK, INC.
Căutarea unui nume de simbol

Funcţia tblsearch va căuta un nume de simbol într-un tabel. Funcţia cere
două argumente: un şir care corespunde unui tabel AutoCAD şi un şir care
corespunde numelui unui simbol cerut.
Dacă numele cerut nu există, funcţia tblsearch returnează nil.
Exemplu
Această expresie caută layerul 0 şi-i returnează lista asociată.
Command: (tblsearch "LAYER" "0")
Recapitulare
• AutoCAd păstrează simbolurile cum ar fi layer-ele şi Block
Definitions în tabele.
• Există 8 tabele în AutoCAD.
• Funcţia tblnext poate scana fiecare simbol din tabel.
• Funcţia tblsearch poate căuta un anume simbol într-un tabel.
• Tabelele nu pot fi modificate direct de AutoLISP.
•216
EXERCITIUL 36: CAUTAREA IN TABELA DE LAYER-E
• Veţi folosi funcţia tblsearch.
• Veţi căuta în tabela Layer numele layerului dat de utilizator.
• Veţi determina dacă layerul există şi veţi informa utilizatorul în

consecinţă.
Instrucţiuni
1. Deschideţi desenul moddim.dwg din directorul student.
2. Într-un fişier nou din editorul de text introduceţi codul care urmează.
Acesta implementează funcţia c:chklayer .
CHKLAYER cere utilizatorului numele layerului şi determină dacă layerul

există în desenul respectiv iar apoi tipăreşte un mesaj adecvat pentru
utilizator.
(defun c:chklayer ()
(setq lname ;get layer name from user

(getstring "ănName of layer: ")
)
(if
(tblsearch "LAYER" lname) ;layer exists?
(prompt (strcat "ănLayer " lname " exists. ")) ;yes
(prompt (strcat "ănLayer " lname " does not exist. ")) ;no
)
(prin1) ;quiet exit

)
3. Salvaţi fişierul text ca chklayer:lsp în directorul student.
5. Activaţi comanda CHKLAYER.
50099176.doc R.2.1 9/21/2011 •217

AUTODESK, INC.
EXERCITIUL 37: EXERCITII SUPLIMENTARE CU TABELE
Etape de lucru
1. Deschideţi fişierul grafic moddim.dwg în directorul student.
2. Într-un fişier nou din directorul student scrieţi două funcţii: c:chktable şi
c:layerset .
3. Salvaţi totul într-un fişier. Încărcaţi funcţiile în AutoCAD şi testaţi-le în

desenul moddim.
c:chktable
1. Întreabă utilizatorul ce tabelă să caute.
2. Întreabă utilizatorul care este simbolul cautat.
3. Caută tabelul pentru simbolul căutat.
4. Spune utilizatorului dacă simbolul căutat există.
c:layerset
1. Întreabă utilizatorul care este numele layerului.
2. Dacă layerul există, funcţia spune operatorului tipul de linie şi culoarea

atribuite layerului.
3. Dacă layerul există, legaţi o variabilă globală de un set de selecţie

format din toate entitaţile de pe layerul respectiv.
•218
EXERCITIUL 14: UN EXECITIU MAI COMPLEX DE CAUTARE IN TABELE
Acesta este un exerciţiu opţional
Etape de lucru
2. Într-un fişier nou din editorul de text, introduceţi codul care urmează.
Acesta implementează funcţia c:tsearch.
3. TSEARCH caută simbolul într-un tabel şi dacă simbolul există tipăreşte

fiecare cod de grup şi valoare din lista asociată simbolului.
50099176.doc R.2.1 9/21/2011 •219

AUTODESK, INC.
(defun c:tsearch ()
;set up list of keywords for user prompt

(initget "Block Dimstyle LAyer LType Style Ucs View VPort")
(setq ttype ;get table type from user

(getkword "ănBlock/Dimstyle/LAyer/LType/Style/Ucs/View/VPort: ")
)

(not ttype)
(exit)
)
(setq ttarget ;get target search name

(getstring (strcat "ăn" ttype " table entry: "))
)

(not ttarget)
(exit)
)
(setq tlist (tblsearch ttype ttarget));get list for target...

;from its table.
(if
(not tlist) ;if no list, then target...
(progn ;was not found, so exit.
(prompt "ănNo such entry.")
(exit)
)
)
(while
tlist ;while we still have a list...
(print (car (car tlist))) ;print first group code...
(print (cdr (car tlist))) ;and value from assoc list...
(setq tlist (cdr tlist)) ;then truncate assoc list.
)
(prin1) ;quiet exit

)
4. Salvaţi fişierul text ca tsearch.lsp în directorul student.
5. Încărcaţi programul în AutoCAD şi testaţi comanda TSEARCH.
•220
Fişiere script şi AutoLISP

Dacă vreţi să folosiţi un program AutoLISP pentru a procesa cîteva desene
în editor, pe rînd, probabil veţi combina un program AutoLISP cu un fişier
script pentru o procesare automată.
AutoLISP se iniţializează la fiecare nouă sesiune de editare, adică ori de

cîte ori începeţi un nou desen sau editaţi unul deja existent. Iniţializarea
eliberează zona de memorie destinată AutoLISP-ului ştergînd toate
funcţiile definite de utilizator şi de aplicaţii, şi variabilele din proces.
Să presupunem că avem o funcţie AutoLISP definită după cum urmează.

Ce se întîmplă cînd această funcţie este în acţiune?
Command: (defun c:my_new () (command "._new" ""))
C:MY_NEW
Command: my_new
Command: ._new File name:
Command: !c:my_new
nil
C:MY_NEW apelează comanda AutoCAD NEW şi începe un nou desen.
După ce editorul grafic a fost iniţializat, verificăm setarea funţiei
C:MY_NEW... şi vedem că este nil. Acest lucru se datorează faptului că
AutoLISP este întotdeauna iniţializat împreună cu editorul grafic.
Cu alte cuvinte, orice funcţie AutoLISP care reciclează editorul grafic se

autodistruge.
Pentru a rezolva această problemă, puteţi folosi fişiere script în combinaţie

cu programe AutoLISP pentru a procesa mai multe desene cu acelaşi cod
AutoLISP. Fişierul script reîncarcă şi apelează programul AutoLISP la
fiecare nou desen. Codul AutoLISP scrie fişierul script, defineşte funcţia
pentru a fi apelată din fişierul script şi apelează fişierul script.
Iată un exemplu tipic.
Dorim să procesăm toate fişierele grafice din directorul student/batchdwg

cu un program AutoLISP care tipăreşte un raport ce cuprinde numărul de
Block Definitions din desen şi numele lor. (Acest exerciţiu presupune că un
astfel de director cu fişiere grafice există deja în computer.)
Fişierul program run.lsp defineşte două funcţii AutoLISP: C:RUN şi

C:RUN_REPORT .
50099176.doc R.2.1 9/21/2011 •221

AUTODESK, INC.
C:RUN execută următoarele activităţi în ordine.
• Vă asigură că aplicaţia ADS XDOS este încărcată.
• Cere un nume de director de la utilizator.
• Cere o listă cu toate fişierele grafice din director.
• Scrie un fişier script care deschide fiecare desen, reîncarcă run.lsp şi

apelează funcţia C:RUN_REPORT pentru fiecare desen.
• Apelează fişierul script.
Funcţia C:RUN_REPORT scrie un fişier raport pentru fiecare desen care

conţine Block Definitions. Fişierul raport are acelaşi nume ca şi desenul cu
o extensie .rpt şi se află în acelaşi director ca şi desenul. Funcţia listează
numele fiecărui Block în desen şi de cîte ori Block a fost inserat.
c:runfoloseşte funcţia dosdir din fişierul xdos.exe, o aplicaţie ADS real mode
pentru ACAD R12 care se află în CompuServe ACAD Forum în Library 2.
xdos este în directorul student din computerul dvs. Instrucţiunile de folosire
a acestei funcţii se află în fişierul xdos.txt.
Într-un desen nou, folosiţi comanda definită în run.lsp. Urmaţi

instrucţiunile de mai jos.
Command: (load "run")
C:RUN_REPORT
Command: run
După ce ultimul desen a fost procesat, examinaţi conţinutul următoarelor
trei fişiere:
• d:ăstudentărun.scr
• d:ăstudentăbatchdwgăblock5.rpt
• d:ăstudentăbatchdwgăblock10.rpt
•222
(defun C:RUN ()
(if
(not (member "DOSDIR" (atoms-family 1))) ;Check for dosdir function.
(if ;If not there, attempt to
(= "bad" (xload "XDOS.EXE" "bad")) ;load XDOS program; exit
(progn ;if attempt fails.
(prompt "ănCan't load XDOS.EXE.")
(exit)
)
)
)
(setq dwgdir (getstring "ănDirectory: ")) ;Get directory from user.
(setq dwgnames ;Get list of drawings.

(dosdir (strcat dwgdir "ăă" "*.dwg") 0)
)
50099176.doc R.2.1 9/21/2011 •223

AUTODESK, INC.
(setq fp (open "run.scr" "w")) ;Open file run.scr for

;writing în current dir.
;The script commands will open each drawing în turn, load the
;file run.lsp and apply the run_report command to each file.
(foreach a dwgnames ;Write script file.

(progn
(princ "(if (= 0 (getvar ă"DBMODă")) (command ă"._OPENă")" fp)
(princ "(command ă"._OPENă" ă"Nă"))ăn" fp)
(princ (strcat dwgdir "ăă" a "ăn") fp)
(princ "(load ă"run.lspă")ăn" fp)
(princ "run_reportăn" fp)
)
)
(setq fp (close fp)) ;Close run.scr file.
(command "._SCRIPT" "run") ;Call script as last

; expression.
)
(defun C:RUN_REPORT ()
(setq block_name_list nil) ;Initialize list of Block names.
(if
(setq block_table_list (tblnext "BLOCK" t)) ;We have a Block?
(progn
(prompt "ănFinding Block names.") ;Keep the customer happy.
(while ;Add its name to the list and
block_table_list ;get the next one.
•224
(setq block_name (cdr (assoc 2 block_table_list)))

(setq block_name_list (cons block_name block_name_list))
(setq block_table_list (tblnext "BLOCK"))
)
;Sort the list of Block names.

(setq block_name_list (acad_strlsort block_name_list))
;Get the number of Insert entities for each Block.

;Create a list of dotted pairs. Each dotted pair consists
;of a Block name and the number of Insert entities.
(prompt "ănFinding INSERT entities.") ;Keep the customer happy.

(setq report_list nil count 0) ;Initialize the list and counter.
(repeat ;For all the Block names...
(length block_name_list) ;find how many INSERT entities.
(setq block_name (nth count block_name_list))
(setq s_set ;Returns selecţion-set of all
(ssget "X" ;the INSERT entities of the
(list ;current block_name.
(cons 0 "INSERT")
(cons 2 block_name)
)
)
)
(setq ;Add a dotted pair of the form
report_list ;("BLOCK_NAME" . "NUMBER") to
(cons ;the report_list.
(cons
block_name
(if ;If, for example, the Block "DOOR"
s_set ;is not inserted în this drawing,
(itoa (sslength s_set)) ;add the dotted pair ("DOOR" . "0").
50099176.doc R.2.1 9/21/2011 •225

AUTODESK, INC.
"0"
)
)
report_list
)
)
(setq count (1+ count)) ;Next Block name.
(princ ".") ;Keep the customer happy.
)
(setq report_list (reverse report_list)) ;Reverse report list.
(setq s_set nil) ;Free selecţion-set.
;Print report to disk file dwgname.rpt.
(prompt "ănWriting report to disk.")

(setq fp (open (strcat (getvar "DWGNAME") ".rpt") "w"))
(write-line (strcat "Drawing " (getvar "DWGNAME") "ăn") fp)

(write-line "Block names # of insertions" fp)
(write-line "=========== ===============" fp)
(setq count 0) ;First Block name.

(repeat
(length report_list) ;Get 'em all...
(setq block_name
(car (nth count report_list))
insert_number
(cdr (nth count report_list))
)
(setq spacer "") ;Calculate number of spaces to 36th
(repeat ;character from end of Block name.
(- 36 (strlen block_name))
(setq spacer (strcat " " spacer))
)
(write-line ;Write Block name, spaces to the
(strcat ;36th character, and the number of
block_name ;INSERT entities for that Block.
spacer
insert_number
)
fp
)
(setq count (1+ count)) ;Next block name.
)
(setq fp (close fp)) ;Close dwgname.rpt file.
)
)
(prin1) ;Quiet exit.
)
•226
50099176.doc R.2.1 9/21/2011 •227

AUTODESK, INC.
Accesul la Polilinii
Poliliniile sînt entităţi complexe. Ele sînt formate dintr-o entitate principală
de tip "POYLINE" urmată de una sau mai multe entităţi de tip "VERTEX"
terminate de o entitate de tip "SEQUEND". Această diagramă ilustrează
lanţul de entităţi şi numele lor.
POLYLINE SEQEND
Main entity Sub entity
Next entity name: Next entity name:
VERTEX Next main entity

in database
VERTEX
Sub entity
Next entity name:
VERTEX
or
SEQEND
Figura 47.Relatia dintre polyline ca entitate principala si subentitati
În afara accesării entităţilor principale neşterse din baza de date, funcţia

entnext va accesa subentităţile unei Polilinii şi atributele entităţilor Insert.
Acest capitol ilustrează acest principiu cu ajutorul unei funcţii care:
• Cere utilizatorului să selecteze o polilinie.
• Accesează subentitaţile unei polilinii.
• Vizualizează un raport despre fiecare entitate pe display.
• Iese atunci cînd a ajuns la capătul poliliniei.
•228
(defun c:polylist ()

(if
(if
(princ) ;aborts
)
(princ)
)
(princ) ;quiet exit
)
(setq epick (entsel "ănSelect polyline: "))

;select an entity
(if
(not epick) ;if no entity selected, exit
50099176.doc R.2.1 9/21/2011 •229

AUTODESK, INC.
(exit)
)
(setq ename (car epick)) ;get entity name

(setq elist (entget ename)) ;get association list
(setq etype (cdr (assoc 0 elist))) ;store entity type
(if
(/= "POLYLINE" etype) ;if not a Polyline, exit
(progn
(prompt "ănNot a polyline.")
(exit)
)
)
(while ;while we have an entity name

(and ;and it's not the end of the
ename ;Polyline...
(/= "SEQEND" etype)
)
(princ "ănEntity type: ") ;print the entity type
(princ etype)
(if ;if it's a Vertex entity...

(= "VERTEX" etype) ;get its group 70 flags and
(progn ;location, and print location
(setq vflags (cdr (assoc 70 elist)))
(setq pt (cdr (assoc 10 elist)))
(princ "ănLocation: ")
(princ (car pt))
(princ " ")
(princ (car (cdr pt)))
(princ " ")
•230
(princ (car (cdr (cdr pt))))

(if ;check each flag and print
(= 1 (logand 1 vflags)) ;each if true
(princ "ănVertex inserted by curve-fitting.")
)
(if
(= 2 (logand 2 vflags))
(princ "ănCurve-fit tangent defined for this vertex.")
)
(if
(princ "ănSpline vertex created by spline-fitting.")
)
(if
(princ "ănSpline frame control point.")
)
(if
(princ "ăn3D Polyline vertex.")
)
(if
(princ "ăn3D Polyline mesh vertex.")
)
(if
(princ "ănPolyface mesh vertex.")
)
)
)
;stop screen from scrolling
(getstring "ănănPress RETURN to continue...")
(setq ename (entnext ename)) ;get next entity în Polyline
(if ;if we have an entity name...

ename ;get its assocation list and
(progn ;entity type
(setq elist (entget ename))
(setq etype (cdr (assoc 0 elist)))
)
)
)
(setq *error* old_error) ;restore old error handler
(prin1) ;quiet exit
)
50099176.doc R.2.1 9/21/2011 •231

AUTODESK, INC.
•232
Accesul la Block Definitions

Block Definitions sînt entităţi complexe. O entitate principală de tip
"BLOCK" cu un nume unic este păstrată în tabela AutoCAD Block. Această
entitate este urmată de una sau mai multe entităţi de orice tip, terminată cu
o entitate de tip "ENDBLK". Această diagramă ilustrează lanţul de entităţi şi
numele entităţilor.
Block Table ENDBLK
Named object Sub entity
Next entity name: Next entity name:

Any type None
Next sub entity
Any type
Next entity name:

Any type
Figura 48. Relatia dintre intrarea in tabela Block si subentitatile acestuia.
Funcţia entnext accesează subentităţile din definiţiile Block. Acest capitol

ilustrează acest principiu printr-o funcţie care:
• Cere utilizatorului să selecteze o entitate Insert care se referă la

Block Definition.
• Accesează Block Definition în cadrul tabelei Block.
• Accesează subentităţile din Block Definition
• Tipăreşte lista asociată fiecărei subentităţi pe display.
• Iese cînd ajunge la capătul entităţii Block Definition.
50099176.doc R.2.1 9/21/2011 •233

AUTODESK, INC.
(defun c:blklist (/ blist bname elist ename epick etype)
;blist Association list from Block table

;bname Name of Block Definition
;elist Entity association list
;ename Entity name
;epick List returned by entsel
;etype Entity type as string
;old_error Default error handler

(if
(if
(princ) ;aborts
)
(princ)
)
•234

(princ) ;quiet exit
)
(setq epick (entsel "ănSelect block: "))

;select an entity
(if
(not epick) ;if no entity selected, exit
(exit)
)
(setq ename (car epick)) ;get entity name

(setq elist (entget ename)) ;get association list
(if
(/= "INSERT" etype) ;if not an Insert, exit
(progn
(prompt "ănNot a block.")
(exit)
)
)
(setq bname (cdr (assoc 2 elist))) ;get name of Block Definition
(setq blist (tblsearch "BLOCK" bname));get its assoc list
(setq ename (cdr (assoc -2 blist))) ;get first entity în Block

(setq elist (entget ename)) ;get its assoc list
(while ;while we have an entity name

(and ;and it's not the end of the
ename ;Block Definition...
(/= "ENDBLK" etype)
)
(print elist) ;print entity's assoc list
;stop screen from scrolling

(getstring "ănănPress RETURN to continue...")
(setq ename (entnext ename)) ;get next entity în Block
(if ;if we have an entity name...

ename ;get its assocation list and
(progn ;entity type
(setq elist (entget ename))
(setq etype (cdr (assoc 0 elist)))
)
)
)
(setq *error* old_error) ;restore old error handler
(prin1) ;quiet exit
)
50099176.doc R.2.1 9/21/2011 •235

AUTODESK, INC.
•236
Crearea entităţilor Line cu funcţia entmake

Funcţia entmake crează noi entităţi AutoCAD fără să folosească comenzi
AutoCAD de tip LINE, ARC, CIRCLE. Funcţia entmake adaugă entităţi noi
direct în baza de date.
Funcţia entmake cere un argument: o listă asociată entităţii. Funcţia

returnează lista asociată entităţii în întregime dacă reuşeşte să creeze o
entitate, altfel returnează nil.
Lista asociată folosită ca argument trebuie să conţină toate informaţiile

necesare pentru a defini entitatea. Definiţii opţionale, cum ar fi layerul
implicit, sînt omise din lista asociată.
De exemplu, fiecare dintre aceste expresii crează o entitate Line în WCS pe

Layerul 0 de la 1,1,0 la 5,5,0.
Exemplul 1
(entmake
'(
(0 . "LINE")
(8 . "0")
(10 1.0 1.0 0.0)
(11 5.0 5.0 0.0)
(210 0.0 0.0 1.0)
)
)
Exemplul 2
(entmake
(list
(cons 0 "LINE")
(cons 8 "0")
(list 10 1.0 1.0 0.0)
(list 11 5.0 5.0 0.0)
(list 210 0.0 0.0 1.0)
)
)
50099176.doc R.2.1 9/21/2011 •237

AUTODESK, INC.
EXERCITIUL 39: CREAREA UNEI LINII CU ENTMAKE
Creaţi o funcţie numită c:xline într-un fişier text numit xline.lsp în directorul
student
Comanda XLINE ar trebui să facă următoarele:

• Să ceară utilizatorului un punct de start.
• Să ceară utilizatorului un punct de sfîrşit.
• Să creeze o entitate de tip Line în baza de date prin apelarea
funcţiei entmake.
• Să deseneze linia între cele două puncte pe layerul curent.
•238
Crearea entităţilor Polylines si Block Definitions

cu funcţia entmake
Entităţi complexe cum sînt poliliniile, definiţiile de Block şi entităţile Insert
atribute pot fi definite prin apelarea de cîteva ori a funcţiei entmake care să
le definească subentităţile.
De îndată ce AutoCAD vede că funcţia entmake crează o entitate complexă,

acesta crează un fişier temporar în care pastrează toate datele definiţiilor.
După definirea entităţii prin apelarea funcţiei entmake ), AutoCAD crează şi
adaugă o entitate de capăt (o entitate SEQEND pentru o polilinie sau o
entitate BLKEND pentru o definiţie Block), desfiinţează fişierul temporar şi,
în cazul definiţiei Block, returnează numele Blockului care a fost definit şi
nu lista asociată entitaţii definite.
Polylines
Expresiile care urmează crează o entitate de tip polilinie pe layerul curent şi
UCS cu o elevaţie 0 şi două vertexuri la 1,1,0 şi 5,5,0.
(entmake
(list
(cons 0 "POLYLINE")
(cons 66 1)
(list 10 0.0 0.0 0.0)
)
)
(entmake
(list
(cons 0 "VERTEX")
(list 10 1.0 1.0 0.0)
)
)
(entmake
(list
(cons 0 "VERTEX")
(list 10 5.0 5.0 0.0)
)
)
(entmake
(list
(cons 0 "SEQEND")
)
)
Blocks
Expresiile care urmează crează o definiţie Block numită myblock în tabelul
Block. Definiţia are un punct de bază de 5,5,0 şi este formată din
următoarele entităţi:
50099176.doc R.2.1 9/21/2011 •239

AUTODESK, INC.
• O entitate de tip Line pe layerul curent şi UCS de la 5,5,0 la 10,1,0.
• O entitate de tip Circle pe layerul curent şi UCS la 5,5,0 cu o rază

de 1.0.
(entmake
(list
(cons 0 "BLOCK")
(cons 2 "MYBLOCK")
(cons 70 0)
(list 10 0.0 0.0 0.0)
)
)
(entmake
(list
(cons 0 "LINE")
(list 10 5.0 5.0 0.0)
(list 11 10.0 1.0 0.0)
)
)
(entmake
(list
(cons 0 "CIRCLE")
(list 10 5.0 5.0 0.0)
(cons 40 1.0)
)
)
(entmake
(list
(cons 0 "ENDBLK")
)
)
•240
EXERCITIUL 40: CREAREA UNEI POLILINII CU FUNCTIA ENTMAKE
1. Creaţi o funcţie numită c:polymake într-un nou fişier text numit

polymake.lsp în directorul student.
Funcţia trebuie să facă următoarele:

• Să facă o nouă entitate de tip Polyline cu funcţia entmake.
• Să introducă o buclă.
• Să ceară utilizatorului un vertex.
• Să apeleze funcţia entmake atîta timp cît utilizatorul
selectează un punct.
• Să iasă din bucla cînd utilizatorul introduce o valoare nulă.
• Să termine de făcut polilinia prin apelarea funcţiei entmake
pentru inserarea entităţii SEQUEND.
2. Salvaţi fişierul text.
3. Încărcaţi programul în AutoCAD şi încercaţi comanda POLYMAKE.
50099176.doc R.2.1 9/21/2011 •241

AUTODESK, INC.
•242
Tratarea şirurilor
AutoLISP dispune de un set redus de funcţii care realizează operaţii de
bază pe şiruri: lungimea şirului, modificarea caracterelor, concatenarea şi
analiza.
Obiective
• Cum să determinaţi numărul de caractere dintr-un şir.
• Cum să modificaţi caracterele dintr-un şir.
• Cum să concatenaţi două sau mai multe şiruri.
• Cum să analizaţi un şir, fiecare caracter pe rînd.
Funcţia strlen
Şirurile de tip text sînt formate din 0 sau mai multe caractere aflate între
semnele citării duble (“). Un şir cu nici un caracter este reprezentat ca "",
sau cu null string.
Funcţia strlen cere un singur şir ca argument. Funcţia returnează lungimea

unui şir în caractere ca un întreg.
Un spaţiu valorează cît un caracter, caracterul escape este echivalent cu

"an".
Exemplu
Introduceţi expresiile care urmează. Aflaţi lungimea cîtorva şiruri de text.
.Command: (strlen "")
0
Command: (strlen "123456789")

9
Command: (strlen "1 3 5 7 9")

9
Command: (strlen "ănPoint:")

7
50099176.doc R.2.1 9/21/2011 •243

AUTODESK, INC.
Funcţia strcase
Funcţia strcase cere un argument şi un argument opţional. Primul argument
trebuie să fie un şir de tip text. Dacă al doilea argument este omis sau este
nil, şirul cu toate caracterele transformate în litere mari este returnat; sau
dacă al doilea argument este t, adică nu este nil, atunci se returnează şirul
cu caracterele transformate în litere mici.
Exemplu
Introduceţi expresiile care urmează. Transformaţi caracterele celor trei
şiruri de tip text.
Command: (strcase "to upper")
"TO UPPER"
Command: (strcase "To Upper")

"TO UPPER"
Command: (strcase "to upper" nil)

"TO UPPER"
Command: (strcase "TO LOWER" t)

"to lower"
Funcţia strcat
Funcţia strcat cere unul sau mai multe argumente şi fiecare dintre ele trebuie
să fie un şir de tip text. Funcţia returnează un singur şir text: rezultatul
concatenării argumentelor.
Funcţia strcat, printre altele, este folositoare pentru a formula cereri la

utilizator. De exemplu, este posibil să fie nevoie să cereţi utilizatorului ca a
n-a instrucţiune dintr-un grup de instrucţiuni să fie procesată. Pentru
aceasta trebuie să luaţi numărul n, sa-l transformaţi într-un şir, apoi să-l
concatenaţi cu restul.
Exemplu
Introduceţi expresiile care urmează. Concatenaţi cele două şiruri.
Command: (setq x "one" y "two")
"two"
Command: (setq z (strcat x y))

"one two"
Command: (setq z (strcat x x z y y))

"one one one two two two"
•244
Exemplu
Introduceţi expresiile care urmează. Formulaţi o cerere dintr-un şir şi un
număr întreg.
Command: (setq index 1)
1
Command: (setq a "Processing object " b "...")
"..."
Command: (strcat a (itoa 1) b)
"Processing object 1..."
Analiza şirurilor
Puţine texte în Lisp acordă subiectului despre analiza şirurilor importanţa
cuvenită. Deşi pare ciudat, probabil vă este mai comod să căutaţi un text
despre limbajul C cu explicaţii şi exemple de analiză a şirului. Manualele
The C Programming Language de Brian Kernighan şi Dennis Ritchiei,
Programming în C de Stephen G. Kochan şi Advanced Turbo C de Herbert
Schildt sînt manuale care acordă cel puţin un capitol şirurilor şi analizei
şirurilor.
Analiza şirurilor simple, adică citirea pe rînd a caracterelor dintr-un şir şi

compararea acestora cu valori, este discutată în următorul capitol destinat
funcţiei substr.
Funcţia substr
Funcţia substr cere trei argumente: un şir de tip text, un număr întreg de
indexare a caracterelor din şir de la stînga la dreapta, şi un pas de
incrementare a numărului de caractere spre dreapta şi inclusiv a caracterului
indexat.
Funcţia substr returnează un şir care începe cu caracterul indexat din şir şi
se continuă cu numărul de caractere din dreapta indexului indicat de al
treilea argument.
Argumentul index începe cu 1; adică primul caracter din şir are indexul 1.
De exemplu această expresie returnează şirul "4".
50099176.doc R.2.1 9/21/2011 •245

AUTODESK, INC.
(substr "123456" 4 1)
Această expresie returnează şirul "456".

(substr "123456" 4 3)
Formarea buclelor de program cu funcţia substr

Pentru a analiza caracterele unui şir pe rînd, ar trebui să apelaţi funcţia
substr aflată într-o buclă.
Un index al unui caracter dintr-un şir este iniţializat cu 1. Bucla începe şi se

repetă pentru fiecare caracter din şir. Fiecare caracter este returnat şi tipărit
separat şi indexul incrementat cu 1 în buclă.
(setq index 1)
(setq string "Hello, world.")
(repeat
(strlen string)
(print (substr string index 1))
(setq index (1+ index))
)
Recapitulare
• strlen returnează lungimea unui şir în caractere.
• Funcţia strcase poate returna un şir de tip text a cărui
caractere sînt transformate în litere mari sau mici.
• Funcţia strcat concatenează două sau mai multe şiruri.
• Analiza şirului în AutoLISP se face cu funcţia substr.
•246
EXERCITIUL 41: SIRURI SI ANALIZA LOR
• Veţi concatena şiruri pentru a crea cereri la utilizator.
• Veţi folosi lungimea şirului pentru a determina de cîte ori
trebuie repetată o buclă.
• Veţi analiza toate caracterele dintr-un şir, pe rînd, şi veţi
elimina toate spaţiile din şir.
Etape de lucru
În editorul de text creaţi un fişier nou numit nospace.lsp în directorul
student.În acest fişier creaţi o funcţie numită nospace. Această funcţie ar
trebui să facă urmatoarele operaţii în ordine.
1. Să ceară un argument: un şir.
2. Să seteze o variabilă de indexare la 1.
3. Să seteze o variabilă de ieşire la şirul nul "".
4. Să înceapă o buclă care să se repete conform numărului de caractere din

şir.
5. Să extragă un caracter din şir de la poziţia curentă.
6. În cazul în care caracterul este un spaţiu, acesta se ignoră; dacă nu,

adaugă caracterul la valoarea concatenată.
7. Să incrementeze indexul cu 1.
8. Să returneze variabila cu spaţiile eliminate.
50099176.doc R.2.1 9/21/2011 •247

AUTODESK, INC.
EXERCITIUL 41: ANALIZA SIRURILOR CU CARACTERE DE DELIMITARE
Puteţi rezolva acest exerciţiu dacă Lotus® 1-2-3® şi Microsoft® Excel sînt
instalate în computerul dvs.
Generalităţi
Programele de calcul tabelar cum sînt programele Lotus 1-2-3 şi Microsoft
Excel pot scrie date într-un fişier de tip text. Fiecare linie din calculul
tabelar reprezintă un singur rînd de text în fişierul de ieşire. Coloanele
dintr-un şir sînt separate unele de altele printr-un caracter delimitator.
Delimitatorul este selectabil de către utilizator şi de obicei lipsit de TAB
sau virgulă.
Programul prezentat mai jos implementează o funcţie numită parse. Funcţia

parse citeşte un singur rînd de text creat după formatul descris mai sus.
Funcţia returnează o lista de şiruri unde fiecare coloană dintr-un rînd este
tratată ca un şir individual.
Funcţia parse cere trei argumente: şirul de analizat, caracterul folosit ca

delimitator în interiorul şirului şi un indicator de condiţie care dacă nu este
nil va returna toate poziţiile unde apare delimitatorul care separă şirul în
lista returnată.
Împreună cu funcţia parse este definită şi funcţia c:test_parse. Funcţia

TEST_PARSE citeşte o listă de şiruri, le analizează pe fiecare şi scrie
rezultatul într-un fişier asociat numit testpars.txt în directorul curent. Fiecare
valoare returnată de parse este testată; dacă apare o eroare, se scrie un mesaj
în fişierul asociat.
Etape de lucru
1. Lansaţi programul de calcul tabelar.
2. În acest program deschideţi fişierul testpars.xls în directorul student.
3. Folosiţi comanda SAVE AS pentru a salva datele ca un format text într-

un fişier. În programul Excel caracterul TAB este delimitator.
4. Închideţi programul de calcul tabelar.
5. În editorul de text, examinaţi formatul Text din fişier.
6. Încărcaţi programul parse.lsp în AutoCAD.
7. Activaţi comanda PARSETEXT şi urmăriţi cererile.
8. PARSETEXT va analiza fiecare şir din fişierul text şi va afişa pe display

lista de şiruri returnată pentru fiecare rînd de către funcţia parse.
•248
; PARSE.LSP
; Version 1.0 3/29/93
;
; (parse str str expr)
;
; Parse a delimited text string and return a list of strings. Adds a
; null string between two sequential delimiters.
;
; Arguments:
;
; str (required) Text string to parse.
; str (required) Character used to delimit the string.
; expr (required) If t, return delimiter as a separate string.
;
; Local variables:
;
; char STR Current character from string.
; index INT Current location of character from string.
; rl LIST Return list of strings.
; sstr STR Current string to add to return list.
; strl INT Length of string.
(defun parse (str delim rd / char index rl sstr strl)
(setq ;initialize...
sstr "" ;string to place în list
rl nil ;list to return
index 1 ;character index în string
strl (strlen str) ;length of string
)
50099176.doc R.2.1 9/21/2011 •249

AUTODESK, INC.
(if ;if string length is zero

(zerop strl) ;return list with null string
'("")
(progn
(repeat ;repeat for the length of string
strl
(setq char (substr str index 1)) ;get a character
(cond
(
(= char delim) ;if it's a delimiter
(if ;and the string is null, it's
(= str "") ;line start or last was delim so
(setq rl (cons "" rl)) ;add null string to return list
(progn ;else
(setq rl (cons sstr rl)) ;add string to return list
(setq sstr "") ;then reinitialize string
)
)
(if ;if flag is true...
rd
(setq rl (cons char rl)) ;add delimiter to return list
)
(if ;if it's the last char în string
(= index strl)
(setq rl (cons "" rl)) ;add null string to return list
)
)
(
t ;if we're here, just append the
(setq sstr (strcat sstr char)) ;current string to the char
(if
(= index strl) ;if it's the last char în string
(progn
(setq rl (cons sstr rl)) ;add string to return list
)
)
)
);end cond
(setq index (1+ index)) ;increment the char index
);end repeat
(reverse rl) ;reverse the list to return so the

;strings are în original order
);end progn
);end if
)
•250
; TEST_PARSE.LSP
; Version 1.0 3/30/93
;
; test_parse
;
; Test the function (parse). Use two lists of strings with different
; delimiter characters: "ăt" and ",". Test for both nil and t delimiter
; flag. Write test results to the log file TESTPARS.TXT în the current
; directory. Write an error message with index every time (parse) fails
; to match a value în a result list.
;
;
; Local variables:
;
; fp FILE Pointer to log file
; string STR Current string argument to parse
; t1 LIST List of strings to test
; t2 LIST List of strings to test
; t1_r1 LIST List of t1 results for nil delim flag
; t1_r2 LIST List of t1 results for t delim flag
; t2_r1 LIST List of t2 results for nil delim flag
; t2_r2 LIST List of t2 results for t delim flag
(defun c:test_parse (/ fp string t1 t1_r1 t1_r2 t2 t2_r1 t2_r2)

(setq
t1
'("" "ăt" "a" "ab" "aăt" "ăta" "aătb" "aătbăt" "ătaăt" "ătăt")
t1_r1
'(("") ("" "") ("a") ("ab") ("a" "") ("" "a") ("a" "b") ("a" "b" "")
("" "a" "") ("" "" "")
)
t1_r2
'(("") ("" "ăt" "") ("a") ("ab") ("a" "ăt" "") ("" "ăt" "a")
("a" "ăt" "b") ("a" "ăt" "b" "ăt" "") ("" "ăt" "a" "ăt" "")
("" "ăt" "" "ăt" "")
)
t2
'("" "," "a" "ab" "a," ",a" "a,b" "a,b," ",a," ",,")
t2_r1
'(("") ("" "") ("a") ("ab") ("a" "") ("" "a") ("a" "b") ("a" "b" "")
("" "a" "") ("" "" "")
)
t2_r2
'(("") ("" "," "") ("a") ("ab") ("a" "," "") ("" "," "a")
("a" "," "b") ("a" "," "b" "," "") ("" "," "a" "," "")
("" "," "" "," "")
)
)
(setq fp (open "testpars.txt" "w"))
50099176.doc R.2.1 9/21/2011 •251

AUTODESK, INC.
(setq index 0)
(repeat
(length t1)
(setq string (nth index t1))
(print string fp)
(print (parse string "ăt" nil) fp)
(print (parse string "ăt" t) fp)
(if
(not
(equal
(setq x (parse string "ăt" nil))
(setq y (nth index t1_r1))
)
)
(print
(strcat
"Test t1_r1 failed în index " (itoa index) "."
)
fp
)
);end if
(if
(not
(equal
(parse string "ăt" t)
(nth index t1_r2)
)
)
(print
(strcat
)
fp
)
);end if
);end repeat
•252
(setq index 0)
(repeat
(length t2)
(setq string (nth index t2))
(print string fp)
(print (parse string "," nil) fp)
(print (parse string "," t) fp)
(if
(not
(equal
(parse string "," nil)
(nth index t2_r1)
)
)
(print
(strcat
)
fp
)
);end if
(if
(not
(equal
(parse string "," t)
(nth index t2_r2)
)
)
(print
(strcat
)
fp
)
);end if
);end repeat
(setq fp (close fp))
(prin1)
)
50099176.doc R.2.1 9/21/2011 •253

AUTODESK, INC.
•254
Pointere de entităţi
Un pointer de entitate este un identificator unic şi permanent pentru o
entitate dintr-un desen AutoCAD. Aplicaţiile pot folosi pointere de entităţi
pentru a menţine legături asociative între entitaţi sau între entităţi şi seturi
arbitrare de date în timpul sesiunii de editare grafică.
Obiective
• Cum să activaţi sau să distrugeţi pointerele de entităţi.
• Cum să extrageţi un pointer dintr-o listă asociată entităţii.
• Cum să găsiţi o entitate cu ajutorul pointerului.
Formatul unui pointer de entitate

Pointerele de entitaţi sînt păstrate ca numere hexadecimale exprimate sub
forma unui şir. De exemplu, primul pointer atribuit entităţii într-un desen
poate fi "1" iar pointerul treizeci şi unu poate fi "1F".
Pointerul unei entităţi nu poate fi schimbat: poate fi numai distrus. Cînd se

şterge o entitate dintr-un desen, pointerul ei este retras şi niciodată refolosit
în acel desen.
Lungimea maximă a unui şir este de 16 caractere, ceea ce înseamnă că

numărul maxim de pointere pentru un singur desen este 264-1.
Pointerele sînt păstrate în codul de grup DXF cimpul 5 al unei liste asociată
entităţii.
Atribuirea de pointere entităţilor

Spunem că al 31-lea pointer atribuit entităţii ar putea fi "1F" deoarece
atribuirea pointerelor nu este întotdeauna secvenţială, deşi întotdeauna
progresează de la mai mic la mai mare. Este imposibil de prevăzut în toate
cazurile care va fi următoarea atribuire pe care o va face AutoCAD-ul; de
aceea este necesar de stabilit în mod explicit pointerul unei entităţi din lista
asociată entităţii, decît să încercăm să ghicim ce pointer va atribui
AutoCAD-ul entităţii.
Activarea si dezactivarea pointerelor

Acţiunea de atribuire a pointerelor este dezactivată în momentul în care
pointerele lipsesc. Comanda HANDLE ON va activa pointerele permanent în
desenul curent.
Pointerele pot fi dezactivate. Deoarece prin aceasta se poate dezactiva orice

legatură între entităţile AutoCAD şi de bazele de date externe (de
exemplu pointerele sînt folosite extensiv de către AutoCAD SQL
Extension), pointerele pot fi distruse printr-un act deliberat din partea
utilizatorului.
50099176.doc R.2.1 9/21/2011 •255

AUTODESK, INC.
Comanda HANDLES DESTROY <CONFIRMATION-STRING> va dezactiva toate

activităţile de atribuire a pointerelor în sesiunea curentă. <CONFIRMATION-
STRING> este unul din cele şase şiruri posibile pe care le poate introduce
utilizatorul. AutoCAD generează unul dintre şiruri la întîmplare în timpul
execuţiei comenzii; de aceea este imposibil de prezis de care şir este nevoie
ca să confirme comanda.
Verificarea atribuirii pointerelor

Variabila de sistem HANDLES este setată la 1 cînd pointerele sînt activate în
sesiunea curentă.
Găsirea unei entităţi cu ajutorul pointerului

Funcţia handent cere un argument de tip şir: pointerul unei entităţi. Dacă
unei entităţi din sesiunea curentă i se atribuie un pointer, funcţia handent va
returna numele entităţii; dacă nu, va returna nil.
Exemplu
Într-o nouă sesiune, introduceţi comenzile şi expresiile care urmează.
Extrageţi un pointer de entitate şi stabiliţi numele entităţii folosind
pointerul.
Activaţi pointerele în sesiunea curentă.

Command: handles
Handles are disabled.
ON/DESTROY: on
Desenaţi cîteva entităţi Line.
Command: line
etc...
Extrageţi un pointer cu una din entităţile Line.
Command: (setq elist (entget (car (entsel))))

Select object: pick a line
Command: (setq ehand (cdr (assoc 5 elist)))
Command: !ehand
"1B" (sau un şir similar)
•256
Extrageţi numele entităţii folosindu-i pointerul.

Command: (setq ename (handent ehand))
Recapitulare
• Pointerele de entităţi sînt păstrate ca numere hexazecimale
exprimate sub formă de şiruri.
• Pointerul nu poate fi schimbat niciodată. El poate fi numai
distrus.
• Pointerele sînt păstrate în coduri DXF de grup 5 într-o listă
asociată entităţii.
• Atribuirea de valori nu este întotdeauna secvenţială.
• Comanda HANDLES activează sau dezactivează pointerele.
• Funcţia handent va returna numele entităţii prin pointerul
entităţii.
50099176.doc R.2.1 9/21/2011 •257

AUTODESK, INC.
EXERCITIUL 43: SALVAREA SETURILOR DE SELECTIE
• Veţi folosi un program pentru a citi pointerele entităţilor.
• Veţi păstra pointerele într-un fişier extern.
• Veţi citi fişierul extern şi veţi crea un set de selecţie din
pointerele entităţilor.
Programul savset.lsp din directorul student implementează două comenzi
pentru AutoCAD: SAVESET şi GETSET.
SAVESET păstrează pînă la şase seturi de selecţie diferite dintr-un desen şi

permite ca acestea să fie folosite în timpul sesiunii de editare grafică.
SAVESET salvează pointerele dintr-un set de selecţie într-un fişier extern a
cărui nume este <dwgname>.st<n>, unde <dwgname> este numele
desenului respectiv şi <n> este un număr cuprins între 1 şi 6.
GETSET citeşte pointerele entităţilor dintr-un fişier creat de SAVESET şi

construieşte setul de selecţie anterior din entităţile asociate cu pointerele.
Etape de lucru
Păstraţi seturile de selecţie în timpul sesiunii de editare prin scrierea şi
cititrea pointerelor în/şi din fişierul extern.
• Deschideţi desenul ssget.lsp din directorul student.
• Încărcaţi programul savset.lsp în AutoCAD.
• Folosiţi comanda SAVESET şi salvaţi două sau mai multe
seturi de selecţie.
• Deschideţi o nouă sesiune de editare grafică cu ssget.
• Încărcaţi programul saveset.lsp.
• Folosiţi comanda GETSET pentru a extrage unul dintre
seturile de selecţie păstrate.
• Folosiţi comanda MOVE cu setul de selecţie anterior.
• Deschideţi fişierul savset.lsp în editorul de text şi examinaţi
codul.
•258
EXECITIUL 44: UN MANAGER SIMPLU PENTRU FISIERELE TIP DWG
Acesta este un exerciţiu opţional
Fişierul drawman.lsp din directorul student implementează un sistem de

management pentru fişiere tip dwg, foarte simplu pentru a ilustra modul
cum pot fi folosite pointerele.
Puteţi folosi comenzile din acest fişier urmînd aceste etape:
1. Încărcaţi fişierul drawman.lsp în AutoCAD.
2. Folosiţi comanda LOGIN.
3. Desenaţi cîteva entităţi.
4. Folosiţi comanda LOGOUT.
5. Folosiţi oricare dintre aceste comenzi pentru a afla informaţii despre

entităţile pe care le-aţi desenat prin legături între pointere şi atribute
într-un bloc inserat aplicaţiei.
FINGER
RLIST
SELUSER
SELECO
Aduceţi fişierul în editorul de text şi studiaţi-l. Codul este scurt, uşor de

înţeles şi bine comentat.
50099176.doc R.2.1 9/21/2011 •259

LISP Romana PDF

Î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

LISP Romana PDF

Încărcat de

Drepturi de autor:

Formate disponibile

AutoLISP

Acest curs reprezintă o culegere de texte şi un ghid pentru un curs

Acest curs este bazat pe o versiune AutoLISP ce poate fi găsită pe toate

50099176.doc R.2.1 9/21/2011 ATC. Iasi •1

Crearea entităţilor cu funcţia entmake.......................................................225

50099176.doc R.2.1 9/21/2011 •3

Generalităţi despre AutoLISP

Lisp este unul dintre limbajele de programare cele mai vechi. Ca şi

Limbajul Lisp are multe caracteristici care se adresează atît profesioniştilor

Common LISP: A Gentle Introduction to Symbolic Computing de David S.

Ce poate face AutoLISP-ul ?

AutoLISP poate crea subrutine şi macrouri puternice. Subrutinele

Subrutinele AutoLISP pot crea noi funcţii AutoLISP şi noi comenzi

Cum încărcăm AutoLISP-ul ?

AutoLISP operează în cadrul editorului grafic AutoCAD. Interpretorul stă

AutoLISP-ul este disponibil numai în cadrul editorului grafic.

Ce trebuie să ştim pentru a folosi AutoLISP-ul ?

Ce editor de text ar trebui folosit ?

Fişierele de text ASCII pot fi întîlnite sub denumirea de fişiere

Versiunea MS-DOS® 5.0 a apărut cu un editor de text simplu numit EDIT.

Aplicaţia NOTEPAD din Microsoft® WindowsTM este un editor de text

Există o varietate de editoare de text gratuite şi care circulă liber pentru

50099176.doc R.2.1 9/21/2011 •5

ACAD). Orice editor profesional de programare este o unealtă bună cu care

Hardware pentru AutoLISP şi necesarul de memorie

Vă sugerăm să lansaţi sesiunea de editare grafică ori de cîte ori utilizaţi

Expresiile simbolice sînt instrucţiuni de bază ale limbajului AutoLISP.

În principal LISP-ul procesează listele: el procesează şi evaluează listele

Listele sînt principalul mijloc de construire a expresiilor simbolice în

O expresie simbolică sau o s-expresie are întotdeauna o anumită valoare.

O expresie simbolică sau o s-expresie reprezintă pur şi simplu o

S-expresiile în AutoLISP sînt construite prin încadrarea unei secvenţe

Parantezele dintr-o s-expresie trebuie să fie echilibrate. Oricărei paranteze

Obs. Cea mai frecventă greşeală în AutoLISP este neînchiderea

50099176.doc R.2.1 9/21/2011 •7

Cum recunoaşte AutoCAD-ul o s-expresie

Figura 1. Diagrama de comunicatie dintre AutoCAD si AutoLISP

S-expresiile şi comenzile AutoCAD

AutoCAD-ul tipăreşte rezultatul intrării s-expresiilor pe linia de comandă.

Figura 2. Cum AutoCAD-ul si AutoLISP-ul comunica intr-o comanda AutoCAD

50099176.doc R.2.1 9/21/2011 •9

Figura 3. Expresia (/360 15) genereaza un array de 24 linii

Caracterul semnul exclamării

Orice s-expresie validă poate urma după semnul exclamării.

Caracterul "bang" este deseori folosit pentru a cere AutoLISP-ului valoarea

• S-expresiile sînt expresii AutoLISP valide aflate între

50099176.doc R.2.1 9/21/2011 •11

Această pagină a fost lăsată liberă în mod intenţionat.

În acest capitol se va studia:

50099176.doc R.2.1 9/21/2011 •13

Tipuri de atomi Exemple Tip de data

simbol pi,x,mid_pt SYM

sir "Hello, world." STR

intreg 1,32767,-32768 INT

numar real 1.0,45.678,-876543.21 REAL

descriptor de fisier <File: #a82> FILE

nume entitate AutoCAD <Entity name: 6000001a> ENAME

set de selectie AutoCAD <Selection set: 1> PICKSET

subr (functie interna) <Subr: #1e32> SUBR

subr externa (Functia ADS) <Ext. Subr: 1 #3a970498> EXSUBR

Tabelul 2. Exemple de atomi din AutoLISP si tipul de date al acestora

Elementele unei liste

(1.0 1.0 0.0)