Lectii LISP romana

AutoLISP

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

document.doc R.2.1 4/12/2023 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

2

AUTODESK, INC. TRAINING LECTII DE BAZA AUTOLISP

Accesul la entităţi simple şi la blocuri...............................................................221

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

document.doc R.2.1 4/12/2023 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


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.


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)

3Command:

AutoCAD AutoLISP(+ 1 2)

3

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)3Command:

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

AutoCAD AutoLISP(/ 360 15)

24

Command:array

polarlast

5,5(/ 360 15)

Command:array

polarlast

5,520

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


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: lineFrom point: 5,5To point: 5,8To point: Enter

Command: arraySelect objects: last1 foundSelect objects: EnterRectangular or Polar array (R/P): pCenter point of array: 5,5Number 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

pi este 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.

document.doc R.2.1 4/12/2023 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.

document.doc R.2.1 4/12/2023 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.

document.doc R.2.1 4/12/2023 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"

document.doc R.2.1 4/12/2023 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 I1. Determinaţi dacă obiectul este atom sau listă.

2. Completaţi rezultatul evaluării în căsuţa corespunzatoare.

Tabelul 3. Determinarea naturii obiectului

18

Obiecte Atomi Liste

73.5

"0,0"

(1.0 2.0 3.0)

"String"

("String")

()


Partea a II-a1. 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:

ExempluCommand: !4.5

Tabelul 4. Determinarea valorii atomului

Partea a III-a1. 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

document.doc R.2.1 4/12/2023 19

Atomi Valori

4.5

"text"

17

setq

xyz

nil

AUTODESK, INC.

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

20


EvaluareaEvaluarea 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: !pi3.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.

Center point of array: 5,5Number of items: (/ 360 15)Angle to fill (+=ccw, -=cw) <360>:Enter

document.doc R.2.1 4/12/2023 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 evaluare

Valoare

Intreg 1 Valoarea este nr. insusi

1

Real 4.5 Valoarea este nr. insusi

4.5

Sir "text" Valoarea este nr. insusi

"text"

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.

document.doc R.2.1 4/12/2023 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.

document.doc R.2.1 4/12/2023 25

AUTODESK, INC.

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.

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.

document.doc R.2.1 4/12/2023 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 I1. 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:

( + 1 2 )

Expresii aritmetice S-expresii

3 + 10 + 5

20 * 15

16 - 10

15 / 3

5 + (10 * 2)

(5 + 10) * 2

Tabelul 9. Traducerea expresiilor aritmetice

document.doc R.2.1 4/12/2023 29

AUTODESK, INC.

Partea a II-a1. 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))

Tabelul 10. Traducerea expresiilor AutoLISP

30

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)


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.5Command: !x4.5

document.doc R.2.1 4/12/2023 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.

Command: (setq x 4.5)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 I1. 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

document.doc R.2.1 4/12/2023 33

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

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)1Command: !x1

Command:(setq x (+ 1 2 3))6 Command: !x6

Command: (setq x (quote (4 (+ 5 6)))(4 (+ 5 6))Command:!x(4 (+ 5 6))

Valoare pentru x

1

4.5

"text"

(1.0 2.0 3.0)

(+ 1 2 3)

(1 (+ 2 3))

Tabelul 12. Legarea lui x unor valori diferite

34



document.doc R.2.1 4/12/2023 35

AUTODESK, INC.

S-expresii AutoLISP în cadrul comenzilor AutoCADS-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))10Command: !x10

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.1429Command: (fix 17.1429)17Command: (fix (/ 6.0 0.35))17


Command: arraySelect objects: ISelect objects: EnterRectangular or Polar array (R/P): rNumber of rows (-) <1>: 1Number 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.

document.doc R.2.1 4/12/2023 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: filletPolyline/Radius/<Select two lines>: rEnter fillet radius <1.0>: (/ 28.0 12.5)

Command: filletPolyline/Radius/<Select two lines>: pick first lineSelect 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ţiuni1. Î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: arcCenter/<Start point>: 5,5Center/End/<Second point>: cCenter: 3,5Angle/Length of chord/<End point>: aIncluded angle: (/ 180 pi)Command: (setq x (* pi (/ 2.0 3.0)))2.0944

Command: circle3P/2P/TTR/<Center point>: 5,5Diameter/<Radius>: !x

Command: circle3P/2P/TTR/<Center point>: 5,5Diameter/<Radius>: (/ x 2)

document.doc R.2.1 4/12/2023 39

AUTODESK, INC.

Command: (setq x (/ 360 15))24

Command: arraySelect objects: pick the arc1 foundSelect objects: EnterRectangular or Polar array (R/P): pCenter point of array: 5,5Number of items: !xAngle to fill (+=ccw, -=cw) <360>:Enter Rotate objects as they are copied? <Y>Enter

Figura 11. Array completat

40



document.doc R.2.1 4/12/2023 41

AUTODESK, INC.

Tipuri de date numericeAutoLISP-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.


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.


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


Verificaţi-i valoarea şi tipul de date

Command: !x4.5Command: (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.

document.doc R.2.1 4/12/2023 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: !x65535Command: (float x)65535.0Command: (fix (float x))65535Command: (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))REALCommand: (type (fix (float x)))INTCommand: (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)3Command: (type (+ 1 2))INT

Această expresie returnează un număr real.

Command: (+ 1.0 2)3.0Command: (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.

document.doc R.2.1 4/12/2023 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 I1.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-a1.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.

document.doc R.2.1 4/12/2023 47

AUTODESK, INC.

Puncte AutoCAD şi liste AutoLISPAutoCAD-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.

document.doc R.2.1 4/12/2023 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: lineFrom point: !pt1To point: !pt2To point: Enter

pt1 (1.0 1.0 0.0)

pt2 (5.0 5.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.

list evaluează fiecare argument, unul după altul şi le memorează valoarea 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: idPoint: !ptX=1.0000 Y=2.0000 Z=3.0000Command:

Figura 16. Valoare returnata de functia list

document.doc R.2.1 4/12/2023 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

Command: (setq x 1.0)1.0Command !x:1.0Command: (setq y 2.0)2.0Command: !y2.0Command: (setq z 3.0)3.0Command: !z3.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: idPoint: !ptX=1.0000 Y=2.0000 Z=3.0000Command:

document.doc R.2.1 4/12/2023 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 I1. 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.

Tabelul 15. Crearea punctelor din liste de numere

document.doc R.2.1 4/12/2023 55

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

AUTODESK, INC.

Partea a II-a1. Î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: lineFrom point: !pt1To point: !pt2To point: Enter

Command: circle3P/2P/TTR/<center point>: 2pFirst point on diameter: !pt1Second point on diameter: !pt2

5,6,0

1,2,0

Figura 19. Linie si cerc folosind variabilele pt1 si pt2

56



document.doc R.2.1 4/12/2023 57

AUTODESK, INC.

Separarea listelorAvî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)

document.doc R.2.1 4/12/2023 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).

document.doc R.2.1 4/12/2023 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ţiuni1. 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

document.doc R.2.1 4/12/2023 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ţiuni1. 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ă.

(1.0 (2.0 3.0) 4.0)

1.0 ((2.0 3.0) 4.0)

(2.0 3.0) ?

? ?

(car xlst) (cdr xlst)

(car (cdr xlst))

(car (car (cdr xlst)))

(cdr (cdr xlst))

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.

Command: (setq pt (list 1.0 2.0 0.0))(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.0Command: !x1.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.

document.doc R.2.1 4/12/2023 65

AUTODESK, INC.

Exemplu


Legaţi variabila pt de o listă cu trei numere reale.

Command: (setq pt (list 1.0 2.0 0.0))(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

document.doc R.2.1 4/12/2023 67

AUTODESK, INC.

Figura care urmează reprezintă coordonatele punctelor în funcţie de variabilele X şi Y.

X1,Y1

X1,Y2

X2,Y1

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 pt1) (car (cdr pt2)))

(list (car pt2) (car (cdr pt1)))

pt2

0,0

Figura 30. Calcularea colturilor unui dreptunghi

document.doc R.2.1 4/12/2023 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)


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: lineFrom point: !pt1To point: !pt2To point: !pt3To point: !pt4To point: close

1,5

1,1

10,5

10,1

0,0

pt1

pt2 pt3

pt4

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

document.doc R.2.1 4/12/2023 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, pt1ypt2 = pt2x, pt2ymidpt = mptx, mpty

Valorile X şi Y ale lui mpt pot fi exprimate aritmetic după cum urmează.

mptx = (pt1x + pt2x)/2mpty = (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 AutoLISPComenzile 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

document.doc R.2.1 4/12/2023 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.



Apelaţi la comanda LINE şi folosiţi variabilele ca argumente.

Command: (command "line" pt1 pt2 "")nil

1,1

5,5

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: circle3P/2P/TTR/<center point>: !pt1Diameter/<Radius>: 0.5Command: (command "circle" pt2 0.5)Command: (command "circle" "2p" pt1 pt2)

Figura 33. Cercuri definite de pt1 si pt2

document.doc R.2.1 4/12/2023 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: arcCenter/<Start point>: !pt1Center/End/<Second point>: eEnd point: !pt2Angle/Direction/Radius/<Center point>: rRadius: 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.

document.doc R.2.1 4/12/2023 77

AUTODESK, INC.

EXERCITIUL 10: TRANSFORMAREA COMENZILOR IN AUTOLISP


Transforma comenzile AutoCAD script în expresii AutoLISP.

Scrie expresiile.

Testa expresiile în editorul AutoCAD.


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

Command: lineFrom point: 1,1To point: 5,5To point: ENTER

Command: circle3P/2P/TTR/<Center point>: 3,3Diameter/<Radius>: 0.5

Command: circle3P/2P/TTR/<Center point>: 2pFirst point on diameter: 1,1Second point on diameter: 5,5

Command: arcCenter/<Start point>: 2,1Center/End/<Second point>: cCenter: 1,1Angle/Length of chord/<End point>: lLength of chord: 1.414

Expresii AutoLISP

(command "line" "1,1" "5,5" "")

or

(command "line" '(1.0 1.0) '(5.0 5.0) "")

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


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.

document.doc R.2.1 4/12/2023 79

AUTODESK, INC.


80


Selecţia interactivă a punctelorAutoLISP-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.

document.doc R.2.1 4/12/2023 81

AUTODESK, INC.

Command: (setq pt1 (getpoint))1,1(1.0 1.0 0.0)

Command: (setq pt2 (getpoint))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.

Command: (setq pt1 (getpoint))<pick a point with the mouse><list of three reals returned>

Command: (setq pt2 (getpoint))<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

Command: (setq pt2 (getpoint))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

Command: (setq pt2 (getpoint))@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.

Command: (setq pt1 (getpoint))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,21.41421Command: !dst11. 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,21.41421Command: !dst11.41421

document.doc R.2.1 4/12/2023 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.

Command: (setq pt1 (getpoint))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,21.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,21.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ţă.

document.doc R.2.1 4/12/2023 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


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


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.

document.doc R.2.1 4/12/2023 87

AUTODESK, INC.


88


FuncţiiPe 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.

setq este 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.

document.doc R.2.1 4/12/2023 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

Introduceţi expresiile care urmează. Definiţi funcţia myfun apoi apelaţi-o. 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

Introduceţi expresiile care urmează. Definiţi funcţia myfun apoi apelaţi-o. myfun va returna distanţa dintre două puncte alese de utilizator.

Command: (defun myfun () (getdist “From point: “))MYFUN

Command: (myfun)From point: pick a pointSecond point: pick a point

document.doc R.2.1 4/12/2023 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))MYFUNCommand: (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))MYFUN10Command: (myfun 1)20Command: (myfun 2)Command:

Figura 38. Valoarea argumentului se afla in corpul de expresii al functiei.

document.doc R.2.1 4/12/2023 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-ONECommand: (add-one 1)2Command: (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)))DTRCommand: (dtr 180)3.14159Command: (dtr 360)6.28319Command: (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-TWOCommand: (add-two 1 2)3Command: (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.

document.doc R.2.1 4/12/2023 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ţiuni1. 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ţiuni1. 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.



document.doc R.2.1 4/12/2023 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: zoomAll/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.

document.doc R.2.1 4/12/2023 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))ZPLUSCommand: (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.000000000Command: nilCommand:

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 pointMagnification or Height <2.250000>: 1125000000000Command: 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.5000000000Command:nilCommand:

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

document.doc R.2.1 4/12/2023 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-a1. 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 AutoLISPPuteţ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.

document.doc R.2.1 4/12/2023 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.

document.doc R.2.1 4/12/2023 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 (list (car pt3) (car (cdr pt1))) "c" ))

Command: (load "rectang")C:RECTANGLE

Command: rectangleFirst 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ă.

document.doc R.2.1 4/12/2023 107

AUTODESK, INC.

( defun c:rectangle () (setq pt1 (getpoint "ănFirst corner: ")) (setq pt3 (getpoint "ănOther corner: ")) (command "_.pline" pt1 (list (car pt1) (car (cdr pt3))) pt3 (list (car pt3) (car (cdr pt1))) "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) (setq pt1 (getpoint "ănFirst corner: ")) (setq pt3 (getpoint "ănOther corner: ")) (command "pline" pt1 (list (car pt1) (car (cdr pt3))) pt3 (list (car pt3) (car (cdr pt1))) "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)1Command: !x1

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_ARGCommand: (local_arg 2)24Command: !x1

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_VARCommand: (local_var)

document.doc R.2.1 4/12/2023 109

AUTODESK, INC.

3Command: !x1

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_VARCommand: (global_var)4Command: !x4

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) (setq old_cmdecho (getvar "CMDECHO")) (setvar "CMDECHO" 0) (setq pt1 (getpoint "ănFirst corner: ")) (setq pt2 (getpoint "ănOther corner: ")) (command "pline" pt1 (list (car pt1) (car (cdr pt3))) pt3 (list (car pt3) (car (cdr pt1))) "c" ) (setvar "CMDECHO" old_cmdecho) (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: undefineCommand 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.

document.doc R.2.1 4/12/2023 111

AUTODESK, INC.

Command: line.- line From point: pick a pointTo 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.

document.doc R.2.1 4/12/2023 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 lucru1. 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 lucru1. 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 egalitateProgramele 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

document.doc R.2.1 4/12/2023 115

AUTODESK, INC.

de funcţii care testează valorile pe baza anumitor criterii sau unele valori pe 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ţiuni1. Î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

document.doc R.2.1 4/12/2023 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 y 1.5)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

document.doc R.2.1 4/12/2023 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


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.



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

document.doc R.2.1 4/12/2023 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 notFuncţ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


ExempluCommand: (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 .

document.doc R.2.1 4/12/2023 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În acest capitol veţi studia:

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 ifFuncţ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ă.

document.doc R.2.1 4/12/2023 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: (if (= x 1) (setq y 1) (setq y 0))1

Command: !y1

Legaţi variabila x de o valoare a lui 0. Legaţi variabila y bazată pe valoarea x.


Command: (if (= x 1) (setq y 1) (setq y 0))0

Command: !y0

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 lucru1. Î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.

document.doc R.2.1 4/12/2023 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.

ExempluCommand: (setq x 1)1

Command: (if (= x 1) (progn (setq y 2) (setq z 3)) (setq y 0))3

Command: !y2

Command: !z3

128


EXERCITIUL 19: EXPRESII MULTIPLE IN CADRUL FUNCTIEI IF

În acest exerciţiu: 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 lucru1. Î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.

document.doc R.2.1 4/12/2023 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ă.

document.doc R.2.1 4/12/2023 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 lucru1. 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.

7. Încărcaţi fişierul în AutoCAD.

8. Folosiţi funcţia testx cu valorile argumentelor 0, 1 şi -1.

132



document.doc R.2.1 4/12/2023 133

AUTODESK, INC.

Bucle de programBuclele 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În acest capitol veţi studia:

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.

ExempluCommand: (repeat 3 (prompt "ănHello"))HelloHelloHellonil

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)0123456789

document.doc R.2.1 4/12/2023 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 lucru1. Î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

document.doc R.2.1 4/12/2023 137

Noname, 01/03/-1,

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

document.doc R.2.1 4/12/2023 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.

document.doc R.2.1 4/12/2023 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"

document.doc R.2.1 4/12/2023 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: textJustify/Style/<Start point>: 1,5Height: 0.5Rotation: 0Text: !txt1

Command: (setvar "texteval" 1)1

Command: textJustify/Style/<Start point>: EnterText: !txt2

Figura 41. entitati tip text

document.doc R.2.1 4/12/2023 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.

document.doc R.2.1 4/12/2023 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 lucru1. 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

a

b

c

d

Tabelul 25. Variabile si functii de tiparire

148


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

document.doc R.2.1 4/12/2023 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 entitati

Descriere

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.


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))<Entity name: 60000022>

Command: !ename<Entity name: 60000022>

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.

Command: (command "erase" ename "")nil

document.doc R.2.1 4/12/2023 151

AUTODESK, INC.

Command: UGROUP

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: circle3P/2P/TTR/<Center point>: 5,5Diameter/<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)<Entity name: 60000028>

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))<Entity name: 60000022>Command: !ename<Entity name: 60000022>

Exemplu


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

Command: (setq ename (entnext))<Entity name: 60000022>

Command: (command "erase" ename "")nil

Command: UERASE

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))<Entity name: 60000028>

Command: (command "move" ename "" "1,0" "")nil

document.doc R.2.1 4/12/2023 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: UMOVE

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))<Entity name: 60000028>

sau

Command: (setq ename1 (entnext))<Entity name: 60000022>Command: (setq ename2 (entnext ename1))<Entity name: 60000028>

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.

document.doc R.2.1 4/12/2023 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 lucru1. 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: scaleallScaling entity 1.Scaling entity 2.Scaling entity 3.

5. Încărcaţi fişierul scaleall.lsp.

6. Activaţi comanda SCALEALL.

document.doc R.2.1 4/12/2023 157

AUTODESK, INC.

Liste asociate entităţilorPuteţ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 punctO 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")

"LINE" ()

(0 . "LINE")

0 "LINE"

car cdr car cdr

car cdr

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

document.doc R.2.1 4/12/2023 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

document.doc R.2.1 4/12/2023 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ă.

Command: (setq ename (entnext))<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( (-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))

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)))( (-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( (-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))

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: (setq ename (entnext))<Entity name: xxxxxxxx>

Command: !ename<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( (-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))

Extrageţi tipul entităţii, Layerul şi punctul de start al sublistei din lista asociată.

Command: (assoc 0 elist)(0 . "LINE")

Command: (assoc 8 elist)(8 . "0")

Command: (assoc 10 elist)(10 1.0 1.0 0.0)

Apelaţi cdr pentru a extrage tipul entităţii, Layerul şi punctul de start din subliste.

Command: (cdr (assoc 0 elist))"LINE"

Command: (cdr (assoc 8 elist))"0"

Command: (cdr (assoc 10 elist))(1.0 1.0 0.0)

document.doc R.2.1 4/12/2023 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 lucru1. 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ă.

document.doc R.2.1 4/12/2023 165

AUTODESK, INC.

C:SCALEALL

(defun c:scaleall () (setq ename (entnext)) ;get first entity (setq counter 1) ;initialize counter (while ename ;we have an entity? (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 (setq ename (entnext ename)) ;get the next entity ) (prin1) ;quiet exit)

C:SCLINE

(defun c:scline () (setq ename (entnext)) ;get first entity (setq counter 1) ;initialize counter (while ename ;we have an entity? (if ;if it's a Line... (= "LINE" (cdr (assoc 0 (entget ename))) ) (progn (command "._SCALE" ename "" "0,0" "0.5");scale it and... (prompt ;tell user which one (strcat "ănScaling entity " (itoa counter) ".ăn" ) ) ) ) (setq counter (1+ counter)) ;increment the counter (setq ename (entnext ename)) ;get the next entity ) (prin1) ;quiet exit)

166



document.doc R.2.1 4/12/2023 167

AUTODESK, INC.

Modificarea unei entităţiModificarea 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.


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.

Command: (setq ename (entnext))<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: (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))( (-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: (assoc 10 elist)(10 7.5 2.5 0.0)

document.doc R.2.1 4/12/2023 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.

1,1,0

5,5,0

5,5,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.

document.doc R.2.1 4/12/2023 171

AUTODESK, INC.

C:SCLINE

(defun c:scline () (setq ename (entnext)) ;get first entity (setq counter 1) ;initialize counter (while ename ;we have an entity? (if ;if it's a Line... (= "LINE" (cdr (assoc 0 (entget ename))) ) (progn (command "._SCALE" ename "" "0,0" "0.5");scale it and... (prompt ;tell user which one (strcat "ănScaling entity " (itoa counter) ".ăn" ) ) ) ) (setq counter (1+ counter)) ;increment the counter (setq ename (entnext ename)) ;get the next entity ) (prin1) ;quiet exit)

C:MODLINE

(defun c:modline () (setq ename (entnext)) ;get first entity (setq counter 1) ;initialize counter (while ename ;we have an entity? (setq elist (entget ename)) ;get its assoc list (if ;if it's a Line... (= "LINE" (cdr (assoc 0 elist))) (progn (entmod ;change its end point (subst '(11 5.0 5.0 0.0) (assoc 11 elist) elist) ) (prompt ;tell user which one (strcat "ănModifying entity " (itoa counter) ".ăn" ) ) ) ) (setq counter (1+ counter)) ;increment the counter (setq ename (entnext ename)) ;get the next entity ) (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 lucru1. 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.

document.doc R.2.1 4/12/2023 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: circle3P/2P/TTR/<Center point>: 5,5Diameter/<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))<Entity name: xxxxxxxx>

Command: !ename<Entity name: xxxxxxxx>

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

document.doc R.2.1 4/12/2023 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 lucru1. Î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.

document.doc R.2.1 4/12/2023 177

AUTODESK, INC.

Tratarea erorilorAutoLISP 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ă.

document.doc R.2.1 4/12/2023 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 )

(setq old_cmdecho (getvar "CMDECHO")) (setvar "CMDECHO" 0) (setq pt1 (getpoint "ănFirst corner: ")) (setq pt3 (getpoint "ănOther corner: ")) (command "pline" pt1 (list (car pt1) (car (cdr pt3))) pt3 (list (car pt3) (car (cdr pt1))) "c" ) (setvar "CMDECHO" old_cmdecho) (setq *error* old_error) ;restore default error handler ;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.

180


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 definită de utilizator old_emdecho a fost facută global aşa încît valoarea ei este accesibilă noii funcţii *error*.

document.doc R.2.1 4/12/2023 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 lucru1. 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.


(setq old_cmdecho (getvar "CMDECHO")) (setvar "CMDECHO" 0)

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

(setq pt1 (getpoint "ănFirst corner: ")) (setq pt3 (getpoint "ănOther corner: ")) (command "._PLINE" pt1 (list (car pt1) (car (cdr pt3))) pt3 (list (car pt3) (car (cdr pt1))) "_C" ) (setvar "CMDECHO" old_cmdecho) (prin1))

document.doc R.2.1 4/12/2023 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


(defun *error* (msg) ;define new error handler

(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 (/= "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 )

(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 )

(setq pt1 (getpoint "ănFirst corner: ")) (setq pt3 (getpoint "ănOther corner: ")) (command "pline" pt1 (list (car pt1) (car (cdr pt3))) pt3 (list (car pt3) (car (cdr pt1))) "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 ) )

document.doc R.2.1 4/12/2023 185

AUTODESK, INC.

(setvar "CMDECHO" old_cmdecho) ;reset original command echo (setq *error* old_error) ;restore default error handler ;if command is successful (prin1) ;quiet exit)

186


Operaţii cu fişiereAutoLISP 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.

document.doc R.2.1 4/12/2023 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.

Command: (setq fp (close fp))nilCommand: !fpnil

Deschideţi fişierul test.txt în editorul text şi examinaţi-l. Ar trebui să conţină trei linii de text.

Codersof theLost Spark

document.doc R.2.1 4/12/2023 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”

Command: (read-line fp)"of the"

Command: (read-line fp)"Lost Spark"

Încercaţi să citiţi pînă la sfîrşitul fişierului. Funcţia read-line va returna nil.

Command: (read-line fp)nil

Închideţi fişierul.

Command: (setq fp (close fp))

nilCommand: !fpnil

document.doc R.2.1 4/12/2023 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ă.

În acest exerciţiu: 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.


document.doc R.2.1 4/12/2023 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


(defun *error* (msg) ;define new error handler (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 (/= "Function cancelled" msg) ;no message if user cancels (if (= msg "quit / exit abort") ;no message if program deliberately (princ) ;aborts (princ (strcat "ănError: " msg));otherwise, print error for user ) (princ) ) (setq *error* old_error) ;restore default error handler (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 (setq r_fp (close r_fp)) (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 r_fp (close r_fp)) (setq w_fp (close w_fp))

;restore original error handler

document.doc R.2.1 4/12/2023 195

AUTODESK, INC.

(setq *error* old_error)

(prin1) ;quiet exit

)

196



document.doc R.2.1 4/12/2023 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 (setq old_error *error*) ;save default error handler

(defun *error* (msg) ;define new error handler (if ;close source file if open io_fp (setq io_fp (close io_fp)) ) (setvar "CMDECHO" old_cmdecho) ;restore command echo (if (/= "Function cancelled" msg) ;no message if user cancels (if (= msg "quit / exit abort") ;no message if program deliberately (princ) ;aborts (princ (strcat "ănError: " msg));otherwise, print error for user ) (princ) ) (setq *error* old_error) ;restore default error handler (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) )

document.doc R.2.1 4/12/2023 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 (setq *error* old_error) ;restore default error handler (prin1) ;quiet exit)

document.doc R.2.1 4/12/2023 201

AUTODESK, INC.

Seturi de selecţieAutoCAD-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.

document.doc R.2.1 4/12/2023 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 objectsSelect objects: Enter<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: eraseSelect objects: !ss1Select objects: Enter

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.

document.doc R.2.1 4/12/2023 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.

Command: (setq ss1 (ssget))Select objects: pick three objectsSelect objects: Enter<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



document.doc R.2.1 4/12/2023 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.

Command: (setq ss1 (ssget))Select objects: pick three objectsSelect objects: Enter<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))<Entity name: xxxxxxxx>

Command: (entget ename)







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.

document.doc R.2.1 4/12/2023 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 lucru1. 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

1. Deschideţi fişierul grafic moddim.dwg din directorul student.

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.

document.doc R.2.1 4/12/2023 211

AUTODESK, INC.

Tabele şi nume de simboluriTabelele 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.

212


Exemplu

Această expresie returnează lista asociată pentru prima intrare în tabelul layer.

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)((0 . "LAYER") (2 . "0") (70 . 0) (62 . 7) (6 . "CONTINUOUS"))

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

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

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

Command: (tblnext "LAYER")nil

document.doc R.2.1 4/12/2023 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.

document.doc R.2.1 4/12/2023 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")((0 . "LAYER") (2 . "0") (70 . 0) (62 . 7) (6 . "CONTINUOUS"))

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.

document.doc R.2.1 4/12/2023 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

1. Deschideţi fişierul grafic 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: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.

document.doc R.2.1 4/12/2023 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: ") ) (if ;if user pressed return, exit (not ttype) (exit) ) (setq ttarget ;get target search name (getstring (strcat "ăn" ttype " table entry: ")) ) (if ;if user pressed return, exit (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 AutoLISPDacă 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_NEWCommand: my_newCommand: ._new File name:Command: !c:my_newnil

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.

document.doc R.2.1 4/12/2023 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:run foloseş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_REPORTCommand: 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) )

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

document.doc R.2.1 4/12/2023 223

AUTODESK, INC.

;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"). "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)) )

224


(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.)

document.doc R.2.1 4/12/2023 225

AUTODESK, INC.


226


Accesul la PoliliniiPoliliniile 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

VERTEX

SEQEND

Main entity

Next entity name:

VERTEX

Sub entity

Next entity name:

VERTEXor

SEQEND

Sub entity

Next entity name:

Next main entityin database

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.

document.doc R.2.1 4/12/2023 227

AUTODESK, INC.

(defun c:polylist () (setq old_error *error*) ;save default error handler

(defun *error* (msg) ;define new error handler (if (/= "Function cancelled" msg) ;no message if user cancels (if (= msg "quit / exit abort") ;no message if program deliberately (princ) ;aborts (princ (strcat "ănError: " msg));otherwise, print error for user ) (princ) ) (setq *error* old_error) ;restore default error handler (princ) ;quiet exit ) (setq epick (entsel "ănSelect polyline: ")) ;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 (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 " ") (princ (car (cdr (cdr pt)))) (if ;check each flag and print (= 1 (logand 1 vflags)) ;each if true (princ "ănVertex inserted by curve-fitting.") )

228


(if (= 2 (logand 2 vflags)) (princ "ănCurve-fit tangent defined for this vertex.") ) (if (= 8 (logand 8 vflags)) (princ "ănSpline vertex created by spline-fitting.") ) (if (= 16 (logand 16 vflags)) (princ "ănSpline frame control point.") ) (if (= 32 (logand 32 vflags)) (princ "ăn3D Polyline vertex.") ) (if (= 64 (logand 64 vflags)) (princ "ăn3D Polyline mesh vertex.") ) (if (= 128 (logand 128 vflags)) (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)

document.doc R.2.1 4/12/2023 229

AUTODESK, INC.


230


Accesul la Block DefinitionsBlock 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

Next sub entity

ENDBLK

Named object

Next entity name:

Any type

Any type

Next entity name:

Any type

Sub entity

Next entity name:

None

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.

document.doc R.2.1 4/12/2023 231

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 (setq old_error *error*) ;save default error handler

(defun *error* (msg) ;define new error handler (if (/= "Function cancelled" msg) ;no message if user cancels (if (= msg "quit / exit abort") ;no message if program deliberately (princ) ;aborts (princ (strcat "ănError: " msg));otherwise, print error for user ) (princ) ) (setq *error* old_error) ;restore default error handler (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 (setq etype (cdr (assoc 0 elist))) ;store entity type (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 (setq etype (cdr (assoc 0 elist))) ;store entity type (while ;while we have an entity name (and ;and it's not the end of the ename ;Block Definition... (/= "ENDBLK" etype) )

232


(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)

document.doc R.2.1 4/12/2023 233

AUTODESK, INC.


234


Crearea entităţilor Line cu funcţia entmakeFuncţ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) ))

document.doc R.2.1 4/12/2023 235

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.

236


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:

document.doc R.2.1 4/12/2023 237

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") ))

238


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.

document.doc R.2.1 4/12/2023 239

AUTODESK, INC.


240


Tratarea şirurilorAutoLISP 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

document.doc R.2.1 4/12/2023 241

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"

242


Exemplu

Introduceţi expresiile care urmează. Formulaţi o cerere dintr-un şir şi un număr întreg.

Command: (setq index 1)1Command: (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".

document.doc R.2.1 4/12/2023 243

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.

244


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.

document.doc R.2.1 4/12/2023 245

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.

246


; 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 )


document.doc R.2.1 4/12/2023 247

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)


248


; 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"))


document.doc R.2.1 4/12/2023 249

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 "Test t1_r2 failed în index " (itoa index) "." ) fp ) );end if (setq index (1+ index)) );end repeat


250


(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 "Test t2_r1 failed în index " (itoa index) "." ) fp ) );end if (if (not (equal (parse string "," t) (nth index t2_r2) ) ) (print (strcat "Test t2_r2 failed în index " (itoa index) "." ) fp ) );end if (setq index (1+ index)) );end repeat (setq fp (close fp)) (prin1))

document.doc R.2.1 4/12/2023 251

AUTODESK, INC.


252


Pointere de entităţiUn 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

document.doc R.2.1 4/12/2023 253

AUTODESK, INC.

Extension), pointerele pot fi distruse printr-un act deliberat din partea utilizatorului.

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: handlesHandles are disabled.ON/DESTROY: on

Desenaţi cîteva entităţi Line.

Command: lineetc...

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)

254


Extrageţi numele entităţii folosindu-i pointerul.

Command: (setq ename (handent ehand))<Entity name: xxxxxxxx>

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.

document.doc R.2.1 4/12/2023 255

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.

256


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.

document.doc R.2.1 4/12/2023 257

Documents

Lectii LISP romana