Liste de fonctions d\'un lisp

vinz34 · le 22 novembre 2007

Bonjour,

Est-il possible d'obtenir une liste des fonctions présentes dans un fichier lisp ?

Je m'explique :

J'utilise un fichier lisp chargé au démarrage qui contient les routines que j'utilise quasi quotidiennement, mais il m'arrive parfois de ne plus me souvenir de la syntaxe exacte d'une commande récemment créée par exemple.

Je cherche donc un moyen de lister tout ce qui commence par un (defun c:

J'ai bien pensé à un open_file et read_line mais je me suis heurté à bien des difficultés !

Si quelqu'un a une idée ...

Bred · le 22 novembre 2007

Salut,

une possibilité : dans l'éditeur visual-lisp d'Autocad, tu fais "vérifier le fenêtre d'édition".

Patrick_35 · le 22 novembre 2007

Salut

Le plus simple est de lister en manuel, donc à lire ;) ton fichier lisp afin de relever toutes les commandes, puis de créer un menu partiel qui les regroupent.

@+

bseb67 · le 22 novembre 2007

Salut Vinz!

J'avais fait un petit lisp à mes débuts, il retourne seulement le nom de la fonction, donc à toi de le modifier pour retourner le nom et les paramètres.

 
;----------------------------------------;
; nom: listing_des_fonctions_simple      ;
; role: répertorie les noms des fonctions;
;       contenues dans le fichier en lisp;
; param: infile => fichier à traiter     ;
; retour: t si tout c'est bien passé     ;
;         nil sinon                      ;
; date: 21/06/2007                       ;
; BLAES Sébastien                        ;
;----------------------------------------;
(defun listing_des_fonctions_simple( infile  / filedes end buffer)

 	; il faut ouvrir infile et stocké les données dans outfile
 	(setq filedes (open (strcat infile) "r"))

 	(cond
	((/= filedes nil)
		(princ (strcat "******** FICHIER: " infile " ********"))

	 	; une fonction si elle contient un en-tête commence par ;-----
	 	; sinon c'est un simple (defun
	 	(setq end nil)
	 	(while (and (= end nil) (/= (setq buffer (read-line filedes)) nil))

		  	; on test ce que contient buffer
		  	(cond					
				; defun
				((/= (setq pos (vl-string-search "(defun " buffer)) nil )
					(setq buffer (substr buffer (+ pos (strlen "(defun "))))
				 	(setq pos (vl-string-search "(" buffer))
				 	(setq buffer (substr buffer 1 pos))
				 	(princ buffer )
				 	(princ "\n")
				)
				; defun
			) ; cond
		) ; while
	 	(princ "******** FIN FICHIER ********" )
	 	(princ "\n")
	 	(princ "\n")
	 	(close filedes)
	 	t
	)
	(t
		(alert (strcat "erreur d'ouverture du fichier " infile))
	 	nil
	) 
) ; cond
 
) ; listing_des_fonctions_simple

[Edité le 22/11/2007 par bseb67]

stephan35 · le 22 novembre 2007

Salut,

Avec un éditeur extérieur, genre Notepad++ qui affiche sur la droite la liste de toutes les fonctions de ton programme .....

a+

bonuscad · le 22 novembre 2007

Cette réponse pourrait être utile, je n'ai pas travaillé dessus depuis longtemps mais je pense qu'elle fonctionne encore.

A l'époque je me servais aussi du bout de code qui suit pour initialiser ma commande.

(Pour info je l'utilisais pour marquer un état par défaut, par exemple à la 1ere installation vierge d'autocad, et je renommais le fichier "atomlst1.ori" obtenu en "atomlst0.ori")

Pour des marquages ultérieurs je conserve bien par contre le fichier "atomlst1.ori" produit.

Comme ceci j'obtenais les fonctions chargées en mémoire par défaut par autocad, applications tierce et pouvais les exclure ensuite pour faire les tris.

NB:Bien sur tous les fichiers (code .lsp et paramètre .ori) dans un dossier de recherche ;)

(defun c:fc-init ( / f lst)
(cond
	((zerop (boole 1 (getvar "dbmod") 1))
		(setq f (findfile "atomlst1.ori"))
		(if f
			(setq f (open f "w"))
			(setq f (open "atomlst1.ori" "w"))
		)
		(setq lst (atoms-family 1))
		(while lst
			(if
				(or
					(= (car lst) "C:FC-INIT")
					(= (car lst) "F")
					(= (car lst) "LST")
				)
				(prompt (strcat "\nSuppression de " (car lst)))
				(write-line (car lst) f)
			)
			(setq lst (cdr lst))
		)
		(close f)
		(prompt "\nCommande FC-LOAD initialisée avec exclusion des fonctions autochargé")
		(prompt "\nUtilisez à nouveau FC-INIT si des modification sont faites dans ")
		(prompt "\nles fichiers auto-chargeant des fonction LISP")
	)
	(T
		(prompt "\nProgramme non effectué.")
		(prompt "\nIl doit être effectué au début d'un NOUVEAU dessin")
	)
)
(setq c:fc-init nil f nil lst nil)
(prin1)
)

Matt666 · le 22 novembre 2007

Aaaaaaahhh J'arrive trop tard !!!!

Il est rapide ce bonuscad....

Je présente quand même ma routine, pas trop trop testée...

;;; STR2LST
;;; Retourne une liste à partir d'une chaîne de caractères concaténée avec un caratère de séparation
;;; str = Chaîne de caractères
;;; sep = caractère de séparation
;;;
;;; (str2lst "0,1,,,,2,3,4,5,6,7,8,9" ",") -> (0 1 "" "" "" 2 3 4 5 6 7 8 9)
;;; (str2lst "0,1,2,3,4,5,6,7,8,9" "" ) -> ("0" "," "1" "," "2" "," "3" "," "4" "," "5" "," "6" "," "7" "," "8" "," "9")

(defun str2lst (str sep / pos)
 (if (setq pos (vl-string-position (ascii sep) str))
   (cons (substr str 1 pos)
  (str2lst (substr str (+ (strlen sep) pos 1)) sep)
   )
   (list str)
 )
)

(defun c:flst (/ tmp lst str ouv ch cn)
 (if (setq ch (getfiled "Sélectionner un fichier lisp"
		 "c:\\program files\\"
		 "lsp"
		 4
       )
     )
   (progn
     (setq ouv (open ch "r"))
     (while (setq str (read-line ouv))
(if (setq pos (vl-string-search "(defun" str nil))
  (progn
    (setq str (substr str (+ pos 8))
	  rou (strcat
		"\nRoutine : "
		(substr	str
			1
			(setq pos (vl-string-search " (" str nil))
		)
		"\t"
	      )
	  str (substr str (+ pos 3))
    )
    (if	(setq pos (vl-string-search "/" str nil))
      (progn
	(setq cn  0
	      str (substr str 1 pos)
	      tmp ""
	)
	(if (and (/= str " ") (/= str ""))
	  (progn
	    (if	(eq (length (setq lst (str2lst str " "))) 1)
	      (setq tmp (strcat " F1 -> " str " | "))
	      (progn
		(foreach pt lst
		  (if (and (/= pt nil)
			   (/= pt "")
		      )
		    (setq tmp (strcat tmp
				      " F"
				      (itoa (setq cn (1+ cn)))
				      " -> "
				      pt
				      " | "
			      )
		    )
		  )
		)
	      )
	    )
	    (if
	      (/= tmp "")
	       (setq
		 tmp (strcat rou
			     (substr tmp 1 (- (strlen tmp) 3))
		     )
	       )
	       (setq tmp rou)
	    )
	    (princ tmp)
	  )
	  (progn
	    (setq tmp rou)
	    (princ tmp)
	  )
	)
      )
      (if (setq pos (vl-string-search ")" str nil))
	(progn
	  (setq	cn  0
		str (substr str 1 pos)
		tmp ""
	  )
	  (if (and (/= str " ") (/= str ""))
	    (progn
	      (if (eq (length (setq lst (str2lst str " "))) 1)
		(setq tmp (strcat " F1 -> " str " | "))
		(progn
		  (foreach pt lst
		    (if	(/= pt "")
		      (setq
			tmp (strcat tmp
				    " F"
				    (itoa (setq cn (1+ cn)))
				    " -> "
				    pt
				    " | "
			    )
		      )
		    )
		  )
		)
	      )
	      (if (/= tmp "")
		(setq
		  tmp
		   (strcat rou
			   (substr tmp 1 (- (strlen tmp) 3))
		   )
		)
	      )
	      (princ tmp)
	    )
	    (progn
	      (setq tmp rou)
	      (princ tmp)
	    )
	  )
	)

      )
    )
  )
)
     )
     (close ouv)
   )
 )
 (princ)
)

Bravo a toi bonusCAD, encore une fois :)

A bientot.

Matt.

EDIT : Ajout de la fonction STR2LST que j'avais honteusement oublié, et amélioration de la routine.

[Edité le 23/11/2007 par Matt666]

EDIT2 : Fonction réajustée et qui tourne sur AutoCAD 2008...

[Edité le 23/11/2007 par Matt666]

bonuscad · le 22 novembre 2007

Aaaaaaahhh J'arrive trop tard !!!!

Mais non, tu ne propose pas du tout la même chose.

Toi tu explore un fichier lisp, moi j'explore les fonctions lisp CHARGEES en mémoire. Si le fichier lisp n'est pas chargé, on ne verra rien de spécial .... :casstet:

Donc si on charge tous les fichiers qui nous intéresse en mémoire et si on a fait un point de marquage juste avant, on aura la liste des fonctions sans peine. Enfin je pense....

Matt666 · le 23 novembre 2007

Toi tu explore un fichier lisp

Oui c'est ce que la routine fait...

moi j'explore les fonctions lisp CHARGEES en mémoire.

Pour tout te dire, je n'ai pas regardé ta routine :(

Désolé...

Mais c'est une sacré bonne idée, je trouve !

Je vais l'essayer...

A bientot.

Matt.

vinz34 · le 23 novembre 2007

Bonjour à tous et merci pour vos réponses.

Patrick_35 : Merci la solution que j'utilise depuis longtemps mais si je change la syntaxe d'une routine ou si j'en rajoute une il faut touours penser à aller modifier la liste manuelle.

bseb67 : Je n'arrive pas à lancer ton lisp

Je fais bien (listing_des_fonctions_simple ("nom_du_lisp.lsp")) ?

Il me retourne : ; erreur: fonction incorrecte: "nom_du_lisp.lsp".

bonuscad : Je ne saisi pas le fonctionnement ; à quel moment voit-on une liste des fonctions ?

C'est que ce atomlst1.ori ?

Je continue à chercher avec le lien que tu as donné.

Matt666 : C'est toi qui te rapproche le plus de ce que je cherche à faire, mais ca me reourne :

; erreur: type d'argument incorrect: FILE nil.

Je ne comprends je suis pourtant aller chercher un fichier qui se trouve dans les chemins de recherche de fichiers support d'Autocad.

Encore merci pour votre participation.

bseb67 · le 23 novembre 2007

Resalut Vinz34;

La fonction se lance ainsi:

(listing_des_fonctions_simple "b:/lisp/utils.lsp")

Il faut entrer le chemin complet du fichier ainsi que son nom. J'utilise les /, car si tu mets \ il faut en mettre deux.

C'est normal qu'il te marque fonction incorrecte:

car ("nom_du_lisp.lsp") n'est pas une fonction lisp ;)

Après, tu peux, en utilisant doslib, chercher tous les fichiers dans un répertoire donné (dos_find je crois) puis faire une boucle pour appeler le listing sur chaque fichier lisp trouvé.

Avec dos_lib, j'ai vu que tu pouvais chercher tous les lisps ou vlx ou fas chargés dans le dessin (chemin + nom de fichier) donc tu peux lancer le listing sur cette liste:

(dos_lisplist t) => ("C:\\Program Files\\AutoCAD MEP 2008\\Express\\acetutil.fas" "C:\\Program

Files\\AutoCAD MEP 2008\\Express\\acetauto.LSP" "C:\\Program Files\\AutoCAD MEP

2008\\Express\\acettest.fas" "T:\\TKDES-SCRIPT\\LISP\\DOSLib\\doslib.lsp"

"T:\\dossiers personnels\\seb\\LISP\\bench.lsp" "T:\\Dossiers

Personnels\\Seb\\LISP\\utils.lsp" "C:\\Program Files\\AutoCAD MEP

2008\\Support\\acad2008.LSP" "C:\\Program Files\\AutoCAD MEP

2008\\Support\\acad2008doc.LSP" "C:\\autofluid4\\menu\\autofluid4.mnl"

"C:\\Documents and Settings\\SBS\\Application Data\\Autodesk\\ACD-MEP

2008\\fra\\Support\\acetmain.mnl")

Lien pour doslib

http://www.fr.emea.mcneel.com/doslib.htm

bseb67 · le 23 novembre 2007

Oulà!!! :mad: :o

La moitié de mon texte dans mon post précédent à disparu !!

Matt666 · le 23 novembre 2007

Bon vu que j'ai pas autocad, je marche un peu à l'aveuglette...

J'ai oublié de joindre une fonction à la routine, c'est normal que ça ne fonctionne pas !!!

J'ai amélioré un peu la routine... Voir le post concerné un peu plus haut... J'ai modifié le post en conséquence.

Au fait j'ai zappé de le mettre dans le premier post, mais je me suis basé sur le code de bseb67 pour faire cette routine... Merci à toi mecton !! ;)

A bientot.

Matt.

[Edité le 23/11/2007 par Matt666]

lili2006 · le 23 novembre 2007

Bonjour à toutes et tous,

Matt666

Test sur A2008 de la dernière routine :

Commande: flst
; erreur: type d'argument incorrect: FILE nil
Commande:

@+,

bseb67 · le 23 novembre 2007

Re,

Enfin le temps d'écrire ce qui était parti.

La bibliothèque doslib contient une fonction dos_lisplist qui renvoie les lisp, vls ou fas chargé dans le dessin. Donc en chargeant doslib, on peut faire une boucle sur le retour de dos_lisplist pour chercher presque toutes les fonctions chargées.

Pourquoi presque? :o

Et bien il suffit de voir quelques lisp à Gile par exemple, car il déclare des fonctions dans des fonctions. Donc en scannant pour chercher le (defun, on trouvera ses fonctions locales, mais si la fonction la contenant n'a pas été lancée au moins une fois, la fonction ne peut être appelée.

Exemple:

 
(defun prout()
(defun super_prout()
	(print "super_prout")
) ;
 (print "prout")
) ; prout

Après un chargement du lisp:

Commande: (super_prout)

; erreur: no function definition: SUPER_PROUT

Commande: (prout)

"prout" "prout"

Commande: (super_prout)

"super_prout" "super_prout"

Ahaha!

Bon, ben, bon week-end à tous :D (pour moi c'est dans moins d'une heure ;))

a+

vinz34 · le 23 novembre 2007

Merci à toi bseb67 c'est exactement ce que je cherchais.

Je n'ai pas pour habitude de créer des routines avec arguments ça m'a un peu dérouté...

Je l'adapte et je l'adopte !!!

Eh vive les 35 heures ! :D

Matt666 · le 23 novembre 2007

Bon ça y est j'ai refais et TESTE SUR AUTOCAD !! Dedieu...

La routine fonctionne sur Autocad 2008...

Je change la routine plus haut.

lili2006 · le 23 novembre 2007

Re,

Quand je lance le Lisp, rien ! :

Commande:
Commande: flst
Commande:

Mais c'est peut être moi qui à un pb !!

Matt666 · le 23 novembre 2007

Tiens !! Bon j'ai remis les variables, et changé les slash de sens, pour voir...

Tu es sur quelle version ?

A demain !

lili2006 · le 23 novembre 2007

Re,

Nouveau test, réponse AutoCAD =>

Commande: flst
Routine : ssmatch_box F1 -> ent
Routine : c:ssm
Commande:

Tu es sur quelle version ?

AutoCAD 2008 et windows vista.

Bonne soirée.

(gile) · le 23 novembre 2007

Salut,

J'y vais de ma contribution.

Une fonction qui retourne une chaîne de toutes les fonctions LISP (defun) du fichier (chemin complet) passé comme argument à la fonction.

EDIT : petite amélioration, les commandes (defun c:xxx ...) apparaissent en majuscules, les sous routines (defun xxx) en minuscules

;; LIST-FUNC
;; Liste les fonctions LISP (defun) d'un fichier et retourne une chaîne
;;
;; Argument
;; filename : le chemin complet du fichier
;;
;; Exemple d'utilisation
;; (list-func "C:\\Program Files\\AutoCAD 2007\\Support\\3d.lsp")

(defun list-func (filename / rslt file line start com end name)
 (setq	rslt ""
file (open filename "r")
 )
 (while (setq line (read-line file))
   (if	(and
  (setq start (vl-string-search "defun" (strcase line T)))
  (or (not (setq com (vl-string-position (ascii ";") line)))
      (	  )
)
     (setq start (+ start 6)
    end	  (cond
	    ((vl-string-position (ascii "(") line (1+ start)))
	    (T (strlen line))
	  )
    name  (vl-string-right-trim
	    " "
	    (substr line (1+ start) (- end start))
	  )
    rslt  (strcat rslt
		  (if (= "c:" (substr (strcase name T) 1 2))
		    (strcase name)
		    (strcase name T)
		  )
		  " "
	  )
     )
   )
 )
 (close file)
 rslt
)

Un exemple de fonction d'appel pour traiter un fichier (taper lsp-file)

;; LISP-FILE
;; Retourne dans la fenêtre de texte la liste de toutes les
;; fonctions LISP (defun) du fichier spécifié.

(defun c:lsp-file (/ file rslt)
 (and (setq file (getfiled "Choisir un fichier LISP" "" "lsp" 0))
      (setq rslt (list-func file))
      (/= "" rslt)
      (princ (strcat "\n" file "\n" rslt))
      (textscr)
 )
 (princ)
)

Un autre exemple pour traiter un répertoire et ses sous répertoires (taper lsp-folder)

;; LSP-FOLDER
;; Retourne dans la fenêtre de texte la liste des fonctions LISP (defun)
;; de tous les fichiers LISP du répertoire et de dses sous répertoires.

(defun c:lsp-folder (/ path rslt file line start com end)
 (and
   (setq path (dirbox "Sélectionnez le dossier" "" 512))
   (setq rslt "")
   (mapcar
     (function
(lambda	(d)
  (mapcar
    (function
      (lambda (f)
	(setq rslt (strcat rslt
			   "\n\n"
			   (strcat d "\\" f)
			   "\n"
			   (list-func (strcat d "\\" f))
		   )
	)
      )
    )
    (vl-directory-files d "*.lsp")
  )
)
     )
     (cons path (getfolders path))
   )
   (and (/= "" rslt) (princ rslt) (textscr))
 )
 (princ)
)

;;; GetFolders
;;; Retourne la liste de tous les sous-dossiers du dossier (ou disque) spécifié (chemin)

(defun GetFolders (path / l c)
 (if (setq l (vl-directory-files path nil -1))
   (apply 'append
   (mapcar
     (function
       (lambda (x)
	 (cons (setq c (strcat path "\\" x)) (GetFolders c))
       )
     )
     (vl-remove "." (vl-remove ".." l))
   )
   )
 )
)

;;; DirBox -Patrick_35-

(defun DirBox (Message Chemin Drapeau / rep sh)
 (setq sh (vlax-create-object "Shell.Application"))
 (if (setq
rep (vlax-invoke sh 'browseforfolder 0 Message Drapeau Chemin)
     )
   (setq rep (vlax-get-property (vlax-get-property rep 'self) 'path))
   (setq rep nil)
 )
 (vlax-release-object sh)
 rep
)

[Edité le 23/11/2007 par (gile)]

[Edité le 24/11/2007 par (gile)]

(gile) · le 24 novembre 2007

J'avais oublié de joindre la routine GetFolders, c'est réparé.

lili2006 · le 24 novembre 2007

Bonjour à toutes et tous,

(Gile), voici le résultat de mes tests =>

j'ai essayé avec le chemin renvoyé par lsp-file =>

Commande: (list-func "C:\Users\Lili2006\Documents\test cadXP\etcp.LSP")
; erreur: type d'argument incorrect: FILE nil

Et avec l'écriture en exemple dans le Lisp "LIST-FUNC", ce qui donne :

Commande: (list-func "C:\\Users\\Lili2006\\Documents\\test cadXP\\etcp.LSP")
"C:ETCP "
*Incorrect*

Enfin, la routine "lsp-folder" =>

Commande: lsp-folder

C:\Users\Lili2006\Documents\test cadXP\cpl.LSP
q

C:\Users\Lili2006\Documents\test cadXP\etcp.LSP
C:ETCP

C:\Users\Lili2006\Documents\test cadXP\flst.LSP
str2lst C:FLST str nil))

C:\Users\Lili2006\Documents\test cadXP\LIST-FUNC.LSP
list-func

C:\Users\Lili2006\Documents\test cadXP\lsp-file.LSP
C:LSP-FILE

C:\Users\Lili2006\Documents\test cadXP\lsp-folder.LSP
C:LSP-FOLDER getfolders dirbox

C:\Users\Lili2006\Documents\test cadXP\ssm.LSP
ssmatch_box C:SSM

C:\Users\Lili2006\Documents\test cadXP\ttr.LSP
C:TTR C:TTR2

C:\Users\Lili2006\Documents\test cadXP\ttr1.LSP
C:TTR1

C:\Users\Lili2006\Documents\test cadXP\ttr2.LSP
C:TTR2

Commande:

Cette routine me renvoi bien le titre de lancement des routines figurant dans le repertoire " test cadXP",

D'après la demande, l'objectif est atteind, non ?

Par contre, que veux dire ce message sur le Lisp 'q" pour la routine "cpl" et "C:FLST str nil))" pour "flst.LSP" et enfin, "C:LSP-FOLDER getfolders dirbox" pour le Lisp "lsp-folder"

?

Quand à

C:\Users\Lili2006\Documents\test cadXP\LIST-FUNC.LSP
list-func

, veut dire qu'il n'y à pas de lancement en ligne (c'est donc une sous-routine ?).

Merci d'avance pour le décodage,...

[Edité le 24/11/2007 par lili2006]

Matt666 · le 24 novembre 2007

Commande: flst
Routine : ssmatch_box F1 -> ent
Routine : c:ssm
Commande:

Bon bah voilà, c'est bon pour moi !!!

Enfin !!!

Routine : F1 -> | F2 -> etc...

Cool !

Gile, ça a l'air pas mal du tout ton pti truc là !!

(gile) · le 24 novembre 2007

Par contre, que veux dire ce message sur le Lisp 'q" pour la routine "cpl" et "C:FLST str nil))" pour "flst.LSP" et enfin, "C:LSP-FOLDER getfolders dirbox" pour le Lisp "lsp-folder"

1) "q" pour le LISP cpl veut dire que la fonction est définie par defun-q, cette fonction est utilisée quand on a besoin de définir une fonction comme une liste. C'est assez exceptionnel, et il s'agissait dans ce cas d'un "exercice de style" pour définir 2 commandes dans une seule expression. La routine list-func ne fonctionne pas pour ce type de definition (les noms de commande n'apparaissant que dans une liste en fin de routine comme argument de la fonction mapcar.

2) "C:FLST str nil))" est encore une imperfection de list-func due à un autre cas très particulier, la présence du mot defun où il n'est pas utilisé comme fonction. List-func comme c:flst lisent le fichier à la rercherche du mot defun et quand elles le trouvent, retourne le mot suivant, à savoir, dans l'immense majorité des cas le nom de la fonction. Dans C:FLST, on retrouve defun dans l'expression :

(vl-string-search "(defun" str nil))

et str nil)) est retourné.

3) "C:LSP-FOLDER getfolders dirbox" Là tout est normal, le fichier lsp-folder.lsp contient 3 définitions de fonctions : (defun c:lsp-folder ...) une commande, et (defun getfolders ...), (defun dirbox ...) deux sous-routines.

Connexion

Liste de fonctions d\'un lisp

Messages recommandés

vinz34

Bred

Patrick_35

bseb67

stephan35

bonuscad

Matt666

bonuscad

Matt666

vinz34

bseb67

bseb67

Matt666

lili2006

bseb67

vinz34

Matt666

lili2006

Matt666

lili2006

(gile)

(gile)

lili2006

Matt666

(gile)

Créer un compte ou se connecter pour commenter

Créer un compte

Se connecter

Forums

Naviguer

Activité

Information importante