PB-LinkedList Hack (just4fun)

[remi_meier]

Achtung: Keine Garantie auf Funktionstüchtigkeit! Dieser Code will nicht
in ein PB-Projekt eingebaut werden

Durch eine Frage in der Lounge, ob man Arrays von LLs oder LLs von LLs
machen kann, hab ich aus Spass mal ein wenig rumprobiert. Ich bin mir
auf keinen Fall sicher, ob das theoretisch sauber wäre oder auch nur
sporadisch funktioniert!
Aber ist doch interessant zu sehen, was so geht

Dieser Code erzeugt ein Array 'p' von LinkedLists. Wenns jemand nicht zu
Lernzwecken benutzen will, soll ers sich nicht mal anschauen, ausser aus
Spass!

Code: Alles auswählen

p1.l
p2.l
Structure strd
  s.s
  l.l
EndStructure

Structure PBLL
  t_rTest.l
  e_rTest.l
EndStructure

; Array von LL-Pointern
Dim p.PBLL(1)

; Test-LL einmal deklarieren und allozieren
NewList rTest.strd()

; LL beladen
AddElement(rTest())
rTest()\s = "Hallo"
AddElement(rTest())
rTest()\s = " Welt!"

; Get Pointer in p(0) -> LL nr. 1
MOV eax, [e_rTest]
MOV p1, eax
MOV eax, [t_rTest]
MOV p2, eax
p(0)\t_rTest = p2
p(0)\e_rTest = p1


;/ Neue LL allozieren -> LL nr. 2
!MOV ecx,s_strd
!MOV ebp,8 ;SizeOf s_strd -> Struktur-Grösse
!MOV ebx,t_rTest
!CALL PB_NewList

; Nun neue LL2 beladen ;-)
AddElement(rTest())
rTest()\s = "Jo,"
AddElement(rTest())
rTest()\s = " du!"
; Get Pointer in p(1) -> LL nr. 2
MOV eax, [e_rTest]
MOV p1, eax
MOV eax, [t_rTest]
MOV p2, eax
p(1)\t_rTest = p2
p(1)\e_rTest = p1



; LL rTest() wieder auf die 1. LL setzen
p2 = p(0)\t_rTest
p1 = p(0)\e_rTest
MOV eax, p1
MOV [e_rTest], eax
MOV eax, p2
MOV [t_rTest], eax
ForEach rTest()
  Debug rTest()\s
Next


; LL rTest() wieder auf die 2. LL setzen
p2 = p(1)\t_rTest
p1 = p(1)\e_rTest
MOV eax, p1
MOV [e_rTest], eax
MOV eax, p2
MOV [t_rTest], eax
ForEach rTest()
  Debug rTest()\s
Next

greetz
Remi

Übrigens: Ich bin bis am 2. August abwesend.

[Deeem2031]

Hm, halt mich für blöd, aber: Was macht der Code?
Ich hab deine beschreibung irgendwie nicht verstanden...

[Leo]

Ich denke er meint, dass man LLs in LLs speichern kann, also so wie bei TreeLLs.

[remi_meier]

So zu sagen ein Array von LLs, also dynamisch LLs erstellen, deren Pointer
dann im Array 'p' gespeichert werden. Man hatt dann nur eine Deklaration,
unter die mehrere LLs gehören... Sche****e kann ich gut erklären.

Naja, der Code macht Folgendes:
1. Eine LL rTest.strd() deklarieren und allozieren
2. Elemente zu dieser LL hinzufügen
3. Pointer zu dieser ersten LL im Array p speichern
4. Unter dem gleichen Namen rTest.strd() eine neue LL allozieren (mit ASM)
5. Zur neuen LL Elemente hinzufügen (hat gleichen Namen wie die 1.)
6. Auch zur 2. LL die Pointer im Array p speichern
7. Wieder zur ersten LL wechseln und alle Elemente ausgeben
8. Wieder zur zweiten LL wechseln und alle Elemente ausgeben

just4fun

[Deeem2031]

Ah! Nu hab ichs kapiert, thx

[Lars]

Für mich sieht das ja eigentlich nur nach Compilerbugs aus

Dass der Compiler auf einmal Symbole annimmt (in diesem Falle z.B.
[c]rTest()\s = " du!" [/c], da wird der Teil einer Struktur plötzlich für den
Compiler zu einer LinkedList), die vorher nie deklariert werden, dürfte
eigentlich bei noch so finsteren Hacks nicht passieren. Man stelle sich vor,
das wäre nicht provoziert, sondern durch einen Tipfehler oder ähnliches
entstanden