[Code-Fehler] Bug: Compilerabsturz

Fragen und Bugreports zur PureBasic 4.0-Beta.
Gesperrt
Benutzeravatar
Leonhard
Beiträge: 602
Registriert: 01.03.2006 21:25

[Code-Fehler] Bug: Compilerabsturz

Beitrag von Leonhard »

Bei mir stürzt bei folgendem Code der Compiler ab:

Code: Alles auswählen

;{ XIncludeFile "lib\PointerList.pbi"
;{ Pointer - List
CompilerIf Defined(PointerList_Version, #PB_Constant)
  CompilerIf #PointerList_Version <> 1.00
    CompilerError "A Pointer - List is defined with an other version as 1.00!"
  CompilerEndIf
CompilerElse
#PointerList_Version = 1.00 ;/ Die Interface-Version

Macro DOUBLEQUOTE$
  "
EndMacro
Macro ASSERT(Bool)
  If Not (Bool)
    CompilerIf #PB_Compiler_Debugger
      Debug "An error at the Source: The ASSERT - Bool must true."
      CallDebugger
    CompilerElse
      MessageRequester("ASSERT - ERROR", "An error at the Source:"+#LF$+"The ASSERT - Bool must true."+#LF$+#LF$+"Debugging:"+#LF$+"Line: "+Str(#PB_Compiler_Line)+"Bool: "+DOUBLEQUOTE$#Bool#DOUBLEQUOTE$)
      End
    CompilerEndIf
  EndIf
EndMacro

;/ Für DeleteElement(..)-Rückgabe
#PointerList_Delete_OK          =  %1    ; Das Element wurde erfolgreich gelöscht. Tritt auch beim Letzen Element ein.
#PointerList_Delete_LastElement = %11    ; Das Letzte Element wurde gelöscht. Es Tritt aus OK ein.
#PointerList_Delete_NoElement   = #False ; Es gibt kein aktuelles Element in der Liste.

;/ Für die Verwendung von ElementSize-Variablen
#PointerList_ElementSize_Default = -1 ; Die Elementengröße ist die Standart-Größe.
#PointerList_ElementSize_Prever  = -2 ; Die Elementengröße ist die vorherige Größe. Dies funktioniert nur mit ReElement(..) und ReCopyElement(..).

Interface PointerList
  ;/ Listenspezifische Funktionen
  Free() ; Gibt die Liste frei
  ReList(ElementDefaultSize) ; Löscht alle Listenelemente, Löscht die Liste und erstellt sie neu
  CountElements.l() ; Gibt die Anzahl der Elemente der Liste zurück.
  ListPos.l() ; Gibt die Position der Liste zurück.
  SetElementDefaultSize(ElementDefaultSize, bChangeElementSizes.b = #False) ; Ändert die Standart-Element-Größe.
                                                                            ; Wenn bChangeElementSizes aktiv ist,
                                                                            ; wird von jedem Element, das die
                                                                            ; alte Größe enthält die Größe auf
                                                                            ; die neue umgeändert.
  GetElementDefaultSize.l() ; Gibt die Standart-Element-Größe zurück
  
  ;/ Elemente Hinzufügen
  AddElement.l(ElementSize = #PointerList_ElementSize_Default) ; Gibt den Pointer des neuen Elementes zurück.
  InsertElement.l(ElementSize = #PointerList_ElementSize_Default) ; Gibt den Pointer des neuen Elementes zurück.
  
  ;/ Elementen-Eigenschaften verändern/bekommen
  ReElement.l(ElementSize = #PointerList_ElementSize_Default) ; Erstellt das Element mit der angegebenen Größe erneut
  ReCopyElement.l(ElementSize = #PointerList_ElementSize_Default) ; Funktioniert wie ReElement(..), nur das hierbei
                                                                  ; der alte Elementinhalt in das neue Element kopiert
                                                                  ; wird (Daten bleiben erhalten, wenn Sie in der neuen
                                                                  ; größe enthalten sind).
  ElementPointer.l() ; Gibt den Pointer des Aktuellen Elementes zurück.
  
  ;/ Elemente Löschen
  DeleteElement.b()
  ClearList()
  
  ;/ Aktives Element verändern
  ResetList() ; Es gibt kein aktuelles Element mehr. Beim nächsten aufruf von NextElement(..) wird das 1. Element zum aktuellen Element.
  SelectElement.l(Position) ; Springt zur Position des Elementes mit der angegebenen Position.
  SearchElement.l(*SelectElement) ; Sucht nach dem angegeben Element und Springt zu der Position des Elementes
  FirstElement.l() ; Setzt das erste Element dem aktuellen Element.
  LastElement.l() ; Setzt das letzte Element dem aktuellen Element.
  NextElement.l() ; Setzt das nächste Element als das aktuelle Element.
  PreviousElement.l() ; Setzt das vorherige Element als das aktuelle Element.
  
  ;/ Vertausche Elemente
  SwapElements.b(*FirstElement, *SecondElement) ; Vertauscht 2 Elemente mit Element-Pointer
  SwapElementsWithPos.b(FirstPos, SecondPos) ; Vertauscht 2 Elemente
  SwapFirst.b() ; Vertauscht das aktuelle mit dem ersten Element
  SwapLast.b() ; Vertauscht das aktuelle mit dem letzten Element
  SwapNext.b() ; Vertauscht das aktuelle mit dem nächsten Element
  SwapPrevious.b() ; Vertauscht das aktuelle mit dem vorherigen Element
EndInterface
Structure PointerList_Element
  *Prever.PointerList_Element
  *this
  *Next  .PointerList_Element
  
  lSize.l ; Größe dieses Elementes
EndStructure
Structure PointerList_Data
  *VirtualTable
  
  *First .PointerList_Element
  *Actual.PointerList_Element
  *Last  .PointerList_Element
  
  lSize.l ; Größe eines neuen Elementes
  
  lCount.l ; Listenelement-Anzahl
  lPos.l ; Listenposition
EndStructure
;{ Declare Methods
Declare _PointerList_Free(*this.PointerList_Data)
Declare _PointerList_ReList(*this.PointerList_Data, ElementSize)
Declare.l _PointerList_CountElements(*this.PointerList_Data)
Declare.l _PointerList_ListPos(*this.PointerList_Data)
Declare SetElementDefaultSize(*this.PointerList_Data, ElementDefaultSize, bChangeElementSizes.b = #False)
Declare.l GetElementDefaultSize(*this.PointerList_Data)

Declare.l _PointerList_AddElement(*this.PointerList_Data, ElementSize = #PointerList_ElementSize_Default)
Declare.l _PointerList_InsertElement(*this.PointerList_Data, ElementSize = #PointerList_ElementSize_Default)

Declare.l _PointerList_ReElement(*this.PointerList_Data, ElementSize = #PointerList_ElementSize_Default)
Declare.l _PointerList_ReCopyElement(*this.PointerList_Data, ElementSize = #PointerList_ElementSize_Default)
Declare.l _PointerList_ElementPointer(*this.PointerList_Data)

Declare.b _PointerList_DeleteElement(*this.PointerList_Data)
Declare _PointerList_ClearList(*this.PointerList_Data)

Declare _PointerList_ResetList(*this.PointerList_Data)
Declare.l _PointerList_SelectElement(*this.PointerList_Data, Position)
Declare.l _PointerList_SearchElement(*this.PointerList_Data, *SelectElement)
Declare.l _PointerList_FirstElement(*this.PointerList_Data)
Declare.l _PointerList_LastElement(*this.PointerList_Data)
Declare.l _PointerList_NextElement(*this.PointerList_Data)
Declare.l _PointerList_PreviousElement(*this.PointerList_Data)

Declare.b _PointerList_SwapElements(*this.PointerList_Data, *FirstElement, *SecondElement)
Declare.b _PointerList_SwapElementsWithPos(*this.PointerList_Data, FirstPos, SecondPos)
Declare.b _PointerList_SwapFirst(*this.PointerList_Data)
Declare.b _PointerList_SwapLast(*this.PointerList_Data)
Declare.b _PointerList_SwapNext(*this.PointerList_Data)
Declare.b _PointerList_SwapPrevious(*this.PointerList_Data)
;}
Macro ForEach_PL(InterfaceName) ;/ Durchläuft die Pointer-Liste. Funktioniert wie ForEach von PureBasic
  InterfaceName\ResetList() : While InterfaceName\NextElement()
EndMacro
Macro Next_PL(InterfaceName = ) ;/ Interface-Namen muss nicht angegeben werden
  Wend
EndMacro
Procedure _PointerList_Free(*this.PointerList_Data)
  ;/ Löscht alle Elemente der Liste
  _PointerList_ClearList(*this)
  
  ;/ Gibt das Listen-Interface frei
  FreeMemory(*this)
EndProcedure
Procedure _PointerList_ReList(*this.PointerList_Data, ElementDefaultSize)
  ;/ Löscht alle Elemente der Liste
  _PointerList_ClearList(*this)
  
  ;/ Setzt die Standart-Variablen der Liste
  *this\lSize  = ElementDefaultSize
  *this\lCount = 0
  *this\lPos   = -1
EndProcedure
Procedure.l _PointerList_CountElements(*this.PointerList_Data)
  ProcedureReturn *this\lCount
EndProcedure
Procedure.l _PointerList_ListPos(*this.PointerList_Data)
  ProcedureReturn *this\lPos
EndProcedure
Procedure SetElementDefaultSize(*this.PointerList_Data, ElementDefaultSize, bChangeElementSizes.b = #False)
  ;/ Wenn die Standart-Größe bei jedem Element, das diese Größe besitzt geändert werden soll:
  If bChangeElementSizes And *this\lSize <> ElementDefaultSize
    Protected *OldActiveElement = *this\Actual ;/ Speichere das Aktuelle Listenelement ab
    
    ;/ Laufe die komplette Liste durch
    _PointerList_ResetList(*this)
    While _PointerList_NextElement(*this)
      If *this\Actual\lSize = *this\lSize ;/ Wenn das Element die vorherige Standart-Größe besitzt
        ;/ Verändere die Größe des Elementes auf die neue Standart-Größe
        _PointerList_ReElement(*this, ElementDefaultSize)
      EndIf
    Wend
    
    ;/ Setzt die aktive Listenposition der vor dem Listendurchlauf
    _PointerList_SearchElement(*this, *OldActiveElement)
  EndIf
  
  ;/ Setzt die ElementDefaultSize (Elemente-Standart-Größe)
  *this\lSize = ElementDefaultSize
EndProcedure
Procedure.l GetElementDefaultSize(*this.PointerList_Data)
  ProcedureReturn *this\lSize
EndProcedure
Procedure.l _PointerList_AddElement(*this.PointerList_Data, ElementSize = #PointerList_ElementSize_Default)
  Protected *ActualElement.PointerList_Element = *this\Actual
  Protected *Element.PointerList_Element = AllocateMemory(SizeOf(PointerList_Element))
  If ElementSize = #PointerList_ElementSize_Default
    ElementSize = *this\lSize
  EndIf
  *Element\this  = AllocateMemory(ElementSize)
  *Element\lSize = ElementSize
  
  If *ActualElement
    If *ActualElement\Next
      ;/ Verbindung zwischen nächstem und neuem Element
      *ActualElement\Next\Prever = *Element
      *Element\Next = *ActualElement\Next
    Else
      *this\Last = *Element
    EndIf
    
    ;/ Verbindung von aktivem und neuem Element
    *ActualElement\Next = *Element
    
    *Element\Prever = *ActualElement
  ElseIf _PointerList_CountElements(*this)
    ASSERT(*this\Last)
    
    *this\Last\Next = *Element
    *Element\Prever = *this\Last
    
    *this\Last = *Element
  Else
    ;/ Kein Element exsistiert
    *this\First = *Element
    *this\Last  = *Element
  EndIf
  
  ;/ Setzt das Aktuelle Element
  *this\Actual = *Element
  
  If *ActualElement = *this\Last
    *this\Last = *Element
  EndIf
  
  *this\lCount + 1 ;/ Element-Anzahl + 1
  *this\lPos   + 1 ;/ Element-Position + 1
  
  ProcedureReturn *Element\this
EndProcedure
Procedure.l _PointerList_InsertElement(*this.PointerList_Data, ElementSize = #PointerList_ElementSize_Default)
  Protected *ActualElement.PointerList_Element = *this\Actual
  Protected *Element.PointerList_Element = AllocateMemory(SizeOf(PointerList_Element))
  If ElementSize = #PointerList_ElementSize_Default
    ElementSize = *this\lSize
  EndIf
  *Element\this  = AllocateMemory(ElementSize)
  *Element\lSize = ElementSize
  
  If *ActualElement
    If *ActualElement\Prever
      ;/ Verbindung von vorigem und neuem Element
      *ActualElement\Prever\Next = *Element
      *Element\Prever = *Element
    EndIf
    
    ;/ Verbindung von aktivem und neuem Element
    *ActualElement\Prever = *Element
    *Element\Next = *ActualElement
  ElseIf _PointerList_CountElements(*this)
    ASSERT(*this\First)
    
    *this\First\Next = *Element
    *Element\Prever = *this\First
    
    *this\First = *Element
  Else
    ;/ Kein Element exsistiert
    *this\First = *Element
    *this\Last  = *Element
  EndIf
  
  ;/ Setzt das Aktuelle Element
  *this\Actual = *Element
  
  If *ActualElement = *this\First
    *this\First = *Element
  EndIf
  
  *this\lCount + 1 ;/ Element-Anzahl + 1
  
  ProcedureReturn *Element\this
EndProcedure
Procedure.l _PointerList_ReElement(*this.PointerList_Data, ElementSize = #PointerList_ElementSize_Default)
  If *this\Actual
    ;/ Das Element wird gelöscht
    FreeMemory(*this\Actual\this)
    
    ;/ Wenn keine Element-Größe angegeben wird, wird die Standart-Größe bzw. die vorherige Größe verwendet
    If ElementSize = #PointerList_ElementSize_Default
      ElementSize = *this\lSize
    ElseIf ElementSize = #PointerList_ElementSize_Prever
      ElementSize = *this\Actual\lSize
    EndIf
    
    ;/ Das Element wird neu erstellt
    *this\Actual\this = AllocateMemory(ElementSize)
    *this\Actual\lSize = ElementSize
    
    ProcedureReturn *this\Actual\this
  EndIf
EndProcedure
Procedure.l _PointerList_ReCopyElement(*this.PointerList_Data, ElementSize = -1)
  ;/ Wenn keine Element-Größe angegeben wird, wird die Standart-Größe bzw. die vorherige Größe verwendet
  If ElementSize = #PointerList_ElementSize_Default
    ElementSize = *this\lSize
  ElseIf ElementSize = #PointerList_ElementSize_Prever
    ElementSize = *this\Actual\lSize
  EndIf
  
  If *this\Actual And *this\Actual\lSize <> ElementSize
    Protected lOldElementSize.l = *this\Actual\lSize
    Protected *OldElementThis = *this\Actual\this
    
    ;/ Das Element wird neu erstellt
    *this\Actual\this = AllocateMemory(ElementSize)
    *this\Actual\lSize = ElementSize
    
    ;/ Hier wird überprüft, ob der alte Speicherwert
    ;/ kleiner als der neue Speicherwert war.
    If lOldElementSize < ElementSize
      ElementSize = lOldElementSize
    EndIf
    
    ;/ Kopiert den alten Speicherwert in den neuen Speicherwert.
    ;/ Somit bleiben die Daten erhalten.
    CopyMemory(*OldElementThis, *this\Actual\this, ElementSize)
    
    ;/ Gibt das alte Element frei
    FreeMemory(*OldElementThis)
    
    ProcedureReturn *this\Actual\this
  EndIf
EndProcedure
Procedure.l _PointerList_ElementPointer(*this.PointerList_Data)
  If *this\Actual
    ProcedureReturn *this\Actual\this
  EndIf
EndProcedure
Procedure.b _PointerList_DeleteElement(*this.PointerList_Data)
  If *this\Actual
    Protected *Element.PointerList_Element = *this\Actual
    Protected bReturn.b
    
    ;/ Setze das Aktuelle Element
    If *Element\Prever
      If *Element\Next
        *Element\Prever\Next = *Element\Next
        *Element\Next\Prever = *Element\Prever
      Else
        *Element\Prever = #Null
      EndIf
      
      *this\Actual = *Element\Prever
      
      ;/ Die Postion veringert sich um 1
      *this\lPos - 1
    ElseIf *Element\Next ;/ Element war das 1. und es gibt noch ein weiteres Element
      ASSERT(*this\First = *Element)
      
      *Element\Next\Prever = #Null
      
      *this\Actual = *Element\Next
    Else ;/ Es gibt kein weiteres Element mehr
      ASSERT(*this\First = #Null)
      ASSERT(*this\Last  = #Null)
      
      *this\Actual = #Null
    EndIf
    
    ;/ Überprüfe, ob Element das 1. Wahr
    If *this\First = *Element
      If *this\Actual
        *this\First = *this\Actual
      Else
        *this\First = #Null
      EndIf
    EndIf
    
    ;/ Setzt den Rückgabewert auf 
    If *this\Last = *Element
      If *this\Actual
        *this\Last = *this\Actual
      Else
        *this\Last = #Null
      EndIf
      
      bReturn = #PointerList_Delete_LastElement
    Else
      bReturn = #PointerList_Delete_OK
    EndIf
    
    ;/ Gebe Element frei
    FreeMemory(*Element\this)
    FreeMemory(*Element)
    
    ;/ Die Elementanzahl wird um 1 kleiner
    *this\lCount - 1
    
    ProcedureReturn bReturn
  EndIf
  ProcedureReturn #PointerList_Delete_NoElement
EndProcedure
Procedure _PointerList_ClearList(*this.PointerList_Data)
  If _PointerList_CountElements(*this) ;/ Wenn mindestens ein Element exsistiert
    Protected bReturn.b
    
    ;/ Der Befehl FirstElement ist hier nicht nötig,
    ;/ da DeleteElement immer das vorherige zum aktuellen
    ;/ macht und dadurch selbst beim löschen das erste
    ;/ Element ansteuert.
    Repeat
      ;/ Löscht das aktuelle Element
      bReturn = _PointerList_DeleteElement(*this)
      
      ASSERT(bReturn <> #PointerList_Delete_NoElement)
    Until bReturn = #PointerList_Delete_LastElement ;/ Springt zum Ende des Programms, 
  EndIf
EndProcedure
Procedure _PointerList_ResetList(*this.PointerList_Data)
  ;/ Setzt kein aktuelles Element
  *this\lPos = -1
  *this\Actual = #Null
EndProcedure
Procedure.l _PointerList_SelectElement(*this.PointerList_Data, Position)
  If Position >= 0 And Position <= *this\lCount - 1
    ;/ Laufe die komplette Liste durch
    _PointerList_ResetList(*this)
    While _PointerList_NextElement(*this)
      If *this\lPos = Position
        ProcedureReturn *this\Actual\this
      EndIf
    Wend
  EndIf
EndProcedure
Procedure.l _PointerList_SearchElement(*this.PointerList_Data, *SelectElement)
  ;/ Laufe die komplette Liste durch
  _PointerList_ResetList(*this)
  While _PointerList_NextElement(*this)
    If *this\Actual\this = *SelectElement
      ProcedureReturn *this\Actual\this
    EndIf
  Wend
EndProcedure
Procedure.l _PointerList_FirstElement(*this.PointerList_Data)
  *this\Actual = *this\First
  *this\lPos = 0
  ProcedureReturn *this\Actual\this
EndProcedure
Procedure.l _PointerList_LastElement(*this.PointerList_Data)
  *this\Actual = *this\Last
  *this\lPos = *this\lCount - 1
  ProcedureReturn *this\Actual\this
EndProcedure
Procedure.l _PointerList_NextElement(*this.PointerList_Data)
  If *this\Actual
    If *this\Actual\Next
      *this\Actual = *this\Actual\Next
      *this\lPos + 1
      ProcedureReturn *this\Actual\this
    EndIf
  ElseIf *this\First
    *this\Actual = *this\First
    *this\lPos = 0
    ProcedureReturn *this\Actual\this
  EndIf
EndProcedure
Procedure.l _PointerList_PreviousElement(*this.PointerList_Data)
  If *this\Actual
    If *this\Actual\Prever
      *this\Actual = *this\Actual\Prever
      *this\lPos - 1
      ProcedureReturn *this\Actual\this
    EndIf
  ElseIf *this\Last
    *this\Actual = *this\Last
    *this\lPos = *this\lCount - 1
    ProcedureReturn *this\Actual\this
  EndIf
EndProcedure
Macro _PointerList_Macro_SwapElements
  If *_FirstElement And *_SecondElement
    ;/ Erstelle eine Swischenvariable und bestücke diese
    Protected *Elementthis   = *_SecondElement\this
    Protected lElementSize.l = *_SecondElement\lSize
    
    ;/ Schreibe First in Secound
    *_SecondElement\this  = *_FirstElement\this
    *_SecondElement\lSize = *_FirstElement\lSize
    
    ;/ Schreibe Secound in First
    *_FirstElement\this  = *Elementthis
    *_FirstElement\lSize = lElementSize
    
    ProcedureReturn #True
  EndIf
EndMacro
Procedure.b _PointerList_SwapElements(*this.PointerList_Data, *FirstElement, *SecondElement)
  ;/ Speichere das Aktuelle Listenelement ab
  Protected *OldActiveElement = *this\Actual
  
  Protected *_FirstElement.PointerList_Element  = _PointerList_SearchElement(*this, *FirstElement)
  Protected *_SecondElement.PointerList_Element = _PointerList_SearchElement(*this, *SecondElement)
  
  _PointerList_Macro_SwapElements
  
  ;/ Wächse auf die vor dem Funktionsaufruf gewählte Funkion
  _PointerList_SearchElement(*this, *OldActiveElement)
EndProcedure
Procedure.b _PointerList_SwapElementsWithPos(*this.PointerList_Data, FirstPos, SecondPos)
  ;/ Speichere das Aktuelle Listenelement ab
  Protected *OldActiveElement = *this\Actual
  
  Protected *_FirstElement.PointerList_Element  = _PointerList_SelectElement(*this, FirstPos)
  Protected *_SecondElement.PointerList_Element = _PointerList_SelectElement(*this, SecondPos)
  
  _PointerList_Macro_SwapElements
  
  ;/ Wächse auf die vor dem Funktionsaufruf gewählte Funkion
  _PointerList_SearchElement(*this, *OldActiveElement)
EndProcedure
Procedure.b _PointerList_SwapFirst(*this.PointerList_Data)
  ;/ Speichere das Aktuelle Listenelement ab
  Protected *OldActiveElement = *this\Actual
  
  Protected *_FirstElement.PointerList_Element  = *this\Actual
  Protected *_SecondElement.PointerList_Element = *this\First
  
  _PointerList_Macro_SwapElements
  
  ;/ Wächse auf die vor dem Funktionsaufruf gewählte Funkion
  _PointerList_SearchElement(*this, *OldActiveElement)
EndProcedure
Procedure.b _PointerList_SwapLast(*this.PointerList_Data)
  ;/ Speichere das Aktuelle Listenelement ab
  Protected *OldActiveElement = *this\Actual
  
  Protected *_FirstElement.PointerList_Element  = *this\Actual
  Protected *_SecondElement.PointerList_Element = *this\Last
  
  _PointerList_Macro_SwapElements
  
  ;/ Wächse auf die vor dem Funktionsaufruf gewählte Funkion
  _PointerList_SearchElement(*this, *OldActiveElement)
EndProcedure
Procedure.b _PointerList_SwapNext(*this.PointerList_Data)
  ;/ Speichere das Aktuelle Listenelement ab
  Protected *OldActiveElement = *this\Actual
  
  Protected *_FirstElement.PointerList_Element  = *this\Actual
  Protected *_SecondElement.PointerList_Element = *this\Actual\Next
  
  _PointerList_Macro_SwapElements
  
  ;/ Wächse auf die vor dem Funktionsaufruf gewählte Funkion
  _PointerList_SearchElement(*this, *OldActiveElement)
EndProcedure
Procedure.b _PointerList_SwapPrevious(*this.PointerList_Data)
  ;/ Speichere das Aktuelle Listenelement ab
  Protected *OldActiveElement = *this\Actual
  
  Protected *_FirstElement.PointerList_Element  = *this\Actual
  Protected *_SecondElement.PointerList_Element = *this\Actual\Prever
  
  _PointerList_Macro_SwapElements
  
  ;/ Wächse auf die vor dem Funktionsaufruf gewählte Funkion
  _PointerList_SearchElement(*this, *OldActiveElement)
EndProcedure
DataSection ; 24 Pointer = 24*4 = 96 Bytes
  _PointerList_VirtualTable:
    Data.l @_PointerList_Free()
    Data.l @_PointerList_ReList()
    Data.l @_PointerList_CountElements()
    Data.l @_PointerList_ListPos()
    Data.l @SetElementDefaultSize()
    Data.l @GetElementDefaultSize()
    
    Data.l @_PointerList_AddElement()
    Data.l @_PointerList_InsertElement()
    
    Data.l @_PointerList_ReElement()
    Data.l @_PointerList_ReCopyElement()
    Data.l @_PointerList_ElementPointer()
    
    Data.l @_PointerList_DeleteElement()
    Data.l @_PointerList_ClearList()
    
    Data.l @_PointerList_ResetList()
    Data.l @_PointerList_SelectElement()
    Data.l @_PointerList_SearchElement()
    Data.l @_PointerList_FirstElement()
    Data.l @_PointerList_LastElement()
    Data.l @_PointerList_NextElement()
    Data.l @_PointerList_PreviousElement()
    
    Data.l @_PointerList_SwapElements()
    Data.l @_PointerList_SwapElementsWithPos()
    Data.l @_PointerList_SwapFirst()
    Data.l @_PointerList_SwapLast()
    Data.l @_PointerList_SwapNext()
    Data.l @_PointerList_SwapPrevious()
EndDataSection

;/ Syntax:
;/   CreatePointerList.l(ElementSize)
;/ Beschreibung:
;/   Gibt ein Interface für eine neue
;/   Pointer-Liste zurück.
;/ Parameter
;/   ElementSize(.l)
;/     Die Größe der Standart-Element-Struktur,
;/     Die bei einem neuen Element erstellt wird.
ProcedureDLL.l CreatePointerList(ElementDefaultSize)
  Protected *object.PointerList_Data = AllocateMemory(SizeOf(PointerList_Data))
  
  *object\VirtualTable = ?_PointerList_VirtualTable
  
  *object\lSize = ElementDefaultSize
  *object\lPos   = -1
  
  ProcedureReturn *object
EndProcedure
CompilerEndIf
;}
;}

Structure Field
  s.s
EndStructure

Define *tmpField.Field
Define sInput.s
Define List.PointerList = CreatePointerList(SizeOf(Field))

Macro Input(Name = "")
  ConsoleColor(12, 0)
  Print("#")
  ConsoleColor(15, 0)
  Print(Name)
  ConsoleColor(10, 0)
  Print("->")
  ConsoleColor(7, 0)
  
  sInput = Input()
EndMacro


OpenConsole()
  Repeat
    Input()
    
    If sInput = "+"
      Input()
      *tmpField = List\AddElement()
      *tmpField\s = sInput
    EndIf
  Until LCase(sInput) = "exit"
CloseConsole()

End
Windows Vista gibt folgende Problemmdebug aus:
Problemsignatur:
Problemereignisname: APPCRASH
Anwendungsname: PBCompiler.exe
Anwendungsversion: 0.0.0.0
Anwendungszeitstempel: 4585daa6
Fehlermodulname: ntdll.dll
Fehlermodulversion: 6.0.6000.16386
Fehlermodulzeitstempel: 4549bdc9
Ausnahmecode: c00000fd
Ausnahmeoffset: 000623af
Betriebsystemversion: 6.0.6000.2.0.0.256.1
Gebietsschema-ID: 1031
Zusatzinformation 1: c5a5
Zusatzinformation 2: 54daafaa4018cee69a1838ebd045c29d
Zusatzinformation 3: b27d
Zusatzinformation 4: b09a4c8167f753503fbd0704a824ea5c

Lesen Sie unsere Datenschutzrichtlinie:
http://go.microsoft.com/fwlink/?linkid= ... cid=0x0407
Tritt dieser Fehler auch bei euch auf?
Zuletzt geändert von Leonhard am 25.07.2007 07:21, insgesamt 1-mal geändert.
Nach oben
Benutzeravatar
ts-soft
Beiträge: 22292
Registriert: 08.09.2004 00:57
Computerausstattung: Mainboard: MSI 970A-G43
CPU: AMD FX-6300 Six-Core Processor
GraKa: GeForce GTX 750 Ti, 2 GB
Memory: 16 GB DDR3-1600 - Dual Channel
Wohnort: Berlin

Beitrag von ts-soft »

> 650 "fehlerhafter" Zeilen :mrgreen:

Code: Alles auswählen

Define.s sInput

Macro Input(Name = "")
  ConsoleColor(12, 0)
  Print("#")
  ConsoleColor(15, 0)
  Print(Name)
  ConsoleColor(10, 0)
  Print("->")
  ConsoleColor(7, 0)
 
  sInput = Input()
EndMacro


OpenConsole()

    Input()
   
    Debug sInput
CloseConsole()
Hab nur den letzten Abschnitt Deines rekursiven Macros mal "laufffähig"
gemacht, ohne das drumherumgedöns

Das soll doch wohl keine Bugmeldung sein :mrgreen:
Hast mir das Wochenende gerettet :lol:

// Nachtrag:
Procedure.b spart nicht ein Byte Speicher ein, lediglich die
Programmausführung wird verlangsamt. Macht also im allgmeinen keinen Sinn
PureBasic 5.73 LTS | SpiderBasic 2.30 | Windows 10 Pro (x64) | Linux Mint 20.1 (x64)
Nutella hat nur sehr wenig Vitamine. Deswegen muss man davon relativ viel essen.
Bild
Nach oben
Benutzeravatar
Leonhard
Beiträge: 602
Registriert: 01.03.2006 21:25

Beitrag von Leonhard »

Ooops :oops:

das hab ich grad übersehen.

Nur ist es ja Komisch, das es einen Compilerabsturz gibt, und nicht einfach ne Fehlermeldung.
Nach oben
Benutzeravatar
ts-soft
Beiträge: 22292
Registriert: 08.09.2004 00:57
Computerausstattung: Mainboard: MSI 970A-G43
CPU: AMD FX-6300 Six-Core Processor
GraKa: GeForce GTX 750 Ti, 2 GB
Memory: 16 GB DDR3-1600 - Dual Channel
Wohnort: Berlin

Beitrag von ts-soft »

Leonhard hat geschrieben:Ooops :oops:

das hab ich grad übersehen.

Nur ist es ja Komisch, das es einen Compilerabsturz gibt, und nicht einfach ne Fehlermeldung.
Fehlerprüfungen innerhalb von Macros gibts kaum. Das ist auch gut so,
je mehr Fehlerprüfungen, um so mehr geht auch nicht mehr, was gehen
sollte. Man sieht doch das endlose Kompilierfenster, ich jedenfalls (PB-IDE),
da weiß man doch gleich das was nicht stimmt.
PureBasic 5.73 LTS | SpiderBasic 2.30 | Windows 10 Pro (x64) | Linux Mint 20.1 (x64)
Nutella hat nur sehr wenig Vitamine. Deswegen muss man davon relativ viel essen.
Bild
Nach oben
Gesperrt

Zurück zu „PureBasic 4.x Beta“