Je trouve pas l\'erreur

[bigsyke]

Bonjour à tous ;)

 

Je suis actuellement entrain de crée un lisp pour savoir sous quelle ename se cache une paire pointé.J'ai voulu commercé par quelque chose qui me paraissais simple au premiere abord mais qui c'est averé compliqué pour moi :P

Alors voir la bête:

(setq sel (car (entsel)))
(while (= (cdr (assoc 2 sel)) "REP1028"))
           (setq sel (entnext sel))
           (entget sel)		
)
(princ "Terminé")
(prin1)

 

Voilà l'erreur que j'obtien lors de son execution:

 

Choix de l'objet: ; erreur: type d'argument incorrect: listp

7ef04230>

 

A quoi cela est il dû et comment y remedier s'il vous plait ;)

[Carboleum]

L'erreur est ici --> (assoc 2 sel)

 

le deuxième argument de la fonction assoc doit être une liste d'association: '((1 . "hello") (2 . "world") (3 . "!"))

dans ton cas, sel est un entityname, il faut en obtenir la liste d'association via la fonction entget.

 

ce qui s'écrit: (assoc 2 (entget sel))

 

 

 

[Edité le 29/5/2011 par Carboleum]

[bigsyke]

Merci pour ton aide :)

Effectivement je n'avais pas vue cette erreur.J'ai donc modifier mon lisp en consequence :

 
setq sel (car (entsel)))
(while (= (cdr (assoc 2 (entget sel)) "REP1028"))
           (setq sel (entnext sel))
           (entget sel)		
)
(princ "Terminé")
(prin1)

 

Néanmoins lorsque je veux tester mon lisp j'ai cette fois ci l'erreur suivante:

Choix de l'objet: ; erreur: nombre d'arguments trop important

 

Est ce possible que dans un lisp on ai trop d'arguments :P ??

[(gile)]

Salut,

 

Problème d'appariement de parenthèses :

(= (cdr (assoc 2 (entget sel)) "REP1028"))

 

La fonction cdr ne requiert qu'un argument, là tu lui en passe deux :

(assoc 2 (entget sel)) et "REP1028"

 

Il fallait écrire :

(= (cdr (assoc 2 (entget sel))) "REP1028")

[bigsyke]

Merci beaucoup Gile pour ton aide et une fois de plus tes conseils sont clairs et precieux.

J'ai bien modifié mon lisp en y integrant un seul argument a la foncyion cdr et cette fois ci lorsque je teste mon lisp je n'ai pas de message d'erreur.

 

Cependant, alors que le but de mon lisp étais de definir sous quel ename se cachais la paire pointé (2 . "REP1028") lorsque mon lisp s'execute j'ai ceux ci sur ma ligne de commande:

 
Choix de l'objet: Terminé

Je me dis alors qu'en faisant (entget sel) je devrais avoir quelque chose qui devrais ressemblé a ceux ci:

((-1 . ) (0 . "ATTRIB") (330 . 7e8cd1b0>).....(2 . "REP1028")...

Au lieu de cela j'ai :

 
((-1 . ) (0 . "INSERT") (330 . 7e8cbcf8>)...(2 . "CART")...

 

Pour moi voilà comment j'ai concu mon lisp:

 

setq sel (car (entsel)))

je selection mon entité graphique puis j'enregistre son ename sous la variable sel

 

(while (= (cdr (assoc 2 (entget sel))) "REP1028")

J'ouvre ma boucle "tant que" en conditionnant la sortie de celle au faite que tant que l'expression (= (cdr (assoc 2 (entget sel))) "REP1028") n'est pas égal à nil celle ci continue a effectué la meme tache (j'espère avoir été suffisament claire :P )

 

(setq sel (entnext sel))

Donc si mon expression (= (cdr (assoc 2 (entget sel))) "REP1028") n'est pas égal a nil alors je fais un entnext de sel jusqu'a tombé sur la paire pointé (2 . "REP1028") ce qui me permettra de sortir de ma boucle

 

(princ "Terminé")

Une fois trouvé le ename sous lequel etais repertorié la paire pointé recherché le message Terminé s'affiche sur ma ligne de commande

 

Voilà, sur le papier cela devrais marché sauf que cela ne fonctionne pas :P

 

Est ce ma logique qui n'est pas la bonne? Ai je oublié un éléments crucial dans tout cette enchainement? En tout cas merci pour toute l'aide que vous pourrez m'apporter ;)

[(gile)]

Un bloc est une entité complexe (composée de sous-entités)

entsel sélection l'entité principale (la référence de bloc)

nentsel permet de sélectionner un composant d'une entité complexe un (attribut par exemple)

 

Donc, soit tu utilises nentsel pour sélectionner directement l'attribut :

 

(if (and
     (setq att (car (nentsel "\nSélectionnez l'attribut: ")))
     (setq elst (entget att))
     (= "ATTRIB" (cdr (assoc 0 (setq elst (entget att)))))
     (= "REP1028" (cdr (assoc 2 elst)))
   )
 ...
 (princ "Sélection non valide")
)

 

Soit tu sélectionnes le bloc et tu parcours ses attributs à la recherche de "REP1028".

 

(if (and
     (setq blk (car (entsel "\nSélectionnez le bloc: ")))
     (setq elst (entget blk))
     (= "INSERT" (cdr (assoc 0 (setq elst (entget att)))))
     (setq att (entnext blk))
   )
 (while (and att
      (setq elst (entget att))
      (= "ATTRIB" (cdr (assoc 0 elst)))
 )
   (if	(= "REP1028" (cdr (assoc 2 elst)))
     ...
   )
   (setq att (entnext att))
 )
)

[bigsyke]

Merci Gile pour ton aide ;)

En plus j'avais completement oublié nentsel qui te permet de selectionner directement l'attribut concerné.

 

Maintenant j'ai repris ton lisp qui permets de parcourir les attributs à la recherche de la paire pointé (2 . "REP1028") afin qu'il m'afficher "TROUVER" si (= "REP-FICH" (cdr (assoc 2 elst))) et "NON TROUVER" si cela n'est pas le cas ce qui donne cela:

(if (and
     (setq blk (car (entsel "\nSélectionnez le bloc: ")))
     (setq elst (entget att))
     (= "INSERT" (cdr (assoc 0 (setq elst (entget att)))))
     (setq att (entnext blk))
   )
 (while (and att
      (setq elst (entget att))
      (= "ATTRIB" (cdr (assoc 0 elst)))
	  )
   (if	(= "REP1028" (cdr (assoc 2 elst)))
     (princ "TROUVER")
  (princ "NON TROUVER")
   )
   (setq att (entnext att))
 )
)

 

Dès l'execution du lisp,je selectionne mon bloc mais ensuite voici le message suivant qui s'affiche:

Sélectionnez le bloc: ; erreur: type d'argument incorrect: lentityp nil

 

 

De plus j'aimerais bien s'il vous plait qu'on m'explique pourquoi mon idée de depart étais mauvaise à savoir pourquoi mon lisp suivant ne s'arrete pas a la sous entité contenant la paire pointé (2 . "REP1028")

 
setq sel (car (entsel)))
(while (= (cdr (assoc 2 (entget sel)) "REP1028"))
           (setq sel (entnext sel))
)
(princ "Terminé")
(prin1)

 

Pour moi ce lisp est le meme, du moins dans l'esprit que celui ci-dessus qui ne fais que compter de 1 à 10

(setq compteur 1)
(while (< compteur 10)
	(princ compteur)
	(setq count (1+ compteur))
)

 

Je sais que je pose beaucoup de question peut etre stupide a vos yeux mais j'essais d'apprendre par moi meme et a force de perceverance et de travail j'espere un jours volé de mes propres ailes ;)

En attendant ce jour béni je vous remercie mille fois pour toute l'aide que vous m'apportez

[(gile)]

Salut,

 

1.

      (setq [b]blk[/b] (car (entsel "\nSélectionnez le bloc: ")))
     (setq elst (entget [b]att[/b]))

att n'est pas initialisé (lentityp nil)

Il y avait une erreur dans le code que tu as copié/collé sans bien essayer de le comprendre...

 

2.

(while (= (cdr (assoc 2 (entget sel)) "REP1028"))

Veut dire : tant que la valeur du groupe DXF 2 est égale à "REP1028".

Autrement dit, dès que la valeur est différente de "REP1028" la boucle s'arrête, ce qui est le cas si à la première itération la variable sel contient une référence de bloc dont le nom n'est pas "REP1028" ou un attribut dont l'étiquette n'est pas "REP1028".

Je pense que tu voulais faire l'inverse : tant que la valeur du groupe DXF 2 est différente de "REP1028".

Attention toutefois avec ce genre de boucle, tu auras une erreur si le bloc sélectionné ne contient aucun attribut dont l'étiquette est "REP1028".

[bigsyke]

Merci Gile pour tes explications!

 

En effet en mettant

 
(while (/= (cdr (assoc 2 (entget sel)) "REP1028"))

cela marche exactement comme je voulais tout en sachant qu'il faut que je sois sur que le bloc selectionner contiennent bien l'etiquette REP1028.

Pour ce qui est de ton lisp j'avais bien vue att n'étais pas le bon terme et qu'a la place j'aurais mis blk mais tu es tellement calé en lisp que j'ai eu un doute ;) . De plus je trouve que tu conditionnes par mal a coup de "if" histoire d'etre sur d'etre dans les clous :)

Je voulais aussi te remercie pour ton explication concernant "while" et je vais immediatement et precieusement la noté sur un pense bete

Grace a toi je vais pouvoir continuer dans mon apprentissage d'autolisp :D

Prochaine étape, faire en sorte que le lisp s'arrete proprement dès qu'il aura atteint le SEQEND

 

En core mille merci pour ton aide Gile ;)