Définir des fonctions

Jusqu'à présent, nous avons tapé des expressions directement dans la ligne de commande. C'est utile pour tester, mais pour écrire de vrais programmes, il faut pouvoir regrouper des instructions et les réutiliser. C'est exactement ce que permettent les fonctions.

Créer une fonction avec defun

La fonction defun (define function) crée une nouvelle fonction :

(defun aire-cercle (rayon)
  (* pi (expt rayon 2))
)

Décortiquons cette définition :

• defun : mot-clé pour définir une fonction
• aire-cercle : le nom de la fonction
• (rayon) : la liste des arguments (ici, un seul)
• (* pi (expt rayon 2)) : le corps de la fonction

Pour utiliser cette fonction :

(aire-cercle 5)    ; → 78.5398
(aire-cercle 10)   ; → 314.159

Plusieurs arguments

Une fonction peut accepter autant d'arguments que nécessaire :

(defun volume-boite (longueur largeur hauteur)
  (* longueur largeur hauteur)
)

(volume-boite 10 5 3)  ; → 150

La valeur de retour

En AutoLISP, une fonction retourne la valeur de sa dernière expression. Il n'y a pas de mot-clé return :

(defun double (nombre)
  (* nombre 2)
)

(double 7)  ; → 14

Si votre fonction contient plusieurs expressions, c'est la dernière qui détermine la valeur de retour :

(defun saluer (nom)
  (princ (strcat "Bonjour " nom " !"))
  (terpri)   ; Retour à la ligne
  nil        ; Retourne nil pour éviter un écho parasite
)

Les variables locales

Par défaut, les variables créées avec setq dans une fonction sont globales : elles restent accessibles après l'exécution de la fonction. Cela peut causer des conflits. Pour éviter cela, déclarez vos variables comme locales en les listant après un / dans la liste d'arguments :

(defun aire-rectangle (longueur largeur / aire)
  (setq aire (* longueur largeur))
  aire
)

Ici :

• longueur et largeur sont des arguments
• aire (après le /) est une variable locale : elle n'existe que pendant l'exécution de la fonction

(aire-rectangle 10 5)  ; → 50
!aire                   ; → nil (la variable locale n'existe plus)

Sans le /, la variable aire resterait accessible en dehors de la fonction, ce qui pourrait interférer avec d'autres parties de votre programme.

Bonne pratique : déclarez toujours vos variables internes comme locales. Les seules variables qui devraient être globales sont celles que vous voulez explicitement partager entre plusieurs fonctions.

Créer des commandes AutoCAD avec c:

La fonctionnalité la plus puissante de defun en AutoLISP est la possibilité de créer de nouvelles commandes AutoCAD. Il suffit de préfixer le nom de la fonction par c: :

(defun c:bonjour ()
  (alert "Bonjour depuis ma commande personnalisée !")
  (princ)
)

Après avoir exécuté cette définition, vous pouvez taper BONJOUR directement dans la ligne de commande d'AutoCAD, comme n'importe quelle commande native !

Quelques points importants :

• Les commandes c: ne prennent pas d'arguments (la liste d'arguments est vide ())
• Elles peuvent avoir des variables locales : (defun c:macommande (/ variable1 variable2) ...)
• Le (princ) à la fin évite l'affichage d'une valeur de retour parasite dans la ligne de commande

Exemple : commande de calcul d'aire

Créons une commande qui demande à l'utilisateur le rayon d'un cercle et affiche l'aire :

(defun c:aire-cercle (/ rayon aire)
  (setq rayon (getreal "\nEntrez le rayon du cercle : "))
  (setq aire (* pi (expt rayon 2)))
  (alert
    (strcat "L'aire du cercle de rayon "
      (rtos rayon 2 2)
      " est "
      (rtos aire 2 2)
    )
  )
  (princ)
)

La fonction getreal affiche un message et attend que l'utilisateur entre un nombre réel. Nous verrons d'autres fonctions d'interaction utilisateur plus tard.

Écrire du code dans un fichier

Taper de longues fonctions dans la ligne de commande n'est pas pratique. En pratique, on écrit le code dans un fichier texte avec l'extension .lsp et on le charge dans AutoCAD.

L'éditeur recommandé : Visual Studio Code

Historiquement, AutoCAD incluait un éditeur intégré appelé VLIDE (Visual LISP IDE). Cet éditeur est aujourd'hui obsolète : son interface n'a pas évolué depuis les années 2000 et il ne bénéficie plus de mises à jour de la part d'Autodesk.

Depuis AutoCAD 2021, Autodesk recommande d'utiliser Visual Studio Code (VS Code) avec l'extension officielle AutoCAD AutoLISP Extension. VS Code est un éditeur gratuit, moderne et largement utilisé par les développeurs du monde entier.

Installer VS Code pour AutoLISP

1. Téléchargez et installez Visual Studio Code (attention, c'est différent de Visual Studio qui est un environnement de développement complet)
2. Installez l'extension AutoCAD AutoLISP Extension depuis le marketplace

Pourquoi préférer VS Code à VLIDE ?

VLIDE propose déjà la coloration syntaxique, un débogueur et une console AutoLISP. Mais VS Code va plus loin :

• Curseurs multiples, recherche avancée, raccourcis clavier puissants
• Refactorisation : renommage de variables, de fonctions et autres transformations automatiques du code
• Intégration Git pour gérer les versions de vos programmes
• Support de l'IA (GitHub Copilot, etc.) pour vous aider à écrire du code

Astuce : dans AutoCAD, la commande VLISP lance directement VS Code si la variable système LISPSYS est à 1 (valeur par défaut depuis AutoCAD 2021). Si vous êtes encore sur VLIDE, passez LISPSYS à 1 et relancez AutoCAD.

Créer et enregistrer un fichier .lsp

1. Dans VS Code, créez un nouveau fichier avec Ctrl+N
2. Sélectionnez le langage AutoLISP (Ctrl+K puis M)
3. Écrivez vos fonctions
4. Sauvegardez le fichier avec l'extension .lsp (par exemple mes-outils.lsp)

Vous pouvez exécuter votre code directement depuis VS Code avec Ctrl+F5, ou le charger manuellement dans AutoCAD.

Charger le fichier dans AutoCAD

Dans la ligne de commande d'AutoCAD, utilisez la commande APPLOAD ou tapez :

(load "C:/chemin/vers/mes-outils.lsp")

Toutes les fonctions définies dans le fichier deviennent immédiatement disponibles.

Astuce : dans les chemins de fichiers en AutoLISP, utilisez des barres obliques / (et non des antislash \), ou doublez les antislash \\.

Fonctions utiles d'interaction

Voici les fonctions de base pour interagir avec l'utilisateur :

;; Demander un nombre entier
(getint "\nEntrez un nombre entier : ")

;; Demander un nombre réel
(getreal "\nEntrez un nombre réel : ")

;; Demander une chaîne
(getstring "\nEntrez votre nom : ")
(getstring T "\nEntrez une phrase : ")  ; T autorise les espaces

;; Demander un point (clic dans le dessin)
(getpoint "\nCliquez un point : ")

;; Demander une distance
(getdist "\nIndiquez la distance : ")

Exemple complet : rectangle paramétrique

(defun c:rect-info (/ point1 longueur largeur aire perimetre)
  ;; Demander les dimensions
  (setq longueur (getreal "\nLongueur du rectangle : "))
  (setq largeur (getreal "\nLargeur du rectangle : "))

  ;; Calculer
  (setq aire (* longueur largeur))
  (setq perimetre (* 2 (+ longueur largeur)))

  ;; Afficher les résultats
  (alert
    (strcat
      "Rectangle " (rtos longueur 2 2) " x " (rtos largeur 2 2)
      "\n\nAire : " (rtos aire 2 2)
      "\nPérimètre : " (rtos perimetre 2 2)
    )
  )
  (princ)
)

Résumé

Concept	Syntaxe
Définir une fonction	(defun nom (args) corps)
Variables locales	(defun nom (args / locales) corps)
Créer une commande AutoCAD	(defun c:nom (/ locales) corps)
Éditeur recommandé	Visual Studio Code + extension AutoLISP
Exécuter depuis VS Code	Ctrl+F5
Charger un fichier	(load "chemin.lsp")
Demander un nombre	(getreal "message")
Demander un point	(getpoint "message")
Demander une chaîne	(getstring "message")

Dans le prochain chapitre, nous allons apprendre les structures de contrôle : comment prendre des décisions avec if et cond, et comment répéter des actions avec while et repeat.

---

Besoin d'un développement AutoCAD (AutoLISP, ObjectARX, .NET, VBA) ? Contactez-moi pour un devis gratuit.