CADxp: Éléments de syntaxe AutoLISP - CADxp

Aller au contenu

Page 1 sur 1
  • Vous ne pouvez pas commencer un sujet
  • Vous ne pouvez pas répondre à ce sujet

Éléments de syntaxe AutoLISP

#1 L'utilisateur est hors-ligne   (gile) 

  • ceinture rouge et blanche 8em dan
  • Groupe : Moderateurs
  • Messages : 11036
  • Inscrit(e) : 02-septembre 05

Posté 23 août 2008 - 13:59

Salut,

Ceci est un extrait d'un document (que je n'arrive pas à terminer) qui devrait servir de support de formation (j'en avais déjà livré des extraits ici et )
Il s'agit des bases de la syntaxe LISP dont la connaissance et la compréhension sont indispensables (à mon avis) pour l'apprentissage de ce langage.


1 Types d’expressions, types de données

Les expressions LISP se partagent entre deux types : liste et atome.
Tout ce qui n’est pas une liste est un atome (excepté nil qui symbolise à la fois rien/vide, une liste vide et la valeur Booléenne faux).

1.1 Les atomes

Les atomes peuvent être des expressions dites "autoévaluantes" :
- les nombres entiers, sans séparateur décimal : 1, -27, 23504 … (compris entre -2147483648 et 2147483647)
- les nombres réels, avec séparateur décimal, 1.0, 0.05, 3.375 …
- les chaînes, ensembles de caractères contenus entre des guillemets : "a", "Le résultat est : 128.5".

ou des expressions évaluables :
- les symboles, suites de caractères (exceptés parenthèses, guillemets, apostrophes, points et points virgules) non exclusivement constituées de chiffres.
Les symboles peuvent être liés à des fonctions (prédéfinies ou définies par l'utilisateur), ou à des données, dans ce cas, on parle de variables, les données stockées dans les variables peuvent être des expressions LISP et aussi des pointeurs vers des objets spécifiques (jeux de sélection, noms d’entités, descripteurs de fichiers…).
Certains symboles sont protégés (prédéfinis), outre les fonctions LISP prédéfinies, il s'agit de T, nil, pi et pause.

1.2 Les listes

La liste est l’expression fondamentale de tous les langages LISP.
Une liste commence avec une parenthèse ouvrante et se termine avec une parenthèse fermante, entre ces parenthèses, chaque élément est séparé par un espace. Les éléments constituant les listes sont des expressions LISP de tout type y compris des listes. Ces imbrications multiples expliquent la multiplication des parenthèses caractéristique à ce langage.

1.3 Nil

Le symbole nil est atypique en ce sens qu’il symbolise plusieurs concepts.
Il exprime la notion de vide : un symbole auquel aucune valeur n’est affectée est nil , une liste qui ne contient aucun élément est nil aussi.
Nil sert aussi pour exprimer le résultat Booléen faux (false) opposé à T vrai (true).
Bien que de type nil, nil est considéré à la fois comme une liste et comme un atome.
(type nil) retourne nil
(atom nil) retourne T
(listp nil) retourne T


2 Syntaxe et évaluation

Un programme LISP (langage dit « fonctionnel ») est essentiellement constitué d’appels de fonction.
Une fonction, en informatique comme en mathématique est un ensemble d’instructions qui retourne un résultat dépendant des arguments (paramètres) qui lui sont passés, les mêmes arguments passés à une fonction retourne toujours le même résultat.
Une expression LISP retourne toujours un résultat (fusse-t-il nil), il n’existe pas en LISP d’instruction qui ne retourne rien.

Le résultat de l’évaluation d’un appel de fonction est retourné à l’endroit même de cet appel.
AutoLISP® fournit de nombreuses fonctions prédéfinies.
La programmation LISP consiste à définir de nouvelles fonctions en utilisant les fonctions préexistantes, qu’elles soient prédéfinies ou définies par l’utilisateur.


2.1 Évaluation des applications de fonction

AutoCAD® intègre un interpréteur qui permet d’évaluer les expressions LISP.
L’interpréteur est accessible directement à la ligne de commande.

Les expressions de type liste destinées à être évaluées sont appelées des appels de fonction (ou applications de fonction).
La notation dite « préfixe » du LISP en détermine la structure : le premier élément est une fonction (opérateur), les suivants les arguments requis par cette fonction.

Suivant les fonctions les arguments peuvent être optionnels et leur nombre variable.

(fonction [argument …])

par exemple 2 + 3 s’écrit en LISP : (+ 2 3)

Commande: (+ 2 3)
5


L’évaluation d’une expression LISP commence par le contrôle de l’appariement des parenthèses.

Commande: (+ 2 3))
; erreur: parenthèse fermante supplémentaire en entrée


S’il manque une (ou des) parenthèse(s) fermantes, il est demandé à l’utilisateur de corriger :

Commande: (+ 2 3
(_>


Ceci fait, l’évaluation est faite et son résultat est retourné :

Commande: (+ 2 3
(_> )
5


Ensuite l’interpréteur recherche la définition de la fonction (premier terme de la liste). Si cette définition n’est pas trouvée, un message d’erreur est retourné :

Commande: (toto)
; erreur: no function definition: TOTO


Si la fonction est définie, la validité de chaque argument (termes suivants) est évaluée, au premier argument incorrect trouvé, un message d’erreur est retourné :

Commande: (+ "2" "3")
; erreur: type d'argument incorrect: numberp: "2"


Les arguments pouvant être aussi des applications de fonction, celles-ci seront évaluées tour à tour et les résultats retournés à l’endroit même de chaque expression.

Par exemple, dans l’expression : (sqrt (+ (* 4 4) (* 3 3))),
(+ (* 4 4) (* 3 3)) est l’argument de la fonction sqrt,
(* 4 4) et (* 3 3) les arguments de la fonction +,
4 et 4 ou 3 et 3 ceux de la fonction *.

L’évaluation procède de façon récursive en réduisant chaque appel de fonction à une expression autoévaluante à partir des expressions les plus imbriquées.
Le suivi de l’expression ci-dessus peut être décrit comme suit :

Saisie (* 4 4)
Résultat: 16
Saisie (* 3 3)
Résultat: 9
Saisie (+ 16 9)
Résultat: 25
Saisie (SQRT 25)
Résultat: 5.0


Soit : (sqrt (+ (* 4 4) (* 3 3))) => (sqrt (+ 16 (* 3 3))) => (sqrt (+ 16 9)) => (sqrt 25) => 5


2.2 Données sous forme de listes (quote)

AutoLISP® intègre de nombreuses fonctions qui requièrent comme argument une (ou des) liste(s). Ce type de liste est considéré comme une donnée unique, par exemple, un point se définit comme une liste de nombres réels, la liste de ses coordonnées : (x y [z]).
Ces listes n’étant pas des applications de fonction, il faut empêcher leur évaluation.
On utilise pour cela la fonction quote.
(quote expression)

(quote (1 2 3)) retourne (1 2 3)
(quote (+ 2 3)) retourne (+ 2 3)

Cette fonction, très largement utilisée, s’abrège avec une apostrophe :

‘(1 2 3) est équivalent à (quote (1 2 3))


PS : comme toujours, n'hésitez pas à me reprendre si je dis des bêtises...
[Edité le 23/8/2008 par (gile)]
Gilles Chanteau - gileCAD -
Développements sur mesure pour AutoCAD
Image IPB
0

#2 L'utilisateur est hors-ligne   lili2006 

  • ceinture rouge et blanche 8em dan
  • Groupe : Moderateurs
  • Messages : 11853
  • Inscrit(e) : 21-décembre 05

Posté 23 août 2008 - 14:30

Bonjour à toutes et tous,

En voilà un bon début,... ;)

Citation

(que je n'arrive pas à terminer)


Aie ! J'espère que si, :P

Je pense qu'on est nombreux sue ce site à être intéressé, pour preuve, on ne trouve ni formateur, ni livre pour débuter seul,... Et même si ce langage "semble" facilememt accessible,..seul, il faut pouvoir dégager suffisament de temps et de motivation,....

En tout cas, je t'encourage car on est aussi nombreux ici à te faire confiance dans ce que tu écris, ainsi que d'autres qui se reconnaîtrons,...

Il manque encore la rubrique "Tuto Lisp", merci Cadmin, ;)
0

#3 L'utilisateur est hors-ligne   (gile) 

  • ceinture rouge et blanche 8em dan
  • Groupe : Moderateurs
  • Messages : 11036
  • Inscrit(e) : 02-septembre 05

Posté 23 août 2008 - 14:49

Citation

pour preuve, on ne trouve ni formateur, ni livre pour débuter seul,...


Des livres, il en existe, des vieux et des plus récents. Tramber, entre autres, a souvent donné des liens (fais une recherche).
Des formateurs aussi, par exemple il me semble bien que Christian (rebcao) propose des formations LISP. Moi même, je suis prêt (enfin presque -mon support n'étant pas terminé) à étudier toute demande.
Gilles Chanteau - gileCAD -
Développements sur mesure pour AutoCAD
Image IPB
0

#4 L'utilisateur est hors-ligne   lili2006 

  • ceinture rouge et blanche 8em dan
  • Groupe : Moderateurs
  • Messages : 11853
  • Inscrit(e) : 21-décembre 05

Posté 23 août 2008 - 15:00

Re,


J'ai les supports de christian, ;)

Citation

Tramber, entre autres, a souvent donné des liens
, oui je les ai aussi !


Autant il y a des domaines que j'arrive à appréhender seul, autant là, je coince et ne fait "aucun" effort pour dégager suffisamment de temps, je dois bien le reconnaître,...

Pour moi, c'est un langage qu'il faut appréhender avec un formateur compétent et mettre les moyens car j'ai vu à maintes reprises l'intérêt d'être autonome dans cette discipline qu'est la "moyenne" programmation,...

Reste plus qu'à trouver le budget pour une formation (avec l'éducation Nationale,....) en ce qui me concerne,...

J'espère un jour,...
0

#5 L'utilisateur est hors-ligne   Tramber 

  • ceinture rouge et blanche 8em dan
  • Groupe : Moderateurs
  • Messages : 8433
  • Inscrit(e) : 29-mars 03
  • LocationStrasbourg

Posté 14 février 2009 - 22:54

Et moi j'espère qu'on fera nous-même un jour des rencontres utilisateurs.
C'est plus sympa et plus efficace que n'importe quoi pout aborder de pareils thèmes....
Image IPB

Bureau d'études dessin.
Spécialiste Escaliers
Développement - Formation

./__\.
(.°=°.)
0

#6 L'utilisateur est hors-ligne   lili2006 

  • ceinture rouge et blanche 8em dan
  • Groupe : Moderateurs
  • Messages : 11853
  • Inscrit(e) : 21-décembre 05

Posté 14 février 2009 - 23:58

Bonsoir à toutes et tous,

On est sur la même longueur d'ondes Tramber, :P
0

#7 L'utilisateur est hors-ligne   mudyf8 

  • ceinture blanche
  • Groupe : Membres
  • Messages : 1
  • Inscrit(e) : 14-mars 10

Posté 04 avril 2010 - 17:56

bonjour a tous je sui nouveau sur ce site et j'aimerai avoir des renseignement a propos des commandes autocad dans un programme lisp :)
0

#8 L'utilisateur est hors-ligne   (gile) 

  • ceinture rouge et blanche 8em dan
  • Groupe : Moderateurs
  • Messages : 11036
  • Inscrit(e) : 02-septembre 05

Posté 04 avril 2010 - 18:18

Salut et bienvenue,

La fonction command permet d'appeler depuis une expression LISP les commandes natives d'AutoCAD®. Les arguments pour la fonction command sont le nom de la commande suivi des options et entrées nécessaire à son exécution.

Pour les commandes ayant une version "ligne de commande" et une version "boite de dialogue", c'est la première qui est utilisée par défaut. Pour forcer l'ouverture de la boite de dialogue, il faut faire précéder l'appel à command par l'expression :
(initdia)


command utilisé sans arguments
(command)
équivaut à un Échap.

Une chaîne vide (blank) "" utilisée comme argument équivaut à un Enter.

pause utilisé comme argument interrompt l'exécution pour permettre une entrée par l'utilisateur.

Lorsque l'argument requis pour la fonction command est un nombre (ou une liste de nombres), il peut être spécifié indifféremment sous la forme d'un entier, d'un réel (ou une liste d'entiers ou de réels) ou d'une chaîne de caractères.
(command "_circle" '(0 0 0) 10)
ou
(command "_circle" '(0.0 0.0 0.0) 10.0)
ou
(command "_circle" "0.0,0.0,0.0" "10.0")


Il est important de noter que lors de l'exécution de la fonction command les accrochages aux objets permanents sont actifs. Il est donc prudent de les désactiver temporairement pour s'assurer que les entités seront créées précisément sur les points spécifiés. Une méthode consiste à utiliser l'option "auc" ou de préférence "_non" avant de spécifier le point pour forcer l'accrochage à "aucun".
Par ailleurs les paramètres requis par la fonction command sont les mêmes que ceux entrés à la ligne de commande : les points sont exprimés en coordonnées SCU courant, les angles dans le système d'unité courant etc.
(command "_line" "_non" '(0 0) "_non" '(20 10) "")


NOTA : Pour une meilleure compatibilité entre les différentes versions d'AutoCAD® est préférable d'utiliser, pour les noms de commande et leurs options, les noms en langage international. Ces noms sont précédés d'un tiret bas (underscore). La fonction AutoLISP getcname traduit les noms de commande exprimés dans la langue de la version courante en langage international et vice-versa :

(getcname "ligne") retourne: "_LINE"
(getcname "_move") retourne : "DEPLACER"


Gilles Chanteau - gileCAD -
Développements sur mesure pour AutoCAD
Image IPB
0

#9 L'utilisateur est hors-ligne   VDH-Bruno 

  • ceinture noire 1er dan
  • Groupe : Membres
  • Messages : 916
  • Inscrit(e) : 29-avril 10

Posté 07 novembre 2010 - 00:10

Bonsoir (gile)

A l’occasion de mes différents tests et évaluations.. J’en profite pour apporter ma petite contribution à ton post..

Citation

- les nombres entiers, sans séparateur décimal : 1, -27, 23504 … (compris entre -2147483648 et 2147483647)
- les nombres réels, avec séparateur décimal, 1.0, 0.05, 3.375 …


Tests qui ont été motivé par ta remarque dans ce sujet. En cherchant si la limite de calcul avec des réels seraient atteinte avant la limite de la pile d’appel..

Citation

avec la fonction factorielle c'est la limite des entiers positifs (2147483647) qui sera atteint avant



Les entiers

Codes:
;; Vérif de la limite supérieur des entiers

(defun entsup	()

  (setq ent 2147483645)

  (while (< ent (1+ ent))

    (setq ent (1+ ent))

  ) ;_ Fin de while

) ;_ Fin de defun


;; Vérif de la limite inférieur des entiers

(defun entinf	()

  (setq ent -2147483645)

  (while (> ent (1- ent))

    (setq ent (1- ent))

  ) ;_ Fin de while

) ;_ Fin de defun


Console VLisp:
ENTSUP 

_$ (entsup)

2147483647

_$ 


ENTINF 

_$ (entinf)

-2147483648


Sur la vérification de l’intervalle donné pour les entiers, rien à dire c’est les essais auxquelles je me suis livré pour arriver à ces lignes de codes qui sont intéressants


Retour d’expérience :

1èrè constatation
Je te laisse méditer sur le résultat retourné par ces lignes de codes..

(defun entsup ()

  (setq ent 2147483645)

  (while  ent

    (setq ent (1+ ent))

    )

  )


Je pensai naïvement pouvoir m’affranchir du teste (< ent (1+ ent)) dans la boucle while, et profiter d’une erreur (interruption du programme) de l’interpréteur sur la limite des entiers. Puis ensuite interroger la variable définie globalement pour connaître la limite..

Mais que nenni le code à tourné en continue, j’ai du interrompre son exécution, lorsque j’ai interrogé la variable qu’elle fut ma surprise de constater :

_$ (entsup)

_$ 

_$ ent

-2084132982

_$


Comme si après avoir atteint sa limite haute, elle continuait son incrémentation depuis sa limite basse.. (J’ai recommencé plusieurs fois le teste, résultat toujours aussi surprenant..)

2ème constatation

La saisie d’un nombre entier supérieur à sa limite (sup ou inf) le convertie automatiquement en nombre réel

 _$ (setq int+ 9999999999999999999)

1.0e+019

_$ (setq int- -9999999999999999999)

-1.0e+019


Ce qui n’heurte pas spécialement ma compréhension des choses. Contrairement au cas précédent.


Les réels

De par leur nature il est plus difficile de fixer un intervalle (comme dans le cas des entiers), de ce que j’avais pu en lire: les nombres réels sont calculés avec une précision de 14 chiffres significatifs,

Le problème c’est qu’il me semble avoir dépassé cette limite de chiffre significatif dans mes tentatives, je n’ai pas encore trouvé l’algorithme probant qui définirai le nombre de chiffres significatifs d’un nombre réels (ce n’est pas encore ma priorité du moment en matière de Lisp)

Voilà si tout cela peut alimenter ce post sur les types de donnée c’est tant mieux..

Amicalement Bruno

0

#10 L'utilisateur est hors-ligne   (gile) 

  • ceinture rouge et blanche 8em dan
  • Groupe : Moderateurs
  • Messages : 11036
  • Inscrit(e) : 02-septembre 05

Posté 07 novembre 2010 - 12:19

Salut,

Dans AutoLISP les entiers relatifs sont codés sur 32 bits, d'où les limites -2^31 et 2^31 - 1

D'autres langages de programmation ont plusieurs types d'entiers codés sur 8 (byte), 16, 32 et 64 bits (ce qui permet d'optimiser l'utilisation de la mémoire).
C# propose même des types d'entiers non signés (toujours positifs) ce qui permet de doubler la limite supérieure pour le même nombre de bits.

Le dépassement de ces limites avec AutoLISP ne provoque pas d'erreur, mais est géré différemment suivant comment il est atteint.
Si une valeur au delà des limites est entrée directement, elle est automatiquement convertie en réel.
Mais si le résultat d'une opération arithmétique sur des entiers dépasse les limites, ce résultat sera faux :
(+ 2147483647 1) retourne -2147483648
(+ 2147483647 3) retourne -2147483646
Ces résultats sont cohérents avec la manière dont sont codés les entiers relatifs (voir ici)

Voir, dans l'aide aux développeurs > AutoLISP Developer's Guide > Using the AutoLISP Language > AutoLISP Basics > AutoLISP Data Types > Integers

Les nombres réels sont, dans AutoLISP, codés en "double précision" à "virgule flottante (on peut considérer que la précision d'un 'double' est de 15 chiffres significatifs)
À cause de la manière dont sont codes les nombres réels en système binaire, il peuvent être entachés d'une imprécision, certes infime mais dont il faut tenir compte lors de comparaisons.
Par exemple, 0,625 est représenté avec exactitude parce qu'on peut le décomposer en puissances de 2 :
0.625 = 0.5 + 0.125 = 2^-1 + 2^-3
Il n'en va pas de même pour 0.001 (et la plupart des nombres réels) dont on aura toujours qu'une approximation qui même si elle est très précise n'en reste pas moins une approximation.



Gilles Chanteau - gileCAD -
Développements sur mesure pour AutoCAD
Image IPB
0

#11 L'utilisateur est hors-ligne   VDH-Bruno 

  • ceinture noire 1er dan
  • Groupe : Membres
  • Messages : 916
  • Inscrit(e) : 29-avril 10

Posté 07 novembre 2010 - 12:37

Merci (gile) pour toutes ces précisions trés intéressantes pour quelqu'un qui comme moi cherche à comprendre, mais dont la culture lui fait cruellement défaut en la matière..
Tes interventions (et liens) en la matière me "prémâche" grandement le travail et je t'en suis trés reconnaissant :D

A+
(Ps: en espérant ne pas devenir trop épuisant à la longue avec mes pseudo-réflexions)
0

#12 L'utilisateur est hors-ligne   DenisHen 

  • ceinture rouge et blanche 6em dan
  • Groupe : Membres
  • Messages : 3118
  • Inscrit(e) : 17-décembre 05
  • LocationSAINT FLORENTIN (Yonne)

Posté 15 février 2011 - 13:30

Bonjour à tous...

Ce sujet tombe à pic...

J'ai développé des dizaines de petites macros en LiSP dans plusieurs ".lsp"... qui sont associées à des menus AutoCAD...

Je m'y replonge depuis quelques semaines et je m’aperçois que je n'ai rien partagé, ce qui n'est pas bien car sans partage, je n'y serais jamais parvenu...

Mon premier souci, c'est de commenter un maximum pour éventuellement en faire un petit "tuto". Ce que je suis sur le point de faire (en fait, cette semaine).

Mon deuxième souci, comment poster le tout, ".lsp", ".mnu"/".mns", ".cui", ".dwg"... Ainsi que la structure des répertoires...
/Support
/Menu
/Block
/...
pour qu'un novice puisse l'installer et en profiter sans y perdre tous ses cheveux...

Mais je vais sérieusement me pencher sur cette question...

Merci encore pour toutes vos aides...

Denis...


LinkedIn et mon site...
Windows 10 Pro 64bits / AutoCAD MAP 3D 2018.0.2
Covadis 16 / Microstation V8i

Sur terre, il y a 10 types de personnes, celles qui comptent en binaire et les autres...
Davantage d'avantages, avantagent davantage. (Bobby Lapointe)
La connaissance s'accroît quand on la partage.(Socrate)
0

Partager ce sujet :


Page 1 sur 1
  • Vous ne pouvez pas commencer un sujet
  • Vous ne pouvez pas répondre à ce sujet

1 utilisateur(s) en train de lire ce sujet
0 membre(s), 1 invité(s), 0 utilisateur(s) anonyme(s)