(gile)

Salut, Si tu as une version pleine, regarde le plugin Increment qui fait ce que tu demandes et bien plus.

Attention, l'ordre dans lequel les rotations sont effectué importe. Des rotations successives sur X, puis Y, puis Z ne donnent pas le me^me résultat que des rotations sur Z, puis Y, puis X. La routine TaitBryan renvoie la liste des angles des rotations sur Z, Y et X d'un bloc qui a subit des rotations successives sur X, puis Y, puis Z. La routine ProperEuler renvoie la liste des angles des rotations sur Z, X et Z d'un bloc qui a subit des rotations successives sur Z, puis X, puis Z. La dernière valeur retournée correspond à la première rotation sur Z, c'est la valeur de la propriété Rotation dans AutoCAD.

Un exemple de commande qui affiche les résultats en ligne de commande dans les unités angulaires courantes. (defun c:EULERANGLES (/ bloc matrice precession nutation lacet tangage roulis) (while (not (and (setq bloc (nentsel "\nSélectionnez une entité du bloc: ")) (= (length bloc) 4) ) ) ) (setq matrice (caddr bloc)) (mapcar '(lambda (s v) (prompt (strcat "\n" s ": " (angtos v)))) '("precession" "nutation" "rotation") (ProperEuler matrice)) (mapcar '(lambda (s v) (prompt (strcat "\n" s ": " (angtos v)))) '("lacet" "tangage" "roulis") (TaitBryan matrice)) (princ) )

Dans la liste renvoyée par nentsel ou nentselp la matrice de transformation occupe la troisième place. Il faut donc faire: (ProperEuler (caddr (nensel)))

Salut, Les références de bloc insérées dans le dessin ne sont que des référence à une définition de bloc. Les référence de bloc ne contiennent pas d'entité à proprement parler, c'est la définition de bloc qui contient les entités. En programmation, on peut accéder directement à la définition du bloc et donc aux entités qu'elle contient. Avec AutoLISP, la fonction tblsearch permet d'accéder aux enregistrements dans une table, par exemple : (tblsearch "BLOCK" "nomDuBloc") renvoie une liste type DXF pour la définition du bloc "nomDuBloc", dans cette liste, le groupe DXF -2 pointe sur la première entité dans la définition du bloc. On accède aux suivantes avec entext généralement dans une boucle while. Avec Visual LISP, on accède à la table des blocs par : (vla-get-Blocks (vla-get-ActiveDocument (vlax-get-acad-object))) puis on accède à une définition avec la fonction vla-Item et on peut parcourir les entités contenues dans la définition avec vlax-for.

Salut, La demande m'en a été faite par message privé et, comme à mon habitude, j'ai conseillé au demandeur de démarrer un sujet sur CADxp afin que toute la communauté bénéficie de la discussion. Comme il n'y a toujours aucune demande à ce propos et que je mes suis penché sur la question, je démarre moi-même le sujet. La demande concernait un équivalent en LISP des réponses données en C# dans cette discussion. Rapidement pour le non-anglophones, il s'agissait de retrouver les angles d'Euler (lacet, tangage, roulis ou yaw, pitch, roll en anglais). En faisant quelques recherche, j'ai trouvé que la demande concernait une forme particulière des angles d'Euler appelés aussi angles de Tait Bryan qui utilisait d'autres axes de rotation que la forme classique (appelée proper Euler par les anglo-saxons). Pour faire court, les angles de Tait Bryan reflètent des rotations successives sur les axes X, Y puis Z et les angles d'Euler "propres" des rotations successives sur les axes Z, puis X, puis à nouveau Z. On peut noter que dans AutoCAD, la première rotation sur Z correspond à la rotation du bloc et les rotations sur X puis Z, au changement de plan. ;; gc:butLast ;; Retourne la liste privée du dernier élément ;; ;; Argument ;; l : une liste (defun gc:butLast (l) (reverse (cdr (reverse l)))) ;; gc:GetNormal ;; Retourne le vecteur unitaire d'un vecteur ;; ;; Argument ;; v : un vecteur (defun gc:GetNormal (v) ((lambda (l) (if (/= 0 l) (mapcar (function (lambda (x) (/ x l))) v) ) ) (distance '(0. 0. 0.) v) ) ) ;; TRP ;; Transpose une matrice -Doug Wilson- ;; ;; Argument ;; m : une matrice (defun trp (m) (apply 'mapcar (cons 'list m))) ;; gc:acos ;; Retourne l'arc cosinus du nombre ;; ;; Argument ;; n : le cosinus de l'angle (defun gc:acos (n) (cond ((equal n 1. 1e-9) 0.) ((equal n -1. 1e-9) pi) ((< -1. n 1.) (atan (sqrt (- 1. (expt n 2))) n) ) ) ) ;; gc:asin ;; Retourne l'arc sinus du nombre ;; ;; Argument ;; n : le sinus de l'angle (defun gc:asin (n) (cond ((equal n 1. 1e-9) (/ pi 2.)) ((equal n -1. 1e-9) (/ pi -2.)) ((< -1. n 1.) (atan n (sqrt (- 1 (expt n 2)))) ) ) ) ;; ProperEuler ;; Renvoie une liste contenant les angles d'Euler en radians (précession, nutation et rotation propre) ;; ;; Argument ;; m : une matrice de transformation telle que celle renvoyée par nentsel ou nentselp (defun ProperEuler (m / theta psi phi) (setq m (mapcar 'gc:GetNormal (if (= (length (car m)) 3) (mapcar 'gc:butlast (trp m)) (gc:butlast (mapcar 'gc:butlast m)) ) ) ) (setq theta (gc:acos (caddr (caddr m)))) (if (< (abs theta) 1e-7) (setq theta 0. psi 0. phi (atan (car (cadr m)) (cadr (cadr m))) ) (setq psi (atan (caddr (car m)) (- (caddr (cadr m)))) phi (atan (car (caddr m)) (cadr (caddr m))) ) ) (list psi theta phi) ) ;; TaitBryan ;; Renvoie une liste contenant les angles de Tait-Bryan en radians (lacet, tangage, roulis ou yaw, pitch, roll) ;; ;; Argument ;; m : une matrice de transformation telle que celle renvoyée par nentsel ou nentselp (defun TaitBryan (m / a b c) (setq m (mapcar 'gc:GetNormal (if (= (length (car m)) 3) (mapcar 'gc:butlast (trp m)) (gc:butlast (mapcar 'gc:butlast m)) ) ) ) (setq b (- (gc:asin (car (caddr m))))) (cond ((< (abs (- b (* pi 0.5))) 1e-7) (setq b (* pi 0.5) a (atan (caddr (cadr m)) (cadr (cadr m))) c 0. ) ) ((< (abs (+ b (* pi 0.5))) 1e-7) (setq b (* pi -0.5) a (atan (- (caddr (cadr m))) (cadr (cadr m))) c 0. ) ) (T (setq a (atan (car (cadr m)) (car (car m))) c (atan (cadr (caddr m)) (caddr (caddr m))) ) ) ) (list a b c) )

Tu ne fais probablement rien "de mal". C'est juste qu'il n'y a aucune magie dans la programmation et que cette (ou ces) routines ne sont pas adaptées à ton besoin.

Salut, La première version est ici, la seconde là.

Salut, Et avec la commande MODIFLONG (_LENGTHEN), option TOtal ?

La fonction wcmatch n'est pas assez puissante pour pour déterminer si une chaîne représente un nombre, mais les expressions régulières permettent ça et beaucoup plus (des exemples avec les nombres réponse #3).

Pour avoir la réponse, tu n'as qu'à tester, c'est si simple en LISP d'entrer une expression à la ligne de commande ou dans la Console Visual LISP...

Salut, (numberp (read ch))

Salut, regarde les fonctions strcat, strcase et substr (ou la section 14 de Introduction à AutoLISP). (strcat (strcase (substr texte 1 1)) (strcase (substr texte 2) T))

Salut, As-tu référencé AdWindows.dll ?

Salut, Qu'est-ce que tu veux dire par : "Ssmatch ne fonctionne pas avec Autocad 2019 !" ? Chez moi, sur AutoCAD 2007 à 2020, tout semble fonctionner correctement. Le code est du LISP basique et je ne vois aucune raison qui pourrait faire qu'il ne fonctionne plus avec AutoCAD 2019.

Alors, il suffit d'aller dans la définition du bloc dynamique (pas d'un bloc anonyme) de rechercher les définitions d'attributs selon test critères et de les effacer. private static void EraseAttrib(Database db, string blockName, string tag) { using (var tr = db.TransactionManager.StartTransaction()) { var bt = (BlockTable)tr.GetObject(db.BlockTableId, OpenMode.ForRead); if (!bt.Has(blockName)) return; var btr = (BlockTableRecord)tr.GetObject(bt[blockName], OpenMode.ForRead); foreach (ObjectId id in btr) { if (id.ObjectClass == RXObject.GetClass(typeof(AttributeDefinition))) { var attDef = (AttributeDefinition)tr.GetObject(id, OpenMode.ForRead); if (attDef.Tag == tag) { tr.GetObject(id, OpenMode.ForWrite); attDef.Erase(); } } } tr.Commit(); } }

Salut, Il faudrait que tu sois plus clair dans ta demande. Parles-tu de définitions de bloc (BlockTableRecord) et de définitions d'attributs (AttributeDefinition) ou de références de block (blockReference) et de références d'attributs (AttributeReference) ? Dans le premier cas, il faudra "synchroniser" les attributs pour que les modifications soient reflétées dans les références insérées. Dans le second cas, les modifications faites aux références uniquement seront annulées en cas de synchronisation des attributs (ATTSYNC).

J'ai laissé un petit mot sur TheSwamp qu'il fréquentait aussi. Sa réputation ne se limitait pas au microcosme francophone.

Il était un pilier de CADxp, sa générosité sans bornes est connue de tous ici où peu n'ont jamais utilisé au moins une de ses routines. Il fut un de mes mentors quand je débutais en LISP et je ne pourrais jamais assez le remercier de m'avoir poussé à utiliser Visual LISP. C'était certainement le plus pointu d'entre-nous pour dénicher et utiliser les "ActiveX". Patrick_35 nous a quitté en mars, il nous laisse une fantastique bibliothèque de routines que malheureusement peu d'entre-nous seront capable de maintenir. Merci pour tout Patrick, les mots me manquent...

Très étrange... Il ne s'agit pas du (vl-load-com) qui est bien présent au début du code. Soit tu n'as pas bien copié tout le code, soit ton AutoCAD est abimé (essaye une réparation ou une réinstallation).

Salut, Je ne sais pas quel LISP tu as essayé, mais avec celui-ci, ça ne devrait pas être trop fastidieux. EL2PL transforme les ellipses ou arcs elliptiques sélectionnés en polylignes. ;; EllipseToPolyline ;; Retourne une polyline (vla-object) qui est une approximation de l'ellipse (ou de l'arc elliptique) ;; ;; Argument : une ellipse (vla-object) (defun EllipseToPolyline (el / doc cl norm cen elv pt0 pt1 pt2 pt3 pt4 ac0 ac4 a04 a02 a24 bsc1 bsc2 bsc3 bsc4 plst blst spt spa fspa srat ept epa fepa erat n ) (vl-load-com) (setq doc (vla-get-ActiveDocument (vlax-get-acad-object)) spc (if (= 1 (getvar 'cvport)) (vla-get-PaperSpace doc) (vla-get-ModelSpace doc) ) cl (and (= (vla-get-StartAngle el) 0.0) (= (vla-get-EndAngle el) (* 2 pi)) ) norm (vlax-get el 'Normal) cen (trans (vlax-get el 'Center) 0 norm) elv (caddr cen) cen (3dTo2dPt cen) pt0 (mapcar '+ (trans (vlax-get el 'MajorAxis) 0 norm) cen) ac0 (angle cen pt0) pt4 (mapcar '+ cen (trans (vlax-get el 'MinorAxis) 0 norm)) pt2 (3dTo2dPt (trans (vlax-curve-getPointAtparam el (/ pi 4.)) 0 norm)) ac4 (angle cen pt4) a04 (angle pt0 pt4) a02 (angle pt0 pt2) a24 (angle pt2 pt4) bsc1 (/ (ang<2pi (- a02 ac4)) 2.) bsc2 (/ (ang<2pi (- a04 a02)) 2.) bsc3 (/ (ang<2pi (- a24 a04)) 2.) bsc4 (/ (ang<2pi (- (+ ac0 pi) a24)) 2.) pt1 (inters pt0 (polar pt0 (+ ac0 (/ pi 2.) bsc1) 1.) pt2 (polar pt2 (+ a02 bsc2) 1.) nil ) pt3 (inters pt2 (polar pt2 (+ a04 bsc3) 1.) pt4 (polar pt4 (+ a24 bsc4) 1.) nil ) plst (list pt4 pt3 pt2 pt1 pt0) blst (mapcar '(lambda (B) (tan (/ b 2.))) (list bsc4 bsc3 bsc2 bsc1) ) ) (repeat 2 (foreach b blst (setq blst (cons b blst)) ) ) (foreach p (cdr plst) (setq ang (angle cen p) plst (cons (polar cen (+ ang (* 2 (- ac4 ang))) (distance cen p)) plst ) ) ) (foreach p (cdr plst) (setq ang (angle cen p) plst (cons (polar cen (+ ang (* 2 (- ac0 ang))) (distance cen p)) plst ) ) ) (setq pl (vlax-invoke spc 'AddLightWeightPolyline (apply 'append (setq plst (reverse (if cl (cdr plst) plst ) ) ) ) ) ) (vlax-put pl 'Normal norm) (vla-put-Elevation pl elv) (mapcar '(lambda (i v) (vla-SetBulge pl i v)) '(0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16) blst ) (if cl (vla-put-Closed pl :vlax-true) (progn (setq spt (vlax-curve-getClosestPointTo pl (vlax-get el 'Startpoint)) spa (vlax-curve-getParamAtPoint pl spt) fspa (fix spa) ept (vlax-curve-getClosestPointTo pl (vlax-get el 'Endpoint)) epa (vlax-curve-getParamAtPoint pl ept) fepa (fix epa) n 0 ) (cond ((equal spt (trans pt0 norm 0) 1e-9) (if (= epa fepa) (setq plst (sublist plst 0 (1+ fepa)) blst (sublist blst 0 (1+ fepa)) ) (setq erat (/ (- (vlax-curve-getDistAtParam pl epa) (vlax-curve-getDistAtParam pl fepa) ) (- (vlax-curve-getDistAtParam pl (1+ fepa)) (vlax-curve-getDistAtParam pl fepa) ) ) plst (append (sublist plst 0 (1+ fepa)) (list (3dTo2dPt (trans ept 0 norm))) ) blst (append (sublist blst 0 (1+ fepa)) (list (k*bulge (nth fepa blst) erat)) ) ) ) ) ((equal ept (trans pt0 norm 0) 1e-9) (if (= spa fspa) (setq plst (sublist plst fspa nil) blst (sublist blst fspa nil) ) (setq srat (/ (- (vlax-curve-getDistAtParam pl (1+ fspa)) (vlax-curve-getDistAtParam pl spa) ) (- (vlax-curve-getDistAtParam pl (1+ fspa)) (vlax-curve-getDistAtParam pl fspa) ) ) plst (cons (3dTo2dPt (trans spt 0 norm)) (sublist plst (1+ fspa) nil) ) blst (cons (k*bulge (nth fspa blst) srat) (sublist blst (1+ fspa) nil) ) ) ) ) (T (setq srat (/ (- (vlax-curve-getDistAtParam pl (1+ fspa)) (vlax-curve-getDistAtParam pl spa) ) (- (vlax-curve-getDistAtParam pl (1+ fspa)) (vlax-curve-getDistAtParam pl fspa) ) ) erat (/ (- (vlax-curve-getDistAtParam pl epa) (vlax-curve-getDistAtParam pl fepa) ) (- (vlax-curve-getDistAtParam pl (1+ fepa)) (vlax-curve-getDistAtParam pl fepa) ) ) ) (if (< epa spa) (setq plst (append (if (= spa fspa) (sublist plst fspa nil) (cons (3dTo2dPt (trans spt 0 norm)) (sublist plst (1+ fspa) nil) ) ) (cdr (sublist plst 0 (1+ fepa))) (if (/= epa fepa) (list (3dTo2dPt (trans ept 0 norm))) ) ) blst (append (if (= spa fspa) (sublist blst fspa nil) (cons (k*bulge (nth fspa blst) srat) (sublist blst (1+ fspa) nil) ) ) (sublist blst 0 fepa) (if (= epa fepa) (list (nth fepa blst)) (list (k*bulge (nth fepa blst) erat)) ) ) ) (setq plst (append (if (= spa fspa) (sublist plst fspa (1+ (- fepa fspa))) (cons (3dTo2dPt (trans spt 0 norm)) (sublist plst (1+ fspa) (- fepa fspa)) ) ) (list (3dTo2dPt (trans ept 0 norm))) ) blst (append (if (= spa fspa) (sublist blst fspa (- fepa fspa)) (cons (k*bulge (nth fspa blst) srat) (sublist blst (1+ fspa) (- fepa fspa)) ) ) (if (= epa fepa) (list (nth fepa blst)) (list (k*bulge (nth fepa blst) erat)) ) ) ) ) ) ) (vla-delete pl) (setq pl (vlax-invoke spc 'AddLightWeightPolyline (apply 'append plst))) (vlax-put pl 'Normal norm) (vla-put-Elevation pl elv) (foreach b blst (vla-SetBulge pl n B) (setq n (1+ n)) ) ) ) (or (zerop (getvar 'delobj)) (vla-delete el)) pl ) ;; Ang<2pi ;; Retourne l'angle, à 2*k*pi près, compris entre 0 et 2*pi (defun ang<2pi (ang) (if (and (<= 0 ang) (< ang (* 2 pi))) ang (ang<2pi (rem (+ ang (* 2 pi)) (* 2 pi))) ) ) ;; 3dTo2dPt ;; Retourne le point 2d (x y) d'un point 3d (x y z) (defun 3dTo2dPt (pt) (list (car pt) (cadr pt))) ;; Tan ;; Retourne la tangente de l'angle (defun tan (a) (/ (sin a) (cos a))) ;;; SUBLIST Retourne une sous-liste ;;; ;;; Arguments ;;; lst : une liste ;;; start : l'index de départ de la sous liste (premier élément = 0) ;;; leng : la longueur (nombre d'éléments) de la sous-liste (ou nil) (defun sublist (lst start leng / n r) (if (or (not leng) (< (- (length lst) start) leng)) (setq leng (- (length lst) start)) ) (setq n (+ start leng)) (while (< start n) (setq r (cons (nth (setq n (1- n)) lst) r)) ) ) ;; K*BULGE ;; Retourne le bulge proportionnel au bulge de référence ;; Arguments : ;; b : le bulge ;; k : le rapport de proportion (entre les angles ou les longueurs d'arcs) (defun k*bulge (b k / a) (setq a (atan B)) (/ (sin (* k a)) (cos (* k a))) ) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; EL2PL ;; Convertit ellipses et arcs elliptiques en polylignes ;; Les objets source sont conservés si la variable DELOBJ = 0, ;; supprimés sinon. (defun c:el2pl (/ *error* fra acdoc ss) (vl-load-com) (defun *error* (msg) (if (and (/= msg "Fonction annulée") (/= msg "Function cancelled") ) (princ (strcat (if (= "FRA" (getvar 'locale)) "\nErreur: " "\Error: " ) msg ) ) ) (vla-endUndoMark acdoc) (princ) ) (setq acdoc (vla-get-ActiveDocument (vlax-get-acad-object))) (if (ssget '((0 . "ELLIPSE"))) (progn (vla-StartUndoMark acdoc) (vlax-for e (setq ss (vla-get-ActiveSelectionSet acdoc)) (EllipseToPolyline e) ) (vla-delete ss) (vla-EndUndoMark acdoc) ) ) (princ) ) ;; PELL ;; Dessine "à la volée" une approximation d'ellipse ou arc elliptique (polyligne) (defun c:pell (/ *error* ec pe do old ent) (vl-load-com) (defun *error* (msg) (if (and msg (/= msg "Fonction annulée") (/= msg "Function cancelled") ) (princ (strcat (if (= "FRA" (getvar 'locale)) "\nErreur: " "\Error: " ) msg ) ) ) (setvar 'cmdecho ec) (setvar 'pellipse pe) (setvar 'delobj do) (princ) ) (setq ec (getvar 'cmdecho) pe (getvar 'pellipse) do (getvar 'delobj) old (entlast) ) (setvar 'cmdecho 1) (setvar 'pellipse 0) (command "_.ellipse") (while (/= 0 (getvar "cmdactive")) (command pause) ) (if (not (eq old (setq ent (entlast)))) (progn (setvar 'delobj 1) (EllipseToPolyline (vlax-ename->vla-object ent)) ) ) (*error* nil) )

Salut didier, C'est quoi ton navigateur ?

Salut et bienvenue, Commande CHAMP > Nom de champs = Objet > sélectionner la polyligne > Propriétés = Elévation.

Un exemple avec une boite de dialogue toute simple pour récupérer une entrée utilisateur. Le formulaire windows (Dialog) contient : un Label (lblMessage) pour le message d'invite à afficher un TextBox (tbxResult) pour l'entrée utilisateur et, éventuellement une valeur par défaut un Button (btnOk) pour valider l'entrée un Button (btnCancel) pour annuler http://gilecad.azurewebsites.net/DotNet/inputbox.png Le code la boite de dialogue : using System.Windows.Forms; namespace InputBoxLispFunction { public partial class Dialog : Form { /// <summary> /// Crée une nouvelle instance de dialog /// </summary> /// <param name="title">Titre de la boite de dialogue</param> /// <param name="message">Message d'invite</param> /// <param name="value">Valeur par défaut</param> public Dialog(string title, string message, string value) { InitializeComponent(); Text = title; lblMessage.Text = message; tbxResult.Text = value; btnOk.DialogResult = DialogResult.OK; btnCancel.DialogResult = DialogResult.Cancel; } /// <summary> /// Obtient le contenu du TextBox /// </summary> public string StringResult => tbxResult.Text; } } Le code de la fonction LISP : using System.Windows.Forms; using Autodesk.AutoCAD.DatabaseServices; using Autodesk.AutoCAD.Runtime; using AcAp = Autodesk.AutoCAD.ApplicationServices.Application; namespace InputBoxLispFunction { public class LispFunction { /// <summary> /// Fonction LISP pour ouvrir une boite de dialogue pour récupérer une entrée utilisteur /// (InputBox titre message [defaut]) /// </summary> /// <param name="resbuf">Arguments passé à la fonction : 2 ou 3 chaînes de caractèrers</param> /// <returns>La chaîne entée par l'utilisateur dans la boite de dialogue ou nil</returns> [LispFunction("InputBox")] public static string InputBox(ResultBuffer resbuf) { var ed = AcAp.DocumentManager.MdiActiveDocument.Editor; try { // contrôle des arguments if (resbuf == null) // aucun argument throw new TooFewArgsException(); var args = resbuf.AsArray(); if (args.Length < 2) // moins de 2 arguments throw new TooFewArgsException(); if (args.Length > 3) // plus de 3 arguments throw new TooManyArgsException(); if (args[0].TypeCode != (int)LispDataType.Text) // le premier argument n'est pas une chaîne throw new ArgumentTypeException("stringp", args[0]); string title = (string)args[0].Value; if (args[1].TypeCode != (int)LispDataType.Text) // le deuxième argument n'est pas une chaîne throw new ArgumentTypeException("stringp", args[1]); string message = (string)args[1].Value; string value = ""; if (args.Length == 3) // le troisième argument (optionnel) est spécifié { if (args[2].TypeCode != (int)LispDataType.Text) // le troisième argument n'est pas une chaîne throw new ArgumentTypeException("stringp", args[2]); else value = (string)args[2].Value; } // ouverture de la boite de dialogue using (var dialog = new Dialog(title, message, value)) { var result = AcAp.ShowModalDialog(dialog); // afficher la boite de dialogue if (result == DialogResult.OK) return dialog.StringResult; // l'utilisateur a cliqué OK else return null; // l'utilisateur a cliqué Annuler } } catch (System.Exception ex) { ed.WriteMessage("\nErreur: " + ex.Message + "\n"); return null; } } } } Le code des classes définissant les exceptions LISP (nombre et type des arguments) : using Autodesk.AutoCAD.DatabaseServices; using Autodesk.AutoCAD.Runtime; namespace InputBoxLispFunction { /// <summary> /// Classe de base pour les exceptions LISP /// </summary> public class LispException : System.Exception { public LispException(string msg) : base(msg) { } } public class TooFewArgsException : LispException { /// <summary> /// Exception LISP "Nombre d'arguments insuffisant" /// </summary> public TooFewArgsException() : base("Nombre d'arguments insuffisant") { } } public class TooManyArgsException : LispException { /// <summary> /// Exception LISP "Nombre d'arguments trop important" /// </summary> public TooManyArgsException() : base("Nombre d'arguments trop important") { } } public class ArgumentTypeException : LispException { /// <summary> /// Exception LISP "Type d'argument incorrect" /// </summary> /// <param name="s">Type attendu (fixnump, numberp, listp, consp, stringp, lentityp, lselsetp)</param> /// <param name="tv">Valeur de l'argument</param> public ArgumentTypeException(string s, TypedValue tv) : base(string.Format( "Type d'argument incorrect: {0} {1}", s, tv.TypeCode == (int)LispDataType.Nil ? "nil" : tv.Value)) { } } }