Gérer un fichier de configuration en AutoLISP

Quand on développe un programme AutoLISP, on a souvent besoin de stocker des paramètres de configuration : un répertoire de sortie, une unité de mesure, un préfixe de nommage, etc.

Le premier réflexe est de penser à un format texte classique comme le .ini :

[general]
unit=cm
output-directory=C:\Output

Mais cela implique d'écrire un analyseur syntaxique (parser) pour lire les sections, les clés et les valeurs. C'est faisable, mais fastidieux.

Tirer parti de la syntaxe d'AutoLISP

AutoLISP est un dialecte de Lisp, et en Lisp, le code et les données partagent la même syntaxe : les listes. On peut donc écrire un fichier de configuration directement sous forme de liste associative, et le charger avec la fonction native read.

Voici un exemple de fichier de configuration Config.cfg :

(
  ("unit" . "cm")
  ("output-directory" . "C:\\Output")
)

C'est une liste de paires pointées (dotted pairs). Chaque paire associe une clé (une chaîne) à une valeur. C'est l'équivalent d'un dictionnaire en Python ou d'un Dictionary<string, string> en .NET.

Charger la configuration

La fonction load-configuration ouvre le fichier, lit toutes les lignes, les concatène, puis utilise read pour transformer le texte en une liste AutoLISP :

;;; Charge une configuration depuis un fichier (liste associative).
;;; path : chemin du fichier de configuration
;;; Retourne la liste associative, ou nil en cas d'erreur
(defun load-configuration (path / file content line configuration)
  (setq file (open path "r"))
  (if file
    (progn
      (setq content "")
      (while (setq line (read-line file))
        (setq content (strcat content line))
      )
      (close file)
      (setq configuration (read content))
      configuration
    )
    (progn
      (princ (strcat "\nErreur : impossible d'ouvrir le fichier " path))
      nil
    )
  )
)

La magie opère à la ligne (read content) : la fonction read d'AutoLISP analyse (parse) le texte et reconstruit la structure de données. Pas besoin d'écrire un analyseur : le langage s'en charge.

Lire et modifier des valeurs

Une fois la configuration chargée dans une variable globale *CONFIG*, on peut lire une valeur avec assoc et la modifier avec subst.

Convention de nommage : en AutoLISP, toute variable non déclarée après le / dans la liste des arguments est globale. Pour bien distinguer les variables globales des variables locales, on utilise une convention de nommage. Ici, les astérisques autour de *CONFIG* signalent immédiatement qu'il s'agit d'une variable globale. Cette notation s'inspire de *error*, la fonction globale bien connue d'AutoLISP qui permet d'installer un gestionnaire d'erreurs personnalisé. On peut aussi utiliser le préfixe $, par exemple $config. L'important est de choisir une convention et de s'y tenir.

;;; Retourne la valeur associée à une clé dans la configuration
(defun get-configuration-value (key)
  (cdr (assoc key *CONFIG*))
)

;;; Modifie ou ajoute une valeur dans la configuration
(defun set-configuration-value (key value / old)
  (setq old (assoc key *CONFIG*))
  (if old
    (setq *CONFIG* (subst (cons key value) old *CONFIG*))
    (setq *CONFIG* (cons (cons key value) *CONFIG*))
  )
)

La fonction get-configuration-value utilise assoc pour trouver la paire correspondant à la clé, puis cdr pour en extraire la valeur.

La fonction set-configuration-value distingue deux cas :

• Si la clé existe déjà, subst remplace l'ancienne paire par la nouvelle.
• Sinon, cons ajoute la nouvelle paire en tête de liste.

Exemple d'utilisation

(defun C:TESTCONFIG ()
  (setq *CONFIG* (load-configuration "C:\\Temp\\Config.cfg"))
  (if *CONFIG*
    (progn
      (princ (strcat "\nUnité : " (get-configuration-value "unit")))
      (princ (strcat "\nRépertoire de sortie : " (get-configuration-value "output-directory")))
    )
    (princ "\nÉchec du chargement de la configuration.")
  )
  (princ)
)

Résultat dans la console d'AutoCAD :

Unité : cm
Répertoire de sortie : C:\Output

Sauvegarder la configuration

On peut aussi écrire une fonction pour sauvegarder la configuration modifiée :

;;; Sauvegarde la configuration dans un fichier
;;; path : chemin du fichier de configuration
;;; Retourne T en cas de succès, nil sinon
(defun save-configuration (path / file pair)
  (setq file (open path "w"))
  (if file
    (progn
      (write-line "(" file)
      (foreach pair *CONFIG*
        (write-line
          (strcat "  (\"" (car pair) "\" . \"" (cdr pair) "\")")
          file
        )
      )
      (write-line ")" file)
      (close file)
      T
    )
    (progn
      (princ (strcat "\nErreur : impossible d'écrire dans le fichier " path))
      nil
    )
  )
)

On écrit chaque paire sur une ligne séparée pour garder le fichier lisible.

Conclusion

En utilisant la syntaxe native d'AutoLISP comme format de données, on obtient un système de configuration simple et efficace sans avoir besoin d'écrire d'analyseur syntaxique. La fonction read fait tout le travail.

---

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