---

Hallo Lisp'ler,
viele von uns haben sich ja schon mit den Lisp-Seiten des von uns allen geschätzten Axel Strube-Zettler (alias mapcar) befaßt.
Vielleicht ist auch der ein oder andere auf das Thema Errorhandler gestoßen...
Ich habe mich mal damit auseinander gesetzt, ein paar Schönheitsfehler gefunden und bereinigt und 'ne Idee für eine Erweiterung gehabt, welche ich jedoch nicht umsetzen konnte.
Ich habe mich mit meinem Problem an Axel gewandt, welcher mich bat die Diskussion um diese Geschichte öffentlich zu machen.
Prima Idee. Here it comes (Inhalte folgen in der Antwort zu diesem Vorwort):
In der Hoffnung auf rege Beteiligung,
Marc

[Diese Nachricht wurde von marc.scherer am 19. Feb. 2004 editiert.]

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

---

Hallo Marc!
Bin dabei.. , aber das weißt du ja!

Gruß Thomas

------------------

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

---

Hier meine Anpassung des von mapcar veröffentlichen Codes:

Code:

---

(defun STARTERRORHANDLER
      (NAME UNDOMODE VARSTOSAVE / ERRORTEMPLATE SAVELIST)
  (setq ERRORTEMPLATE
        '((MSG / NAME UNDO SAVEDVARS PREVIOUSHANDLER)
          (while
            (> (getvar "cmdactive") 0)
            (command)
          )
          ;; **************************************************************************
          ;; Hier eine Änderung: Ich will doch diese Meldung nur haben, wenn Fehlerfall
          ;; nicht wenn ich ENDERRORHANDLER aufrufe...
          ;; **************************************************************************
          (if
            MSG
            (progn
            (princ (strcat "\n" NAME ": vorheriger Handler = "))
            (princ PREVIOUSHANDLER)
            )
          )
          (command "_.undo" "_end")
          ;; **************************************************************************
          ;; Hier eine Änderung: Undo soll doch auch NUR im Fehlerfall ausgeführt werden.
          ;; NICHT wenn ENDERRORHANDLER ruft
          ;; **************************************************************************
          (if
            (and
            UNDO
            MSG
            )
            (command "_.u")
          )
          (foreach
            PAIR
            SAVEDVARS
            (setvar (car PAIR) (cdr PAIR))
            ;; **************************************************************************
            ;; Schönheitskorrektur: Rücksetzmeldungen nur im Fehlerfall...
            ;; **************************************************************************
            (if
            MSG
            (progn
              (princ
              (strcat
                "\n"
                NAME
                ": Setze \""
                (car PAIR)
                "\" zurück auf "
              )
              )
              (princ (cdr PAIR))
            )
            )
          )
          (setq *ERROR* PREVIOUSHANDLER)
          ;; **************************************************************************
          ;; Schönheitskorrektur: Meldungen nur im Fehlerfall...
          ;; **************************************************************************
          (if
            MSG
            (progn
            (princ (strcat "\n" NAME ": \"" MSG "\""))
            (if
              PREVIOUSHANDLER
              (PREVIOUSHANDLER MSG)
            )
            )
          )
          )
  ) ;_ end of SETQ
  (command "_.undo" "_begin")
  (foreach PAIR VARSTOSAVE
    (setq
      SAVELIST (cons (cons (car PAIR) (getvar (car PAIR))) SAVELIST)
    ) ;_ end of SETQ
    ;; **************************************************************************
    ;; Korrektur: Bei Dir steht >>    (SETVAR (CAR PAIR) (CDR PAIR))
    ;; läuft aber nur mit "CADR" nicht mit "CDR"
    ;; **************************************************************************
    (setvar (car PAIR) (cadr PAIR))
  ) ;_ end of FOREACH
  (setq *ERROR* (append
                  (list (car ERRORTEMPLATE))
                  (if UNDOMODE
                    '((setq UNDO 't))
                  ) ;_ end of IF
                  (list (list 'setq
                              'PREVIOUSHANDLER
                              (cons 'quote
                                    (list *ERROR*)
                              ) ;_ end of CONS
                        ) ;_ end of LIST
                  ) ;_ end of LIST
                  (list (list 'setq 'NAME NAME))
                  (list (cons 'setq
                              (cons 'SAVEDVARS
                                    (list (cons 'quote
                                                (list SAVELIST)
                                          ) ;_ end of CONS
                                    ) ;_ end of LIST
                              ) ;_ end of CONS
                        ) ;_ end of CONS
                  ) ;_ end of LIST
                  (cdr ERRORTEMPLATE)
                ) ;_ end of APPEND
  ) ;_ end of SETQ
)

---

Meine Idee zur Erweiterung der Routine betrifft das WKS.
Was ich ständig habe, ist das setzen des WKS am Anfang einer Funktion und zurücksetzen eines eventuell vorher bestehenden BKS.

Dazu schicke ich immer folgendes dem Starterrorhandler nach:

Code:

---

(setq UCSFLAG (WORLD-UCS)) ;; Funktion WORLD-UCS siehe unten

---

und stelle dem ENDERROHANDLER folgendes voran:

Code:

---

(if UCSFLAG
    (command "_.ucs" "_p")
) ;_ end of if

---

Wie könnte man diese Funktionalität noch in das Errortemplate einbauen, ohne das es die hervoragenden Eigenschaften (zuverlässige Arbeit AUCH bei verschachteltem Error-Handling) der Basis-Funktion negativ beeinflußt?
Ich habe schon rumgepuzzelt, aber leider nicht genug Durchblick
um ein zufriedenstellendes Ergebnis zu erhalten.

Ich hatte mir gedacht, das man den Starterrorhandler-Aufruf noch um ein WKSFLAG Argument erweitern könnte, ähnlich dem UNDOMODE.
Ist WKSFLAG T, setze WKS und resette BKS, wenn eines vorhanden war.
Ist aber bei verschachteltem Starterrorhandler-Aufruf schwierig, oder?

Hier noch die WKS-Funktion für o.g. Aufruf:

Code:

---

(defun WORLD-UCS (/ RETVAL)
  (if (= (getvar "worlducs") 0)
    (progn
      (command "_.ucs" "_w")
      (setq RETVAL t)
    ) ;_ end of progn
  ) ;_ end of if
  RETVAL
) ;_ end of defun

---

..

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

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

---

..eine Erweiterung für evtl. Verwendung von globalen Variablen .. nicht nur Systemvariablen :

(defun StartErrorHandler
  .......
      (foreach PAIR SAVEDVARS
        (if (Getvar (car PAIR))
          (setvar(car PAIR)(cadr PAIR))
          (set (read(car PAIR)) (cadr PAIR))
        )
      )
......
und für evtl. Ausleuchten abschalten
    (setq ZAEHLER 0)
    (setq AUSWAHLSATZ (ssget "X"))
    (while (and AUSWAHLSATZ (setq ELEMENT (ssname AUSWAHLSATZ ZAEHLER)))       
        (redraw ELEMENT 4)                     
        (setq ZAEHLER (1+ ZAEHLER))
    )
........

der gesamte Code _meiner_ Anpassung ist z.B. unter http://ww3.cad.de/foren/ubb/uploads/CADmium/SORT_BY_LAYER.txt
mit enthalten

P.S. Eine gemeinsame "Eierlegende Wollmilchsau" als CAD.DE -Error-Handler wär nicht schlecht!

Thomas

------------------

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

---

Hi,

prima Idee!
Und für alle, die was gegen (command - Aufrufe in Lisps haben  das ActiveX-Äquivalent für die UNDO-Markierungen:
(or *doc* (setq *doc* (vla-get-ActiveDocument (vlax-get-acad-object))))
  (vla-endundomark *doc*)
  (vla-startundomark *doc*)

Hat leider zwei kleine Nachteile:
1. Unter LT+Extender wäre das nicht einsetzbar und
2. wären das die einzigen ActiveX-Zeilen im ganzen Errorhandler.

Aber wen(n)'s nicht stört...

Gruß
CADchup

------------------
www.cadditions.de

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

---

Hi Leute,

freut mich ja, dass das nun doch mal auf Interesse stößt;-)

Ich hab's bisher nur überflogen, werde mich erst im Laufe des Tages noch mal richtig damit auseinander setzen. Aber eines gleich vorab: Die Änderungen, was die Meldungen betrifft, sind schon ok. Ich veröffentliche auf meinen Seiten ja auch nie fertige Programme - für die Downloads zum Direktanwenden ist ja Cadwiesel zuständig, und es ist ja schon vorgekommen, dass ich Sachen da reingestellt habe und nicht bei mir. Mir ging's bei den Meldungen nur um den Lerneffekt - da, wo dieser Errorhandler bisher in der Praxis läuft, schwallt er die User auch nicht so voll;-)))

Ich fänd das eine gute Idee, wenn das Ding zum Schluss so richtig ausgefeilt hier und/oder bei Cadwiesel zum Download bereitstünde - ich glaube, ich habe das auf meiner Seite auch schon so formuliert: Es macht doch wirklich keinen Sinn, dass Hundertausende Lisp-Programmierer sich bei jedem Programm immer wieder einen neuen Errorhandler schreiben. In allen anderen Sprachen wird auf Bibliotheken zurückgegriffen, nur die AutoLispler tun sich damit ganz gewaltig schwer und versuchen immer wieder, das Rad neu zu erfinden...

Ich melde mich also noch einmal!

Gruß, 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

---

Tja, ich bin noch nicht viel weiter:-( Ich habe mich erstmal mit dem Fehler befasst, den Marc da festgestellt hat: Die Zeile
(if undo(command"_u")) war schlicht falsch. Ich hatte das auch schon mal gemerkt und bei mir verbessert, hatte aber vergessen, es im Tutorial zu korrigieren.

Ich habe das aber erstmal zum Anlass genommen, gleich ein weiteres Problem zu lösen, das damit zusammenhängt: Bei einem verschachtelten Aufruf mit Undo-Flag lassen sich die Undo-Gruppen nicht nahtlos aneinandersetzen, da zwischen den Undogruppen jeweils der Programmaufruf als Einzelbefehl gespeichert wird. Die Undo-Schachtelung sieht also z.B. bei 3 Errorhandlern so aus, dass man 5 Undos braucht, um wieder in den Urzustand zu kommen. An diesem Problem bastele ich schon seit langem, finde aber keine Lösung. Ich habe aber die Sache jetzt so umgestrickt, dass (bei eingeschaltetem Undo-Flag) auch ein Fehler im 5. verschachtelten Programm alles auf den Zustand vor dem Start des 1. Programms zurücksetzt.

Dazu muss nur diese falsche Zeile (if undo(command"_u")) durch das hier ersetzt werden:

Code:

---

(if(and undo msg)
  (if(listp previousHandler)(command"_u""_u")(command"_u"))
)

---

Dadurch werden ab der zweiten Instanz des Handlers immer zwei Undos ausgelöst, in der ersten Instanz aber nur eines (Getestet wird einfach, ober der vorherige Handler eine Liste ist - die eingebaute Acad-*Error*-Funktion ist aber eine <#Subr> ).

Und nun zur eigentlichen Sache, den UCSs. Der Verdacht liegt nahe, dass dann auch noch z.B. der Ausschnitt oder das Layout oder irgendetwas auch noch eingebaut werden soll;-))) Damit es nun aber nicht eine lange Reihe von Flags gibt, denke ich eher an ein Konzept mit 'Huckepack'-Funktionen, die vom Handler mitgezogen und ausgeführt werden. Da ließe sich dann alles drin unterbringen, z.B. das Rücksetzen der Uservariabeln oder sonstwas.

Ich melde mich am Montag oder Dienstag nochmal dazu.

Gruß, 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

---

eine Ergänzungsidee habe ich dem Thema auch noch beizusteuern !

Es betrifft die Texthöhe. Ich setze bei Funktionen, die einzeiligen Text erstellen immer die Texthöhe des Stils auf 0. Dann kann ich sichergehen, dass beim entsprechenden Command-Befehl auch nach der Texthöhe gefragt werde.

Am Ende der Funktion und bei der entsprechenden Fehlerroutine wird dann die alte Texthöhe wieder eingesetzt.

Gruß Jan :-)

------------------
jan :-)

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

---

Ich habe mich heute nochmal mit der Sache befasst, bin aber noch nicht bei den Huckepack-Funktionen angekommen. Erstmal habe ich ein bisschen aufgeräumt, und das ist dabei herausgekommen:

1. Ich habe mich von dem bisherigen Undo-Konzept verabschiedet. UNDO BEGIN und UNDO END kennen nun mal leider keine Verschachtelung, d.h. jedes BEGIN schließt automatisch eine noch offene Gruppe ab. Das lässt sich leider überhaupt nicht austricksen. Neues Modell: Nur noch die oberste (erste) Instanz des Errorhandlers erzeugt eine UNDO-Gruppe, alle weiteren nicht. Und nach dem Motto 'der letzte macht das Licht aus' schließt auch die erste Instanz die Gruppe zum Schluss ab. Auch bei neunzehnfach verschachteltem Handling gibt es also nur ein BEGIN/END.

2. Damit eine Instanz auch 'weiß', ob sie die erste oder eine spätere Instanz ist, habe ich einen Instanzenzähler eingebaut: Jeder Errorhandler hat nun eine lokale Variable namens instance, die eine Zahl von 1 bis nn enthält. Das ist nun ein schönes Beispiel dafür, dass in Lisp Funktionen durchaus als Datenlisten ausgewertet werden können: Der Anfang der *error*-Routinen sieht nun so aus:

( (MSG / NAME UNDO SAVEDVARS PREVIOUSHANDLER INSTANCE)
  (SETQ INSTANCE 0) ; <<< neu!
  (SETQ UNDO nil)
  (SETQ PREVIOUSHANDLER  ... usw.

Auch diese Zeile wird dynamisch eingesetzt. Ist der vorherige Handler die eingebaute SUBR, kommt da eine 0 hin - wenn nicht, wird diese Zahl aus der aktuellen *error*-Funktion ausgelesen und inkrementiert:

(1+(caddr(cadr *error*)))

Da wird also mit caddr und cadr auf ein Programm zugegriffen, cadr ermittelt die Zeile, caddr extrahiert die Zahl.

3. Das gesamte Ausgabe(Meldungs-)system habe ich auch umgebaut. Normalerweise arbeitet das Errorhandling jetzt völlig unsichtbar. Zum Ausprobieren kann man aber eine globale Variable namens *VERBOSE* setzen - dann gibt der Errorhandler einige Meldungen aus, aber auch nur dann, wenn ein Fehler auftritt. Die neuen Instanznummern werden dabei auch mit angezeigt.

Zum Ausprobieren hier der überarbeitete Code, und dazu ein paar Funktionen, mit denen man die Verschachtelungen schön testen kann. Die Eingabe einer Zahl dient nar dazu, dass man an dieser Stelle so schön ESC drücken kann.

Code:

---

(defun startErrorHandler(name undoMode varsToSave /
                          ErrorTemplate saveList instance o_cmdecho)
  (setq errorTemplate
  '( (msg / name undo savedVars previousHandler instance)
      ;... Zeile wird noch eingesetzt  ;(setq instance <> )
      ;... Zeile wird noch eingesetzt  ;(setq undo [T|nil])
      ;... Zeile wird noch eingesetzt  ;(setq previoushandler <> )
      ;... Zeile wird noch eingesetzt  ;(setq name <> )
      ;... Zeile wird noch eingesetzt  ;(setq savedvars (quote ...
      (while(>(getvar "cmdactive")0)(command))
      (if(= instance 1)
        (progn
          (command"_undo""_end")
          (if(and undo msg)(command"_u"))
        )
      )
      (foreach pair savedVars
        (setvar(car pair)(cdr pair))
        (if(and msg *verbose*)
          (progn
            (princ(strcat"\n"name"("(itoa instance)"): Setze \"" (car pair)"\" zurück auf "))
            (princ(cdr pair))
          )
        )
      )

      (setq *error* previousHandler)
      (if msg
        (progn
          (if(and(= instance 1)*verbose*)
            (princ(strcat"\nError:" name"("(itoa instance) "): \"" msg "\""))
          )
          (if previousHandler(previousHandler msg))
        )
      )
      (if(= instance 0)(princ))
    )
  )
  ;************
  (setq instance
    (if(or(=(type *error*)'SUBR)(null *error*))
      1
      (1+(caddr(cadr *error*)))
    )
  )
  (if(= instance 1)
    (progn
      (setq o_cmdecho(getvar"cmdecho"))
      (setvar"cmdecho"0)
      (command"_undo""_begin")
      (setvar"cmdecho"o_cmdecho)
    )
  )
  (foreach pair varsToSave
    (setq saveList
      (cons
        (cons(car pair)(getvar(car pair)))
        saveList
      )
    )
    (setvar(car pair)(cdr pair))
  )
  (setq *error*
    (append
      (list(car ErrorTemplate))
      (list(list 'setq'instance instance))
      (if undomode
      '((setq undo 'T))
      '((setq undo nil))
      )
      (list
        (list 'setq
          'PreviousHandler
          (cons'quote(list *error*))
        )
      )
      (list(list 'setq 'name name))
      (list
        (cons'setq
          (cons'savedvars
            (list(cons'quote(list savelist)))
          )
        )
      )
      (cdr ErrorTemplate)
    )
  )
  (princ)
)

(defun endErrorHandler( / )
  (*error* nil)
)

(defun c:Test1( / )
  (startErrorHandler "Test1-Handler" 'T '(("cmdecho" . 0)("filedia" . 0)))
  (command "_line" '(0 0)'(100 100)"")
  (getint "\nZahl für Test1 eingeben: ")
  (c:Test2)
  (endErrorHandler)
)

(defun c:Test2( / )
  (startErrorHandler "Test2-Handler" 'T '(("dispsilh" . 0)("filedia" . 0)))
  (command "_line" '(50 0)'(150 100)"")
  (getint "\nZahl für Test2 eingeben: ")
  (c:Test3)
  (endErrorHandler)
)

(defun c:Test3( / )
  (startErrorHandler "Test3-Handler" 'T '(("attreq" . 0)("fillmode" . 0)))
  (command "_line" '(100 0)'(200 100)"")
  (getint "\nZahl für Test3 eingeben: ")
  (c:Test4)
  (endErrorHandler)
)

(defun c:Test4( / )
  (startErrorHandler "Test4-Handler" 'T '(("cmdecho" . 0)("ucsicon" . 0)))
  (command "_line" '(150 0)'(250 100)"")
  (getint "\nZahl für Test4 eingeben: ")
  (c:Test5)
  (endErrorHandler)
)

(defun c:Test5( / )
  (startErrorHandler "Test5-Handler" 'T '(("surftab1" . 16)("surftab2" . 16)))
  (command "_line" '(200 0)'(300 100)"")
  (getint "\nZahl für Test5 eingeben: ")
  (endErrorHandler)
)

---

Gruß, 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

---

Noch was vergessen: Das neue Konzept impliziert auch, dass das mitgegebene Undo-Flag wirklich nur noch in der ersten Instanz wirksam ist - alles andere war sowieso Kuddelmuddel;-)

------------------

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

---

Hi Axel,
ich hänge an Deinen Lippen... :-)
Aber wie hast Du das mit der Huckpack-Funktion gemeint?
Übergabe eines Codes als Argument?
Hab' k.A. wie das für den Fall der BKS/WKS/BKS laufen könnte...

Zum Schleifenzähler: Eigentlich ist doch nur 'n "FirstInstance" Flag notwendig, oder habe ich da was falsch verstanden? Ist der Zähler essenziell oder nur für das Debuggen gut?

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

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

---

... an meinen Lippen? Ist doch bis auf das Tastaturklappern eher eine geräuschlose Kommunikation;-)

Genau genommen ist der Instanzenzähler gar nicht notwendig. Es würde ja reichen, wenn jede Instanz einfach auf (if(or(null previousHandler)(=(type previousHandler)'SUBR))...) testen würde, und nur, wenn dieser Test ein T ergibt, wird das _u ausgeführt. Ich finde ihn aber ganz nett im Fehlerfall - man hat zwar die Namen der Handler, aber so hat man zusätzlich die Information über die Reihenfolge. Es wäre ja denkbar, dass die Programme sogar rekursiv arbeiten;-) Das ist auch der Grund, weshalb ich hier die Zählung bei 1 statt bei 0 angefangen habe.

Die Huckepackfunktionen natürlich wie immer: eine (lambda-)expression als Argument. Das kann dann inline-code werden oder es können auch externe fertige Programme sein, die man anklinkt. Du kannst ja schon mal zwei Routinen bereitstellen: (save-ucs) und (restore-ucs ucsdata) zum Sichern und Wiederherstellen des BKS.

So wie ich das sehe, werden das 3 neue Argumente:

1 on-start (wird sofort nach dem Sichern der Sysvars ausgeführt)
2 on-end (immer, wird als letztes vom Handler ausgeführt)
3 on-error (wird nur im Fehler-/Abbruchfall ausgeführt)

Bis denne, 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

---

Eine kleine Vorbereitung für die Huckepack-Funktionen: Es geht nicht, dass man Daten wie die des aktuellen BKS einfach in einer globalen Variablen speichert, also etwa so:

Code:

---

(defun save-ucs( / )
  (setq *ucsdata*(vla-irgendwas...
)

(defun restore-ucs( / )
  (vla-irgendwas-anderes ... *ucsdata*)
)

---

Das würde nämlich bedeuten, dass jede weitere Instanz des Handlers diese BKS-Daten gnadenlos überschreibt! Daher müssen die Daten auf einem Stapel (stack) abgelegt werden. In diesem Fall ist das simpelste Stackmodell angesagt: der LIFO-Stack (Last In First Out). Für einen Stack braucht man immer zwei Funktionen, das Ablegen (push) und das Wegnehmen (pop). Die sehen so aus:

Code:

---

;legt ein Element auf einem Stapel ab und gibt es zurück
(defun push!(elm stacksym / )
  (set stacksym(cons elm(eval stacksym)))
  elm
)

;nimmt ein Element von einem Stapel herunter und gibt es zurück
(defun pop!(stacksym / elm)
  (setq elm(car(eval stacksym)))
  (set stacksym(cdr(eval stacksym)))
  elm
)

---

Das Ausrufungszeichen kennzeichnet diese Funktionen als destruktiv, d.h. es erfolgt eine Bindung als Seiteneffekt (wie bei set, setq, defun und ssadd). ssadd ist ein prima Beispiel - wir schreiben da ja nicht (setq ss(ssadd ss element)), sondern nur (ssadd ss element), und schon ist der neue Wert an ss gebunden. append im Gegensatz ist nicht destruktiv - da muss ein explizites setq drumgewickelt werden, wenn eine Bindung erfolgen soll!

Zurück zu push! und pop!: Die Funktion push! hat zwar eine Rückgabe, aber die interessiert nicht. Und schön an die Quotezeichen denken!

Für die Kommandozeile zum Ausprobieren:

Code:

---

(push! '(1 2 3) '*myStack*) => (1 2 3)
!*myStack*                  => ((1 2 3))
(push! 4 '*myStack*)        => 4
!*myStack*                  => (4(1 2 3))
(push! nil '*myStack*)      => nil
!*myStack*                  => (nil 4(1 2 3))
(push! '(x y) '*myStack*)  => (x y)
!*myStack*                  => ((x y)nil 4(1 2 3))

;pop! nimmt das jeweils letzte Element wieder aus dem Stack und gibt es zurück:

(pop! '*myStack*)          => (x y)
!*myStack*                  => (nil 4(1 2 3))
(pop! '*myStack*)          => nil
!*myStack*                  => (4(1 2 3))
(pop! '*myStack*)          => 4
!*myStack*                  => ((1 2 3))
(pop! '*myStack*)          => (1 2 3)
!*myStack*                  => nil

---

Da pop! sowohl nil zurückgibt, wenn der Stack leer bzw. nicht vorhanden ist, als auch dann, wenn ein nil gepusht wurde, muss man sorgfältig darauf achten, dass nicht mehr gepoppt als gepusht wird;-)

Also: Daten wie die BKS-Daten nicht mit setq einer Variablen zuweisen, sondern pushen und poppen. Nur so überschreiben sich die verschachtelten Aufrufe nicht gegenseitig die Daten!

Code:

---

(defun save-ucs( / )
  (push! (vla-irgendwas ...) '*ucsdata*)
)

(defun restore-ucs( / )
  (vla-irgendwas-anderes (pop! '*ucsdata*))
)

---

So, ich hoffe, ich hab das Prinzip verständlich rübergebracht...

Gruß, 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

---

Da du die Handler stapelts, kannst du doch auch deine anderen Vars, wie UCS usw mit reinpacken

(setq ErrorTemplate .....                                      
...  
      (foreach PAIR SAVEDVARS
        (if (Getvar (car PAIR))
          (setvar(car PAIR)(cadr PAIR))
          (set (read(car PAIR)) (cadr PAIR))
        )
      )
..

und SetERRORHANDLER dann

(if (=(type VARS_TO_SAVE) 'LIST)   
    (foreach PAIR VARS_TO_SAVE
      (if (=(type PAIR) 'LIST)
(if (=(length PAIR) 2)
  (if (=(type(car PAIR)) 'STR)

            (if (Getvar (car PAIR))    
              (progn
                (setq SAVELIST  (append SAVELIST
                                        (list (list (car PAIR) (getvar (car PAIR)))))
                )                                                                    
                (setvar(car PAIR)(cadr PAIR))     
              )
              (progn
                (setq SAVELIST  (append SAVELIST  
                                        (list (list (car PAIR) (eval(read(car PAIR))))))
                )                                                                      
                (set (read(car PAIR)) (cadr PAIR))       
              ) 
            )
          )
        )
      )
    )
  ) 

oder nicht ?

Aber die Huckepack mit lambdas ist mit Sicherheit universeller.

[Sorry, die Formatierung ist so wie sie rüberkommt wirklich Sch..]
------------------
  - Thomas -

[Diese Nachricht wurde von CADmium am 24. Feb. 2004 editiert.]

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

---

Hi Thomas,

das ginge im Prinzip, aber ich versuche, die Sache so klein wie möglich zu halten. Mit deinem Code habe ich allerdings Probleme: Völlig unleserlich, da ohne Prinzip ein- und ausgerückt, und ich sehe, dass du mit (length..) auf ein Pair zugreifst - das erzeugt einen Fehler... Oder sind's keine Pairs, sondern Listen? Dann solltest du sie auch nicht 'Pair' nennen;-)

Mir gefällt der Gedanke aber nicht besonders, denn die Strukturen sind nicht gleich: Den Sysvars wird normalerweise beim Start des Errorhandlers ein Wert verplättet, den Lisp-Variablen aber nicht - die haben ja schon einen. Hier liegt aber das Prinzip des gleichzeiten Abspeicherns und Neusetzens vor.

Ich würde die Lisp-Variablen eher über den Start-Hook speichern und im Bad-Hook zurücksetzen. Da hat man dann alle Freiheiten - und wem das dann zu nervig ist, ellenlange Variablenlisten zu tippen, der kann sich im Start-Hook sogar ein Abbild des gesamten Lisp-Speichers auf die Platte schreiben und im Error-Fall wieder einlesen.

Es kommt auch gleich ein Beispiel, wie man (Lisp-)Variablen speichern kann, aber zunächst nochmal der Code des Errorhandlers mit einer Änderung, nämlich der Aufruf der Hook-Funktionen (jetzt muss man sie nicht mehr angeben, wenn man sie nicht braucht reicht ein nil):

Code:

---

(defun startErrorHandler(name undoMode varsToSave on-start
on-good on-bad / ErrorTemplate saveList instance o_cmdecho)
  (setq errorTemplate
  '( (msg / name undo savedVars previousHandler instance on-start on-good on-bad)
      ;... Zeile wird noch eingesetzt  ;(setq instance <> )
      ;... Zeile wird noch eingesetzt  ;(setq undo [T|nil])
      ;... Zeile wird noch eingesetzt  ;(setq previoushandler <> )
      ;... Zeile wird noch eingesetzt  ;(setq name <> )
      ;... Zeile wird noch eingesetzt  ;(setq savedvars (quote ...
      ;... Zeile wird noch eingesetzt  ;(setq on-start...
      ;... Zeile wird noch eingesetzt  ;(setq on-good...
      ;... Zeile wird noch eingesetzt  ;(setq on-bad...
      (while(>(getvar "cmdactive")0)(command))
      (if(= instance 1)
        (progn
          (command"_undo""_end")
          (if(and undo msg)(command"_u"))
        )
      )
      (foreach pair savedVars
        (setvar(car pair)(cdr pair))
        (if(and msg *verbose*)
          (progn
            (princ(strcat"\n"name"("(itoa instance)"): Setze \"" (car pair)"\" zurück auf "))
            (princ(cdr pair))
          )
        )
      )
      (if msg
        (progn
          (if(and(= instance 1)*verbose*)
            (princ(strcat"\nError:" name"("(itoa instance) "): \"" msg "\""))
          )
          (if on-bad((eval on-bad)))
        )
        (if on-good((eval on-good)))
      )
      (setq *error* previousHandler)
      (if(= instance 1)
        (princ)
        (*error* msg)
      )
    )
  )
  ;************
  (setq instance
    (if(or(=(type *error*)'SUBR)(null *error*))
      1
      (1+(caddr(cadr *error*)))
    )
  )
  (if(= instance 1)
    (progn
      (setq o_cmdecho(getvar"cmdecho"))
      (setvar"cmdecho"0)
      (command"_undo""_begin")
      (setvar"cmdecho"o_cmdecho)
    )
  )
  (foreach pair varsToSave
    (setq saveList
      (cons
        (cons(car pair)(getvar(car pair)))
        saveList
      )
    )
    (setvar(car pair)(cdr pair))
  )
  (if on-start((eval on-start)))
  (setq *error*
    (append
      (list(car ErrorTemplate))
      (list(list 'setq'instance instance))
      (if undomode
      '((setq undo 'T))
      '((setq undo nil))
      )
      (list
        (list 'setq
          'PreviousHandler
          (cons'quote(list *error*))
        )
      )
      (list(list 'setq 'name name))
      (list
        (cons'setq
          (cons'savedvars
            (list(cons'quote(list savelist)))
          )
        )
      )
      (list(list 'setq 'on-start on-start))
      (list(list 'setq 'on-good on-good))
      (list(list 'setq 'on-bad on-bad))
      (cdr ErrorTemplate)
    )
  )
  (princ)
)

---

Und nun das Beispiel: Die Funktion macht nix ausser ein paar Lisp-Variablen modifizieren. Gibt man eine Zahl ein, bleiben diese Werte erhalten. Bricht man die Zahleneingabe ab, werden die Variablen zurückgesetzt.

Code:

---

(defun save-vars(vars stack / )
  (foreach var vars
    (push!(cons var(eval var))stack)
  )
)

(defun restore-vars(stack / var)
  (repeat(length(eval stack))
    (setq var(pop! stack))
    (set(car var)(cdr var))
  )
)

(defun c:LV-Test( / )
  (startErrorHandler "LV-Test" 'T
    nil
  '(lambda( / )
      (if(= instance 1)
        (save-vars'(myVar1 myVar2 myVar3)'*myVarStack*)
      )
    )
    nil
  '(lambda( / )
      (if(= instance 1)
        (restore-vars '*myVarStack*)
      )
    )
  )
  (setq myVar1 4 myVar2 5 myVar3 6)
  (getint "\nIrgendeine Zahl eingeben oder ESC für Abbruch: ")
  (EndErrorHandler)
)

;Und so kann man's ausprobieren:

>(setq myVar1 1 myVar2 2 myVar3 3)
>LV-Test

---

Ach so, push! und pop! müssen auf dieser Party anwesend sein;-)

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

---

@Axel
1.Formatierung kommt wirklich saumäßig rüber - ist eigentlich nicht meine Art - war bei copy-paste-löschwasweg wohl übereifrig.
2.die Pairs sind Listen ala 2 - VarName und Var-Wert(egal was) und ich überprüfe wohl ein wenig viel <grins>
@All
3.die 3 Funktionen "on-start" "on-good" "on-bad" - denke ich - sind die universellste Lösung
4.und jetzt noch die Überlegung von Cadchup "Command _undo" oder vl-...??

------------------
- Thomas -

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

---

Da wo 'Pairs' draufsteht, sollten auch Pairs drin sein;-) In diesem Fall sind dotted pairs auch effektiver.

Zu der Command-Frage: Ich lese das ja öfters hier: "... sollte man vermeiden ..." - Warum denn eigentlich? Wirklich begründen will das aber keiner. Performance? Doch nicht bei einem vereinzelten Aufruf von UNDO *lach*. Die Performance-Frage würde sich stellen, wenn einer ein Programm schreibt, das Zehntausende UNDOs hintereinander absetzt;-)

Man sollte einfach nicht so pauschalisieren, sondern sich die jeweils beste Lösung heraussuchen. Wenn Mengen von Geometrie erzeugt werden, dann ist entmake besser/schneller als command, ohne Frage. Aber wenn ich nur mal vom Modell- in den Papierbereich will, dann ist ein command der sinnvollste Weg. Keine der Alternativen ist grundsätzlich schlecht oder gut, sie haben nur in gewissen Situationen ihre Stärken und Schwächen. Die muss man kennen und nutzen bzw. vermeiden.

Hier geht's um den Bruchteil einer Millisekunde! Und dafür einen Wust von ActiveX reinbringen? Das wichtigste Argument ist aber: So läuft der Handler mit jeder AutoCAD-Version einschließlich 2.6 (habe ich zwar nicht getestet, sollte aber gehen). Ältere Versionen kenne ich leider nicht, da kann ich also nichts dazu sagen;-)

Gruß, 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

---

Hi,
habe das nur schwer nachvollziehen können <schwitz>...

Bzgl. meines Wunsches der BKS/WKS/BKS Sache ist nun folgendes herausgekommen:

Code:

---

(defun C:WKSTEST (/)
  (STARTERRORHANDLER
    "WKSTest"
    't
    NIL
    '(lambda (/ UCSFLAG)
      (if (= INSTANCE 1)
        (progn
          (setq UCSFLAG (WORLD-UCS))
          (save-vars '(UCSFLAG) '*myVarStack*)
          )
      ) ;_ end of if
    ) ;_ end of lambda
    '(lambda (/ UCSFLAG)
      (if (= INSTANCE 1)
        (progn
          (restore-vars '*myVarStack*)
          (PREVIOUS-UCS)
          )
      ) ;_ end of if
    ) ;_ end of lambda
    '(lambda (/ UCSFLAG)
      (if (= INSTANCE 1)
        (progn
          (restore-vars '*myVarStack*)
          (PREVIOUS-UCS)
          )
      ) ;_ end of if
    ) ;_ end of lambda
  ) ;_ end of startErrorHandler
  (getint "\nIrgendeine Zahl eingeben oder ESC für Abbruch: ")
  (ENDERRORHANDLER)
)

;;; Funktion ermittelt, ob das Welt-Koordinatensystem
;;; zur Zeit des Aufrufs aktuell ist.
;;; Wenn nicht, wird es gesetzt und T zurückgegeben
;;; Wenn ja gibt die Funktion nil zurück
(defun WORLD-UCS (/ RETVAL)
  (if (= (getvar "worlducs") 0)
    (progn
      (command "_.ucs" "_w")
      (setq RETVAL t)
    ) ;_ end of progn
  ) ;_ end of if
  RETVAL
) ;_ end of defun

(defun PREVIOUS-UCS (/)
  (if UCSFLAG
    (command "_.ucs" "_p")
  ) ;_ end of if
) ;_ end of defun

---

Problem: Das mehrmalige Aufrufen und Abbrechen der WKSTEST Routine bewirkt die Merkwürdigkeit, das ein "verdrehtes", also ein anderes BKS wiederhergestellt wird. Wie zur Hölle das denn? Das verstehe ich nicht.

Zweitens: Axel, nur für mein Verständnis, ist die Variable UCSFLAG in den lambda Funktionen dort richtig um keine globale Variable UCSFLAG am Ende zu haben??

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

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

---

Hi,
und wieder bin ich über: (cdr pair) gestolpert...
Und da hab ich gedacht, es wäre doch schick, wenn es egal ist,
ob ich die Sysvar-Liste so:

Code:

---

'(("osmode" . 0)("cmdecho" . 0))

oder so

'(("osmode" 0)("cmdecho" 0))

eingebe.

---

Eine Änderung mit "listp" in:

Code:

---

(foreach PAIR VARSTOSAVE
  (setq SAVELIST
        (cons
          (cons (car PAIR) (getvar (car PAIR)))
          SAVELIST
        ) ;_ end of cons
  ) ;_ end of setq
  (setvar (car PAIR)
          (if (listp (cdr PAIR))
            (cadr PAIR)
            (cdr PAIR)
          ) ;_ end of if
  ) ;_ end of setvar
) ;_ end of foreach

---

erledigt das Problem...

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

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

---

Hi Marc,

vielleicht machst du dir das Leben ja nur selber schwer;-) Es müssen ja gar keine komplizierten, ellenlangen lambda-expressions sein. Du willst ja diese Sachen permanent benutzen - also pack sie in Funktionen, die du dann verwendest. Z.B. so:

Code:

---

; Greift auf die Variable instance des
; Errorhandlers zu - nur in diesem
; Environment aufrufen!
(defun save-ucs (/ ucsflag)
  (if (= instance 1)
    (progn
      (setq ucsflag (world-ucs))
      (save-vars '(ucsflag) '*ucsData*)
    )
  )
)

; Greift auf die Variable instance des
; Errorhandlers zu - nur in diesem
; Environment aufrufen!
(defun restore-ucs (/ ucsflag)
  (if (= instance 1)
    (progn
      (restore-vars '*ucsData*)
      (previous-ucs)
    )
  )
)

; Etwas gekürzt
(defun world-ucs ( / )
  (if (= (getvar "worlducs") 0)
    (progn (command "_.ucs" "_w")'T)
  )
)

(defun previous-ucs ( / )
  (if ucsflag
    (command "_.ucs" "_p")
  )
)

---

Dann sieht der Aufruf des Handlers viel gemütlicher aus:

Code:

---

(defun c:bks-test( / )
  (startErrorHandler
    "bks-test"
    'T
    '(("cmdecho" . 0)("ucsicon" . 3))
    'save-ucs    ; on-start
    'restore-ucs ; on-good
    nil          ; Undo setzt auch das BKS zurück!
  )
  (command "_line" '(100 0)'(100 100)"")
  (command "_ucs" "_n" '(100 0))
  (getint "\nIrgendeine Zahl eingeben oder mit ESC abbrechen: ")
  (endErrorHandler)
)

---

Zu deiner Frage wegen der Variablen UCSFLAG: Genau darum geht's - würde man da nur eine globale Variable *UCSFLAG* anlegen, würde eine zweite Instanz des Errorhandlers diese natürlich sofort überschreiben. In deinem Beispiel ist diese Variable allerdings nebensächlich, sie dient ja nur dem temporären Speichern. Abgelegt wird ja in *myVarStack* - bzw. ich hab das mal *ucsData* genannt. Der Name spielt aber gar keine Rolle, solange man beim pop den selben verwendet wie beim push. Der springende Punkt sind also diese Variablen, nicht ucsflag.

Im Prinzip ist schon alles ok, wie du es gemacht hast - allerdings sehe ich einen kleinen Denkfehler in der Logik: Es reicht wohl nicht, mit _ucs _p zu arbeiten. Damit kriegt man ja nur das letzte BKS - aber das Programm kann ja beliebig viele BKS produzieren und setzen. Dann kommst du nur auf das vorletzte, aber nicht auf das ursprüngliche zurück. Ich denke, man muss da schon die kompletten BKS-Daten speichern und das dann wiederherstellen.

Ehrlich gesagt: Ich hab jetzt keine Ahnung, wie man das macht. Wenn's nur um benannte BKS geht, kein Problem - UCS-Tabelleneintrag speichern und wiederherstellen (nur der Name des BKS würde nicht reichen - vielleicht läuft im Errorhandler ja ein ganz fieses Programm , das alles in der Zeichnung umbenennt - auch die BKS. Bei unbenannten BKS muss man wohl die UCS-Sysvars auslesen und sich dann ein Programm zum Wiederherstellen basteln - oder hat jemand eine bessere Idee? Deswegen wollte ich ich diese Aufgabe ja gern dir überlassen;-)

So, nun noch mal ein Hinweis zu den Funktionen save-ucs und restore-ucs - ich habe ja schon durch den Kommentar darauf hingewiesen: Diese Funktionen greifen auf die Variable instance im übergeordneten Namensraum zu. Das ist eine der Stärken von AutoLisp, aber gleichzeitig auch eine große Schwäche. Ruft man diese Funktionen ausserhalb des Errorhandlers auf, stürzen sie ab, weil es kein Instance gibt. Klar, dass man das weglassen könnte, aber dann würden bei verschachtelten Aufrufen evtl. mehrere BKS hintereinander wiederhergestellt. Weiss jetzt nicht, ob das REGEN verursachen würde... Die REGENmacherei sollte man den Schamanen überlassen. Ein Grund mehr, bei solchen Sachen nicht schnelle lambda-expressions zu verwenden, sondern getestete, fertige Funktionen. Es gibt ja kaum was schöneres als die Meldung "Es ist ein Fehler innerhalb der *Error*-Funktion aufgetreten". Das sollte man tunlichst vermeiden!

Und zum Schluss noch zu den PAIRS - ein beliebtes Thema. Bei ("cmdecho" . 0) bzw. ("cmdecho" 0) ist das ja gut und schön - aber wie ist es dann bei ("insbase" 0 0 0)? Mit den dotted pairs hat man die gewohnten Strukturen wie in der Geometrie-Datenbank. Alles Andere verwirrt nur, finde ich. So muss ich nicht nachdenken oder nachschauen. Ich würde also dafür plädieren, es beim konservativen Modell zu belassen. Deinen Code habe ich auch nicht ausprobiert - weiss nicht, was der bei insbase macht...

So, Schluss für heute. Jetzt wird gedaddelt;-)
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

---

Hi Axel,
das mit dem BKS sehe ich für mich als gelöst an.
Ich habe eigentlich immer nur den Fall am Anfang WKS setzen zu müssen und am Ende BKS (wenn aktiv war) wiederherzustellen.
Sollte ich mal 'n Pgm schreiben, welches an den BKS'en rummacht werde ich den von Dir angesprochenen BKS-Handler wohl schreiben müssen, aber derzeit ist da für mich kein Bedarf.

Der dotted Pair Kram ist natürlich 'ne Sache für sich. Da könnte man das streiten anfangen, ob überhaupt jemals jemand die INSBASE zur Laufzeit verändern wollte... Aber generell hast Du natürlich recht. Mit DPairs läuft es auf jeden Fall. Also konservatives Modell. Bin überzeugt...

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

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

---

Na denn hat ja wohl keiner mehr was dazu zu sagen?
Hier der finale Code, im Programm-Kommentar sind ein paar Beispiele zu finden.

Code:

---

;|
Globaler Errorhandler
Inklusive Undo-Funktion
Inklusive Huckepack-Funktions Unterstützung
- Beim Start
- Bei Durchlauf ohne Fehler
- Im Fehlerfall

Februar 2004
In Zusammenarbeit mit diversen CAD.DE Membern entstanden

Besonderer Dank an MAPCAR (http://www.autolisp.mapcar.net) für den Basis-Error-Handler
und all die netten Informationen über die netten Lisp-Interna :-).

StartErrorHandler : Stapelbare Fehlerbehandlungsroutine
Argumente:
NAME      = Frei wählbarer String.
Wenn eine (*error*)-Funktion etwas auf dem Bildschirm ausgibt,
setzt sie diesen Namen dazu, damit man erkennen kann, was von
welcher Instanz des Errhandlers kommt.

UNDOMODE     = kann T oder nil sein.
Gibt an, ob im Fehler- bzw. Abbruchsfall gleich der Befehl 'UNDO'
ausgeführt werden soll, um alle bis dahin
vorgenommen Aktionen sofort rückgängig zu machen.

VARS_TO_SAVE = Eine Liste der zu setzenden System- und globalen Variablen

ON-START     = Funktion die beim Start ausgeführt wird (nil für "nichts ausführen")

ON-GOOD      = Funktion die bei fehlerfreiem Durchlauf ausgeführt wird  (nil für "nichts ausführen")

ON-BAD       = Funktion die im Fehlerfall ausgeführt wird (nil für "nichts ausführen")

***********************************************************
* Debugging / Rückmeldungen des Errorhandlers aktivieren: *
* Setzen der GLOBALEN Variablen (setq *VERBOSE* T)        *
***********************************************************

Beispiel 1: Setzen / Rücksetzen von Sysvars
-------------------------------------------
(defun C:TEST (/)
  (STARTERRORHANDLER
    "Funktion TEST"
    't
    '(("cmdecho" . 0) ("filedia" . 0))
    nil
    nil
    nil
  ) ;_ end of startErrorHandler
 
  (machwas)
 
  (ENDERRORHANDLER) ;_ setzt die Variablen aus dem Argument NAME wieder zurück
) ;_ end of defun

Beispiel 2: Verwendung von User-definierten Variablen
-----------------------------------------------------
(defun C:LV-TEST (/)
  (STARTERRORHANDLER
    "LV-Test"
    't
    NIL
    '(lambda (/)
       (if (= INSTANCE 1)
         (SAVE-VARS '(MYVAR1 MYVAR2 MYVAR3) '*MYVARSTACK*)
       ) ;_ end of if
     ) ;_ end of lambda
    NIL
    '(lambda (/)
       (if (= INSTANCE 1)
         (RESTORE-VARS '*MYVARSTACK*)
       ) ;_ end of if
     ) ;_ end of lambda
  ) ;_ end of startErrorHandler
  (setq MYVAR1 4
        MYVAR2 5
        MYVAR3 6
  ) ;_ end of setq
  (getint "\nIrgendeine Zahl eingeben oder ESC für Abbruch: ")
  (ENDERRORHANDLER)
) ;_ end of defun

Beispiel 3: Setzen des WKS / Rücksetzen des BKS
-----------------------------------------------------
(defun C:WKSTEST (/)
  (STARTERRORHANDLER
    "WKSTest"
    't
    '(
      ("CMDECHO" . 0)
      ("CMDDIA" . 0)
      ("FILEDIA" . 0)
     )
    'SAVE-UCS                           ; on-start
    'RESTORE-UCS                        ; on-good
    NIL                                 ; Undo setzt auch das BKS zurück!
  ) ;_ end of startErrorHandler
  (getint "\nIrgendeine Zahl eingeben oder ESC für Abbruch: ")
  (ENDERRORHANDLER)
) ;_ end of defun

|;
(defun STARTERRORHANDLER (NAME         UNDOMODE     VARSTOSAVE
                          ON-START     ON-GOOD      ON-BAD
                          /            ERRORTEMPLATE
                          SAVELIST     INSTANCE     O_CMDECHO
                         )
  (setq ERRORTEMPLATE
         '((MSG         /           NAME        UNDO        SAVEDVARS
            PREVIOUSHANDLER         INSTANCE    ON-START    ON-GOOD
            ON-BAD
           )
           ;;... Zeile wird noch eingesetzt  ;(setq instance <> )
           ;;... Zeile wird noch eingesetzt  ;(setq undo [T|nil])
           ;;... Zeile wird noch eingesetzt  ;(setq previoushandler <> )
           ;;... Zeile wird noch eingesetzt  ;(setq name <> )
           ;;... Zeile wird noch eingesetzt  ;(setq savedvars (quote ...
           ;;... Zeile wird noch eingesetzt  ;(setq on-start...
           ;;... Zeile wird noch eingesetzt  ;(setq on-good...
           ;;... Zeile wird noch eingesetzt  ;(setq on-bad...
           (while (> (getvar "cmdactive") 0) (command))
           (if
            (= INSTANCE 1)
            (progn
             (command "_undo" "_end")
             (if
              (and UNDO MSG)
              (command "_u")
             )
            )
           )
           (foreach
            PAIR
            SAVEDVARS
            (setvar (car PAIR) (cdr PAIR))
            (if
             (and MSG *VERBOSE*)
             (progn
              (princ
               (strcat
                "\n"
                NAME
                "("
                (itoa INSTANCE)
                "): Setze \""
                (car PAIR)
                "\" zurück auf "
               )
              )
              (princ (cdr PAIR))
             )
            )
           )
           (if
            MSG
            (progn
             (if
              (and (= INSTANCE 1) *VERBOSE*)
              (princ
               (strcat "\nError:" NAME "(" (itoa INSTANCE) "): \"" MSG "\"")
              )
             )
             (if
              ON-BAD
              ((eval ON-BAD))
             )
            )
            (if
             ON-GOOD
             ((eval ON-GOOD))
            )
           )
           (setq *ERROR* PREVIOUSHANDLER)
           (if
            (= INSTANCE 1)
            (princ)
            (*ERROR* MSG)
           )
          )
  ) ;_ end of setq

  ;;*****************************************************

  (setq INSTANCE
         (if (or (= (type *ERROR*) 'SUBR) (null *ERROR*))
           1
           (1+ (caddr (cadr *ERROR*)))
         ) ;_ end of if
  ) ;_ end of setq
  (if (= INSTANCE 1)
    (progn
      (setq O_CMDECHO (getvar "cmdecho"))
      (setvar "cmdecho" 0)
      (command "_undo" "_begin")
      (setvar "cmdecho" O_CMDECHO)
    ) ;_ end of progn
  ) ;_ end of if
  (foreach PAIR VARSTOSAVE
    (setq SAVELIST
           (cons
             (cons (car PAIR) (getvar (car PAIR)))
             SAVELIST
           ) ;_ end of cons
    ) ;_ end of setq
    (setvar (car PAIR) (cdr PAIR))
  ) ;_ end of foreach
  (if ON-START
    ((eval ON-START))
  ) ;_ end of if
  (setq *ERROR*
         (append
           (list (car ERRORTEMPLATE))
           (list (list 'setq 'INSTANCE INSTANCE))
           (if UNDOMODE
             '((setq UNDO 't))
             '((setq UNDO NIL))
           ) ;_ end of if
           (list
             (list 'setq
                   'PREVIOUSHANDLER
                   (cons 'quote (list *ERROR*))
             ) ;_ end of list
           ) ;_ end of list
           (list (list 'setq 'NAME NAME))
           (list
             (cons 'setq
                   (cons 'SAVEDVARS
                         (list (cons 'quote (list SAVELIST)))
                   ) ;_ end of cons
             ) ;_ end of cons
           ) ;_ end of list
           (list (list 'setq 'ON-START ON-START))
           (list (list 'setq 'ON-GOOD ON-GOOD))
           (list (list 'setq 'ON-BAD ON-BAD))
           (cdr ERRORTEMPLATE)
         ) ;_ end of append
  ) ;_ end of setq
  (princ)
) ;_ end of defun

;|
Globalen Errorhandler zurücksetzen und Sysvars wiederherstellen.

Besonderer Dank an MAPCAR (http://www.autolisp.mapcar.net) für seinen Error-Handler

endErrorHandler : Errorhandler zurücksetzen und Sysvars wiederherstellen
Argumente:
Keine

Beispiel:
Einfach am Ende der Routine

(ENDERRORHANDLER)

aufrufen.

|;
(defun ENDERRORHANDLER (/)
  (*ERROR* NIL)
) ;_ end of defun

;;; Sub-Functions für eventuelle Huckepack-Funktionen des Errorhandler.

;;; Funktion ermittelt, ob das Welt-Koordinatensystem
;;; zur Zeit des Aufrufs aktuell ist.
;;; Wenn nicht, wird es gesetzt und T zurückgegeben
;;; Wenn ja gibt die Funktion nil zurück
(defun WORLD-UCS (/)
  (if (= (getvar "worlducs") 0)
    (progn (command "_.ucs" "_w") 't)
  ) ;_ end of if
) ;_ end of defun

;;; Funktion stellt vorheriges BKS wieder her, wenn UCSFLAG T ist
(defun PREVIOUS-UCS (/)
  (if UCSFLAG
    (command "_.ucs" "_p")
  ) ;_ end of if
) ;_ end of defun

;;; Greift auf die Variable instance des
;;; Errorhandlers zu - nur in diesem
;;; Environment aufrufen!
(defun SAVE-UCS (/ UCSFLAG)
  (if (= INSTANCE 1)
    (progn
      (setq UCSFLAG (WORLD-UCS))
      (SAVE-VARS '(UCSFLAG) '*UCSDATA*)
    ) ;_ end of progn
  ) ;_ end of if
) ;_ end of defun

;;; Greift auf die Variable instance des
;;; Errorhandlers zu - nur in diesem
;;; Environment aufrufen!
(defun RESTORE-UCS (/ UCSFLAG)
  (if (= INSTANCE 1)
    (progn
      (RESTORE-VARS '*UCSDATA*)
      (PREVIOUS-UCS)
    ) ;_ end of progn
  ) ;_ end of if
) ;_ end of defun

;;; Legt ein Element auf einem Stapel ab und gibt es zurück
;;; Notwendig z.B. für das Wiederherstellen von Uservariablen u.ä.
;;; Argumente:
;;; ELM = Name der Variablen
;;; STACKSYM = Name des Stacks
(defun PUSH! (ELM STACKSYM /)
  (set STACKSYM (cons ELM (eval STACKSYM)))
  ELM
) ;_ end of defun

;;; Nimmt ein Element von einem Stapel herunter und gibt es zurück
;;; Notwendig z.B. für das Wiederherstellen von Uservariablen u.ä.
;;; Argumente:
;;; STACKSYM = Name des Stacks
(defun POP! (STACKSYM / ELM)
  (setq ELM (car (eval STACKSYM)))
  (set STACKSYM (cdr (eval STACKSYM)))
  ELM
) ;_ end of defun

;;; Sub-Function für das Sichern von Uservariablen auf einem Stack
;;; Argumente:
;;; VARS = Liste von Variablennamen
;;; STACK = Name des Stacks
(defun SAVE-VARS (VARS STACK /)
  (foreach VAR VARS
    (PUSH! (cons VAR (eval VAR)) STACK)
  ) ;_ end of foreach
) ;_ end of defun

;;; Sub-Function für das Wiederherstellen von Uservariablen aus einem Stack
;;; Argumente:
;;; STACK = Name des Stacks
(defun RESTORE-VARS (STACK / VAR)
  (repeat (length (eval STACK))
    (setq VAR (POP! STACK))
    (set (car VAR) (cdr VAR))
  ) ;_ end of repeat
) ;_ end of defun

---

.

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

[Diese Nachricht wurde von marc.scherer am 27. Feb. 2004 editiert.]

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

---

Finaler Code? Nee - das läuft erstmal, mehr nicht. Jetzt kommt die Testphase! Und dann war da ja uch noch der Wunsch nach Texthöhe und so - wo bleibt's?

Ausserdem: Wenn du zufrieden bis mit dem _previous-BKS, ok, ok, ich bin's aber nicht. Ich bin doch grad zum 'Krümelkacker' gewählt worden;-) Jedenfalls lässt das mein sportlicher Ehrgeiz nicht zu, dass das bei verschachtelten Aufrufen nicht geht...

Da kommt also noch was!

Gruß, 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

---

Hi Axel,
ja, ja, so lieben wir Dich.
Texthöhen-Geschichte läßt sich doch über on-start on-good on-error Funktions-Argument lösen. Soll der Jan doch mal mit seiner Sub dafür rüberkommen... Kann ja auch mal was tun und nicht immer nur ziehen...

@UCS: Da könnte man IMHO doch mit temporär benannten BKS arbeiten, die Namen auffn Stack tun und am Ende wieder löschen?

PS: Haste meine Mail bekommen?

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

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

---

Ja klar, Texthöhe kann er sich ja leicht einbinden - das sehe ich übrigens auch so;-) Ich bringe dann noch ein paar Beispiele zu den Hook-Funktionen.

Antwort auf die mail geht auch gleich raus.

Gruß, 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

---

Ach so, wieder was vergessen: Nee, das BKS benennen geht nicht. Wie gesagt, das Ganze würde ja abkacken, wenn man ein Programm startet, das zur Aufgabe hat, alle BKS zu löschen oder so. Ist nicht von der Hand zu weisen, ich erinnere mich, dass ich mal eins geschrieben habe, das so aussah:

(defun C:kosmische-putzfrau( / )
  ... ; clean up everything
)

Im Ernst: Wenn's um Firmenstandards geht oder so - macht ja Sinn, dass Dinge da begrenzt werden. Da sind natürlich Layer das beste Beispiel, aber stell dir mal einen Bestand von 10000 DWGs vor, in denen nur simple Stanzblechteile drin sind, und in jeder 20. Zeichnung hat der inzwischen ausgeschiedene Kollege X dann hundertzwanzig BKSse angelegt, weil er einfach 'ne Niete im Kopfrechnen war:-(((

Da wir grade dabei sind: "Objektfang??? Ich brauche keinen Objektfang!!! So alt und zitterig bin ich noch nicht!!!" (O-Ton eines mir bekannten Firmenchefs)

Gruß, 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

---

Hi Axel,
wieso geht das nicht mit benannten BKS?
Wenn ich mir TimeStamp-Namen erzeuge, die BKS so nenne, die Namen auf den VARSTACK packe und dann nur die lösche deren Namen aufm VarStack liegen? Wo ist das Problem?
Oder hab' ich was falsch verstanden?

Und was meinst Du mit dem OFang-Thema??

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

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

---

Tag zusammen.

EDIT: Bemerkung kann mir jemand erklären, warum innerhalb der CODE-Tags der Text dennoch an die Wand geklatscht wird? - liegt wohl an dden deaktivierten Smilies ...

Ich will auch mal einen kleinen Beitrag zu dieser herkulischen Aufgabe leisten. Wenngleich ich wohl nur mit Mühe auf den hier entwickelten Error-Handler umschwenken kann - werde es aber sicher irgendwann mal in Angriff nehmen - deckt er sich in vielen Details mit dem Konstruckt, das ich seit geraumer Zeit verwende. Ein paar Bemerkungen zum Design:

(1) Ich kann nur unterstreichen, dass die eigendliche *error*-Funktion so schlank wie möglich bleiben sollte und tunlichtst viele Aufgaben auf externe Funktionen auszulagern sind.

(2) Mir geht der Ansatz, SysVars auf einem Stack abzulegen noch nicht  weit genug, denn ich möchte gerne SysVars auch unabh. von einer neuen Error-Handling-Ebene setzen und wieder herstellen können. Allerdings kann ich die Vor- und Nachteile einer Implementierung mit externer SysVar-Stack-Verwaltung (wobei der Error-Handler nur für einen kontrollierten Reset der Stack-Werte zuständig ist) nicht wirklich abschätzen - ist vielleicht auch nur die Macht meiner Gewohnheiten. Jedenfalls lässt sich auch damit jederzeit im Programm jede SysVar setzen und auch wieder in ihren Ursprungs-Zustand zurückführen, ohne das Error-Handling bemühen zu müssen.

(3) Die Handhabung der Undo-Funktionalitäten im AutoCAD, so denke ich zumindest, ist in einer Stack-basierten Verwaltung gut aufgehoben. Bisher verwende ich einen Ansatz bei dem der Inhalt der SysVar UNDOCTL auf diesem Stack abgelegt wird und damit in Abhängigkeit von deren Wert festgestellt werden kann, ob eine Gruppe nun zu schließen ist oder nicht. Damit ist es z.B. auch möglich, innerhalb einer Funktion mehrere UNDO-Gruppen zu erzeugen und im Fehlerfall nur die gerade noch nicht geschlossene wieder auf zurück zu spulen - kommt darauf an, ob innerhalb einer Funktion unabhängige Änderungen vorgenommen werden.

(4) Stack-Implementierung ist in Lisp eine recht einfache Angelegenheit, wie Axel ja weiter oben gezeigt hat. Allerdings geht da auch noch einiges mehr als dieser nahe liegende Ansatz mit der Liste. Deshalb habe ich mal ein Lisp-Modul zur Stack- oder auch Keller-Verwaltung zusammengestellt:

Code:

---

;
;*******************************************************************************************
;****                                                                                  ****
;****  Function | :stack-*                                                            ****
;****  Return  | s.o.                                                                ****
;****  Globals  | redefiniert <_stack-BackBone_>                                      ****
;****  SideEff  | s.o.                                                                ****
;****  Subject  | Implementierung einer Stack-Verwaltung (auch n-fach Stack)          ****
;****  Appropos | stack, stapel, keller, n-fach, multi                                ****
;****  Support  | A2k                                                                  ****
;****                                                                                  ****
;****  Version 1.00 2003-08-05                      - Achim Dabrunz                    ****
;****                                                                                  ****
;*******************************************************************************************
;****                                                                                  ****
;****  Implementierung einer Stack-Verwaltung mit folgenden Funktionen:                ****
;****                                                                                  ****
;****  Zugriffe:                                                                      ****
;****  (1) (:stack-top <Stack-ID> )                -> Oberstes Stack-Element          ****
;****  (2) (:stack-pop <Stack-ID> )                -> Oberstes Stack-Element          ****
;****  (3) (:stack-push <Stack-ID> <neuesElement> ) -> [FUNCTION|STRING]:              ****
;****                                                  [gekapselte StackDaten|Error-MSG]****
;****  (4) (:stack-length <Stack-ID> )              -> NUMBER: Länge des ref. Stacks    ****
;****  (5) (:stack-IDList)                        -> LIST: Aufzählung aller <Stack-ID>****
;****                                                                                  ****
;****  Verwaltung:                                                                    ****
;****  (1) (:stack-clearAll)                      -> - keine Rückgabe -              ****
;****  (2) (:stack-clear <Stack-ID> )              -> - keine Rückgabe -              ****
;****  (3) (:stack-purge)                          -> - keine Rückgabe -              ****
;****                                                                                  ****
;****  Ein Stack wird hierbei über seine <Stack-ID> identifiziert. Abgesehen von der  ****
;****  Limitierung durch die Speicherausstattung des System (und der Speicher-Verwal-  ****
;****  tung durch AutoCAD) gibt es keine Einschränkung in der Anzahl oder Länge eines  ****
;****  (der) Stacks. Die Daten sind in der Funktion <_stack-BackBone_> gekapselt.      ****
;****                                                                                  ****
;****  Die <Stack-ID> kann eine beliebige, von NIL verschiedene ATOMARE Größe sein.    ****
;****                                                                                  ****
;****  Homogenität der Stacks ist weder paarweise noch innerhalb eines einzelnen Stacks****
;****  erforderlich. Es ist also möglich - wann das sinnvoll ist sei dahin gestellt -  ****
;****  Daten unterschiedlichster Struktur und Komplexität auf einem Stack abzulegen und****
;****  auch wieder auszulesen.                                                        ****
;****                                                                                  ****
;*******************************************************************************************
;
(defun :stack-clearAll ( / )
  (setq _stack-BackBone_ (lambda()nil))
); end DEFUN <:stack-clearAll>

(defun :stack-clear (#id / )
  (setq _stack-BackBone_
    (:capsule
      ':id
      (list (list(vl-remove-if
                  (function(lambda(x)(= #id(car x))))
                  (_stack-BackBone_)
            ))
      )
    )
  )
); end DEFUN <:stack-clear>

(defun :stack-purge ( / )
  (setq _stack-BackBone_
    (:capsule':id (list (list(vl-remove-if-not'cdr(_stack-BackBone_)))))
  )
); end DEFUN <:stack-purge>

(defun :stack-length (#key / )
  (length(cdr(assoc #key (_stack-BackBone_))))
); end DEFUN <:stack-length>

(defun :stack-IDList ( / )
  (:l-1(_stack-BackBone_))
); end DEFUN <:stack-IDList>

(defun :stack-top (#id / )
  (cadr(assoc #id (_stack-BackBone_)))
); end DEFUN <:stack-top>

(defun :stack-pop (#id)
  ((lambda(wert)
    (setq _stack-BackBone_
      (:capsule':id (list (list(:assl-apply'cdr(_stack-BackBone_) #id))))
    )
    wert
  )
  (:stack-top #id)
  )
); end DEFUN <:stack-pop>

(defun :stack-push (#id #value / )
  (if (not(listp #id));** nur, wenn auch eine atomare ID (NOT NIL) übergeben wird
    (setq _stack-BackBone_
      (:capsule':id (list (list(add-AssocList(_stack-BackBone_)#id #value))))
    )
    (princ"\nunzulässige Stack-ID\n")
  )
); end DEFUN <:stack-push>

(defun _stack-BackBone_()nil)

---

Ein paar Erläuterungen zu den verwendeten Funktionen und Ideen:

(a) :capsule habe ich ja schon das eine oder andere mal vorgestellt. Mit dieser Funktion werden (lokale) Werte an Funktions-Argumente gebunden - wie auch hin und wieder diskutiert, bevorzuge ich dies Variante der expliziten Änderung von Funktionen, wie sie nicht zuletzt bei dieser Error-Handler-implemtierung Verwendung findet. Hier noch einmal die Impementierung:

Code:

---

;
;*******************************************************************************************
;****                                                                                  ****
;****  Befehle : A2k-Lisp                                                              ****
;****                                                                                  ****
;****  Aufruf  : (:capsule <Function> <ArgList> )                                      ****
;****                                                                                  ****
;****          <Function> ::= ge-QUOTE-te Funktion                                    ****
;****                          [z.B. 'myFunction]                                      ****
;****          <ArgList>  ::= LISTE, deren Länge mit der Anzahl der Funktions-Argumente****
;****                          von <Function> übereinstimmt - alle zu bindenden Kon-    ****
;****                          stanten, sind in LISTEN zu verpacken                    ****
;****                          [z.B. '(x y (5))]                                        ****
;****                                                                                  ****
;****  Rückgabe: UserSubRoutine (type ..) -> USUBR                                    ****
;****                                                                                  ****
;*******************************************************************************************
;****                                                                                  ****
;****  Routine zum Kapseln von (lokalen) Konstanten in Funktions-Aufrufen              ****
;****                                                                                  ****
;****                                                                                  ****
;****  Version 1.00 1999-10-07 A2k                                                    ****
;****                                                                                  ****
;****  Autor : Achim Dabrunz                                                          ****
;****                                                                                  ****
;*******************************************************************************************
;****                                                                                  ****
;****  Die Routine erzeugt aus einer beliebigen Lisp-Funktion mit n > 0 Argumenten    ****
;****  eine neue Funktion, deren Arbeitsweise der ursprünglichen gleicht, bei der aber ****
;****  einige der vormaligen Argumente durch GEBUNDENE Konstanten ersetzt wurden.      ****
;****                                                                                  ****
;****  Der Vorteil der Kapselung besteht darin, dass auf diesem Wege Snapshots LOKALER ****
;****  Variablen in Träger-Funktionen nach 'außen' transportiert werden können.  D.h., ****
;****  durch die Kapselung kann der Wert einer lokalen Variablen zu einem bestimmten  ****
;****  Zeitpunkt konserviert werden und die Konservierung überdauert auch die Lebens-  ****
;****  spanne der Vater-Variablen, hat also auch außerhalb des lokalen Kontexts noch  ****
;****  den gleichen Wert.                                                              ****
;****                                                                                  ****
;*******************************************************************************************
;****                                                                                  ****
;****  Beispiel1 :                                                                    ****
;****                                                                                  ****
;****  (defun #+# (x y)(+ x y))                - nur 'ne Funktion                      ****
;****  (#+# 2 3) -> 5                          - keine echte Überraschung              ****
;****                                                                                  ****
;****  (setq #+5 (:capsule'#+#'(x (5))))      - das kapselt die <5> ein              ****
;****                                                                                  ****
;****  =>                                                                              ****
;****                                                                                  ****
;****  (#+5 7) -> 12                          - das ist 'ne kleine Überrachung        ****
;****                                                                                  ****
;*******************************************************************************************
;****                                                                                  ****
;****  Beispiel2 :                                                                    ****
;****                                                                                  ****
;****  (defun show-local ( / n)                - <n> ist wirklich lokal !!            ****
;****    (setq n 1)                            - <1> ist völlig willkürlich gewählt    ****
;****    (:capsule'#+#                        - jetzt wird EIN-gekapselt              ****
;****              (list'x (list n))                                                  ****
;****    )                                                                            ****
;****  )                                                                              ****
;****                                                                                  ****
;****  (setq #+n (show-local))                - jetzt kommt's                        ****
;****                                                                                  ****
;****  =>                                                                              ****
;****                                                                                  ****
;****  (#+n 7) -> 8                            - das ist 'ne ECHTE Überraschung        ****
;****                                                                                  ****
;*******************************************************************************************
;****                                                                                  ****
;****  Manipulationen    : - keine -                                                  ****
;****                                                                                  ****
;****  Globale Bezeichner : - keine -                                                  ****
;****                                                                                  ****
;*******************************************************************************************
;
(defun :capsule (:capsule#func :capsule#bindings / )
  (eval
    (list'lambda
          (vl-remove-if'vl-consp :capsule#bindings)
          (cons :capsule#func
                (mapcar
                  (function(lambda(:capsule#arg)
                    (if (vl-consp :capsule#arg)
                      (apply'quote :capsule#arg);** THEN
                      :capsule#arg;** ELSE
                    )
                  ))
                  :capsule#bindings
                )
          )
    )
  )
); end DEFUN <:capsule>

---

(b) :id ist nix anderes als die Identitäts-Funktion:

Code:

---

(defun :id(x)x)

---

(c) :l-1 ist nix anderes als ein:

Code:

---

(defun :l-1(listOfLists)
(mapcar'car listOfLists)
)

---

(d) :assl-apply wendet eine Funktion auf einen mit einem Schlüssel (auch verschchtelt) assozierten Wert einer Assoc-Liste an. der Aufruf lautet:

(:assl-apply <function> <assoc-list> <Keys> )

Ein Beispiel:

(:assl-apply '1+ '((1 . 2)(2 . -7)) 2) -> ((1 . 2)(2 . -6))

oder

(:assl-apply 'strcase '((1 . "foo")(2 . "baa")) 2) -> ((1 . "foo")(2 . "BAA"))

Die Funktion ist so stark mit den übrigen meiner Funktionen meiner Assoc-List-Verarbeitung verzahnt, dass die Implementierungs-details hier nix bringen. Ich denke aber, dass sich was passendes in jeder hier verwendeten Lisp-Bibo finden lässt.

Für Kritik und Anregungen bin ich immer dankbar.

Achim Dabrunz

[Diese Nachricht wurde von Dabrunz am 27. Feb. 2004 editiert.]

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

---

Hi Achim,
hui. Und wieder raucht mir der Kopf. Habe schon beim ersten Stolpern über Dein :capsule nix begriffen, aber mir damals schon 'ne Kopie auf die Platte zum Auseinanderklamüstern (lesen -> verstehen) gepackt. Bin aber nie dazu gekommen mal da ran zu gehen.
Das Problem bei Teilen Deiner Ausführungen ist wohl Dein großes Wissen um Programmier-Theorie. Das ein oder andere haben wohl viele hier (ich inklusive) noch nie gehört, geschweige denn sich Gedanken um sowas gemacht. Vielleicht schätze ich das auch nur falsch ein und bin der einzige dem der Kopf raucht...
Wenn Du Teile des von Dir geposteten Codes in den Errorhandler einbaust und es noch für blöde wie mich angemessen kommentierst ist das fein; ich staune und lerne :-). Wenn Du da keine Lust zu hast, kann ich das auch verstehen und hoffe auf weitere, interessante Kopfnüsse von Dir (als Denkanstoß sind die immer gut).

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

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

---

Hi Achim!

Ich wusste doch, dass das noch kein 'final code' sein kann... hab ja auf diesen Beitrag schon gewartet;-) Und ich wusste auch, wie er in etwa aussehen wird.

Jetzt bin ich hier nicht nur mit einem (Marc) sondern mit zwei Code-Unästheten konfrontiert:-( Damit meine ich diese Unsitte, an jede Klammer dranzukommentieren, wer sie wann und wo aufgemacht hat, wie die Eltern hießen, und warum sie eine gebogene Form hat... Mir reicht in meinem Code das Wissen, dass zu einer schließenden Klammer die öffnende entweder
etwas weiter links steht (bei Einzeilern)
oder
exakt senkrecht darüber - und unter exakt verstehe ich exakt
Ich rücke auch immer um 2 ein, aber nicht mal um 2, mal um 3 und mal um 7. Bei Marcs Code tun mir ja schon immer die Augen weh, aber bei dir, Achim, kommt dann noch der ausgeprägte Hang hinzu, Variablen '#@²*-?!#' oder so zu nennen. Ich falle immer wieder drauf rein, und dann fällts mir immer erst nach einer Minute wieder ein: Nein, da ist doch gar kein ByteCode-Compiler drübergefahren, und es ist auch kein CL! In Common Lisp sieht ja alles so aus wie Achims Variablen - nur da hat der # ja eine Bedeutung, hier jedoch nicht;-) Und ASSEMBLER isses auch nicht, trotz Marcs Hang zu Großbuchstaben. In jedem Chat würde er sich damit ja einen Ban einfangen...

Ich kann jedenfalls solchen Code nicht vom Blatt singen, weil ich echte Mühe habe, das bisschen Ausführbare aus dem großen Kommentar-Ozean zu fischen. Dann doch wenigstens die Klammer-Kommentare ab Column 863, dann verschwinden sie rechts aus dem Fenster;-)))

Also, ich werd's mal durch meinen PrettyPrinter mit eingebautem DeCommenter jagen und mich dann im Einzelnen zur Sache äussern. Im Moment hab ich auch grad noch andere Sorgen - vor einer guten halben Stunde hat sich mein Rechner zu einem spontanen Reboot entschlossen und ist dann nach längerem Plattencheck (240GB dauern nun mal) mit leicht veränderten Einstellungen wiedergekommen (1280x1024 - sah aus wie Standard-VGA). Ich beobachte das jetzt alles mit Skepsis...

Der Grund war überigens - Achim, halt dich fest! - Master of Orion II. Hab's aus der Kellertruhe rausgeholt, läuft unter 2000, was ich eigentlich nicht erwartet hätte. Nur eins verträgt es nicht, nämlich den Beschuss von Tiny-Planeten mit dem Stellar-Converter. Da schlägt offensichtlich was direkt vom Flux Shield in den Arbeitsspeicher durch... Muss mal nachsehen, ob ich mir da jetzt ein Loch in einen 512er Riegel geschossen habe. (So, Marc, jetzt weisst du auch, was ich so ballere)

UNDOCTL ist übrigens ein heisses Thema, das noch gar nicht diskutiert wurde. Bringt es denn wirklich was, wenn man UNDOCTL mitsichert? Wenn das im Handler Programm UNDOCTL auf 2 setzt, dann nutzt auch das beste Errorhändling nix mehr. Dann kann man eigentlich nur noch make-a-backup und restore-last-backup als start-hook und bad-hook mitgeben. Leider gibt's ja nun mal in AutoLisp keine eingebauten Hooks, sonst könnte man über den SymTable-Hook verhindern, dass ein Programm überhaupt die Zeichenkette "UNDOCTL" enthalten oder erzeugen darf.

Aber nun mal zur SysVars-Verwaltung. Natürlich bietet es sich an, die Syvars statt wie bisher in einer einfachen Liste auf einem Stack abzulegen. Ob da allerdings ein komplizierteres Modell als meine beiden Rudis angesagt wäre, lasse ich erstmal dahingestellt. Das Stack-Prinzip erlaubt es ja auch, eine SysVar mehrfach zu sichern, was allerdings im bisherigen Listenmodell auch möglich ist - es wird ja nur sequenziell drauf zugegriffen und nicht mit assoc oder so. Jedenfalls ist durchaus die Möglichkeit da, auch noch zur Laufzeit des gehandelten Programms zu pushen und zu poppen.

Es entsteht aber eine Gefahr: Ich halte es für das erstrebenswerte Ziel, den ganzen E-Handler in eine Moduldatei zu verpacken (mitsamt dem UCS-Save/Restore usw. und die dann nur in die jeweiligen Programme mit (load"errorhandler") einzubinden. Im Prinzip aber dann 'Black Box', denn jede Möglichkeit, zur Laufzeit noch zu interagieren, verstärkt das Risko, sich den Errorhandler mit dem Programm abzuschießen. Beispiel: Eine unmotivierte Zeile (setq *SysVarStack* 3.14) ohne lokale Deklaration oder so. Es würde also einiges dafür sprechen, dem gesamten Errorhandling per Kapselung noch mal ein Kondom überzuziehen - nur so sicherheitshalber.

So, jetzt werfe ich erstmal meinen PrettyPrinter an, bevor ich ganz blind werde...

Gruß, Axel

@Achim: (:l-1 ...) hat's also ohne optimierendes Update überlebt. Wann wird die volljährig?

------------------

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

---

Hi Axel,
<kicher> Ja das glaub' ich, daß Du bei meinem Code blind wirst...
Du benutzt soweit ich weiß, ja auch nur 'nen Ascii-Editor ohne Coloring für den Kram.
Ich benutze den VLISP-Editor, der bei Acad ja dabei ist.
Der färbt mir den Code so schön ein und knallt den ganzen Kommentar da rein (na ja nicht alles :-)). Die Formatierung und StringCases macht der auch automatisch, da denk' ich gar nich drüber nach...
DEINEN Code, lieber Axel, jag' ich immer erst durch die VLIDE um überhaupt irgendwas zu begreifen... *lach* So hat jeder halt seine Präferenzen...

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

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

---

Zitat:

---

Original erstellt von mapcar:

Jetzt bin ich hier nicht nur mit einem (Marc) sondern mit zwei Code-Unästheten konfrontiert

[..]

Ich rücke auch immer um 2 ein, aber nicht mal um 2, mal um 3 und mal um 7.

---

Ja-ja, zumindest was die Einrücktiefe und End-Kommentare angeht (obwohl ich sie gerne als visuelle Kontext-Tennzeichen benutze, habe ich meinen Beitrag mal bereinigt) kann ich dir in Grenzen Recht geben. Bei Einrückungen bin ich bisweilen inkonsequent, dennoch:

Code:

---

(setq blabla (func arg1
                  arg2
            )
      laber  (noch-ne-func arg)
)

---

empfinde ich durchaus als strukturierte Einrückung.

Zitat:

---

[..] bei dir, Achim, kommt dann noch der ausgeprägte Hang hinzu, Variablen '#@²*-?!#' oder so zu nennen. [..] In Common Lisp sieht ja alles so aus wie Achims Variablen - nur da hat der # ja eine Bedeutung, hier jedoch nicht [..]

---

Natürlich haben die eine Bedeutung!

# - kennzeichnet Funktions-Argumente, teilweise - wenn ich mir nicht völlig sicherbin, ob Namenskonflikte mir das Leben schwer machen können - mit dem Funktionsnamen als Präfix;

_ - zeichnet Funktionen aus, die einzig für den internen Aufruf gedacht sind;

: - kennzeichnet Bibliotheks-Funktionen - abgesehen von ein paar Altlasten ...

* - ist so'ne Altlast, bezeichnet bisweilen globale Größen - wie gesagt: Altlast;

? - dient als Postfix-Kennzeichen für Prädikaten-Funktionen und Variablen, die einen Wahrheitswert tragen, was ich auch als äußerst sinnvoll erachte und

! - wie bereits bei deinem obigen Beispiel zu sehen, zeigt an, dass es sich um eine destruktive Funktion handelt.

Zitat:

---

UNDOCTL ist übrigens ein heisses Thema, das noch gar nicht diskutiert wurde. Bringt es denn wirklich was, wenn man UNDOCTL mitsichert?

---

Nein, ein reines Mitsichern bringt nix. Ich denke ungefähr so:

undo-push

Code:

---

(...;; rauf auf einen Stack mit dem da:

  (setq Changes 0)
  ;** wenn nur ein Befehl rückgängig :
  (if (= 2 (logand UNDOCTL 2))
    (progn
      (command "_.undo""_control""_all")
      (setq Changes (+ 2 Changes))
    )
  ); end IF:nur ein Befehl rückgängig

  ;** wenn keine Gruppe aktiv :
  (if (and (= 1 (logand UNDOCTL 1))
          (/= 8(logand UNDOCTL 8))
      )         
    (progn
      (command "_.undo""_begin")
      (command "_.undo""_auto""_off")
      (setq Changes (+ 8 Changes))
    )
  ); end IF:keine Gruppe aktiv
 
  ;** wenn AUTO ON :
  (if (= 4 (logand UNDOCTL 4))                                           
    (progn
      (command "_.undo""_auto""_off")
      (setq Changes (+ 4 Changes))
    )
  ); end IF:AUTO ON
 
  ;** Rückgabewert
  Changes                                                                   
)

---

undo-pop

Code:

---

(...;; runter vom Stack mit undoChanges

  (if (and (= 8 (logand undoChanges 8))
          (= 8 (logand (getvar "UNDOCTL") 8))
      )
    (command "_.undo""_end")
  )
 
  (if (= 4 (logand undoChanges 4))
    (command "_.undo""_auto""_on")
  )
  (if (= 2 (logand undoChanges 2))
    (command "_.undo""_control""_one")
  )
  (if (= 1 undoChanges)       
    (command "_.undo""_control""_none")
  )
)

---

Achim Dabrunz

______________________________________

Ab hier wird's reichlich OT:

Zitat:

---

Der Grund war überigens - Achim, halt dich fest! - Master of Orion II. Hab's aus der Kellertruhe rausgeholt, läuft unter 2000, was ich eigentlich nicht erwartet hätte. Nur eins verträgt es nicht, nämlich den Beschuss von Tiny-Planeten mit dem Stellar-Converter.

---

Ja, das ist ein Bug, wie auch ein Rückzug am Rand der Taktik-Karte. Bin übrigens nach reichlich frustrierendem MOO3-Gebrauch auch reumütig zurück gekehrt, gibt bei mir keinen Sound, aber: Who cares? Die DOS-Variante ist deutlich stabiler. Den Patch 1.31 hast du? Versuch mal
http://dosbox.sourceforge.net/

Zitat:

---

@Achim: (:l-1 ...) hat's also ohne optimierendes Update überlebt. Wann wird die volljährig?

---

Ich bin nicht sicher, aber ich glaube das ist tatsächlich die final und ich kann mich auch nicht mehr gegen diesen "syntaktischen Zucker" wehren. Was die Volljährigkeit angeht, bin ich nich' so sicher ich kenn das Baby erst seit 1998 ..

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

---

So, nun zu später Stunde nochmal zu Achims (ersten) Beitrag:

Ich hab mir den Code nochmal angesehen. Das Kapseln kannte ich ja schon - ist aber hier nur Beiwerk zum vorgeschlagenen Stack-Konzept. Und da hapert's bei mir nun etwas. Achim, da musst du dir nun Kritik von mir gefallen lassen: Es bringt nix, den Code so ausführlich hier zu posten, wenn die Hälfte fehlt und niemand das nachvollziehen bzw. ausprobieren kann. Es fehlt nicht nur :assl-apply, sondern auch addAssocList (ohne Doppelpunkt) - und die Aufgabe, sich da was selber zusammen zu puzzeln ist nicht trivial. Sonst würdest du in diesem Zusammenhang ja auch nicht von 'Verzahnung mit meinen anderen Funktionen' reden. Da musst du dann schon bereit sein, deinen Code mal so umzuarbeiten, dass er für alle nachvollziehbar und ausprobierbar ist.

Für viele in diesem Forum geposteten Probleme hätte ich ad hoc eine Lösung parat - ich müsste sie nur rauskopieren und hier rein setzen. Nur - damit könnte hier keiner was anfangen, weil der Code genau wie bei dir ohne meine Bibo nicht läuft. Entweder mache ich mir die Mühe und stell ein lauffähiges Päckchen zusammen, oder ich habe nicht die Zeit/Lust dazu, dann lasse ich's. Aber es bringt absolut nix, hier Code zu posten, der nicht laufen kann.

Zur Sache selbst: Ich sehe im Moment auch nicht die Notwendigkeit, ein komplexeres Stack-Modell einzuführen. Wir vertreten da - glaube ich - auch zwei verschiedene Ansätze: Du gehst von einem Errorhandling aus, das du in deinen Programmen benutzt. Mir geht's hier aber nicht um etwas, was ich in meinen Programmen benutze, sondern um einen Handler, den Andere (Forumsteilnehmer) in ihren Programmen benutzen können. Ich versuche also, den Handler so weit wie möglich 'abschusssicher' zu machen, während du weisst, dass du dich bei deinem Handler darauf verlassen kannst, dass er nicht von einem DAU angewendet wird.

Dein Stack-Konzept ist in keiner Weise sicherer als meins, ausser dass du mehrere Stacks in einer *special var* ablegst und dadurch die Wahrscheinlichkeit eines zufälligen Abschusses sinkt. Aber das ist marginal. Das Kapselkonzept ist zwar nett und effektiv beim Codieren, bringt aber auch keinerlei zusätzlicher Sicherheit, sondern nur Schreibkomfort.

Der Ansatz, auch während des gehandelten Programms weitere Sysvars zu pushen und zu poppen, ist mir ja nicht neu - ich habe erst '95 angefangen, meine Funktionen mit einem Zeitstempel zu versehen, aber mein (:setvar ...) und (:getvar ...) hat noch keinen. Ich bin aber sehr vorsichtig damit, das hier reinzubringen, denn es ist, wie gesagt, eine große Gefahr, dass die Benutzer dieses Handlers ihn sich dann von innen heraus kaputt zu machen, wenn das nicht entsprechend DAU-sicher implementiert ist.

Ich denke im Moment eigentlich eher über eine eher gegenteilige Lösung nach: Ein ErrorHandler-Wizard, bei dem man sich in einem Dialog die gewünschten Features zusammenklickt (wie z.B. "[x] Bei Absturz BKS wiederherstellen" usw.) Wenn man sich die Features zusammengeklickt hat, erzeugt er eine Datei, die man mit (load"...") einbindet, und die Aufrufe heissen dann nur noch (StartErrorHandler) und (EndErrorHandler) - ohne jegliche Argumente. Und der irgendwo darin befindliche Stack(-Backbone) ist abschusssicher. Da frage ich mich allerdings, wie man das bewerkstelligen könnte, denn das würde voraussetzen, dass der User das Programm in eine Klammer setzt und quotet - hygienische Makros kennt AutoLisp ja nun mal nicht. Aber was das betrifft, sehe ich schwarz, das wird nicht akzeptiert. Hier liegen also eher psychologische als technische Probleme vor...

So, jetzt schau ich mal nach dem Patch für MOOII;-)

Gruß, Axel

PS: Mit der Bedeutung des # -- das war nicht ganz präzise formuliert: Da ging's mir eben nicht um die psychologische Bedeutung, sondern um die technische Funktion. Die hat er nun mal nicht in AutoLisp - genausowenig wie mein ! in push!

Noch'n PS: Ja, es ist 'Smilies deaktivieren'. Entweder der Code sieht ******e aus, oder man hat andere Verwesungen. Weiter oben das 'Klammerauf-ohne-Doppelpunkt-Klammerzu' kann er nicht darstellen, wenn ich die Smilies _nicht_ deaktiviere. Musste also 'Doppelpunkt' in Worten statt eines ':' schreiben. Diese bescheuerten Grinsemännchen sind das bescheuertste, was die EDV bisher hervorgebracht hat. Wobei natürlich der Zusammenhang zwischen Smilies und Codedarstellung auch nicht unbedingt gottgegeben ist... 

------------------

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

---

Zitat:

---

Original erstellt von mapcar:
...Ich denke im Moment eigentlich eher über eine eher gegenteilige Lösung nach: Ein ErrorHandler-Wizard, bei dem man sich in einem Dialog die gewünschten Features zusammenklickt (wie z.B. "[x] Bei Absturz BKS wiederherstellen" usw.) Wenn man sich die Features zusammengeklickt hat, erzeugt er eine Datei, die man mit (load"...") einbindet, und die Aufrufe heissen dann nur noch (StartErrorHandler) und (EndErrorHandler) - ohne jegliche Argumente...

---

Hi Axel,
ist das nicht ein bißchen übertrieben ? Ich vermute mal, wer einen "ErrorHandler-Wizard"  braucht, baut sich keinen Errorhandler in seinen Code ein.....
Meiner Meinung nach genügt ein soweit wie möglich narrensicherer Error-Handler und einige Beispiele, wie man diesen in seine Programme einflegt.
Zum Nachvollziehen für Lernwillige (wie mich )wären vielleicht ein paar Kommentare (nicht unbedingt jedes end - das erschließt sich von alleine ) mehr und auch für Otto-Normalo sprechende Variablenbezeichnungen  anzudenken.
Sonst bleibt am Ende nur ein toller Code , den keiner einsetzt!
(geht auch an die Adresse von Achim)

------------------
- Thomas -

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

---

Ich finde es echt klasse, das Ihr euch so viel Mühe gebt, bei der Entwicklung, auch wenn die meisten überhaupt keinen Durch,- oder Überblick haben werden.
Es ist auch ein echt schwierig zu verstehendes Ding.
Mittlerweile hat der gesammte Code Zeilenmäßig größere Ausmasse angenommen, als die meissten Lispprogramme Gesamtzeilen haben.
Es muss doch eine kompacktere Lösung geben, so einen Fehler abzufangen und zur Ausgangssituation zurückzukehren.

so, ich will mal eine vielleicht unqualifizierte Frage stellen.
Habt ihr den Errorhandler mal in Verbindung von offenen Dialogboxen und/oder per vlax-get.. zugewiesenen Variablen getestet?

...to be continued 

------------------
Gruß
CADwiesel
Besucht uns im CHAT

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

---

Thomas schrub:
> Ich vermute mal, wer einen "ErrorHandler-Wizard"  braucht, baut sich keinen Errorhandler in seinen Code ein.....

Da bin ich mir nicht so sicher. Eine Million Lispler schreibt immer wieder '(setq *error* old_error), ohne auch nur im Ansatz begriffen zu haben, warum... Ausserdem: Auch ich benutze Wizards - wir arbeiten nicht am C64. Wer versteht denn schon was von dem ganzen 'grünen' Code in Visual C++ (= irgendwelche Wizard-Makros)? Wir benutzen auch die vla-curve-...-Funktionen, ohne den mathematischen Hintergrund zu verstehen. Mein Reden ist ja auch immer: Warum ständig das Rad neu erfinden? Dieser Handler soll funktionieren und anwenderfreundlich sein. Verstehen? Gerne - muss aber nicht sein. Er soll auch mit chaotischen Anfänger[n|programmen] laufen.

Cadwiesel schrub:
> ... in Verbindung mit offenen Dialogboxen ...

Schönes Thema. War eines, das ich für die Hooks im Hinterkopf hatte, allerdings muss ich ehrlich sagen, dass ich das bisher nie richtig in den Griff gekriegt habe. Lange, lange her! Wie war das - irgendein Aufruf von irgendeinem close, unload oder so ohne alle Argumente, angeblich sollten dann alle weg sein. Hat bei mir aber nie geklappt. Wer kann mir da mal auf die Sprünge helfen? Ich glaube, Achim, der Hinweis kam damals von dir... Gibt aber echt nix Ätzenderes als eine herrenlose Dialogbox auf dem Schirm:-(

Ich denke auch noch an offene Dateien. Die sind nun kein Problem - das ist in meinem eigenen Handler seit 10 Jahren drin, dass die alle geschlossen werden. Aber da sind wir wieder bei der Psychologie: Werden die Anwender dieses Handlers bereit sein, (safe-open ...) statt (open ...) zu verwenden? Nur so kriegen wir die offenen Dateien auf den Absturz-Stack. Die Funktion open einfach stillschweigend umdefinieren ist ja inzwischen auch nicht mehr...

Und da sind der Themen noch mehr - letztendlich bis zum Rollback in der Datenbank.

Cadwiesel schrub:
> Mittlerweile hat der gesammte Code Zeilenmäßig größere Ausmasse angenommen

Mit Verlaub gesagt: Quatsch. Das täuscht vielleicht - der Handler hat noch keine hundert Zeilen - und ich werde ihn sicherlich noch mal straffen. Ich erinnere mich z.B. an das kleine Lisp-Bonus-Programm 'edge.lsp', das so in R9-12 (???) dabei war. Damit konnte man die 4 Seiten eines 3DFace sichtbar/unsichtbar machen. Das brachte (schätze ich) erstmal 300 Zeilen Errorhandling mit. Nur für diesen einen Zweck. (Bitte nicht hauen, wenn ich jetzt falsch geschätzt habe - das ist Jahre her...)

Thomas schrub:
> Sonst bleibt am Ende nur ein toller Code , den keiner einsetzt!

Dieses Risiko ist mir bewusst. Aber es ist nun mal ein Errorhandler, der verschachtelbar ist. Das macht ihn komplex, da ist nicht dran zu rütteln. Natürlich ist dieser Thread in seiner Länge auch abschreckend für jemand, der 'nur mal' nach einem Errorhandler sucht - tausend Versionen, und noch kein Ende in Sicht. Aber ich werde, wenn er dann fertig ist, noch eine schöne Anleitung verfassen. Wenn man die ganze Entstehungsgeschichte nicht sieht, wird er schon viel freundlicher wirken.

Cadwiesel schrub:
> per vlax-get.. zugewiesenen Variablen

Was meinst du damit?

Und ferner schrub er:
> Mittlerweile hat der gesammte Code Zeilenmäßig größere Ausmasse angenommen, als die meissten Lispprogramme Gesamtzeilen haben.

Nö. Meine Programme liegen meistens im Bereich zwischen 500 und 5000 Zeilen. Teilweise arbeite ich da schon knapp 10 Jahre dran weiter.

Viel kompakter wird's also nicht gehen, es sei denn, man schraubt die Ansprüche deutlich runter.

Gruß, 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

---

sooo, dann will ich hier gleich mal weiterschruben
Ist schon echt 'gemein' von dir hier so viele Gedanken und Äußerungen zu dem Thema zu bringen, und das wo ich doch ein Minimalist in Sachen tippen bin. (Zeigefinger auch noch verbunden :-(  )

Ok wie ich sehe, scheint die ganze Geschichte doch langsam extrem Nachdenking zu verursachen. Ich kann mir nicht vorstellen, das dieses Thema so neu ist. Was sagen die Englischsprachigen Grazien dazu? Raini hat doch schon vor Jahren eine Biblio entwickelt, die Sache dürfte doch eigentlich schon lange durch sein.
Mann kann natürlich auch Sportlichem Ehrgeiz dem 'Rad neu erfinden' gegenüberstellen, aber vielleicht sollten wir einfach mal in den Adesk-Diskussions Groups nachfragen.

Ps. Axel ich meinte mit vlax-get... die Geschichten, wenn die Variablen nicht wieder wichtig oder garnicht per vlax-release-object freigegeben werden.
besonders blöd, wenn noch andere Apps dadurch den Speicher zumüllen.

so CU bis später

------------------
Gruß
CADwiesel
Besucht uns im CHAT

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

---

Hi,

ich lese mir die Beiträge hier ca. alle ein bis zwei Tage von vorne bis hinten durch und jedesmal wirft mein Hirn irgendwann Blasen. 
Trotzdem: Ein schönes Thema, das in deutschen Foren wohl noch nie so ausführlich diskutiert wurde.

So langsam drängt sich mir allerdings der Verdacht auf, dass es den eierlegenden Wollmilcherrorhandler, der alles mögliche berücksichtigt und auch noch unter Steinzeit-Acad läuft, nicht geben kann oder aber so komplex ist, dass er von kaum jemand verstanden, geschweige denn eingesetzt wird.
Die Notwendigkeit eines verschachtelbaren Errorhandlers sehe ich aber ist es nicht so, das die meisten, "üblichen" AutoLISP-Tools ohne Verschachtelung auskommen auch wenn sie aus mehreren Funktionen bestehen?
Sollte man dann nicht die Wollmilchsau irgendwo mittig durchhacken und einen "Single-Universal-Errorhandler" und zusätzlich eine XL-Version (meinetwegen mit "Wizard") zusammenklammern?

Fragt
CADchup

P.S. @CADwiesel: Ich habe mir Reinis Errorhandling nicht angesehen, aber seine STDError.lsp hat weit über 700 Zeilen 

------------------
www.cadditions.de

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

---

Ich finde auch im Grund müssten da fast zwei Erorrhanler bei raus kommen.
Für die meisten meiner Tools wäre der Erorrhanlder der größte Teil.
Vielleicht gibt es ja noch ne Abgespeckte Version. Mal davon abgesehen das ich hier auch wie ein Schuljunge mitlese. Stellt sich auch die Frage ob der Erorrhandler für den Normalverbraucher auf Akzeptanz stößt.

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

---

In der Sache selbst bin ich leider noch nicht weiter, hatte viel zu tun die letzten Tage. Es wird also noch ein paar Tage dauern. Aber zu den Meinungen will ich schon mal Stellung nehmen:

Eine 'abgespeckte' Version wäre nicht verschachtelbar, würde sich im Aufruf und den Argumenten aber überhaupt nicht von der 'Vollversion' unterscheiden. Sparen würde man nur einige Codezeilen im Handler - aber es muss doch keiner das Ding abtippen, um es zu benutzen. Der Aufruf würde 'kleiner', wenn man auch die Hook-Funktionen rausstriche. Dann hätte man drei Argumente weniger - würde aber im Falle eines Absturzes evtl. doch auf einem verstellten BKS, auf ein paar offenen Dateien oder einem hängenden Dialogfenster sitzenbleiben. Wem würde diese Version denn etwas bringen?

Der Handler ist schon sehr klein, und er soll's auch bleiben. Reini Urbans std-error ist um ein Vielfaches größer, und ich habe nicht mal eine Ahnung, ob der wirklich stapelbar ist, mit welchen Versionen er läuft usw. Ich habe mich auch nie  damit auseinandergesetzt, da ich finde, dass die ganze STD-Bibliothek nicht wirklich benutzerfreundlich dokumentiert ist. Es fehlen mir jedenfalls die Hinweise, wie dieser Handler arbeitet und auf welchem Konzept er beruht.

Ich glaube, hier wird was verwechselt: Nicht der Handler ist kompliziert, jedenfalls nicht in der Anwendung. Da ist er sausimpel - der Code mag ja kompliziert sein für jemand, der sich noch nie mit selbstmodifizierenden Funktionen auseinandergesetzt hat. In Diskussionen Lisp vs. VBA wird das ja oft ins Feld geführt: Lisp ist KI-Sprache, da kann man Programme schreiben, die Programme schreiben, die Programme schreiben --- und VBA ist die Sprache, wo man CTRL-C, CTRL-V, CTRL-V anwendet, damit etwas dreimal hintereinander passiert. Warum dann gleich die Befürchtung, dass alles zu kompliziert wird? Es wird doch nur mal das genutzt, was Lisp ausmacht.

Tja, warum gibt es so einen Handler bisher noch nicht? Hmmm... Vielleicht gibt es ihn doch (std-error)? Ich habe den bisher nicht mal ausprobiert wegen der Dokumentation! Oder woanders? Ich habe bisher keinen gefunden, so einfach ist das. Auch Autodesk hat mal was gemacht, ich glaube im Rahmen der Express-Tools - hat mir aber nicht gefallen, und der war auch nicht verschachtelbar. Und unser aller Tony hat da auch nix auf seinen Seiten - jedenfalls habe ich zu diesem Thema nirgendwo etwas gefunden, was mich überzeugt hätte.

Da offenbart sich ein Problem, das die AutoLisp-Programmer-Gemeinde einfach hat: Dieser von mir schon öfters angesprochene Zwang, das Rad ständig neu zu erfinden. Reini Urban hat das vor Jahren ganz genau erkannt und versucht, dem etwas entgegenzusetzen - aber vergeblich. Jeder bastelt weiter vor sich hin. 

Wer eine abgespeckte Version will: Nur zu, der Code ist hier. Man muss ja nur so viel davon verstehen, um unfallfrei einen Teil rauszulöschen. Das steht doch jedem frei. Ich selbst habe aber kein Interesse daran, denn ich mache mir auch deshalb einige Arbeit und Gedanken, weil ich das Ding ja selbst einsetze - in ähnlicher Form, teilweise mit Features, die bisher hier nicht drin sind, teilweise aber auch ohne die, die hier vorliegen. Bisher jedenfalls;-)

Die Realität sieht anders aus als 'abgespeckt': Ich arbeite in einer Schokoladenfabrik (öh - nicht wirklich!): Ich schreibe ein schönes Variantenprogramm für Weihnachtsmänner aus Schokoladenspritzguss - voll errorgehandelt natürlich. Dann kommt Ostern, und ich schreibe noch eins für Osterhasen, natürlich auch voll errorgehandelt. Und dann noch eins für die Pfingstochsen ... die Herzchen zu Valentinstag ... und zum Totensonntag gibt's dann noch Schokoladenkreuze und -kränze. Geht alles ohne verschachteltes Errorhandling. Und dann kommt der Chef und sagt "Machen Sie doch mal ein zentrales Schokoladenprogramm, aus dem man in alle Geschmacks- und Jahreszeitenrichtungen verzweigen kann!" Natürlich sollen die -männer-, -hasen-, ochsen- und -kreuzchenprogramme unverändert weiterlaufen. Tja, dann habe ich ein Programm am Hals, das aus schon errorgehandelten Unterprogrammen besteht. Wer soll dann die Abkacker ausbaden? Die, die die Unterprogramme einzeln aufrufen, oder die, die das Gesamtprogramm benutzen?

Gruß + Frohe Weihnachten, - Ostern, - Pfingsten
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

---

Ok hast mich ja so weit überzeugt(zumindest was meine Wenigkeit betrifft .
Vielleicht muss man ja auch erst einmal abwarten was dabei rauskommt.
Würde mich bloß freuen wenn's für Gestalten wie mich (Wochenend und Gelegenheitsprogrammierer) eine kleine Erklärung dazu gibt.
In der Tat finde ich auch doof das  die Lispler keine Bibos verwenden.
Reini Urban hat schlecht dokumentiert da habe ich dann keine Lust mich durchzuwühlen.
Ansonsten aber zunächst ein  großes Dankeschön für eure Bemühungen.
Gruß Speedcad

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

---

Da du dich ja schon durch den Namenhaften AmiMarkt gewühlt hast, und nichts Augenschmausiges gefunden hast, scheint das ja evtl. doch eine weltweite Sensation werden zu können. Vielleicht ist es ja doch so, das noch niemand einen wirklich umfänglichen Errorhandler geschaffen hat, der die heutigen Fehlerquellen berücksichtigt.

Ich für meinen Teil, finde es hochachtungsvoll, wieviel Angagement und Interesse von Axel in dieses Projekt gesteckt wird, und werde es auf alle Fälle übernehmen/einsetzen.

------------------
Gruß
CADwiesel
Besucht uns im CHAT

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

---

Zitat:

---

Original erstellt von mapcar:
...Dann hätte man drei Argumente weniger - würde aber im Falle eines Absturzes evtl. doch auf einem verstellten BKS, auf ein paar offenen Dateien oder einem hängenden Dialogfenster sitzenbleiben. Wem würde diese Version denn etwas bringen?

---

Dem kleinen Tool, das gerade mal FILEDIA und CMDECHO verstellt.
Ich bin der Meinung, dass man nicht immer mit der Schrotflinte auf Spatzen schießen sollte, wenn ein einzelnes Kügelchen schon ausreicht, um den Vogel in die richtige Richtung zu lenken.
Die Realität sieht, zumindest bei mir, so aus, dass ich einerseits häufig kleine Tools weitergebe, die solo, ohne Bibo oder andere Tools arbeiten und gerade deshalb so schön handlich sind.
Andererseits gibt es da allerdings auch größere, zusammenhängende und -arbeitende Pakete, denen ein "ausgewachsenes" Errorhandling durchaus gut zu Gesicht stände.
Daher mein Plädoyer für zwei Versionen.
Natürlich kann man die XS-Version aus der großen destillieren. Schauen wir also, was noch kommt.

Zitat:

---

Original erstellt von mapcar:
...Ich glaube, hier wird was verwechselt: Nicht der Handler ist kompliziert, jedenfalls nicht in der Anwendung...?

---

Nee, keine Verwechslung. Das bißchen Aufruf ist ja kaum der Rede wert. <grins>

Habe eben mal im Netz und insbesondere der Autodesk Newsgroup nach Error Handling gefahndet. Nix Großartiges. Noch nicht mal die dortigen Korniferen  lassen mehr als die Standard-Versionen sehen.
Hm.

Ratlos,
CADchup

------------------
www.cadditions.de

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

---

Wars das jetzt eigentlich? Alle zufrieden ?

------------------
- Thomas -
"Bei 99% aller Probleme ist die umfassende Beschreibung des Problems bereits mehr als die Hälfte der Lösung desselben."

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

---

Zur Information ( und weil's noch zum Thema paßt )

------------------
- Thomas -
"Du bist einen uns unbekannten Weg in eine andere Form des Seins gegangen. - Wir sehen uns wieder in deinem Paradies! - Tschüß Axel.."

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