INTRODUCERE IN AUTOLISP

INTRODUCERE ÎN AUTOLISP

În acest capitol vom introduce într-un mod accesibil elemente de bază legate de limbajul de programare AutoLISP, care vor da posibilitatea utilizatorilor să realizeze programe în acest limbaj în vederea automatizării muncii de proiectare.

Detalii asupra acestor elemente se dau pe larg în documentația care însoțește produsul AutoCAD și alte lucrări de specialitate în domeniu.

15.1. De ce trebuie învățat AutoLISP?

AutoLISP este bazat pe limbajul de programare de uz general XLISP care face parte din familia limbajelor LISP (LISt Processing). Limbajul LISP este mai puțin cunoscut în comparație cu limbajele BASIC, FORTRAN, PASCAL, COBOL și chiar C, dar a fost ales de autorii AutoCAD-ului ca limbaj de interfață în proiectarea asistată, datorită unor avantaje:

Este ideal pentru manevrarea informațiilor specifice AutoCAD-ului

Excelează în tratarea unitară a unor entități eterogene

Este ușor de învățat și stăpânit

Datorită sintaxei simple, un interpretor LISP este foarte ușor de implementat și cere memorie puțină

Este limbajul ales pentru cercetarea și dezvoltarea inteligenței artificiale precum și a sistemului expert.

AutoLISP este un limbaj funcțional (operează numai cu funcții care pot fi proprii sau create de utilizator), el efectuând prelucrări de liste.

Datorită faptului că AutoLISP este un limbaj de programare, trebuie învățată sintaxa sa specifică pentru a comunica cât mai bine cu AutoCAD-ul și cu baza de date a desenului.

15.2. Elemente de bază în utilizarea AutoLISP-ului

15.2.1. Tipuri de date în AutoLISP

În AutoLISP formatul datelor este legat de tipurile de date. AutoLISP acceptă folosirea următoarelor tipuri de date:

Numere întregi - sunt numere care nu au virgulă (punct zecimal). De exemplu, 9 este un întreg, dar 9.018 și 9.0 nu sunt numere întregi. Deși AutoLISP folosește intervalul de 32 biți pentru calculul valorilor, aceste valori transferate între AutoLISP și AutoCAD sunt limitate la 16 biți, deci nu se poate transfera o valoare întreagă mai mare decât +32767 sau mai mică decât -32768 în AutoCAD.

Numere reale - sunt numere care au virgulă (punct zecimal). De exemplu, 7.082 și 7.0 sunt numere reale, dar 7 nu este. Numerele reale sunt memorate într-un format de dublă precizie, de tip virgulă mobilă, furnizând cel puțin 14 zecimale semnificative, chiar dacă pe linia de comandă a AutoCAD-ului sunt afișate numai 6 zecimale.

Simboluri - sunt colecții de caractere alfabetice pe care AutoLISP le folosește ca nume de variabile; o valoare memorată este reprezentată printr-un simbol. În următorul exemplu funcția "setq" folosește simbolul "pt1" pentru a memora valoarea (3,7) (coordonatele unui punct):

(setq pt1 '(3 7))

Termenii "simbol" și "variabilă" sunt folosiți echivalent.

Liste - sunt colecții de simboluri, numere reale, numere întregi și șiruri, pe care AutoLISP le evaluează ca seturi de acțiuni. Organizarea listelor și legăturile dintre ele determină ordinea acțiunilor AutoLISP în executarea unei rutine. O listă este delimitată de paranteze rotunde. Pentru a specifica coordonatele grafice ale unui punct în 2D, exprimate sub forma unei liste, se scrie (3.6 9.72). Prima valoare reprezintă coordonata X, iar cea de-a doua este coordonata Y. Punctele 3D sunt exprimate ca liste a trei numere reale (X, Y, Z), astfel: (4.81 2.1 6.95). Prima valoare este coordonata X, cea de-a doua este coordonata Y și a treia este coordonata Z.

Șiruri (strings) - sunt colecții de caractere numerice sau alfabetice, care nu pot fi evaluate și pe care AutoLISP le reține ca o entitate unică. Un text în AutoLISP se scrie între ghilimelele speciale ("). De exemplu, "Cartea mea" este un șir, dar Cartea mea nu este șir. De asemenea "9.07" este un șir, dar 9.07 nu este șir.

Descriptori de fișiere - sunt etichete alfanumerice stabilite pentru fișiere deschise de AutoLISP. Când o funcție AutoLISP necesită accesarea unui fișier (pentru citit sau scris), etichetele trebuie să fie indicate. În exemplul de mai jos este deschis fișierul "info.dat", făcându-l accesibil altor funcții pentru citit și stabilește valoarea descriptorului de fișier la simbolul "r":

(setq fiș (open "info.dat" "r")) ar putea să returneze <File: #34614>

Nume de entități. Numele unei entități este o etichetă numerică stabilită pentru entitățile dintr-un desen. Această etichetă poate fi referită de funcțiile AutoLISP pentru a permite selectarea de entități pentru procesare în diferite feluri. În următorul exemplu se setează simbolul "e1" la numele ultimei entități introduse în desen:

(setq e1 (ultima_entitate)) ar putea să returneze <Entity name: 60000016>

AutoLISP-ul utilizează câteva convenții lexicale:

O expresie poate fi scrisă pe mai multe linii.

Un comentariu începe cu caracterul (;) și continuă până la sfârșitul liniei respective. De exemplu:

; Această linie este un comentariu

Orice text scris astfel " ;| ....|; " este ignorat.

Spațiile multiple între simboluri sunt echivalente unui singur spațiu.

Numele simbolurilor pot fi orice secvență de caractere cu excepția: ( ) . ' " ;

Numele de funcții și simboluri pot fi introduse cu litere mari sau mici.

În cadrul șirurilor de caractere, backslash-ul (\) este utilizat 10210m1217k pentru introducerea caracterelor de control care transmit comenzi către periferice. De exemplu, următoarea funcție afișează prompt-ul "Introduceți primul punct" pe o linie nouă:

(prompt "\nIntroduceți primul punct: ")

15.2.2. Interpretorul AutoLISP

Interpretorul AutoLISP traduce instrucțiunile din programul AutoLISP și transmite aceste instrucțiuni AutoCAD-ului și unității centrale de prelucrare a calculatorului. La baza fiecărui interpretor LISP stă evaluatorul. Evaluatorul ia o linie introdusă de utilizator, o evaluează și returnează rezultatul. Acesta este procesul de evaluare în AutoLISP.

Expresii AutoLISP

Toate expresiile AutoLISP au următoarea formă:

(nume_funcție [argumente] ...)

Fiecare expresie începe cu o paranteză deschisă și este alcătuită din numele unei funcții și o listă opțională de argumente pentru acea funcție (fiecare dintre ele poate fi o expresie). Expresia se termină apoi cu o paranteză închisă. Fiecare expresie returnează o valoare care poate fi folosită de o altă expresie; dacă aceasta nu există, AutoLISP returnează valoarea AutoCAD-ului.

Dacă se introduce o expresie AutoLISP ca răspuns la prompt-ul "Command" al AutoCAD-ului, AutoLISP evaluează expresia și afișează rezultatul.

Când o expresie este incorect introdusă sau citită dintr-un fișier, AutoLISP ar putea afișa următorul prompt:

n>

unde "n" este un număr întreg care indică numărul de nivele sau paranteze rămase deschise. Dacă acest prompt apare, trebuie să introducem n paranteze închise pentru a ieși din această condiție. O greșeală frecventă este omiterea închiderii ghilimelelor duble (") într-un șir text, caz în care greșala este interpretată asemănător și modificarea (prin introducerea de paranteze) nu are nici un efect. Pentru a corecta această condiție se anulează funcția introducând Ctrl-C și se reintroduce corect funcția.

Variabile AutoLISP

Variabilele AutoLISP sunt de patru tipuri: număr întreg, număr real, punct, șir. Tipul unei variabile îi este asociat automat, în funcție de tipul de valoare care i se atribuie. Variabilele rețin valorile lor până la atribuirea unei noi valori sau până când sesiunea curentă de lucru ia sfârșit. Variabilele pot lua orice nume, cu condiția ca primul caracter să fie alfabetic. Variabila "pi" este presetată cu valorea lui p și poate fi folosită ca și celelalte variabile definite de noi.

Pentru a atribui valori variabilelor se folosește funcția "setq" (vezi paragraful 15.3.3). Formatul acesteia este: (setq nume_variabilă valoare). Funcția "setq" atribuie valoarea specificată variabilei al cărei nume este dat. De asemenea returnează valoarea ca rezultat al funcției.

Se poate folosi valoarea unei variabile ca răspuns la un prompt din AutoCAD, introducând numele variabilei precedat de un semn al exclamării (!). Să presupunem, de exemplu, că am setat variabila "a1" la valoarea 15.8802. Se poate introduce acum "!a1", ori de câte ori se dorește ca răspunsul la o cerere AutoCAD să fie 15.8802. De exemplu:

Distance betwen columns (|||):!a1

Similar, dacă se dorește trasarea unui segment din punctul (2.4, 5.0) atribuit variabilei "pt", se poate introduce:

Command: line

From point: !pt

Observație: Nu se poate folosi o variabilă ca referire la o comandă AutoCAD. De exemplu, dacă s-a atribuit șirul "Line" variabilei "X" și apoi se introduce "!X" drept răspuns la prompt-ul Command: al AutoCAD-ului, se va afișa doar "LINE", iar comanda LINE nu va fi executată.

15.2.3. Definirea funcțiilor

Toate funcțiile AutoLISP (prezentate în partea a doua a acestui capitol) pot fi introduse din interiorul AutoCAD-ului, în linia de comandă, pentru a vedea cum acționează. De exemplu, dacă se scrie lista (* 15 3.5) la prompt-ul AutoCAD-ului și apoi se apasă tasta Enter, AutoLISP va returna 52.5, deci:

Command:(* 15 3.5)

În acest caz s-a folosit funcția matematică înmulțire (*) pentru a face produsul numerelor 15 și 3.5. Acest lucru este posibil pentru că scrierea funcției a început cu o paranteză deschisă care invocă interpretorul AutoLISP pentru a prelua informațiile din linia de comandă.

A scrie linii din interiorul AutoCAD-ului (ca mai sus) se justifică numai pentru mici încercări (rutine alcătuite din câteva instrucțiuni). Dacă avem rutine mai mari pe care le introducem linie cu linie, după executarea rutinei este posibil să primim mesajul unei erori (v. anexa). În acest caz, totul trebuie scris de la capăt, fiindcă nu putem să ne întoarcem în vreo linie scrisă anterior.

Pentru a evita acest neajuns putem scrie rutina sub forma unui fișier text cu extensia .LSP, în afara AutoCAD-ului, folosind un editor de texte, ca de exemplu Norton Commander (cel mai mic și cel mai simplu editor) sau EDIT din sistemul DOS. Fișierul astfel creat va fi transmis AutoLISP-ului de unde poate fi încărcat folosind funcția AutoLISP "load".

Pentru a putea scrie și corecta rutine și programe AutoLISP, este necesar ca din AutoCAD să fie posibil accesul într-un editor de texte. Acest lucru se realizează punând în fișierul ACAD.PGP linia:

NC,NC, 72000, ,4

sau

EDIT, EDIT, 72000, Fișier de ediat: ,4

Prima linie va permite lansarea Norton Commander-ului iar a doua linie lansarea editorului EDIT.COM din DOS. Spațiul alocat este de 72000 de octeți și el poate fi mărit dacă la încercarea de editare a unui fișier se primește un mesaj de genul Out of memory. După scrierea liniei respective în fișierul ACAD.PGP se face o resetare a calculatorului și apoi se lansează AutoCAD-ul.

Pentru definirea și memorarea unui grup de funcții (rutină), în vederea execuțiilor ulterioare, se folosește funcția AutoLISP DEFUN (Defining FUNction). Crearea de funcții și rutine este "miezul" eficienței acestui limbaj. Când într-o listă este scris numele funcției, AuoLISP găsește acest nume în memorie și execută instrucțiunile legate de acest nume. Funcția "defun" este prezentată pe larg în paragraful "Funcții procedurale".

Dacă vom considera că numele fișierului în care sunt scrise instrucțiunile funcției cu numele "Calcul" este "Test.lsp", pentru a executa funcția "Calcul", la prompt-ul Command: din AutoCAD se tastează:

Command: (load "Test") enter

CALCUL este afișat numele funcției definită în cadrul fișierului.

Command: (calcul)

Deci, pentru executarea instrucțiunilor ce compun funcția, la prompt-ul "Command:" se tastează numele funcției, delimitat de paranteze. După execuție se returnează rezultatul ultimei expresii evaluate.

Dacă în definiția funcției punem prefixul "C:" la numele funcției, funcția definită va fi tratată ca o comandă AutoCAD. De exemplu, considerând prima linie din definiția funcției ca fiind:

(defun C:calcul () <expresii...)

apelarea funcției se face astfel:

Command: (load "Test")

C:CALCUL este afișat numele funcției

Command: calcul

Spre deosebire de primul caz când prefixul "C:" nu exista, acum, după încărcarea fișierului Test.lsp, pentru executarea instrucțiunilor funcției, s-a răspuns la prompt-ul "Command:" cu numele funcției "calcul" ca și cum aceasta ar fi o comandă AutoCAD, deci invocarea funcției s-a făcut doar prin introducerea numelui funcției fără prfixul "C:" și fără delimitarea acestuia de paranteze.

Modul acesta de definire a funcțiilor permite adăugarea de noi comenzi create de utilizator la cele existente în AutoCAD. Această manieră de lucru este o foarte puternică utilitate a AutoLISP-ului. Odată definită, noua comandă poate folosi toate facilitățile permise de AutoLISP și AutoCAD, inclusiv apelarea transparentă, precedând numele funcției cu un apostrof (').

Când este chemată o funcție definită ca o comandă, din cadrul altei funcții AutoLISP, trebuie folosit numele întreg (cu prefix); de exemplu, C:calcul.

Dacă se dorește ca funcția "calcul" să fie permanent accesibilă, ori de câte ori se intră în AutoCAD, se crează un fișier cu numele special "acad.lsp" al cărui conținut să fie reprezentat de această funcție. Lansând AutoCAD-ul din directorul în care se află fișierul "acad.lsp" astfel creat, acesta îl va încărca în mod automat de fiecare dată.

În paragrafele următoare se prezintă funcțiile AutoLISP de bază. Parantezele drepte utilizate în sintaxa funcțiilor pentru a delimita anumite argumente sau expresii arată că acestea sunt opționale. Rezultatul returnat de o funcție este arătat cu simbolul "

15.3. Funcții AutoLISP

15.3.1. Funcții matematice

În această categorie de funcții sunt cuprinse funcțiile aritmetice de bază, funcțiile logaritmice și funcțiile trigonometrice. Funcțiile matematice vor returna întotdeauna un număr întreg sau real, depinzând de tipul de argumente din listă. Dacă toate numerele din listă sunt întregi, rezultatul returnat este un număr întreg (restul oricărei operații matematice va fi abandonat); de exemplu, rezultatul împărțirii lui 47 la 3 , în calculul cu numere întregi, va fi 15 în loc de 15.6667. Dacă numai unul din numerele din lista de argumente este real, AutoLISP le va converti pe toate în numere reale și va realiza operații matematice cu virgulă mobilă. În acest caz, rezultatul returnat va fi un număr real.

Funcția (+ <n1> <n2> .....) - returnează suma numerelor din listă; n1, n2, ...sunt reale sau întregi. Exemple:

Funcția (- <n1> <n2> ........<nk>) - returnează diferența numerelor din listă; n1,n2,......,nk sunt reale sau întregi. Dacă lista cuprinde mai mult de două numere, al treilea și fiecare număr care urmează este scăzut din rezultatul scăderii anterioare. Exemple:

Funcția (* a b c ...) - returnează produsul numerelor pe care le cuprinde lista; a, b, c, .... sunt reale sau întregi. Exemple:

Funcția (/ a1 a2 a3 .....) - returnează câtul numerelor din listă; a1, a2, a3, ....sunt reale sau întregi. În cazul în care lista are mai mult de două argumente, primul număr este împărțit la produsul următoarelor. Exemple:

8 și este similar cu (/96 (* 4 3))

Funcțiile (max) și (min)

(max <n1> <n2> ......) returnează maximul dintre argumente

(min <n1> <n2>....) returnează minimul dintre argumente

Exemple:

(max 27 32 3 -10)

(min 4 3 2 -15)

Fiecare din funcțiile (+) (-) (*) (/) (max) (min) permit mai multe argumente.

Se observă că, imediat după prima paranteză (fără vreun blanc), urmează numele funcției, apoi blanc și argumente; după ultimul argument se pune imediat paranteza închisă.

Funcțiile (1+) și (1-)

(1+a); (1-a) - incrementează cu plus 1, respectiv în minus 1 numărul "a" care poate fi real sau întreg. Exemple:

(1+ -12)

(1- -5)

Funcția (abs <n>) - întoarce valoarea absolută a lui "n" (modulo). Exemplu:

(abs -3.987)

Funcția (exp <n>) - returnează () (antilogaritmul natural). Exemplu:

(exp 2)

Funcția (expt <bază> <putere>) - returnează baza ridicată la putera specificată; argumentele pot fi numere întregi sau reale. Exemple:

(expt 2 4.0)

(expt 9 3)

Funcția (fix <n>) - returnează conversia lui <n> într-un întreg; <n> poate fi întreg sau real. Exemple:

(fix 3.7)

(fix -12.99)

Funcția (float <n>) - returnează conversia lui <n> într-un real; <n> poate fi un întreg sau real. Exemple:

(float 9)

(float 46.3)

Funcția (gcd <întreg1> <întreg2>) - returnează cel mai mare divizor comun al numerelor <întreg1> și <întreg2> , deci argumentele trebuie să fie numere întregi. Exemple:

(gcd 24 78)

(gcd 36 -52) error: improper argument

Se observă că în cazul celui de-al doilea exemplu apare un mesaj de eroare.

Funcția (rem <n1> <n2>) - returnează restul împărțirii numerelor <n1> <n2>; aplică <n1> modulo <n2>, argumentele fiind atât numere intregi cât și reale. Exemplu:

(rem 368 17)

Funcția (sqrt <n>) - returnează rădăcina pătrată (radicalul) a lui <n> număr real. Exemplu:

(sqrt 16)

Funcția (atan <n1> [<n2>])

Dacă <n2> nu este dat, atan returnează arctangenta lui <n1> în radiani de la - la + radiani. Exemplu:

(atan 0.5)

Dacă se dă atât <n1> cât și <n2>, se returnează arctangenta lui <n1>/<n2>, în radiani. Exemplu:

(atan 2.0 3.0)

Funcția (cos <unghi>) - returnează cosinusul unui unghi, unde unghiul este în radiani. Exemple:

(cos 0.0)

(cos 1.2)

Funcția (sin <unghi>) - returnează sinusul unui unghi, unde <unghi> este exprimat în radiani. Exemplu:

(sin 1.0)

Funcția (log <n>) - returnează logaritmul natural din <n>, unde <n> este real. Exemplu:

(log 4.5)

15.3.2. Funcții de manipulare a listelor

Multe dintre funcțiile AutoLISP, cum ar fi funcțiile șir și matematice, sunt comune celor mai multe limbaje de programare. Funcțiile de manipulare a listelor sunt totuși unice în limbajul LISP. Funcțiile care urmează sunt de bază în programarea AutoLISP, oferind unele instrumente puternice pentru manipularea simbolurilor. Iată câteva informații specifice structurării listelor.

O listă poate fi alcătuită din simboluri, numere, șiruri sau alte liste. Un simbol este creat doar atunci când este declarat ca al doilea element al unei liste care începe cu una din funcțiile AutoLISP "defun", "setq" sau "quote". Fiecare simbol care este creat este adăugat listei și de fiecare dată când simbolul este evaluat printr-o expresie, AutoLISP trebuie mai întâi să caute în listă numele acelui simbol.

Funcția (list <expr1> <expr2>...<exprk)

Această funcție primește orice număr de expresii <expr> (inclusiv șiruri) și le listează împreună, returnând o listă. Exemple:

(list 3.9 6.7)

(list '(x y z)) ((X Y Z))

Funcția list este frecvent folosită pentru a defini o variabilă punct 2D sau 3D.

Funcția (append <list1> <list2>....<listk>)

Această funcție preia oricâte liste și le consideră o singură listă; deci reunește mai multe liste în una singură. Exemplu:

(append '(a b c) '(d e f)) (a b c d e f)

Funcția (assoc <articol> <alist>)

Această funcție caută <articol> în lista asociată <alist>, ca element cheie și returnează intrarea din <alist>. Exemplu: presupunem lista asociată cu numele 'tabel definită ca o asociere de mai multe liste;

((grupa 42) (număr_studenți 25) (bursieri 8) (restanțieri 5))

atunci,

(assoc 'bursieri tabel) BURSIERI 8

(assoc 'restanțieri tabel) RESTANTIERI 5

(assoc 'integraliști tabel) nil

Funcțiile (car <list>)

(cdr <list>)

(cadr <list>)

Fie lista (setq tl '(a b c d e))

(car tl) a; adică primul element al listei;

(cadr tl) b; adică al doilea element;

(caddr tl) c; al treilea element al listei;

(cadddr tl) d; al patrulea element;

(cdr tl) b c d e; toate elementele cu excepția primului;

(cddr tl) c d e; elementele listei fără primele două;

(cdddr tl) d e;

(cddddr tl) e;

Exemplu:

(setq p1 '(7 15))

(setq p2 '(10 20))

(setq p3 '(car p1 cadr p2))

În ultima instrucțiune din exemplu, variabilei punct "p3" i se atribuie coordonatele (7, 20); adică coordonata x a punctului "p1" și coordonata y a punctului "p2".

Funcția (cons <noul_prim_element> <list>)

Această funcție adaugă noul element ca prim element la o listă <list> și returnează noua listă. Exemplu:

(cons 'a '(b c)) (a b c)

Funcția (last <list>) - returnează ultimul element din <list>; parametrul <list> nu trebuie să fie nul. Exemplu:

(last '(a b c d e)) e

Funcția (member <expr> <list>)

Această funcție cercetează lista <list> pentru a găsi expresia <expr> și returnează partea din <list> rămasă după prima întâlnire a lui <expr>, începând cu aceasta. Exemple:

(member 'c '(a b c d c d e)) (c d c d e)

(member 'q '(a b c d)) nil

Funcția (nth <n> <list>) - returnează elementul cu numărul "n" din listă. Primul element din listă corespunde lui n=0, nu lui n=1. Exemplu:

(nth 3 '(f g h i j k) i

Funcția (reverse <list>) - returnează <list> cu elementele puse în ordine inversă. Exemplu:

(reverse '(d e f)) (f e d)

Funcția (subst <articol_nou> <articol_vechi> <list>)

Această funcție caută <articol_vechi> în <list> și returnează o copie a <list> în care <articol_vechi> este înlocuit cu <articol_nou> Exemplu:

Fie lista (setq exemplu '(a b c d))

atunci

(subst 'z 'c exemplu) (a b z d)

15.3.3. Funcții de atribuire

Funcțiile din această grupă atribuie sau citesc valori prin AutoCAD și AutoLISP.

Funcția (getvar <nume_var>)

Această funcție regăsește valoarea unei variabile de sistem AutoCAD. Exemplu:

(getvar "FILLETRAD") 0.25 dacă raza de racordare specificată pentru comanda FILLET cea mai recentă a fost 0.25 unități.

Funcția (quote <expr>) - returnează <expr> neevaluată. Exemplu:

(quote (+ 9 7.1))

Funcția (setq <simbol> <expr>)

Această funcție atribuie valoarea <expr> numelui de variabilă <simbol>. Este principala funcție de atribuire din AutoLISP, fiind similară cu "Last" din BASIC și cu ":=" din PASCAL și C. Exemple:

(setq a 30) (setq x 34.2)

(setq b "DA") (setq c '(a x))

Funcția (set <simbol> <expr>)

Această funcție setează (fixează) valorea lui <simbol>, unde <simbol> este un nume de simbol, evaluând <expr> și returnând acea valoare. Exemplu:

(set 'a 6) 6 și setează simbolul <a>; este identic cu (setq a 6)

Funcția (setvar <nume_var> <valoare>)

Această funcție setează o variabilă de sistem AutoCAD pe valoarea <valoare> și returnează acea valoare. Exemplu:

(setvar "FILLETRAD" 0.5) 0.5 setând raza de racordare FILLET a AutoCAD-ului pe 0.5 unități.

15.3.4. Funcții procedurale

Funcțiile procedurale sunt folosite pentru a descrie o serie de instrucțiuni, pas cu pas, pentru a fi executate de calculator.

Funcția (apply <funcție> <listă>) - execută funcția specificată prin <funcție> cu argumentele date de <listă> și returnează rezultatul. Exemplu:

(apply '+' (1 2 3)) 6 (aplică funcția "+" pe argumentele listei (1 2 3)

Această funcție lucrează numai cu funcții înglobate sau definite de utilizator (cele create cu funcția DEFUN sau LAMBDA)

Funcția (command <args>....)

Această funcție execută comenzi AutoCAD din interiorul AutoLISP-ului și întotodeauna returnează nil. Argumentele <args> reprezintă comenzi AutoCAD și subcomenzi ale lor. Exemplu:

(setq pt1 '(7 15))

(setq pt2 (getpoint "Introduceți un punct: "))

(command "line" pt1 pt2)

Secvența de expresii setează o valoare pentru punctul "pt1", cere o valoare pentru "pt2" ( de la tastatură sau mouse) și execută comanda LINE a AutoCAD-ului.

Un șir nul (" ") este echivalent cu introducerea unui spațiu de la tastatură. Apelul lui Command fără argumente este echivalent cu introducerea unui CTRL/C de la tastatură, ducând la abandonarea celor mai multe comenzi.

Funcția (defun nume_func (argument / variabile locale) <expresii>....)

DEFUN definește o funcție cu numele "nume_func". După numele funcției urmează lista de argumente (posibil vidă) separată de lista de variabile locale printr-un slash (/). Slash-ul trebuie să fie separat de simbolul primei variabile locale și de ultimul argument prin cel puțin un spațiu. După lista de argumente și simbolurile variabilelor locale se dau una sau mai multe expresii de evaluare la execuția funcției.

Nu toate funcțiile necesită argumente sau variabile locale, dar o listă trebuie să fie prezentă chiar dacă este vidă. Iată câteva exemple de folosire a funcției DEFUN. Numele funcției definite este "test".

(defun test ( ) <expresii>...) nu conține argumente sau variabile locale

(defun test (x) <expresii>...) un argument , fără variabile locale

(defun test (x y) <expresii>...) două argumente, fără variabile locale

(defun test (x y / z) <expresii...) două argumente, o variabilă locală

(defun test (/ a b) <expresii>...) fără argumente, două variabile locale

Argumentele funcției trebuie să aibă nume diferite, de exemplu, funcția defun test1 (x x / a)..) este incorect definită. Dar putem defini funcții care au variabile locale cu același nume, de exemplu, funcția defun test2 (x y / a a b) ...) este corect definită.

Când funcția definită este invocată, argumentele sale vor fi evaluate și asociate simbolurilor argument. Variabilele dintr-o funcție obținute prin atribuire (de exemplu, prin funcția setq) sunt variabile globale și pot fi utilizate în orice rutină din program. Variabilele locale pot fi folosite numai în cadrul funcției respective fără a schimba corelațiile acestora la nivelele exterioare. Funcția va returna rezultatul ultimei expresii evaluate. Toate expresiile anterioare din funcție au numai efecte laterale. Funcția DEFUN însăși returnează numele funcției definite. Exemplul 1:

(defun adun (x)

(+10 x)) adun (a fost returnat numele funcției)

Dacă într-un program este apelată funcția de mai sus :

(adun 5) ea returnează 15 ( la 10 a fost adunat argumentul "x" căruia i s-a atribuit valoarea 5)

Exemplul 2:

(defun AC ()

(setq r (getreal "Dați raza cercului:"))

(setq aria (* pi (expt r 2)))

Acest exemplu va calcula aria unui cerc de rază dată. Raza cercului se introduce de la tastatură la cererea "Dați raza cercului" afișată pe ecran.

Funcția (eval <expr>) - returnează rezultatul evaluării expresiei <expr>, unde <expr> este orice expresie LISP. Exemple: dându-se atribuirile

(setq a 245)

(setq b 'a)

atunci

(eval a)

(eval (abs -10))

Funcția (lambda <argument> <expr>....) - definește o funcție anonimă. Este folosită în mod tipic atunci când definirea generală a unei funcții noi nu se justifică. LAMBDA returnează valoarea ultimei sale <expr> și este adesea folosită împreună cu APPLY sau MAPCAR pentru a executa o funcție pe o listă. Exemplu:

(apply '(lambda (a b c) (* a (+ b c))) '(5 20 14))

Funcția (mapcar <funcție> <list1>...<listn>)

Această funcție returnează rezultatul aplicării funcției <funcție> pe elementele individuale exprimate de <list1> până la <listn>, date ca argumente ale lui <funcție>. Exemple:

(setq a 10 b 20 c 30)

(mapcar '1+ (list a b c ))

(mapcar '+ '(10 20 30) '(45 3))

Funcția (progn <expr>...) - evaluează fiecare <expr> secvențial și returnează valoarea ultimei expresii. Exemplu:

(setq a 80 b 80)

(if (= a b) (progn (setq a (+a 10)) (setq b (-b 10))))

Când funcția PROGN este folosită, ea permite evaluarea mai multor expresii și nu a uneia cum se întâmplă în mod normal după "then".

Funcția (repeat <nr> <expr> .....)

Această funcție evaluează fiecare <expr> de <nr> ori și returnează valoarea ultimei expresii. Exemplu:

(setq a 10)

(setq b 100)

(repeat 3 (setq a (+a 10))

(setq b (+ b 100)))

15.3.5. Funcții condiționale

Funcțiile condiționale sunt acelea care testează rezultatele expresiei și realizează operații specificate în funcție de rezultatele testelor. În AutoLISP pot fi realizate trei tipuri de teste coniționale: "cond", "if", "while".

Funcția (cond (<test1> <result_expr1>.... <rezult_exprN>)....)

Această funcție evaluează primul articol din fiecare listă (în ordinea dată) până ce unul dintre aceste articole returnează altă valoare decât nil. Atunci ea evaluează acele expresii care urmează după testul trecut și returnează valoarea ultimei expresii din listă. COND este funcția condițională principală din AutoLISP. Exemplu:

(setq a 12)

(cond ((= a 12) 1) ((= a 13) 0))

Funcția (if <expr_test> <expr_atunci> [<expr_altfel>])

Această funcție evaluează expresii în mod condițional. Dacă <expr_test> nu este nil atunci este evaluată expresia <expr_atunci>, altfel este evaluată expresia <expr_ altfel>. Exemplu:

(setq a 7)

(if (= a 7) "DA" "NU") DA

Funcția (while <expr_test> <expr1>..... <exprN>)

Această funcție evaluează <expr_test> și dacă nu este nil, evaluează celelalte expresii după care evaluează din nou <expr_test>. Aceasta continuă până ce <expr_test> devine nil (deci evaluările trebuie să modifice ceva din <expr_test>, altfel ciclarea nu se va termina niciodată.). Exemplu:

(setq a 1)

(while (<= a 10)

..... alte funcții (se execută de 10 ori)

(setq a (1+a)))

15.3.6. Funcții relaționale

Funcțiile relaționale returnează rezultatele unui test al relației dintre mai mulți atomi. Atomii pot fi egali între ei, diferiți sau pot avea multe alte relații.

Funcția (= <atom1> <atom2>.....)

Funcția relațională "egal cu" returnează true dacă toți <atom>-ii sunt numeric egali și nil în caz contrar. Funcția este valabilă pentru numere și șiruri. Exemple:

(setq a 1) (= a b c) true

(setq b 1) (= "eu" "eu") true

(setq c 1) (= "eu" "tu") nil

Funcția (/= <atom1> <atom2>)

Funcția relațională "neegal cu" returnează true dacă <atom1> nu este egal cu <atom2> și nil dacă cei doi atomi sunt numeric egali. Funcția este nedefinită dacă se dau mai mult de două argumente. Exemplu:

(setq a 1)

(setq b 2)

(/= a b) true

Funcția (< <atom1> <atom2> .....)

`Aceasta este funcția relațională "mai mic decât". Ea returnează true dacă primul <atom1> este numeric mai mic decât <atom2> și nil altfel. Dacă sunt mai mulți atomi se returnează true dacă fiecare atom este mai mic decât atomul din dreapta sa, deci dacă șirul de atomi este strict crescător. Exemplu:

(setq a 1) (setq c 3)

(setq b 2) (< a b c) true

Funcția (<= <atom1> <atom2> ....)

Aceasta este funcția relațională "mai mic sau egal cu". Ea returnează true dacă <atom1> este mai mic sau egal cu <atom2>. Dacă sunt mai mult de doi atomi, se returnează true dacă fiecare atom este mai mic sau egal cu atomul din dreapta sa. Exemplu:

(<= 1 2 3 3.0 4 5 5 5) true

Funcția (> <atom1> <atom2>....)

Aceasta este funcția relațională "mai mult decât". Ea returnează true dacă <atom1> este mai mare decât <atom2> și nil altfel. Dacă sunt mai mulți atomi, se returnează true dacă fiecare atom este mai mare decât atomul din dreapta sa, deci dacă șirul este strict descrescător. Exemplu:

(> 3 2 1) true

Funcția (>= <atom1> <atom2> ......)

Aceasta este funcția relațională "mai mare sau egal cu". Ea returnează true dacă <atom1> este mai mare sau egal cu <atom2> și nil altfel. Dacă se dau mai mult de doi atomi, se returnează true dacă fiecare atom este mai mare sau egal cu atomul din dreapta sa. Exemple:

(>= 3 2 2 1) true

(>= 3 2 3 1) nil

Funcția (eq <expr1> <expr2>)

Această funcție determină dacă expresiile <expr1> și <expr2> sunt identice. Funcția returnează true dacă cele două expresii sunt identice și nil altfel. Este folosită în mod tipic pentru a determina dacă cele două liste sunt identice. Exemple:

(setq a '(c d e f)) (eq g b) true

(setq b '(c d e f) (eq a g) nil

(setq g b)

Observație: Variabilele g și b sunt asociate aceluiași obiect prin SETQ (sunt exact aceeași listă), dar a și g nu, deci nu sunt identice deși conținutul este același, nu sunt aceeași listă.

Funcția (equal <expr1> <expr2> [<variație>])

Această funcție determină dacă <expr1> și <expr2> sunt egale, mai precis dacă ele sunt evaluate prin același lucru. Funcția returnează true dacă cei doi atomi sunt egali sau diferența dintrei ei este egală sau mai mare decât <variație> și nil altfel. Exemple:

(setq x 3.14159) (equal x y 0.00001) true

(setq y 3.141593) (equal x y) nil

15.3.7. Funcții predicative

Funcțiile predicative sunt acelea care produc un efect bazat pe testul uneia sau mai multor expresii. Subiectul este expresia care trebuie testată, iar predicatul este rezultatul testului.

Funcția (and <expr> ...)

Această funcție returnează AND logic al unei liste de expresii. Ea încetează evaluarea și returnează nil dacă o expresie este evaluată ca nil, altfel returnează true. Nil are rolul de "nu", iar orice altceva de "da". Exemple:

(setq a 1) (setq d nil)

(setq b 2) (and a b c) true

(setq c "xyz") (and a b d) nil

Funcția (atom <arg>)

Această funcție returnează nil dacă <arg> este o listă și true altfel. Orice nu este o listă este considerat un atom. Exemple:

(setq x 'a) (atom x) true

(setq y '(a b c)) (atom 'y) true

(atom 'x) true    (atom y) nil

Funcția (listp <arg>) - returnează True, dacă argumentul este o listă și nil, dacă argumentul este orice altceva. Exemple:

(setq a 1) (setq b '(x y z))

(listp a) C nil (listp b) True

Funcția (minusp <arg>)

Această funcție permite testarea argumentului <arg> pentru a vedea dacă este un număr întreg sau real negativ, caz în care returnează True; în caz contrar returnează nil. Argumentul de tip șir nu este recunoscut. Exemple:

(minusp 12) nil

(minusp -3.14159) True

Funcția (not <arg>) - returnează opusul valorii argumentului <arg>. Dacă argumentul este evaluat ca True, funcția "not" returnează nil; dacă argumentul este evaluat ca nil, funcția returnează True. Exemple:

(setq x 2) (setq y nil) nil

(not x) nil (not y) True

Funcția (null <arg>) - permite testarea unui argument pentru a vedea dacă este nil. Funcția "null" returnează valoarea True dacă argumentul este nil și returnează nil dacă nu este. Exemple:

(setq x nil) (setq x 2)

(null x) True (null x) nil

Funcția (numberp <arg>) - returnează True dacă argumentul <arg> este o valoare întreagă sau reală; în caz contrar va returna nil. Exemple:

(numberp 3.57) True

(setq x "un șir")

(numberp x) nil

Funcția (or <expr1.... <exprN>)

Dacă nici-o expresie nu este nil, evaluarea se oprește la acea expresie și valoarea returnată este True. Exemple:

(setq a nil) (setq c 1)

(setq b nil) (or a b c) True

(or a b) nil

Funcția (type <arg>) - ne permite să cunoaștem tipul argumentului prin tipărirea simbolului corespunzător tipului de date din care acesta face parte. Exemple:

(setq x 4.52) (type 'x) SYM

(type x) REAL (type "proiectare") STR

Funcția (zerop <arg>) - permite să determinăm dacă un argument este un număr întreg sau real și îl evaluează ca zero. Funcția returnează True dacă argumentul este un întreg sau real și este zero; altfel returnează nil. Argumentul de tip șir nu este recunoscut. Exemple:

(zerop 5) nil (zerop 0.0) True

(zerop 0) True (zerop (- 1 1)) True

15.3.8. Funcții pentru prelucrarea șirurilor de caractere

Aceste funcții permit prelucrarea șirurilor de caractere cu AutoLISP. Există posibilitatea afișării șirurilor, testării, comparației și modificării caracteristicilor lor.

Funcția (strcase <șir> [<case>] - va lua un șir și va converti toate caracterele din el în litere mari sau mici în funcție de valoarea argumentului <case>. Dacă argumentul <case> există și nu este nil, toate caracterele șirului <șir> sunt convertite în litere mici; dacă argumentul <case> nu există sau este evaluat ca nil, șirul va fi convertit în litere mari. Exemple:

(setq x "proiectare")

(strcase x 1) "proiectare"

(strcase x) "PROIECTARE"

(strcase x nil) "PROIECTARE"

Funcția (strcat <șir1> <șir2>....<șirN>)

Cu această funcție se pot concatena șiruri de caractere. Concatenarea va fi în ordinea în care șirurile apar în listă. Exemplu:

(strcat "Îmi" " place" " AutoLISP") "Îmi place AutoLISP"

Funcția (strlen <șir>) - returnează un număr întreg care reprezintă numărul de caractere ale șirului. Exemplu:

(setq x "AutoLISP")

(strlen x)

Funcția (substr <șir> <start> [<nr_caract>]) - este folosită pentru extragerea unui subșir dintr-un șir. Începând cu <start> subșirul alcătuit din numărul de caractere <nr_caract> care urmează (inclusiv blancuri), va fi returnat. Dacă numărul de caractere este omis, restul șirului care începe cu <start> va fi returnat. Exemple:

(substr "Îmi place AutoLISP" 11) "AutoLISP"

(substr "Îmi place AutoLISP" 5 5) "place"

Funcția (angtos <unghi> [<mod> [<precizie>]])

Această funcție convertește un unghi într-un șir. Argumentul <unghi> trebuie să fie un număr real și exprimă valoarea unghiului în radiani. Metoda se bazează pe variabila de sistem DIMZIN exprimată prin argumentul <mod>. Dacă valoarea argumentului mod este:

0 - șirul va fi exprimat în grade sexazecimale;

1 - formatul va fi grade/minute/secunde;

2 - șirul va fi exprimat în grade centezimale;

3 - șirul va fi măsurat în radiani;

4 - șirul va fi măsurat în unități topografice.

Argumentul <precizie> trebuie să fie întreg și exprimă numărul de zecimale dorite. Argumentele <mod> și <precizie> sunt opționale; dacă nu sunt date vor fi folosite valorile implicite curente ale variabilelor de sistem. Exemplu:

(angtos (/ pi 2) 0 2)

Funcția (ascii <șir>) - returnează codul ASCII (număr întreg) al argumentului <șir>. Exemple:

(ascii "U")

(ascii "u")

(ascii "T")

Funcția (atof <șir>) - convertește un șir care conține o expresie numerică într-un număr real. Exemple:

(atof "3.14159")

(atof "numărul 15")

Funcția (atoi <șir>) - convertește un șir care conține o expresie numerică într-un număr întreg. Exemple:

(atoi "3.14159")

(atoi "numărul 72")

Funcția (chr <număr>) - returnează caracterul corespunzător codului ASCII; realizează procesul invers funcției "ascii". Exemple:

(chr 83) "S"

(chr 115) "s"

Funcția (Itoa <întreg>) - convertește un număr întreg într-un șir ASCII. Exemple:

(itoa -35)

(itoa 1997)

Funcția (read <șir>) - returnează primul atom sau listă dintr-un șir; șirul trebuie să fie fără blancuri. Exemplu:

(setq a "AutoCAD") "AutoCAD"

(read a) AutoCAD

Funcția (rtos <număr> [<mod> [<precizie>]]) - returnează un șir ca și funcția "itoa", dar numărul poate fi formatat în timp ce este citit ca șir. Dacă este dat un argument <mod>, acesta trebuie să aibă una din valorile următoare:

1 - creează un șir în notație științifică;

2 - creează un șir zecimal;

3 - creează un șir în notație Engineering;

4 - creează un șir în notație arhitecturală;

5 - creează fracții simple.

Argumentul <precizie> corespunde numărului de zecimale. Exemple:

(rtos pi 5 8)

(rtos pi 1 4) "3.1416E+00"

15.3.9. Funcții grafice

Funcțiile grafice în AutoLISP se împart în două categorii principale: funcții pentru tratarea graficelor și funcții grafice pentru ecran. Se pot adăuga entități grafice la baza de date cu o categorie de funcții și manipula grafice pe ecranul calculatorului folosind cealaltă categorie de funcții.

Funcția (angle <pct1> <pct2>)

Această funcție returnează unghiul unei drepte ce unește punctul UCS <pct1> cu punctul UCS <pct2>. Acest unghi este măsurat în radiani în sens trigonometric față de direcția pozitivă a axei OX a planului curent. Exemplu:

(angle '(2.0 2.0) '(5.0 5.0))

Funcția (distance <pct1> <pct2>)

Această funcție returnează distanța 3D între punctele <pct1> și <pct2>. Dacă variabila de sistem FLATLAND este nenulă, DISTANCE așteaptă puncte 2D (coordonata z este ignorată). Exemplu:

(distance '(2.0 2.0) '(5.0 5.0))

Funcția (inters <pct1> <pct2> <pct3> <pct4> [<onseg>])

Funcția INTERS analizează două linii drepte și returnează punctul lor de intersecție sau nil dacă ele nu se intersectează. Parametrii <pct1> <pct2> sunt capetele primei drepte, iar <pct3> <pct4> sunt capetele celei de-a doua drepte.

Dacă este prezent și argumentul opțional <onseg> și este nil, atunci liniile definite de cele patru argumente <pct> sunt considerate de lungime infinită și INTERS returnează punctul lor de intersecție, chiar dacă acesta nu se află pe nici unul dintre segmentele determinate de acele puncte. Dacă argumentul <onseg> lipsește sau nu este nil, atunci punctul de intersecție trebuie să se afle între limitele de segment pentru a fi găsit de INTERS, altfel se returnează nil. Exemplu:

(setq a '(0 0) b'(1 1))

(setq c '(0 1) d '(1 0))

(inters a b c d)

Funcția (osnap <pct> <șir_mod>)

Această funcție returnează un punct care este rezultatul aplicării modurilor "object snap" descrise de <șir_mod> pe punctul <pct>. Exemplu:

(osnap '(1.0 1.0) "mid") nil

Dacă nu se găsește nici un punct care să întrunească acele condiții "object snap" exprimate de <șir_mod> pentru punctul <pct>, atunci se returnează nil.

Funcția (polar <pct> <unghi> <distanță>)

Această funcție returnează punctul UCS aflat la unghiul <unghi> și distanța <distanță> de punctul UCS <pct>. Parametrul <unghi> este exprimat în radiani față de direcția pozitivă a axei OX, în sens trigonometric. Deși <pct> poate fi un punct 3D, <unghi> este întotdeauna raportat (proiectat pe) planul curent de construcție. Dacă variabila de sistem FLATLAND este zero, se returnează un punct 3D, iar altfel 2D. Exemplu:

(polar '(0 0) 45.0 1)

Funcția (redraw [<nume_entitate> [<mod>]])

Funcțiea REDRAW fără argumente va reface imaginea curentă exact ca și comanda REDRAW din AutoCAD. Dacă este apelată cu un argument <nume_entitate> va fi redesenată entitatea selectată.

Funcția (trans <pct> <from> <to> [<disp>])

Această funcție translatează un punct dintr-un sistem de coordonate în altul. Argumentul <from> indică sistemul de coordonate în care este reprezentat punctul <pct>, iar <to> este un cod care specifică sistemul de coordonate dorit pentru punctul returnat. Argumentul opțional <disp>, dacă nu este nil, arată că <pct> este un vector 3D în loc de 2D. Argumentele <from> și <to> pot fi:

- 0 pentru WCS (World Coordonate System);

- 1 pentru UCS (User Coordonate System);

- 2 pentru viewport-ul curent;

- 3 pentru spațiul hârtie.

15.3.10. Funcții pentru introducerea datelor

Pentru a comunica cu AutoLISP-ul și prin el cu AutoCAD-ul, utilizatorul trebuie să introducă anumite valori. Există multe căi de comunicare cu AutoCAD-ul: pot fi tipărite răspunsurile de la tastatură, se pot alege valori dintr-un digitizor sau am putea folosi un mouse. AutoLISP-ul oferă un set de funcții cu ajutorul cărora putem comunica cu AutoCAD-ul.

Funcția (getangle [<pct>] [<prompt>])

Această funcție așteaptă introducerea de către utilizator a unui unghi; <prompt> este un șir opțional de afișat ca prompt, iar <pct> este un punct opțional 2D în UCS-ul curent. Unghiul este exprimat în radiani, cu respectarea planului curent de construcție. Se poate specifica un unghi prin introducerea unui număr în formatul curent de unghiuri al AutoCAD-ului, dar este returnat în radiani. Se poate da AutoLISP-ului unghiul dorit pe cale grafică prin indicarea a două puncte cu mouse-ul, astfel încât AutoCAD-ul să prezinte o linie elastică de la primul punct la punctul curent indicat pentru a vizualiza unghiul. Argumentul <pct> (dacă este specificat), va fi considerat primul dintre cele două puncte. Exemple:

(getangle)

(setq a '(12.34 45.67))

(getangle a "Dați cel de-al doilea punct: ")

Dați cel de-al doilea punct: 85.32,90.87

Funcția (getcorner <pct> [<prompt>])

Această funcție returnează un punct <pct> în UCS-ul curent, ca punct de bază și desenează un dreptunghi începând din acel punct, până în punctul dat cu mouse-ul. exemplu:

(getcorner '(10.00 12.35) "Click pentru punctul opus:") coordonatele punctului opus

Funcția (getdist [<pct>] [<prompt>])

Această comandă așteaptă introducerea unei distanțe de către utilizator. Parametrul <prompt> este un șir opțional ce va fi afișat ca prompt, iar <pct> este un punct de bază 2D sau 3D opțional din UCS-ul curent. Se poate specifica o distanță prin introducerea oricărui număr sau se pot da două puncte, iar AutoCAD-ul va returna distanța dintre ele. Exemplu:

(getdist '(17.32 20.35) "Faceți "click" pentru punctul 2 ") distanța dintre puncte

Funcția (getint [<prompt>])

Această funcție așteaptă introducerea unui întreg și returnează acel întreg. Valoarea poate varia de la -32768 la +32767, iar <prompt> este un șir opțional de afișat ca prompt. Exemplu:

(setq num (getint "Introduceți un număr:")

Funcția (getpoint [<pct>] [<prompt>])

Această funcție așteaptă introducerea unui punct <pct>. Parametrul <prompt> este un șir opțional de afișat ca promp. Se poate răspunde, specificând un punct prin indicare cu mouse-ul sau dându-i coordonatele. Exemple:

(setq p1 (getpoint "Introduceți un punct"))

(setq p2 (getpoint '(12.7 20.5) "Al doilea punct:"))

Funcția (getreal [<prompt>])

Această funcție așteaptă introducerea unui număr real și returnează acel număr real. Parametrul <prompt> este un șir opțional de afișat ca prompt. Exemplu:

(setq val (getreal "Introduceți un număr real:"))

Funcția (getstring [<cr>] [<prompt>])

Funcția "getstring" așteaptă introducerea unui șir și returnează acel șir. Dacă șirul este mai lung de 132 de caractere se returnează primele 132 de caractere. Dacă se adaugă și parametrul boolean <cr> care nu este nil, șirul introdus poate conține și blancuri (trebuind astfel să fie încheiat cu RETURN). Altfel, șirul de intrare este încheiat cu blanc sau RETURN. Exemple:

(setq s (getstring))

(setq s (getstring "Care este prenumele dv. ?))

(setq s (getstring T "Care este numele dv. ?))

15.3.11. Funcții pentru ieșire

În paragraful precedent s-a observat utilitatea unei forme a ecranului text la prompt-urile asociate cu familia de funcții "get". Acum vom vedea cum, cu ajutorul unor funcții, AutoLISP trimite textul pe ecran sau într-un fișier fără a aștepta răspunsul utilizatorului.

Funcția (prin1 [<expr> [<descriptor_fiș>]])

Această funcție tipărește expresia <expr> pe ecran sau într-un fișir și returnează <expr>. Dacă argumentul <descriptor_fiș> există și este valid, se presupune că un fișier a fost deschis și în acesta se va scrie expresia, altfel expresia este tipărită pe ecran. Expresia trebuie să fie de tipul permis de AutoLISP. Se pot tipări șiruri, numere întregi și reale printre multe tipuri admise. Exemplu:

(setq a 24.82)

(setq b '(m n))

(setq str "AutoCAD\nLISP")

(prin1 a) tipărește 24.82 și

(prin1 b) tipărește (m n) și (m n)

(prin1 str) tipărește "AutoCAD\nLISP" și "AutoCAD\nLISP"

Presupunând că "f" este un descriptor valid al unui fișier deschis pentru scris, la apelarea funcției:

(prin1 "AutoCAD" f)

calculatorul scrie "AutoCAD" în fișierul specificat și va returna "AutoCAD".

Funcția (princ [<expr> [<discriptor_fiș>]]) - este similară cu "prin1", dar eventualele caractere de control care apar în expresie nu sunt tipărite. Exemplu:

(setq str "AutoCAD\nLISP")

(princ str) tipărește: AutoCAD

LISP

și returnează "AutoCAD\nLISP"

Funcția (princ) scrisă fără expresie, determină AutoLISP să nu afișeze nimic pe linia de comandă.

Funcția (print [<expr> [<descriptor_fiș>]]) - face în mod esențial același lucru ca și "prin1". Singura diferență este că funcția "print" trece la o linie nouă înaintea tipăririi șirului și adaugă un blanc la sfârșit. Un șir ca "Acesta este șirul meu" este tipărit ca și cum ar fi fost "\nAcesta este șirul meu.\n", dar tipărit cu ajutorul funcției "prin1". Exemplu:

(setq str "AutoCAD\nLISP")

(print str) tipărește: linie nouă

"AutoCAD\nLISP" spațiu

și returnează "AutoCAD\nLISP"

Funcția (prompt <mesaj>)

Această funcție afișează <mesaj> (care este un șir) pe suprafața ecranului și returnează nil. Pe configurațiile AutoCAD cu două ecrane, funcția "prompt" afișează mesajul pe ambele ecrane și de aceea este preferabilă funcției "princ". Exemple:

(setq str "AutoCAD\nLISP")

(prompt str) tipărește: AutoCAD

LISP și nil

(prompt "Noua valoare:") tipărește Noua valoare: și nil.

Funcția (terpri) - realizează simpla cerință de tipărire pe ecran a unei singure linii și returnează nil. Exemplu:

(terpri) nil

și o nouă linie este afișată pe ecran.

15.3.12. Funcții pentru operații cu fișiere

AutoLISP este capabil să scrie și să citească fișiere, precum să și adauge noi date în acestea. Pentru a face acest lucru, AutoLISP ne oferă accesul la sistemul de operare a funcțiilor prin propriul său mecanism. Cine este familiarizat cu limbajul "C" va constata că mecanismul AutoLISP nu diferă mult de metodele de accesare a fișierelor pe care le știe deja.

Funcția (open <nume_fiș> <mod>) - deschide un fișier pentru accesarea funcțiilor AutoLISP de intrare/ieșire. Această funcție returnează un descriptor de fișier pentru a fi folosit de alte funcții de intrare/ieșire; de aceea trebuie să fie atribuită unui simbol folosind funcția "setq". Exemplu:

(setq a (open "test.lsp" "r"))

Argumentul <nume_fiș> este un șir care specifică numele și extensia fișierului care va fi deschis. Dacă numele fișierului se află într-un director (de exemplu "cad"), trebuie specificată și calea sub forma: "/cad/test.lsp". Argumentul <mod> este un simbol de citit/scris și trebuie să fie un șir care conține o singură literă mică, cu următoarele semnificații:

"r" - deschide fișierul pentru citit; dacă <nume_fiș> nu există, este returnat nil.

"w" - deschide fișierul pentru scris. Dacă <nume_fiș> nu există, un nou fișier este creat și deschis; dacă există deja, datele sunt scrise peste cele existente în fișier.

"a" - deschide fișierul pentru completare. Dacă <nume_fiș> nu există un nou fișier este creat și deschis; dacă <nume_fiș> există deja, el este deschis și pointer-ul va fi poziționat la sfârșitul ultimei date din fișier, iar noile date sunt scrise aici și adăugate la cele existente. În exemplele următoare vom presupune că numele fișierelor nu există:

(setq a (open "test1.txt" "w")) <File: #nnn>

(setq a (open "test2.lsp" "r")) nil

Funcția (close <descriptor_fiș>) - închide un fișier și returnează nil. Argumentul <descriptor_fiș> este un descriptor de fișier obținut de la funcția "open". După o închidere descriptorul de fișier este neschimbat, dar nu mai este valid. De exemplu, presupunând că "x" este un descriptor valid al fișierului deschis,

(close x) închide fișierul asociat și returnează nil.

Funcția (findfile <nume_fiș>)

Această funcție caută în biblioteca AutoCAD calea pentru fișierul specificat de <nume_fiș> și dacă acesta este găsit, returnează calea și numele fișierului. În exemplele următoare vom presupune că fișierul "prog1.lsp" există și se află în directorul /acad , fișierul "prog2 se află în directorul /acad/support și fișierul "prog3.lsp" nu există; atunci:

(findfile "prog1.lsp") "/acad/prog1.lsp"

(findfile "prog2.txt") "/acad/suport/prog2.txt"

(findefile "prog3.lsp") nil

Funcția (load <nume_fiș> [<onfailure>])

Această funcție încarcă un fișier de expresii AutoLISP și evaluează acele expresii. Parametrul <nume_fiș> este un șir care reprezintă numele fișierului fără extensie (aceasta fiind presupusă implicit ca fiind .LSP). În nume pot fi incluse calea și "drive"-ul, ca de exemplu "A:/programe/test". Dacă se folosesc backslash-uri pentru separarea subdirectoarelor, va trebui să utilizăm două caractere de acest fel pentru a obține un slash într-un șir; exemplu "A:\\programe\\test".

Dacă operația se încheie cu succes, LOAD returnează numele ultimei funcții definite în fișier. De exemplu, presupunând că fișierul test de mai sus cuprinde mai multe funcții, ultima fiind denumită FUNC, la încărcarea acestui fișier:

(load "test") este returnat FUNC

În cazul în care operația eșuează, apare un mesaj de eroare AutoLISP. Dacă, însă este furnizată o valoare pentru <onfailure>, LOAD returnează valoarea acestui argument în locul mesajului de eroare. Exemple:

(load "test1" "Greșit") Greșit

(load "test2") mesaj eroare AutoLISP

Funcția (read-char [<descriptor_fiș>]) - citește un singur caracter de la tastatură sau din fișierul deschis (descris prin <descriptor_fiș>) și returnează un cod ASCII (întreg) reprezentând caracterul citit. Dacă argumentul <descriptor_fiș> nu este specificat și nu există caractere date de la tastatură, funcția "read-char" așteaptă să le introducem. De exemplu, presupunând că nu s-a introdus nici un caracter,

(read-char)

așteaptă să introducem ceva. Dacă se introduce ABC urmat de Enter "read-char" returnează 65 (codul zecimal ASCII pentru litera A). La următoarele trei apelări, funcția "read-char" returnează 66 (litera B), 67 (litera C) și respectiv 10 (linie nouă). Dacă este apelată din nou, "read-char" așteaptă din nou introducerea unui caracter.

Funcția (read-line [<descriptor_fiș>]) - citește un șir de la tastatură sau dintr-un fișier deschis de <descriptor_fiș>. Dacă "read-line" ajunge la sfârșitul fișierului, returnează nil, altfel returnează șirul citit. Exemplu:

(read-line f)

unde "f" este un descriptor valid

Funcția (write-char <număr> [<descriptor_fiș>]) - scrie un caracter pe ecran sau în fișierul descris de <descriptor_fiș>. Argumentul <număr> este codul zecimal ASCII pentru caracterul care urmează să fie scris și reprezintă de asemenea valoarea returnată de funcție. Exemple:

(write-char 67) 67 și scrie litera C pe ecran.

Presupunând că "f" este un descriptor pentru un fișier deschis

(write-char 67 f) 67 și scrie litera C în fișier

Funcția (write-line <șir> [<descriptor_fiș>]) - scrie șirul pe ecran sau în fișierul deschis (descris de <descriptor_fiș>). Funcția returnează șirul menționat în mod normal, dar omite mențiunile când scrie în fișier. De exemplu, presupunând că "f" este un descriptor valid al unui fișier deschis

(writ-line "Test" f) scrie Test în fișier și "Test"