nombre de paramètres variable

[bseb67]

Salut!

 

Il existe des fonctions lisp (comme rtos) qui prennent un ou plusieurs paramètres.

Ce que je cherche c'est faire la même chose avec une fonction appelée efface_bloc:

 

(efface_bloc nom_du_bloc) ou

(efface_bloc nom_du_bloc point_d'insertion)

 

Si quelqu'un sait comment faire merci ;)

 

En langage C c'est possible car on peut donner des valeurs par défaut:

(efface_bloc nom_du_bloc point_d'insertion=nil)

 

 

Merci!

[Bred]

Salut,

Si je comprends bien, ce que tu veux faire c'est passer des arguments à une fonction.

(le forum "débuter en lisp" aurait été plus approprié.)

 

Les arguments à passer dans une fonction lisp juste après (defun ....

Exemple :

 

(defun additionne-ça ([b]arg1 arg2 arg3[/b])
(+ arg1 arg2 arg3)
)

 

donc, si tu fais :

 

(additionne-ça 8 2 3)

ça te retournera 13.

 

et si tu fais

(additionne-ça 8 2 nil)

ça te retournera 10.

 

Ne pas confondre avec la déclaration de variable locale !!!

(defun additionne-ça (arg1 arg2 arg3 [b]/ result[/b])
(setq result (+ arg1 arg2))
)

 

 

[(gile)]

Si je peux me permettre quelques précisions, en LISP, il n'y a pas d'argument optionnels, tous doivent être spécifiés, même si certains sont nil.

 

Les exemples que donne Bred, s'ils illutrent le principe, ne sont pas tout à fait justes, il importe, dans la routine de vérifier si un ou des arguments sont nil.

 

La routine ne vérifie pas la validité des arguments.

 

(defun additionne-ça (arg1 arg2 arg3)
(+ arg1 arg2 arg3)
) 

 

et l'expression :

 

(additionne-ça 8 2 nil) 

 

retourne le message d'erreur : ; erreur: type d'argument incorrect: numberp: nil

 

La routine pourrait être quelque chose du style :

 

(defun additionne-ça (arg1 arg2 arg3 / result)
 (apply '+ (vl-remove-if-not 'numberp (list arg1 arg2 arg3)))
) 

 

et les résultats seraient alors :

 

(additionne-ça 8 2 3) -> 6

(additionne-ça 8 2 nil) -> 10

(additionne-ça 8 nil nil) -> 8

(additionne-ça nil nil nil) -> 0

 

 

Autre exemple de routine avec un argument qui peut être nil.

La routine sublst fonctionne comme la fonction LISP substr (avec une liste au lieu d'une chaine).

Avec la fonction substr, l'argument pour spécifier la longueur de la "sous chaine" est optionnel pour retourner le restant de la chaine, avec sublst il doit être nil pour un comportement similaire.

 

;; SUBLST Retourne une sous-liste
;;
;; Arguments :
;; lst : la liste
;; start : l'index du premier élément de la sous liste (premier élément : 1)
;; leng : nombre d'éléments de la sous liste (ou nil pour le reste de la liste)
;;
;; Exemples
;; (sublst '(1 2 3 4 5 6) 3 2) -> (3 4)
;; (sublst '(1 2 3 4 5 6) 3 nil) -> (3 4 5 6)

(defun sublst (lst start leng / rslt)
 (or (      (setq leng (- (length lst) (1- start)))
 )
 (repeat leng
   (setq rslt	(cons (nth (1- start) lst) rslt)
  start	(1+ start)
   )
 )
 (reverse rslt)
) 

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

 

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

[Bred]

il importe, dans la routine de vérifier si un ou des arguments sont nil.

Désolé, je suis encore aller trops vite....

 

Il m'arrive de mettre des arguments à nil, mais il est vrais que je les tests dans mes routines (ce que je n'ai pas fait dans l'exemple)

 

ce que j'aurai du marquer :

(defun additionne-ça (arg1 arg2 arg3)
(if arg3
(+ arg1 arg2 arg3)
(+ arg1 arg2)
)
)

[bseb67]

Salut!

 

Je cherchais juste à savoir comment éviter d'appeler la fonction avec des nil pour les arguments.

Je sais qu'il faut tester après si on avait nil ou non.

Ma fonction efface tous les blocs ayant pour nom nom_du_bloc ou ceux dont le point d'insertion est

point_d'insertion.

Comme je l'ai écris, il existe des fonctions lisp qui le font (rtos citée ou strcat par exemple)

 

Merci quand même. je passerai donc nil lors de l'appel

[Didier-AD]

Salut,

 

moi, ce que je fais de plus en plus, c'est passer une liste comme argument; ainsi j'y mets ce que je veux et je traite les éléments dans la fonction

 

exemple

;; syntaxes possibles 
;; (efface_bloc (list Nombloc)) 
;; (efface_bloc (list Nombloc Pointinsertion)) 
;;-----------------------------------------------------------------------------------
(defun efface_bloc (lparam)
   (if (cadr lparam)  ;; le point d'insertion est fourni
       (progn
           (etcaetera.si le point est fourni)
       )
       (progn
           (etcaetera.si le point n'est pas fourni)
       )
)   

 

si je reprends l'exemple de la sousliste

 
;; (sublst '((1 2 3 4 5 6) 3 2)) -> (3 4)
;; (sublst '((1 2 3 4 5 6) 3 )) -> (3 4 5 6)


(defun sublst (lparam/ lst start leng rslt)
(mapcar 'set (list 'lst 'start 'leng) lparam 
(or (<= 1 leng (- (length lst) start))
(setq leng (- (length lst) (1- start)))
)
(repeat leng
(setq rslt (cons (nth (1- start) lst) rslt)
start (1+ start)
)
)
(reverse rslt)
) 

 

je suis venu à cette technique à force de vouloir faire évoluer mes fonctions sans devoir réécrire toutes celles qui y font appel

 

[bseb67]

Salut didier!

 

Oui, c'est une bonne astuce :P !

 

Le seul petit souci est que si quelqu'un reprend mes fonctions, il devra capter le truc :casstet:

 

Après les mystères du C avec la pile, voici ceux du lisp.