CADsite forum

Beste CADliefhebbers,

Heeft iemand de broncode van de interne subroutine acet-str-to-list
(vanaf AutoCAD 2000), of een procedure die hetzelfde kan in lisp
(dus niet in Visual Lisp).
Bij de subroutine aanroep (acet-str-to-list Delimiter  Delimitedstring)
moet men een Delimiter (bijv "\t") en een Delimitedstring
(bijv. "Meneer\tvan Dalen") aangeven.
Door de aanroep (acet-str-to-list "\t" "Meneer\tvan Dalen") kan men de
tab delimited string omzetten naar de list ("Meneer" "van Dalen").
In mijn laatste vakantiedagen ben ik me weer eens bezig gaan houden,
met  o.a Cad Scene Investigations project ThomCAD (attribuutwaarden
in Excel) en het nieuwe project HofHyp (URL's en hyperlinks).
Het zou voor mij leuk zijn, als ThomCAD  vanaf  AutoCAD release 13
zou draaien.
Bij voorbaat mijn dank.

Groetjes HofCAD CSI

(defun Hcad-str-to-lst (delimiter tekst /)
 (setq del_lng (strlen delimiter))
 (setq txt_lng (strlen tekst))
 (setq chm 0
   str_lst nil
   si 1)
 (while
   (= del_lng (strlen (setq st (substr tekst si del_lng))))
   (if (= st delimiter)
     (progn
       (setq str_lst (append (list (substr tekst 1 (1- si))) str_lst ))
       (setq si (+ si del_lng))
   (setq si1 si)
     )
     (setq si (1+ si))
   )
 )
 (setq str_lst (reverse (append (list (substr tekst si1 (1- si))) str_lst)))
)

probeer deze eens, want weet niet goed wat je juist zoekt....

Citaat van: WebRacer
probeer deze eens, want weet niet goed wat je juist zoekt....

Beste WebRacer,

Je hebt toch aardig geraden wat ik zoek.
Ik wil je meteen bedanken, voor je programma. :D
Misschien had ik mijn voorbeeld ingewikkelder moeten maken,
zodat je ook mee had kunnen nemen als er 2 tabs achter elkaar staan.
Bijvoorbeeld:
(setq x "een\taantal\tvan\t2\t\ttabs\tgeeft\t\meneer\van Dalen\tproblemen")
Want in deze situatie krijg ik met (setq y1 (Hcad-str-to-lst "\t" x))
geen lege string.
(prin1 y1) geeft dan jammer genoeg niet:
("een" "aantal" "van" "2" "" "tabs" "geeft" "meneer" "van Dalen" "problemen")
Zelf heb ik onderstaand programma in elkaar gesleuteld:

(defun TABSTR2LST (delim str / hstr n nt nlst slst)
 (setq   nt (strlen str)
   n  0
 )
 (setq nlst (list 0))
 (while (<= (setq n (1+ n)) nt)
   (if   (= delim (substr str n 1))
     (setq nlst (cons n nlst))
   )
 )
 (setq nlst (cons (1+ nt) nlst))
 (setq nlst (reverse nlst))
 (repeat (1- (length nlst))
   (setq hstr (substr str
             (1+ (car nlst))
             (- (cadr nlst) (car nlst) 1)
          )
   )
   (setq slst (cons hstr slst))
   (setq nlst (cdr nlst))
 )
 (reverse slst)
)

Het nadeel van bovenstaand programma is, dat het veel trager
dan het onderstaande Vlisp programma is:

(defun STR2LST (delim str / hlst n)
 (setq delim (ascii delim))
 (while (setq n (vl-string-position delim str))
   (setq hlst          (cons (substr str 1 n) hlst)
     str          (substr str (+ 2 n))     
   )
 )
 (reverse (cons str hlst))
)

Dus ik ben er voorlopig niet volledig uit. :cry:

Groetjes HofCAD CSI

deze subroutine:
[/color][/b](defun Hcad-str-to-lst (delimiter tekst /)
(setq del_lng (strlen delimiter))
(setq txt_lng (strlen tekst))
(setq chm 0
      str_lst nil
      si 1
      si1 1
      si2 1)
(while
  (= del_lng (strlen (setq st (substr tekst si del_lng))))
  (if (= st delimiter)
    (progn
      (setq str_lst (append (list (substr tekst si1 (1- si2))) str_lst ))
      (setq si1 (+ si del_lng)
        si2 1
        si (1+ si))
    )
    (progn
      (setq si (1+ si))
      (setq si2 (1+ si2))
    )
  )
)
(setq str_lst (reverse (append (list (substr tekst si1 (1- si))) str_lst)))
)


met deze gegevens:

setq x "een\taantal\tvan\t2\t\ttabs\tgeef\t\meneer\van Dalen\tproblemen")

(setq y1 (Hcad-str-to-lst "\t" x))


heeft mij dit resultaat:

("een" "aantal" "van" "2" "" "tabs" "geef" "meneervan Dalen" "problemen")

Ik hoop dat dit wel is wat je zoekt...

Citaat van: WebRacer
Ik hoop dat dit wel is wat je zoekt...

Beste CADliefhebbers,

WebRacer heeft het goed gezien, wat ik zoek.
En bij deze wil ik hem ook bedanken voor zijn bijdrage.
Maar echt tevreden ben ik nog niet helemaal, want als ik bovenstaande
programma 's laad en het onderstaande programma test draai,
dan krijg ik bij mijn 'met turf gestookte' computer:

De string: "Geven\t2\t\ttabs\tMeneer\tvan Dalen\tproblemen?" geeft met:
(STR2LST "\t""Geven\t2\t\ttabs\tMeneer\tvan Dalen\tproblemen?")
als resultaat:
("Geven" "2" "" "tabs" "Meneer" "van Dalen" "problemen?")
Bovenstaand 30000 keer uitvoeren kost:
elapse time: 3.85 seconds

De string: "Geven\t2\t\ttabs\tMeneer\tvan Dalen\tproblemen?" geeft met:
(TABSTR2LST "\t""Geven\t2\t\ttabs\tMeneer\tvan Dalen\tproblemen?")
als resultaat:
("Geven" "2" "" "tabs" "Meneer" "van Dalen" "problemen?")
Bovenstaand 30000 keer uitvoeren kost:
elapse time: 18.38 seconds

De string: "Geven\t2\t\ttabs\tMeneer\tvan Dalen\tproblemen?" geeft met:
(Hcad-str-to-lst "\t""Geven\t2\t\ttabs\tMeneer\tvan Dalen\tproblemen?")
als resultaat:
("Geven" "2" "" "tabs" "Meneer" "van Dalen" "problemen?")
Bovenstaand 30000 keer uitvoeren kost:
elapse time: 22.69 seconds

Dus ik ben bij al de drie programma's tevreden over de uitkomst,
maar als ik kijk naar de tijd is alleen het Vlisp programma STR2LST
goed te noemen.
Mijn frustratie is dus dat het Visual Lisp programma bijna 5x zo snel is.

Groetjes HofCAD CSI




(defun c:test (/ start total i x x1)
(textscr)
(setvar "CMDECHO" 0)
(setq x "Geven\t2\t\ttabs\tMeneer\tvan Dalen\tproblemen?")
(setq x1 "\042Geven\\t2\\t\\ttabs\\tMeneer\\tvan Dalen\\tproblemen?\042")

(princ (strcat "\nDe string: " x1 " geeft met:"))
(princ (strcat "\n(STR2LST \042\\t\042" x1 ")"))
(princ "\nals resultaat:\n")
(prin1 (STR2LST "\t" x))
(princ "\nBovenstaand 30000 keer uitvoeren kost:")
(setq start (getvar "date") i 1)
(while (< i 30000)
(STR2LST "\t" x)
(setq i (1+ i)))
(setq total (- (getvar "date") start)
total (* 86400.0 (- total (fix total))))
(princ (strcat "\nelapse time: " (rtos total 2 2) " seconds\n"))

(princ (strcat "\nDe string: " x1 " geeft met:"))
(princ (strcat "\n(TABSTR2LST \042\\t\042" x1 ")"))
(princ "\n als resultaat:\n")
(prin1 (TABSTR2LST  "\t" x))
(princ "\nBovenstaand 30000 keer uitvoeren kost:")
(setq start (getvar "date") i 1)
(while (< i 30000)
(TABSTR2LST "\t" x)
(setq i (1+ i)))
(setq total (- (getvar "date") start)
total (* 86400.0 (- total (fix total))))
(princ (strcat "\nelapse time: " (rtos total 2 2) " seconds\n"))
(setvar "CMDECHO" 1)
(princ)

(princ (strcat "\nDe string: " x1 " geeft met:"))
(princ (strcat "\n(Hcad-str-to-lst \042\\t\042" x1 ")"))
(princ "\n als resultaat:\n")
(prin1 (Hcad-str-to-lst "\t" x))
(princ "\nBovenstaand 30000 keer uitvoeren kost:")
(setq start (getvar "date") i 1)
(while (< i 30000)
(Hcad-str-to-lst "\t" x)
(setq i (1+ i)))
(setq total (- (getvar "date") start)
total (* 86400.0 (- total (fix total))))
(princ (strcat "\nelapse time: " (rtos total 2 2) " seconds\n"))

(princ)
)

sneller maar het verschil is hier ook duidelijk.

De string: "Geven\t2\t\ttabs\tMeneer\tvan Dalen\tproblemen?" geeft met:
(STR2LST "\t""Geven\t2\t\ttabs\tMeneer\tvan Dalen\tproblemen?")
als resultaat:
("Geven" "2" "" "tabs" "Meneer" "van Dalen" "problemen?")
Bovenstaand 30000 keer uitvoeren kost:
elapse time: 1.11 seconds

De string: "Geven\t2\t\ttabs\tMeneer\tvan Dalen\tproblemen?" geeft met:
(TABSTR2LST "\t""Geven\t2\t\ttabs\tMeneer\tvan Dalen\tproblemen?")
als resultaat:
("Geven" "2" "" "tabs" "Meneer" "van Dalen" "problemen?")
Bovenstaand 30000 keer uitvoeren kost:
elapse time: 5.45 seconds

De string: "Geven\t2\t\ttabs\tMeneer\tvan Dalen\tproblemen?" geeft met:
(Hcad-str-to-lst "\t""Geven\t2\t\ttabs\tMeneer\tvan Dalen\tproblemen?")
als resultaat:
("Geven" "2" "" "tabs" "Meneer" "van Dalen" "problemen?")
Bovenstaand 30000 keer uitvoeren kost:
elapse time: 7.09 seconds

Als je dacht dat lisp sneller was dan Vlisp, dan zit je er goed naast,
het was trouwens ook de bedoeling van de ontwikkelaars van Vlisp om bepaalde dingen sneller te laten uitvoeren, vandaar de bende nieuwe commando's.. tov Lisp...

maar enfin:

4.79 Sec  -  23.89 sec  - 26.65 Sec  -> acad 2006
4.01 Sec  -  22.47 Sec  - 25.25 Sec  -> acad 2004

hier ook nog even met 2006 getest
blijkt sneller dan 2002 dus mischien komt het toch nog goed komen tussen mij en de nieuwste versie

Command: test

De string: "Geven\t2\t\ttabs\tMeneer\tvan Dalen\tproblemen?" geeft met:
(STR2LST "\t""Geven\t2\t\ttabs\tMeneer\tvan Dalen\tproblemen?")
als resultaat:
("Geven" "2" "" "tabs" "Meneer" "van Dalen" "problemen?")
Bovenstaand 30000 keer uitvoeren kost:
elapse time: 0.92 seconds

De string: "Geven\t2\t\ttabs\tMeneer\tvan Dalen\tproblemen?" geeft met:
(TABSTR2LST "\t""Geven\t2\t\ttabs\tMeneer\tvan Dalen\tproblemen?")
als resultaat:
("Geven" "2" "" "tabs" "Meneer" "van Dalen" "problemen?")
Bovenstaand 30000 keer uitvoeren kost:
elapse time: 4.23 seconds

De string: "Geven\t2\t\ttabs\tMeneer\tvan Dalen\tproblemen?" geeft met:
(Hcad-str-to-lst "\t""Geven\t2\t\ttabs\tMeneer\tvan Dalen\tproblemen?")
als resultaat:
("Geven" "2" "" "tabs" "Meneer" "van Dalen" "problemen?")
Bovenstaand 30000 keer uitvoeren kost:
elapse time: 5.52 seconds

Citaat van: WebRacerAls je dacht dat lisp sneller was dan Vlisp, dan zit je er goed naast,
het was trouwens ook de bedoeling van de ontwikkelaars van Vlisp om bepaalde dingen sneller te laten uitvoeren, vandaar de bende nieuwe commando's.. tov Lisp...

Beste CADliefhebbers,

Ik heb opgemerkt aan jullie elapsed time resultaten, jullie computer
niet meer stoken met turf maar een energievoorziening  hebben van
steenkool, aardolie, gas of misschien wel met elektriciteit.
Maar dat doet volgens mij niets of zeer weinig aan de verhouding af.

Dat VisualLISP sneller is dan gewoon AutoLISP, was mij ook allang
duidelijk.
Zie o.a het voorbeeld in de Sample\Visuallisp\activex met al-tst.lsp
en vla-tst.lsp, maar daar is de snelheidsverhouding ongeveer 1.05.
Maar het kan dus ook best aan mij liggen, dat bij het tab delimited string
probleem, de snelheidsverhouding ongeveer 5 is.
Dit is een veel slechtere verhouding, en kan veroorzaakt zijn door het
feit dat ik gewoon weg niet kan goed programeren. :oops:
Misschien moet ik me er maar gewoon bij neer leggen. :cry:

Groetjes HofCAD CSI

PS Daar acet-str-to-list (volgens mij zit die in de expresstools ergens)
ook niet zo snel is, zit ik misschien wel in een goed gezelschap. :lol:
Voeg maar eens de volgende regels boven de laatste (princ) aan
test.lsp toe.

(princ (strcat "\nDe string: " x1 " geeft met:"))
(princ (strcat "\n(acet-str-to-list \042\\t\042" x1 ")"))
(princ "\n als resultaat:\n")
(prin1 (acet-str-to-list "\t" x))
(princ "\nBovenstaand 30000 keer uitvoeren kost:")
(setq start (getvar "date") i 1)
(while (< i 30000)
(acet-str-to-list "\t" x)
(setq i (1+ i)))
(setq total (- (getvar "date") start)
total (* 86400.0 (- total (fix total))))
(princ (strcat "\nelapse time: " (rtos total 2 2) " seconds\n"))

Command: test

De string: "Geven\t2\t\ttabs\tMeneer\tvan Dalen\tproblemen?" geeft met:
(STR2LST "\t""Geven\t2\t\ttabs\tMeneer\tvan Dalen\tproblemen?")
als resultaat:
("Geven" "2" "" "tabs" "Meneer" "van Dalen" "problemen?")
Bovenstaand 30000 keer uitvoeren kost:
elapse time: 5.05 seconds

De string: "Geven\t2\t\ttabs\tMeneer\tvan Dalen\tproblemen?" geeft met:
(TABSTR2LST "\t""Geven\t2\t\ttabs\tMeneer\tvan Dalen\tproblemen?")
als resultaat:
("Geven" "2" "" "tabs" "Meneer" "van Dalen" "problemen?")
Bovenstaand 30000 keer uitvoeren kost:
elapse time: 23.34 seconds

De string: "Geven\t2\t\ttabs\tMeneer\tvan Dalen\tproblemen?" geeft met:
(Hcad-str-to-lst "\t""Geven\t2\t\ttabs\tMeneer\tvan Dalen\tproblemen?")
als resultaat:
("Geven" "2" "" "tabs" "Meneer" "van Dalen" "problemen?")
Bovenstaand 30000 keer uitvoeren kost:
elapse time: 26 seconds

De string: "Geven\t2\t\ttabs\tMeneer\tvan Dalen\tproblemen?" geeft met:
(acet-str-to-list "\t""Geven\t2\t\ttabs\tMeneer\tvan Dalen\tproblemen?")
als resultaat:
("Geven" "2" "" "tabs" "Meneer" "van Dalen" "problemen?")
Bovenstaand 30000 keer uitvoeren kost:
elapse time: 30.42 seconds