---

IDECLARE.zip

habt ihr manchmal auch das problem, daß ihr bei eurer lisp-programmierung vielleicht die eine oder andere deklaration von var's vergeßt ??
oder es mühselig wird, am schluss alle var's zu finden und abschliessend zu deklarieren ??
ich habe in den tiefen des internets ein command-line proggie gefunden, welches einem die arbeit abnimmt.

das programm deklariert alle gefundenen variablen. eine globale var erkennt das programm durch einen präfix # oder eigene z.b. *globalvar* (*).

aufruf des programms : ideclare *.lsp * (2. ausdruck = def. für globale var)

empfehlung : einen separaten ordner anlegen und dort alle lisps ablegen und mit *.lsp aufrufen, denn das programm findet irgendwie keine datei, aber mit *.lsp oder a*.lsp geht's !

aufruf ohne parameter = hilfetext (eng)
der alte quellcode wird gesichert unter *.org (standard)
ich habe es eben mit einige Quellcodes probiert, auch mit unterfunktionen. scheint einwandfrei zu funktionieren !!

der autor des programms : Rollin Laird <rplaird@earthlink.net>

eine KLASSE idee (imho)

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP

---

Leider bleibt's eine unsichere Methode, da es letztlich Variablen im strengeren Sinne in AutoLisp gar nicht gibt. Schliesslich kann man die Bindung eines Wertes an ein Symbol auch über Konstruktionen wie (set(read(strcat(read-line ... usw. erreichen, d.h. es entstehen Bindungen an Symbole, die im Sourcecode gar nicht vorhanden sind. Natürlich macht das nicht jeder, OK;-)

Wenn man einfach mal testen will, was so im Speicher hängenbleibt, reicht aber ein wesentlich einfacheres Verfahren:

(defun birth-control!( / )
(setq *old-family* (cons'*old-family*(atoms-family 0)))
(princ)
)

(defun young-kids( / ) ; langsame, einfache Version
(foreach e(atoms-family 0)
(if(not(member e *old-family*))
(setq l3(cons e l3))
)
)
(reverse l3)
)

Befehl: (birth-control!)
Befehl: (load "myProgram") => C:MYPROGRAM
Befehl: myProgram (ausführen)
Befehl: (young-kids) => (*GLOBAL1* I DONE ...)

Oooops, da haben wir einen Schleifenzähler namens 'i' und ein Flag namens 'done' vergessen zu lokalisieren! Das kann bös ins Auge gehen!

birth-control wirkt auch bei 'Variablen', die nicht im Sourcecode stehen;-)

Gruss, Axel

------------------
Meine AutoLisp-Seiten
Meine private Homepage
Mein Angriff auf dein Zwerchfell
Mein Lexikon der Fotografie
Mein gereimtes Gesülze
Meine Überzeugung...

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP

---

irgendwie hab ich's ja geahnt, daß da noch andere möglichkeiten vorh. sind !

deine routine is interessant und das langsamere stört mich nicht ;-)

Zitat:

---

...Konstruktionen wie (set(read(strcat(read-line ... usw. erreichen, d.h. es entstehen Bindungen an Symbole, die im Sourcecode gar nicht vorhanden sind. Natürlich macht das nicht jeder, OK;-)

---

ERWISCHT !
hab' das mit dem set eh noch nicht ganz so kapiert, wofür man so etwas gebrauchen kann, naja anfänger halt :-)

dank dir für dein statement !

[Diese Nachricht wurde von benwisch am 11. April 2003 editiert.]

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP

---

Ich erklär doch so gerne;-)

Wenn du eine Funktion mit Argumenten fütterst, werden diese evaluiert:

(setq a 3 b 4)
(+ a b) => 7   ;Die Funktion + evaluiert die beiden Symbole a und b und addiert deren Inhalte

Noch ein Beispiel:

(setq a "this" b "that")
(strcat a b) => "thisthat"  ;strcat macht das genauso

Aber defun z.B. nicht:
(setq a 'meineFunktion)

(defun a ( / ) ....) => Geht nicht - dann heisst die Funktion 'a'!
(defun (eval a) ( / ) ... => auch nicht!!! Fehler!

Defun erwartet ein Symbol als erstes Argument, und das muss nicht mal gequotet werden: defun unterdrückt im Gegensatz zu + oder strcase die Evaluation des 1. Arguments.

Solche Funktionen, die die Evaluation eines oder mehrerer Argumente unterdrücken, nennt man Special Forms. Defun ist eine SF, es unterdrückt nicht nur die Ev. des ersten Arguments, sondern auch aller anderen. while unterdrückt alle ausser dem ersten, foreach alle ausser dem zweiten.

Langer Rede kurzer Sinn: setq ist eine special form von set. Das q im Namen zeigt an, dass das 1. [3. 5. 7. ...] Argument gequotet wird. Also:

(set 'a 3) <=> (setq a 3)
Die beiden Ausdrücke haben identische Wirkung. Wenn man den Variablenname kennt, verwendet man üblicherweise setq. Ist der Variablenname aber verborgen (d.h. in einer anderen Variablen abgelegt), nimmt man set:

(setq varname(read(getstring "Wie soll die Variable heissen?: ")))
(set varname 777)

Nehmen wir mal an, der User gibt "dingenskirchen" ein. In der set-Anweisung evaluiert varname zum Symbol dingenskirchen. Nachher hat dingenskirchen (oder was immer der DAU eintippt) den Wert 777. Würde man hier setq verwenden, dann hätte varname zum Schluss den Wert 777!

Das sollte es doch klarmachen, oder? Und dieses kleine Beispiel zeigt, wie leicht man es plötzlich mit Variablen zu tun hat, die in keinem Sourcecode auftauchen. Ein Tool, dass Source-Dateien untersucht, kann 'dingenskirchen' niemals finden. Über die Atomliste kann man sowas allerding nachträglich aufspüren. Hat man dann so eine dynamische Variable gefunden, kann man z.B. mit (let ...) durchaus dafür sorgen, dass sie lokal bleibt.

Gruss, Axel

------------------
Meine AutoLisp-Seiten
Meine private Homepage
Mein Angriff auf dein Zwerchfell
Mein Lexikon der Fotografie
Mein gereimtes Gesülze
Meine Überzeugung...

[Diese Nachricht wurde von mapcar am 11. April 2003 editiert.]

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP

---

jetzt bin immer noch nicht im we, da ich mir das verdeutlichen wollte. jetzt ist mir der unterschied zw. set und setq klar, jedoch der sinn dieser funktion nur zum teil....

Code:

---

(defun FUNK (W1 W2 /)
  (read (chr (+ W1 W2)))
  )
(defun dwgna (/)
  (setq *wo?* (read(substr (getvar "dwgprefix") 4))
  ))

(set (FUNK 65 7) (* 5 2)) ;dynvar H gesetzt
(dgwna);_ richtet eine *global* ein
(set *wo?* "hier tut sich was");_entspricht im bsp. PROJEKTE="hier tut sich was"

---

spontan (naja, stimmt nicht ganz) fällt mir eine nutzbringende möglichkeit ein...

Code:

---

(setq global-list '(*v1* *v2* *v3* *v4* *v5*));_ alle globale Vars in einer liste speichern

(mapcar '(lambda (x) ( set x nil)) global-list);_mit einem schlag alle globalen Vars zurücksetzen, oder was auch immer

---

die zeit wird mir bestimmt noch'n paar mehr nutzbringende möglichkeiten für diese funktion geben....

@mapcar
danke für deine wertvollen info's
...so machen hobby's spaß !!!!

schönes we

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP

---

Ok, Benwisch,

ich versuche mal, dir den Sinn solcher Methoden auf ganz andere Weise klarzumachen: Ein Mitschnitt der Autocad-Kommandozeile:

------------
Befehl  einlesen)
was-denn? Schrauben
wo-denn? e://import//schrauben.txt
Danke! Funktionen für Schrauben M6, M8, M10, M12 ... wurden erzeugt!
Befehl: zoom
g
Befehl: (zeichne-m8 35)
... usw.

So etwa könnte das aussehen. Du importierst eine Parametrik, und Lisp erzeugt dir daraus einen Haufen Funktionen, die du ab sofort benutzen kannst.

Anderes Beispiel: Es ist doch ziemlich lästig, dass man auf Geometriedaten, sagen wir mal den Layer, immer mit
(cdr(assoc 8(entget... zugreifen muss. Also schreibt man sich folgende Funktion:

(defun mk-assocs( / )
  (foreach task
    '( ("ename" . -1)("etype" . 0)("layer" . 8)("color" . 62)   ("space" . 67)("owner" . 330))
        (set(read(strcat(car task)"<"))(list(list'ent)(list'cdr(list'assoc(cdr task)(list'entget'ent)))))
  )
)

Die haut man sich dann in die acad.lsp. Und ab jetzt geht alles einfacher: Um z.B. einen Layer zu ermitteln, reicht das:

(layer< (entlast))  => "0"
(space< (car(entsel))) => 0
(mapcar'owner<(ssget)) => (<Objektname: 40084cf8> <Objektname: ......)

Und das war nur eine Auswahl von ein paar Gruppencodes! Nimm dir die DXF-Referenz und tipp alle ein, bei denen es Sinn macht: ("handle" . 5), ("name" . 2)("layout" . 410) usw.!!!

So schaffst du mit 3 Zeilen Code vielleicht hundert Funktionen, die du den Rest deines Lebens benutzen kannst. Und für KEINE dieser Funktionen gibt es irgendeinen Sourcecode. Und wenn du Geschmack daran gefunden hast:

(color>(entlast)3) => und schon ist das Ding grün! (Hier nicht mit drin!)

Wird der Sinn jetzt klar?

Ach so: Hier nochmal die für 'VisualLisp' otimierte Version, die Funktionen erzeugt, keine ausführbaren Listen:

(defun mk-assocs( / )
  (foreach task '( ("ename" . -1)("etype" . 0)("layer" . 8)("color" . 62)("space" . 67)("owner" . 330))
    (eval(list'defun(read(strcat(car task)"<"))(list'ent)(list'cdr(list'assoc(cdr task)(list'entget'ent)))))
  )
)

Gruss, Axel

------------------
Meine AutoLisp-Seiten
Meine private Homepage
Mein Angriff auf dein Zwerchfell
Mein Lexikon der Fotografie
Mein gereimtes Gesülze
Meine Überzeugung...

[Diese Nachricht wurde von mapcar am 12. April 2003 editiert.]

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP

---

Axel, Du bist ein "Tier"...
Ich bin (mal wieder) sprachlos.

------------------
Ciao,
Marc

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP

---

schliesse mich voll an marc's worten an !!
damit hast du mir bestimmte regionen in der black box "aufgebohrt". megatoll, daß man hier so unterstützt wird....

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP