Aktuelle Zeit: 24.08.2019 09:04

Alle Zeiten sind UTC + 1 Stunde [ Sommerzeit ]




Ein neues Thema erstellen Auf das Thema antworten  [ 19 Beiträge ]  Gehe zu Seite Vorherige  1, 2
Autor Nachricht
 Betreff des Beitrags: Re: Suche IDE Tool. Deklarierte, aber ungenutzte Vars, Konst
BeitragVerfasst: 28.02.2019 11:19 
Offline

Registriert: 18.08.2017 09:35
@ts
Ich will nicht wissen wie deine Messie Wohnung aussieht :lol: Du hebst wahrscheinlich bei dir auch alles auf und willst nichts wegschmeissen :D
Aber jeder nach seiner Fason, wenn er sonst nicht zu tun hat ......... oder zu faul ist :mrgreen:

_________________
Bild


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags: Re: Suche IDE Tool. Deklarierte, aber ungenutzte Vars, Konst
BeitragVerfasst: 28.02.2019 11:33 
Offline
Benutzeravatar

Registriert: 25.04.2006 17:29
Wohnort: Nähe Hamburg
ts-soft hat geschrieben:
...der Aufwand steht in keinem Verhältnis zum Ergebnis und bringt niemanden etwas.
Das ist genau der Punkt, bei dem Du Dich irrst. Außerhalb des eigenen Mikrokosmos gelten evtl. andere "Naturgesetze" als die, die man aus eigener Erfahrung kennt. Ich habe aber gelernt damit umzugehen, dass die meisten Mitmenschen nur ihre eigene Meinung und Einschätzungen gelten lassen. Von daher alles gut. :)

_________________
"Never run a changing system!"
PB 5.62, OS: Windows 7 Pro x64, Desktopscaling: 125%, CPU: I7 6500, RAM: 16 GB, GPU: Intel Graphics HD 520
Ich bin Baujahr 1968, also aktuell 51.


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags: Re: Suche IDE Tool. Deklarierte, aber ungenutzte Vars, Konst
BeitragVerfasst: 28.02.2019 13:10 
Offline
Benutzeravatar

Registriert: 08.09.2004 00:57
Wohnort: Berlin
An diesen Menschen (hoffe ich mal) dessen Name hier nur aus Sonderzeichen besteht (deswegen wird er ja auch von vielen nicht angesprochen), wo ist denn Dein aufgeräumter Code? Konnte hier nichts entdecken, was über 2 Zeilen geht!

Von mir findest Du hier reichlich Codes, die Syntaktisch alle sehr aufgeräumt sind und einheitlich einem Stil folgen.

Ich denke mal, Du weißt gar nicht worum es geht.

Gruß
Thomas

_________________
PureBasic 5.70 | SpiderBasic 2.21 | Windows 10 Pro (x64) | Linux Mint 19.2 (x64)
"Die Jugend von heute mit ihren Ballerspielen, hocken nur in der Bude - wir haben früher die Leute noch draußen erschossen!"
Bild


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags: Re: Suche IDE Tool. Deklarierte, aber ungenutzte Vars, Konst
BeitragVerfasst: 28.02.2019 13:42 
Offline

Registriert: 18.08.2017 09:35
Lieber Thomas, ich muss dir nichts beweisen. Ich kann trotzdem eine Meinung haben! Oder warum machst du dich in einem anderen Offtopic Thread z.b. über BER lustig obwohl du selber noch nie einen Flughafen gebaut hast? Merkste selber wie unlogisch dein Text "wo ist denn Dein aufgeräumter Code?" ist.
Und nun Schluss damit. Zurück zum Thema. :)

_________________
Bild


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags: Re: Suche IDE Tool. Deklarierte, aber ungenutzte Vars, Konst
BeitragVerfasst: 03.03.2019 21:36 
Offline
Benutzeravatar

Registriert: 11.08.2005 19:08
ts-soft hat geschrieben:
Ich deklariere auch gerne Konstanten, die zwar nicht genutzt werden, aber zum Thema gehören. Wenn das "Unsauberer Code" ist, dann will ich nur noch unsauberen Code :lol:
Da gebe ich dir recht. Unbenutze Feld-Variablen von Strukturen sollte man ebenfalls besser drin lassen... :lol: :)

ts-soft hat geschrieben:
Im Ernst, der Aufwand steht in keinem Verhältnis zum Ergebnis und bringt niemanden etwas. Aber jeder nach seiner Fason, wenn er sonst nicht zu tun hat :mrgreen:
Ich denke da eher an ein einfaches Tool. Um wirklich alles zu prüfen, ob es unbenutzt ist, wäre ein Mammutprojekt und nahezu ein kompletter PureBasic-Code-Parser. :freak:

Mein erster Gedanke war alle Objekte-Vorkommnisse zu zählen. Die Zählung wäre dabei natürlich pro Module und Procedure separat behandelt worden.
Probleme:
  • Keine Unterscheidung zwischen globalen und lokalen Objekten
  • Objekt-Typ (Procedure? Variable? Array?) wird dabei nicht ermittelt (Ok, zwischen normaler Variable und Procedure/Array/Liste könnte man anhand der angehängten geöffneten Klammer unterscheiden)
... es steht also nur jeweils der Objekt-Name und die Anzahl der Vorkommnisse in der Baum-strukturierten Ergebnisliste.

Neue Idee: Nur Module, Proceduren und Variablen prüfen. Die Einschränkung auf diese Objekt-Typen geben auch mehr Sinn. Mal schauen, ob das vom Aufwand her akzeptabel ist.

Zu viele Warn-Meldungen über unbenutzte Objekte können Programmierer schnell nerven. In Foren von C++ oder Go kann man von zahlreichen Hilferufenden lesen, die nach dem Ausschalter solcher Meldungen fragen :lol:

@Kurzer:
Am besten wäre sicherlich, wenn du deinen Programmierstil verbesserst:
  • Globale Variablen weitestgehend vermeiden
  • Code modularer gestalten: Codes in mehr Proceduren auslagern (vorzugsweise sollten die Proceduren in anderen Projekten einfach wiederverwendbar sein)
  • Proceduren schlank halten, damit sie ohne zu scrollen vollständig sichtbar sind
Danach sollte es nicht mehr so viele Variablen in einem Scope (Haupt-Code, Modul, Procedure) geben. Code-Leichen durch Entfernen von Code wird dadurch ebenfalls weitestgehend vermieden.

_________________
Bild
Warum OpenSource eine Lizenz haben sollte
PureBasic-CodeArchiv-Rebirth: Git-Repository / Download -- Jede Hilfe ist willkommen!
Manjaro Xfce x64 (Hauptsystem) :: WindowsXP/Xubuntu x86 (VirtualBox) :: PureBasic (Linux: x86/x64, Windows: x86) :: jeweils neueste Version


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags: Re: Suche IDE Tool. Deklarierte, aber ungenutzte Vars, Konst
BeitragVerfasst: 04.03.2019 22:28 
Offline
Benutzeravatar

Registriert: 25.04.2006 17:29
Wohnort: Nähe Hamburg
Sicro hat geschrieben:
Mein erster Gedanke war alle Objekte-Vorkommnisse zu zählen. Die Zählung wäre dabei natürlich pro Module und Procedure separat behandelt worden.
Probleme:
Keine Unterscheidung zwischen globalen und lokalen Objekten
Objekt-Typ (Procedure? Variable? Array?) wird dabei nicht ermittelt (Ok, zwischen normaler Variable und Procedure/Array/Liste könnte man anhand der angehängten geöffneten Klammer unterscheiden)
... es steht also nur jeweils der Objekt-Name und die Anzahl der Vorkommnisse in der Baum-strukturierten Ergebnisliste.

Hallo Sicro, Du musst Dir da nicht so viel Arbeit mit machen. Also von meiner Seite aus war das keine Programmier-Bitte an Dich. ;-)
Wenn Du selber Spaß dran hast, dann ist es okay und dann mach auch nur so viel wie Du Lust dran hast.

Sicro hat geschrieben:
@Kurzer:
Am besten wäre sicherlich, wenn du deinen Programmierstil verbesserst:
  • Globale Variablen weitestgehend vermeiden
  • Code modularer gestalten: Codes in mehr Proceduren auslagern (vorzugsweise sollten die Proceduren in anderen Projekten einfach wiederverwendbar sein)
  • Proceduren schlank halten, damit sie ohne zu scrollen vollständig sichtbar sind
Danach sollte es nicht mehr so viele Variablen in einem Scope (Haupt-Code, Modul, Procedure) geben. Code-Leichen durch Entfernen von Code wird dadurch ebenfalls weitestgehend vermieden.

Die Sache mit dem Programmierstil ist immer so eine Sache... Ich hänge mal den Code meines aktuellen, aber unfertigen Moduls hier rein, dann kannst Du beurteilen, ob Deine Einwände oben zutreffen. :wink:

Ich denke eher, dass es daran liegt, dass Programmieren ein evolutionärer Prozess ist (zumindest bei mir) und man zwangsläufig im Laufe der Projektpflege immer wieder Dinge umstellt oder erweitert, weil man dafür einfach nun eine bessere Lösung oder eine neue Idee gefunden hat. Für mich ist die "evolutionäre Entwicklung " jedenfalls ziemlich normal und das mag auch dran liegen, dass ich aus Zeitgründen ein Projekt nie in einem Zug voll durchprogrammieren und fertigstellen kann. In den Pausen, die ich dazwischen mache, fallen mir dann meist auch wieder Verbesserungen zum Projekt ein, die ich dann in der nächsten Session einbaue.

So gesehen, kann ich an meinem Programmierstil vermutlich nicht viel verändern. Was die Codequalität angeht (ich meine damit nicht die Art und Weise, wie man seinen Code formatiert und organisiert), bin ich aber gern für Verbesserungsvorschläge offen.

Hier wie versprochen, mein unfertiger Modulcode für ein Customgadget (Graphanzeige mit Unterstützung mehrere Datenbuffer, die dann als Kurvenform visualisiert werden sollen). Der Code ist allein nicht lauffähig, aber man kann hoffentlich gut meinen "Programmierstil" darin erkennen. Die Kommentare in den Prozedurköpfen sind derzeit auch nur dummies. Die TABs, besonders bei den Kommentaren, werden vom Forum leider zerfleddert.

Hier mal das derzeitige Aussehen in einem Testprogramm (zu sehen sind zwei Instanzen des Gadgets. Die Kurven selbst werden noch nicht gezeichnet):

Bild

Code:
;*************************************************************************
;*
;* GraphGadget (c) Kurzer
;*
;*************************************************************************
;*
;* Modulname         : GraphGadget
;* Filename          : mod_GraphGadget.pbi
;* Filetype          : Module [MainApp, Formular, Include, Module, Data]
;* Programming lang. : Purebasic 5.62
;* String-Format     : Unicode [Ascii, Unicode, Multi]
;* Platform          : Windows [Windows, Mac, Linux, Multi]
;* Processor         : Multi [x86, x64, Multi]
;* Compileroptions   : -
;* Version           : 1.00
;* Date              : xx.xx.20xx
;* Autor             : Kurzer
;* -----------------------------------------------------------------------
;* DESCRIPTION:
;*
;* ...
;*
;* -----------------------------------------------------------------------
;* Changelog:
;* 1.00 - rel xx.xx.xx:
;*            Erste Version
;*
;*************************************************************************

;*************************************************************************
;- Constants global scope
;*************************************************************************
Enumeration 1
   #GG_DATAMODE_BYTE
   #GG_DATAMODE_WORD
   #GG_DATAMODE_LONG
   #GG_DATAMODE_INTEGER
   #GG_DATAMODE_QUAD
   #GG_DATAMODE_FLOAT
   #GG_DATAMODE_DOUBLE
EndEnumeration

DeclareModule GraphGadget
   ;- --- [Declaration] -------------------------------------------------------
   
   ;*************************************************************************
   ;- Compiler directives (module scope only)
   ;*************************************************************************
   EnableExplicit
   
   ;*************************************************************************
   ;- Macros (module scope only)
   ;*************************************************************************
   
   ;*************************************************************************
   ;- Constants (module scope only)
   ;*************************************************************************
   Enumeration 1
      #GG_DATAMODE_BYTE
      #GG_DATAMODE_WORD
      #GG_DATAMODE_LONG
      #GG_DATAMODE_INTEGER
      #GG_DATAMODE_QUAD
      #GG_DATAMODE_FLOAT
      #GG_DATAMODE_DOUBLE
   EndEnumeration
   
   #GG_MINBORDERSIZE = 0
   #GG_MINBUTTONSIZE = 10
   #GG_MINGRIDSIZE = 2
   #GG_MINVIEWHEIGHT = 10
   #GG_MAXBUFFERS = 10               ; 0 - 9
   
   #GG_DEFAULT_SHOWDATA = #False
   #GG_DEFAULT_SHOWGRID = #True
   #GG_DEFAULT_GRIDSIZE = 90
   #GG_DEFAULT_BORDERSIZE = 5
   #GG_DEFAULT_BUTTONSIZE =25
   
   #GG_DEFAULT_BACKGROUNDCOLOUR = $474746
   #GG_DEFAULT_BORDERCOLOUR = $F6F6F5
   #GG_DEFAULT_GRAPHCOLOUR = $D3FFDA
   #GG_DEFAULT_GRIDCOLOUR = $BFFEFF
   
   #GG_GRIDFONTSIZE = 8
   
   ;*************************************************************************
   ;- Structures (module scope only)
   ;*************************************************************************
   Structure Graph
      iGraphCanvasID.i
      iGraphFontID.i
      
      iGraphX.i                           ; Position within the Container Canvas gadeget
      iGraphY.i                           ; -"-
      iGraphWidth.i                     ; Size of the graph view (will be calculated)
      iGraphHeight.i                  ; -"-
      iGraphBackgroundColour.i   ; Backgroundcolour of the graph view
   EndStructure
   
   Structure Buttons
      iButtonSize.i                     ; Size of the controllbuttons (width & heigth)
      
      iButtonBeginID.i
      iButtonBeginX.i
      iButtonBeginY.i
      
      iButtonPageBackID.i
      iButtonPageBackX.i
      iButtonPageBackY.i
      
      iButtonBackID.i
      iButtonBackX.i
      iButtonBackY.i
      
      iButtonForwardID.i
      iButtonForwardX.i
      iButtonForwardY.i
      
      iButtonPageForwarID.i
      iButtonPageForwardX.i
      iButtonPageForwardY.i
      
      iButtonEndID.i
      iButtonEndX.i
      iButtonEndY.i
      
      iScrollBarID.i
      iScrollBarWidth.i
      iScrollBarX.i
      iScrollBarY.i
   EndStructure
   
   Structure Buffer
      iBufferAddress.i               ; Startaddress of the databuffer
      iBufferLengthInBytes.i      ; Length of the databuffer in bytes
      iBufferLengthInRecords.i   ; Length of the databuffer in records (entries)
      iBufferOffsetInRecords.i   ; Offset in records of the read pointer starting from the buffer address
      iBufferDataMode.i               ; How to interpret the data in the buffer (see #GG_DATAMODE_XY constants)
      iBufferRecordSize.i            ; How many bytes does a single value in the buffer need (depending on the Datamode)?
      iBufferShowData.i               ; Set to #True if the buffer data have to be shown in the graph, otherwise set to #False
      iBufferShowGrid.i               ; Set to #True if the scaling grid have to be shown in the graph, otherwise set to #False
      iBufferGraphGridSize.i      ; Size of the scale grid that belongs to the buffer data
      iBufferGraphGridYPos.i      ; Y-Position of the scale grid within the graph canvas in pixels
      iBufferGraphColour.i         ; Color of the graph that belongs to the buffer data
      iBufferGraphGridColour.i   ; Color of the scale grid that belongs to the buffer data
   EndStructure
   
   Structure GraphGadget
      ; Gadget
      iGadgetCanvasID.i
      
      iGadgetX.i                        ; Position of the Container Canvas gadeget
      iGadgetY.i                        ; -"-
      iGadgetWidth.i                  ; Size of the whole gadget
      iGadgetHeight.i                  ; -"-
      iGadgetBorderSize.i            ; Size of the gadget border
      iGadgetBorderColour.i         ; Bordercolour of the view
      iGadgetMutex.i                  ; Mutex object for internal functions. Prevents collisions when accessing a gadget from multiple threads.
      
      
      stGraph.Graph                     ; Graph canvas
                                             ; Buttons
      stButtons.Buttons               ; Controllbuttons
                                             ; Buffers
      stBuffer.Buffer[10]
      
   EndStructure
   
   ;*************************************************************************
   ;- Variables, Arrays, Linked Lists, Maps (module scope only)
   ;*************************************************************************
   
   ;*************************************************************************
   ;- Interfaces, Prototypes (module scope only)
   ;*************************************************************************
   
   ;*************************************************************************
   ;- Procedures (public)
   ;*************************************************************************
   Declare.i Create(x.i, y.i, iGadgetWidth.i, iGadgetHeight.i, iGadgetBorderSize=#GG_DEFAULT_BORDERSIZE, iButtonSize=#GG_DEFAULT_BUTTONSIZE, iGadgetBorderColour.i=#GG_DEFAULT_BORDERCOLOUR, iGraphBackgroundColour.i=#GG_DEFAULT_BACKGROUNDCOLOUR)
   Declare   Free(*GraphGadget.GraphGadget)
   Declare   Update(*GraphGadget.GraphGadget)
   Declare.i SetBuffer(*GraphGadget.GraphGadget, iBufferNumber.i, iBufferAddress.i, iBufferLength.i, iBufferOffset.i=0, iBufferDataMode=#GG_DATAMODE_INTEGER, iBufferGraphColour.i=#GG_DEFAULT_GRAPHCOLOUR)
   Declare.i SetBufferOffset(*GraphGadget.GraphGadget, iBufferNumber.i, iBufferOffsetInRecords.i=0)
   Declare.i SetBufferGrid(*GraphGadget.GraphGadget, iBufferNumber.i, iBufferShowGrid.i=#False, iBufferGraphGridSize.i=#GG_DEFAULT_GRIDSIZE, iBufferGraphGridYPos.i=-1, iBufferGraphGridColour.i=#GG_DEFAULT_GRIDCOLOUR)
   Declare   ClearBuffer(*GraphGadget.GraphGadget, iBufferNumber.i)
   Declare.i Id(*GraphGadget.GraphGadget)
   
EndDeclareModule

Module GraphGadget
   ;-
   ;- --- [Implementation] -------------------------------------------------------
   ;-
   ;*************************************************************************
   ;- Private Procedures
   ;*************************************************************************
   Procedure   CalcGUI(*GraphGadget.GraphGadget)
      ; +-----------------------------------------------------------------
      ; |Description  : -
      ; |Arguments    : arg1    : Handle to struct
      ; |Results      : -
      ; |Remarks      : -
      ; +-----------------------------------------------------------------
      With *GraphGadget
         \stGraph\iGraphX = \iGadgetBorderSize
         \stGraph\iGraphY = \iGadgetBorderSize
         \stGraph\iGraphWidth = \iGadgetWidth - \iGadgetBorderSize * 2
         \stGraph\iGraphHeight = \iGadgetHeight - \stButtons\iButtonSize - (\iGadgetBorderSize * 3)
         
         \stButtons\iButtonBeginY = \iGadgetHeight - \iGadgetBorderSize - \stButtons\iButtonSize
         \stButtons\iButtonPageBackY = \stButtons\iButtonBeginY
         \stButtons\iButtonBackY = \stButtons\iButtonBeginY
         \stButtons\iButtonForwardY = \stButtons\iButtonBeginY
         \stButtons\iButtonPageForwardY = \stButtons\iButtonBeginY
         \stButtons\iButtonEndY = \stButtons\iButtonBeginY
         \stButtons\iScrollBarY = \stButtons\iButtonBeginY
         
         \stButtons\iButtonBeginX = \iGadgetBorderSize
         \stButtons\iButtonPageBackX = \stButtons\iButtonBeginX + \stButtons\iButtonSize + \iGadgetBorderSize
         \stButtons\iButtonBackX = \stButtons\iButtonPageBackX + \stButtons\iButtonSize + \iGadgetBorderSize
         \stButtons\iButtonForwardX = \stButtons\iButtonBackX + \stButtons\iButtonSize + \iGadgetBorderSize
         \stButtons\iButtonPageForwardX = \stButtons\iButtonForwardX + \stButtons\iButtonSize + \iGadgetBorderSize
         \stButtons\iButtonEndX = \stButtons\iButtonPageForwardX + \stButtons\iButtonSize + \iGadgetBorderSize
         
         \stButtons\iScrollBarX = \stButtons\iButtonEndX + \stButtons\iButtonSize + \iGadgetBorderSize
         \stButtons\iScrollBarWidth = \iGadgetWidth - \stButtons\iScrollBarX - \iGadgetBorderSize
      EndWith
   EndProcedure
   Procedure   SetScrollBarValues(*GraphGadget.GraphGadget, iBufferNumber.i)
      ; +-----------------------------------------------------------------
      ; |Description  : -
      ; |Arguments    : arg1    : Handle to struct
      ; |Results      : -
      ; |Remarks      : -
      ; +-----------------------------------------------------------------
      With *GraphGadget
         SetGadgetAttribute(\stButtons\iScrollBarID, #PB_ScrollBar_Minimum, 0)
         ; SetGadgetAttribute(\stButtons\iScrollBarID, #PB_ScrollBar_Maximum, \stBuffer[iBufferNumber]\iBufferLength)
         ; HIER
         
      EndWith
      ProcedureReturn #True
   EndProcedure
   Procedure.i IsBufferValid(*GraphGadget.GraphGadget, iBufferNumber.i)
      ; +-----------------------------------------------------------------
      ; |Description  : -
      ; |Arguments    : arg1    : Handle to struct
      ; |Results      : #True if buffer is valid, otherwise #False
      ; |Remarks      : -
      ; +-----------------------------------------------------------------
      With *GraphGadget
         If \stBuffer[iBufferNumber]\iBufferAddress = 0 Or
            \stBuffer[iBufferNumber]\iBufferLengthInBytes = 0 Or
            \stBuffer[iBufferNumber]\iBufferLengthInRecords = 0 Or
            \stBuffer[iBufferNumber]\iBufferOffsetInRecords >= \stBuffer[iBufferNumber]\iBufferLengthInRecords Or
            \stBuffer[iBufferNumber]\iBufferDataMode = 0 Or
            \stBuffer[iBufferNumber]\iBufferGraphGridSize < #GG_MINGRIDSIZE
            ProcedureReturn #False
         EndIf
      EndWith
      ProcedureReturn #True
   EndProcedure
   Procedure   DrawGrid(*GraphGadget.GraphGadget)
      ; +-----------------------------------------------------------------
      ; |Description  : -
      ; |Arguments    : arg1    : Handle to struct
      ; |Results      : -
      ; |Remarks      : -
      ; +-----------------------------------------------------------------
      Protected.i x, iGridValue, iBufferNumber, iGridOffset, iGridLineLength
      Protected.s sGridValue
      
      With *GraphGadget
         If StartDrawing(CanvasOutput(\stGraph\iGraphCanvasID))
            ; Erase Background
            DrawingMode(#PB_2DDrawing_Default)
            Box(0, 0, \stGraph\iGraphWidth, \stGraph\iGraphHeight, \stGraph\iGraphBackgroundColour)
                  
            For iBufferNumber = 0 To #GG_MAXBUFFERS - 1
               ; Debug "Nr.: " + Str(iBufferNumber) + ", Adr:" + Str(\stBuffer[iBufferNumber]\iBufferAddress) + ", Len:" + Str(\stBuffer[iBufferNumber]\iBufferLength) + ", GridSize: " + Str(\stBuffer[iBufferNumber]\iBufferGraphGridSize) + ", Valid: " + Str(IsBufferValid(*GraphGadget, iBufferNumber))
               If IsBufferValid(*GraphGadget, iBufferNumber) = #True And \stBuffer[iBufferNumber]\iBufferShowGrid = #True
                  
                  ; Correct the buffer offset to display only up to the buffer length in the graph.
                  If \stBuffer[iBufferNumber]\iBufferOffsetInRecords + \stGraph\iGraphWidth > \stBuffer[iBufferNumber]\iBufferLengthInRecords
                     iGridOffset = \stBuffer[iBufferNumber]\iBufferLengthInRecords - \stGraph\iGraphWidth
                     iGridLineLength = \stBuffer[iBufferNumber]\iBufferLengthInRecords - 1
                     If iGridOffset < 1 : iGridOffset = 0 : x = 0 : EndIf
                     x = - iGridOffset % \stBuffer[iBufferNumber]\iBufferGraphGridSize
                     ; Draw END line
                     Line(iGridLineLength, \stBuffer[iBufferNumber]\iBufferGraphGridYPos-15, 1, 30, \stBuffer[iBufferNumber]\iBufferGraphGridColour)
                  Else
                     iGridOffset = \stBuffer[iBufferNumber]\iBufferOffsetInRecords
                     iGridLineLength = \stGraph\iGraphWidth - 1
                     x = - iGridOffset % \stBuffer[iBufferNumber]\iBufferGraphGridSize
                  EndIf
                  
                  iGridValue = iGridOffset + x
                  
                  ; Draw scaling grid and values
                  DrawingFont(FontID(\stGraph\iGraphFontID))
                  Box(0, \stBuffer[iBufferNumber]\iBufferGraphGridYPos, iGridLineLength, 1, \stBuffer[iBufferNumber]\iBufferGraphGridColour)
                  Repeat
                     If x < \stBuffer[iBufferNumber]\iBufferLengthInRecords
                        DrawingMode(#PB_2DDrawing_Default)
                        Line(x, \stBuffer[iBufferNumber]\iBufferGraphGridYPos-5, 1, 10, \stBuffer[iBufferNumber]\iBufferGraphGridColour)
                        
                        ; Draw grid values
                        sGridValue = Str(iGridValue)
                        DrawingMode(#PB_2DDrawing_Transparent)
                        DrawText(x - TextWidth(sGridValue) / 2, \stBuffer[iBufferNumber]\iBufferGraphGridYPos + #GG_GRIDFONTSIZE, sGridValue, \stBuffer[iBufferNumber]\iBufferGraphGridColour)
                     EndIf
                  
                     iGridValue + \stBuffer[iBufferNumber]\iBufferGraphGridSize
                     x + \stBuffer[iBufferNumber]\iBufferGraphGridSize
                  Until x >= iGridLineLength + iGridOffset % \stBuffer[iBufferNumber]\iBufferGraphGridSize
               EndIf
            Next iBufferNumber
            
            StopDrawing()
         EndIf
      EndWith
   EndProcedure
   
   ;-
   ;*************************************************************************
   ;- Public Procedures
   ;*************************************************************************
   Procedure.i Create(x.i, y.i, iGadgetWidth.i, iGadgetHeight.i, iGadgetBorderSize=#GG_DEFAULT_BORDERSIZE, iButtonSize=#GG_DEFAULT_BUTTONSIZE, iGadgetBorderColour.i=#GG_DEFAULT_BORDERCOLOUR, iGraphBackgroundColour.i=#GG_DEFAULT_BACKGROUNDCOLOUR)
      ; +-----------------------------------------------------------------
      ; |Description  : -
      ; |Arguments    : arg1    : Handle to struct
      ; |Results      : #False (0) in case of errors, Pointer to gadget structure, if all went ok
      ; |Remarks      : -
      ; +-----------------------------------------------------------------
      Protected *GraphGadget.GraphGadget
      
      ; Parametercheck
      If iGadgetWidth - 8 * (iButtonSize + iGadgetBorderSize) - iGadgetBorderSize * 2 < 0 Or ; 8 x because of the scrollbar gadget, this counts 2 times of the buttonsize
         iGadgetHeight - #GG_MINVIEWHEIGHT - iButtonSize - iGadgetBorderSize * 3  < 0 Or
         iGadgetBorderSize < #GG_MINBORDERSIZE Or
         iButtonSize < #GG_MINBUTTONSIZE
         ProcedureReturn #False
      EndIf
      
      ; Allocate memory for the gadgetstructure
      *GraphGadget = AllocateStructure(GraphGadget)
      If *GraphGadget <> 0
         With *GraphGadget
            ; Store gadget parameters into internal structure
            \iGadgetX = x
            \iGadgetY = y
            \iGadgetHeight = iGadgetHeight
            \iGadgetWidth = iGadgetWidth
            \iGadgetBorderSize = iGadgetBorderSize
            \stButtons\iButtonSize = iButtonsize
            \stGraph\iGraphBackgroundColour = iGraphBackgroundColour
            \iGadgetBorderColour = iGadgetBorderColour
            
            \iGadgetMutex = CreateMutex()
            If \iGadgetMutex <> 0
               ; Calculate internal GUI positions
               CalcGUI(*GraphGadget.GraphGadget)
               
               ;- Outer canvas act as container
               \iGadgetCanvasID = CanvasGadget(#PB_Any, \iGadgetX, \iGadgetY, iGadgetWidth, iGadgetHeight, #PB_Canvas_Container)
               If \iGadgetCanvasID <> 0
                  ; Store the gadgetstructure handle into the gadgetdata
                  SetGadgetData(\iGadgetCanvasID,*GraphGadget)
                  
                  ; Draw gadget background (border)
                  If StartDrawing(CanvasOutput(\iGadgetCanvasID))
                     DrawingMode(#PB_2DDrawing_Default)
                     Box(0, 0, \iGadgetWidth, \iGadgetHeight, \iGadgetBorderColour)
                     StopDrawing()
                  EndIf
                  
                  ; Add control buttons
                  \stButtons\iButtonBeginID = ButtonGadget(#PB_Any, \stButtons\iButtonBeginX, \stButtons\iButtonBeginY, \stButtons\iButtonSize, \stButtons\iButtonSize, "|<")
                  \stButtons\iButtonPageBackID = ButtonGadget(#PB_Any, \stButtons\iButtonPageBackX, \stButtons\iButtonPageBackY, \stButtons\iButtonSize, \stButtons\iButtonSize, "<<")
                  \stButtons\iButtonBackID = ButtonGadget(#PB_Any, \stButtons\iButtonBackX, \stButtons\iButtonBackY, \stButtons\iButtonSize, \stButtons\iButtonSize, "<")
                  \stButtons\iButtonForwardID = ButtonGadget(#PB_Any, \stButtons\iButtonForwardX, \stButtons\iButtonForwardY, \stButtons\iButtonSize, \stButtons\iButtonSize, ">")
                  \stButtons\iButtonPageForwarID = ButtonGadget(#PB_Any, \stButtons\iButtonPageForwardX, \stButtons\iButtonPageForwardY, \stButtons\iButtonSize, \stButtons\iButtonSize, ">>")
                  \stButtons\iButtonEndID = ButtonGadget(#PB_Any, \stButtons\iButtonEndX, \stButtons\iButtonEndY, \stButtons\iButtonSize, \stButtons\iButtonSize, ">|")
                  \stButtons\iScrollBarID = ScrollBarGadget(#PB_Any, \stButtons\iScrollBarX, \stButtons\iScrollBarY, \stButtons\iScrollBarWidth, \stButtons\iButtonSize, 0, 99, 100)
                  
                  ; Inner canvas for waveform
                  \stGraph\iGraphCanvasID = CanvasGadget(#PB_Any, \stGraph\iGraphX, \stGraph\iGraphY, \stGraph\iGraphWidth, \stGraph\iGraphHeight)
                  CloseGadgetList()
                  If \stGraph\iGraphCanvasID <> 0
                     ; Draw graph gadget background
                     If StartDrawing(CanvasOutput(\stGraph\iGraphCanvasID))
                        DrawingMode(#PB_2DDrawing_Default)
                        Box(0, 0, \stGraph\iGraphWidth, \stGraph\iGraphHeight, \stGraph\iGraphBackgroundColour)
                        StopDrawing()
                     EndIf
                     
                     ; Font for waveform canvas scale
                     \stGraph\iGraphFontID = LoadFont(#PB_Any, "Arial", #GG_GRIDFONTSIZE)
                     If \stGraph\iGraphFontID <> 0
                        
                        ; Evtl. BindEvent...
                        
                        ; If all went ok, return the handle to the gadgetstructure
                        ProcedureReturn *GraphGadget
                     EndIf
                  EndIf
               EndIf
            EndIf
            ; In case of errors, the programm execute this part
            Free(*GraphGadget.GraphGadget)
         EndWith
      EndIf
      ProcedureReturn #False
   EndProcedure
   Procedure   Free(*GraphGadget.GraphGadget)
      ; +-----------------------------------------------------------------
      ; |Description  : -
      ; |Arguments    : arg1    : Handle to struct
      ; |Results      : -
      ; |Remarks      : -
      ; +-----------------------------------------------------------------
      
      ; Parametercheck
      If *GraphGadget = 0
         ProcedureReturn
      EndIf
      
      ; Wait until the Gadget is unlocked
      LockMutex(*GraphGadget\iGadgetMutex)
      
      With *GraphGadget
         If \stGraph\iGraphFontID <> 0 : FreeFont(\stGraph\iGraphFontID) : EndIf
         If \stGraph\iGraphCanvasID <> 0 : FreeGadget(\stGraph\iGraphCanvasID) : EndIf
         If \iGadgetCanvasID <> 0 : FreeGadget(\iGadgetCanvasID) : EndIf
      EndWith
      
      UnlockMutex(*GraphGadget\iGadgetMutex)
      FreeMutex(*GraphGadget\iGadgetMutex)
      FreeStructure(*GraphGadget)
   EndProcedure
   ;
   Procedure   Update(*GraphGadget.GraphGadget)
      ; +-----------------------------------------------------------------
      ; |Description  : Draws the graph
      ; |Arguments    : arg1    : Handle to struct
      ; |Results      : -
      ; |Remarks      : -
      ; +-----------------------------------------------------------------   
      
      ; Parametercheck
      If *GraphGadget = 0
         ProcedureReturn
      EndIf
      
      ; Wait until the Gadget is unlocked
      LockMutex(*GraphGadget\iGadgetMutex)
      
      With *GraphGadget
         DrawGrid(*GraphGadget.GraphGadget)
            ;       If StartDrawing(CanvasOutput(*GraphGadget\stGraph\iGraphCanvasID))
            ;          StopDrawing()
            ;      EndIf
      EndWith
      
      UnlockMutex(*GraphGadget\iGadgetMutex)
   EndProcedure
   Procedure.i SetBuffer(*GraphGadget.GraphGadget, iBufferNumber.i, iBufferAddress.i, iBufferLengthInRecords.i, iBufferOffsetInRecords.i=0, iBufferDataMode=#GG_DATAMODE_INTEGER, iBufferGraphColour.i=#GG_DEFAULT_GRAPHCOLOUR)
      ; +-----------------------------------------------------------------
      ; |Description  : -
      ; |Arguments    : arg1    : Handle to struct
      ; |Results      : #False in case of error, #True if all went ok
      ; |Remarks      : -
      ; +-----------------------------------------------------------------
      
      ; Parametercheck
      If *GraphGadget = 0 Or
        iBufferNumber >= #GG_MAXBUFFERS Or
        iBufferAddress = 0 Or
        iBufferLengthInRecords = 0 Or
        iBufferOffsetInRecords >= iBufferLengthInRecords
         ProcedureReturn #False
      EndIf
      
      ; Wait until the Gadget is unlocked
      LockMutex(*GraphGadget\iGadgetMutex)
      
      With *GraphGadget
         \stBuffer[iBufferNumber]\iBufferAddress = iBufferAddress
         \stBuffer[iBufferNumber]\iBufferLengthInRecords = iBufferLengthInRecords
         \stBuffer[iBufferNumber]\iBufferOffsetInRecords = iBufferOffsetInRecords
         \stBuffer[iBufferNumber]\iBufferDataMode = iBufferDataMode
         \stBuffer[iBufferNumber]\iBufferGraphColour = iBufferGraphColour
         
         Select iBufferDataMode
            Case #GG_DATAMODE_BYTE
               \stBuffer[iBufferNumber]\iBufferRecordSize = SizeOf(Byte)
            Case #GG_DATAMODE_WORD
               \stBuffer[iBufferNumber]\iBufferRecordSize = SizeOf(Word)
            Case #GG_DATAMODE_LONG
               \stBuffer[iBufferNumber]\iBufferRecordSize = SizeOf(Long)
            Case #GG_DATAMODE_INTEGER
               \stBuffer[iBufferNumber]\iBufferRecordSize = SizeOf(Integer)
            Case #GG_DATAMODE_QUAD
               \stBuffer[iBufferNumber]\iBufferRecordSize = SizeOf(Quad)
            Case #GG_DATAMODE_FLOAT
               \stBuffer[iBufferNumber]\iBufferRecordSize = SizeOf(Float)
            Case #GG_DATAMODE_DOUBLE
               \stBuffer[iBufferNumber]\iBufferRecordSize = SizeOf(Double)
            Default
               \stBuffer[iBufferNumber]\iBufferRecordSize = 1
         EndSelect
         
         \stBuffer[iBufferNumber]\iBufferLengthInBytes = iBufferLengthInRecords * \stBuffer[iBufferNumber]\iBufferRecordSize
         
         \stBuffer[iBufferNumber]\iBufferShowGrid = #GG_DEFAULT_SHOWGRID
         \stBuffer[iBufferNumber]\iBufferShowData = #GG_DEFAULT_SHOWDATA
         \stBuffer[iBufferNumber]\iBufferGraphGridSize = #GG_DEFAULT_GRIDSIZE
         \stBuffer[iBufferNumber]\iBufferGraphGridColour = #GG_DEFAULT_GRIDCOLOUR
      EndWith
      
      UnlockMutex(*GraphGadget\iGadgetMutex)
      ProcedureReturn #True
   EndProcedure
   Procedure.i SetBufferOffset(*GraphGadget.GraphGadget, iBufferNumber.i, iBufferOffsetInRecords.i=0)
      ; +-----------------------------------------------------------------
      ; |Description  : -
      ; |Arguments    : arg1    : Handle to struct
      ; |Results      : #False in case of error, #True if all went ok
      ; |Remarks      : -
      ; +-----------------------------------------------------------------
      
      ; Wait until the Gadget is unlocked
      LockMutex(*GraphGadget\iGadgetMutex)
      
      ; Parametercheck
      If *GraphGadget = 0 Or
        iBufferNumber >= #GG_MAXBUFFERS Or
        *GraphGadget\stBuffer[iBufferNumber]\iBufferAddress = 0 Or
        iBufferOffsetInRecords >= *GraphGadget\stBuffer[iBufferNumber]\iBufferLengthInRecords
         UnlockMutex(*GraphGadget\iGadgetMutex)
         ProcedureReturn #False
      EndIf
      
      With *GraphGadget
         \stBuffer[iBufferNumber]\iBufferOffsetInRecords = iBufferOffsetInRecords
      EndWith      
      
      UnlockMutex(*GraphGadget\iGadgetMutex)
      ProcedureReturn #True
   EndProcedure
   Procedure.i SetBufferGrid(*GraphGadget.GraphGadget, iBufferNumber.i, iBufferShowGrid.i=#False, iBufferGraphGridSize.i=#GG_DEFAULT_GRIDSIZE, iBufferGraphGridYPos.i=-1, iBufferGraphGridColour.i=#GG_DEFAULT_GRIDCOLOUR)
      ; +-----------------------------------------------------------------
      ; |Description  : -
      ; |Arguments    : arg1    : Handle to struct
      ; |Results      : #False in case of error, #True if all went ok
      ; |Remarks      : -
      ; +-----------------------------------------------------------------
      
      ; Wait until the Gadget is unlocked
      LockMutex(*GraphGadget\iGadgetMutex)
      
      ; Parametercheck
      If *GraphGadget = 0 Or
        iBufferNumber >= #GG_MAXBUFFERS Or
        iBufferGraphGridSize < #GG_MINGRIDSIZE Or
        iBufferGraphGridYPos < -1 Or
        iBufferGraphGridYPos > *GraphGadget\stGraph\iGraphHeight
         UnlockMutex(*GraphGadget\iGadgetMutex)
         ProcedureReturn #False
      EndIf
      
      With *GraphGadget
         \stBuffer[iBufferNumber]\iBufferShowGrid = iBufferShowGrid
         \stBuffer[iBufferNumber]\iBufferGraphGridSize = iBufferGraphGridSize
         \stBuffer[iBufferNumber]\iBufferGraphGridColour = iBufferGraphGridColour
         If iBufferGraphGridYPos = -1
            \stBuffer[iBufferNumber]\iBufferGraphGridYPos = \stGraph\iGraphY + \stGraph\iGraphHeight / 2
         Else
            \stBuffer[iBufferNumber]\iBufferGraphGridYPos = iBufferGraphGridYPos
         EndIf
      EndWith      
      
      UnlockMutex(*GraphGadget\iGadgetMutex)
      ProcedureReturn #True
   EndProcedure
   Procedure   ClearBuffer(*GraphGadget.GraphGadget, iBufferNumber.i)
      ; +-----------------------------------------------------------------
      ; |Description  : Discards all settings of an active buffer. However, the buffer memory is NOT released and must be handled by the user.
      ; |Arguments    : arg1    : Handle to struct
      ; |Results      : -
      ; |Remarks      : -
      ; +-----------------------------------------------------------------
      
      ; Wait until the Gadget is unlocked
      LockMutex(*GraphGadget\iGadgetMutex)
      
      ; Parametercheck
      If *GraphGadget = 0 Or
        iBufferNumber >= #GG_MAXBUFFERS
         UnlockMutex(*GraphGadget\iGadgetMutex)
         ProcedureReturn
      EndIf
      
      With *GraphGadget
         ClearStructure(\stBuffer[iBufferNumber], Buffer)
      EndWith
      
      UnlockMutex(*GraphGadget\iGadgetMutex)
   EndProcedure
   
   Procedure.i Id(*GraphGadget.GraphGadget)
      ; +-----------------------------------------------------------------
      ; |Description  : Returns the ID of the canvas gadget
      ; |Arguments    : arg1    : Handle to struct
      ; |Results      : -
      ; |Remarks      : -
      ; +-----------------------------------------------------------------
      
      ; Parametercheck
      If *GraphGadget = 0
         ProcedureReturn 0
      EndIf
      
      ProcedureReturn *GraphGadget\iGadgetCanvasID
   EndProcedure
   
   ;-
   ;*************************************************************************
   ;- Data Section
   ;*************************************************************************
   DataSection
      
   EndDataSection
   
EndModule

_________________
"Never run a changing system!"
PB 5.62, OS: Windows 7 Pro x64, Desktopscaling: 125%, CPU: I7 6500, RAM: 16 GB, GPU: Intel Graphics HD 520
Ich bin Baujahr 1968, also aktuell 51.


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags: Re: Suche IDE Tool. Deklarierte, aber ungenutzte Vars, Konst
BeitragVerfasst: 31.03.2019 19:04 
Offline
Benutzeravatar

Registriert: 11.08.2005 19:08
ts-soft hat geschrieben:
In der erstellten ausführbaren Datei taucht es in keinster Weise auf, so sehe ich den Sinn nicht so ganz?
Nehmen wir mal an, nach ein paar Jahren möchte man selbst oder jemand anderes den Code erweitern. Der Programmierer liest sich also die Kommentare und die Code-Zeilen durch, um den Code (wieder) zu verstehen. Es wäre ärgerlich für den Programmierer, wenn er zum Beispiel eine Variable im Code verfolgt und nach vielen Zeilen an Code plötzlich feststellt, dass die Variable gar nicht wirklich verwendet wird.
Siehe: https://softwareengineering.stackexchange.com/questions/340444/why-unused-variables-is-such-an-issue

Kurzer hat geschrieben:
Hallo Sicro, Du musst Dir da nicht so viel Arbeit mit machen. Also von meiner Seite aus war das keine Programmier-Bitte an Dich. ;-)
Wenn Du selber Spaß dran hast, dann ist es okay und dann mach auch nur so viel wie Du Lust dran hast.
Alles gut. :) Wie geschrieben, steht so ein Tool schon eine Weile auf meiner ToDo-Liste. Geplant ist nur ein einfaches Tool.
Das Tool wird wahrscheinlich niemals genau erkennen können, ob eine Variable nach der Definition wirklich sinnvoll verwendet wird. Beispiel:
Code:
; Hier ist offensichtlich, dass "a" sinnvoll verwendet wird:
Define a = 1
x = a + 2
; vorausgesetzt, "x" wird später im Code ausgelesen
Code:
; Hier ist es unklar:
; - Liest die WinAPI-Funktion "a", dann wird "a" sinnvoll verwendet
; - Schreibt die WinAPI-Funktion in "a", dann wird "a" nicht sinnvoll verwendet,
;   wenn "a" im späteren Code nicht ausgelesen wird
Define a = 1
WinAPI_GetInfo(@a)

Kurzer hat geschrieben:
Ich denke eher, dass es daran liegt, dass Programmieren ein evolutionärer Prozess ist (zumindest bei mir) und man zwangsläufig im Laufe der Projektpflege immer wieder Dinge umstellt oder erweitert, weil man dafür einfach nun eine bessere Lösung oder eine neue Idee gefunden hat.
Sehr hilfreich ist, wie schon geschrieben, so viel Code wie möglich in unabhängige Modules/Procedures auszulagern. Die Modules/Procedures können dann später auch leicht in anderen Projekten wieder verwendet werden. Wenn eine bessere Lösung für eine Aufgabe gefunden wurde, muss im besten Fall nur der alte Procedure-Code umgeschrieben werden. Wenn die Procedure-Parameter angepasst werden müssen, dann ist die Änderung im Haupt-Code dennoch gering.

Hilfreich ist auch, wenn man das Projekt mehr plant. Wir Hobby-Programmierer programmieren manchmal einfach los, ohne das Projekt vorher im Detail zu planen...

Kurzer hat geschrieben:
Hier wie versprochen, mein unfertiger Modulcode für ein Customgadget (Graphanzeige mit Unterstützung mehrere Datenbuffer, die dann als Kurvenform visualisiert werden sollen). Der Code ist allein nicht lauffähig, aber man kann hoffentlich gut meinen "Programmierstil" darin erkennen.
Danke für den Code. Sieht ganz gut aus. Manche Procedures sind horizontal und manche Code-Zeilen vertikal zu lang, aber wenn du das Projekt alleine programmierst und du eine hohe Bildschirmauflösung verwendest, wodurch die Procedure-Blöcke/Code-Zeilen vollständig (ohne zu scrollen) anzeigt werden, ist alles ok. Außer du verwendest eine Versionsverwaltung wie Git und vergleichst immer wieder mal verschiedene Code-Versionen. Dann wäre es am besten, wenn du die Code-Zeilen auf die Hälfte der Bildschirmbreite reduzierst, damit zwei unterschiedliche Code-Versionen nebeneinander betrachtet werden können. Im Team sollte man sich am besten an den Programmierer mit der niedrigsten Auflösung oder an die gängige Code-Zeilenlänge von max. 80 Zeichen richten.

Für weitere Programmierstil-Tipps sollten wir am besten einen neuen Thread aufmachen.

_________________
Bild
Warum OpenSource eine Lizenz haben sollte
PureBasic-CodeArchiv-Rebirth: Git-Repository / Download -- Jede Hilfe ist willkommen!
Manjaro Xfce x64 (Hauptsystem) :: WindowsXP/Xubuntu x86 (VirtualBox) :: PureBasic (Linux: x86/x64, Windows: x86) :: jeweils neueste Version


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags: Re: Suche IDE Tool. Deklarierte, aber ungenutzte Vars, Konst
BeitragVerfasst: 02.04.2019 21:12 
Offline
Benutzeravatar

Registriert: 25.04.2006 17:29
Wohnort: Nähe Hamburg
Moin Sicro,

Zitat:
Sehr hilfreich ist, wie schon geschrieben, so viel Code wie möglich in unabhängige Modules/Procedures auszulagern. Die Modules/Procedures können dann später auch leicht in anderen Projekten wieder verwendet werden. Wenn eine bessere Lösung für eine Aufgabe gefunden wurde, muss im besten Fall nur der alte Procedure-Code umgeschrieben werden. Wenn die Procedure-Parameter angepasst werden müssen, dann ist die Änderung im Haupt-Code dennoch gering.
Das stimmt, die Module nutze ich für so etwas auch gern. Ich arbeite aber auch gerne mit Programm- bzw. Projekttemplates. Also komplette Programmhülsen, die bereits mehrere Fenster enthalten sowie alle Verwaltungsfunktionen dafür (Event- Programmstruktur- und Resizehandler sowie Funktionen um Settings zu speichern / zu laden usw.). Schade, dass es die bei PB nicht standardmäßig gibt. Also quasi ein Templatemanager/Designer, der noch eine Ebene über dem integrierten Formdesigner angesiedelt ist.

Zitat:
Hilfreich ist auch, wenn man das Projekt mehr plant. Wir Hobby-Programmierer programmieren manchmal einfach los, ohne das Projekt vorher im Detail zu planen...
Auch das stimmt und ich habe das bei einem Projekt explizit und minutiös angewendet, weil ich wusste, dass ich es nicht in einem Zug fertigstellen würde. Es ist komplex, abstrakt und kompliziert (im Gegensatz zur Verarbeitungsfähigkeit meines Denkapparates ;-) ).
Daher habe ich die gesamte Verarbeitungslogik, alle Strukturen und Dateiformate zuvor rein virtuell in viele kleine Bausteine aufgeteilt und alles in einem Dokument beschrieben, so dass man ohne Quellcode alle Verarbeitungsschritte unmissverständlich nachvollziehen kann. In dem Dokument habe ich auch gleich alle für die spätere Implementierung nötigen Funktionen namentlich und funktionell festgelegt. Das war auch gut so, denn ich habe bei diesem Projekt mittlerweile eine 6 Monatige Pause eingelegt. Ohne die niedergeschriebenen Informationen würde ich es sehr schwer haben da wieder neu anzusetzen. Diesen Aufwand betreibe ich aber nicht bei allen Projekten.

Zitat:
Danke für den Code. Sieht ganz gut aus. Manche Procedures sind horizontal und manche Code-Zeilen vertikal zu lang, aber wenn du das Projekt alleine programmierst und du eine hohe Bildschirmauflösung verwendest, wodurch die Procedure-Blöcke/Code-Zeilen vollständig (ohne zu scrollen) anzeigt werden, ist alles ok. Außer du verwendest eine Versionsverwaltung wie Git und vergleichst immer wieder mal verschiedene Code-Versionen. Dann wäre es am besten, wenn du die Code-Zeilen auf die Hälfte der Bildschirmbreite reduzierst, damit zwei unterschiedliche Code-Versionen nebeneinander betrachtet werden können. Im Team sollte man sich am besten an den Programmierer mit der niedrigsten Auflösung oder an die gängige Code-Zeilenlänge von max. 80 Zeichen richten:
Zu lange Codezeilen kann ich noch nachvollziehen, speziell wo du GitHub erwähnst (habe ich allerdings noch nie genutzt), wobei sich natürlich die "vertikale Länge" der Prozeduren vergrößert, wenn man die Zeile früher umbricht.

Prozeduren, die länger (höher) als eine Bildschirmseite sind, finde ich dann nicht schlimm, wenn sich ein Teil des Inhalts aufgrund von Wiederverwendbarkeit *nicht* auslagern lässt. Was ich meine ist, dass ich keinen Code aus einer Prozedur auslagern würde, *nur* weil er die ursprüngliche Prozedur zu lang macht. Anders sieht es aus, wenn der ausgelagerte Codeteil auch von anderen Prozeduren nutzbar wäre - es also eine Wiederverwendbarkeit innerhalb des Projekts gäbe.

Allerdings bin ich auch offen für Neues und eigene mir gern aktuelle Standards an, wenn sie mir sinnvoll erscheinen. Ich kenne ich deinen Background in puncto Programmierung nicht - nur meinen eigenen. Ich selbst bin bis dato immer Autodidakt gewesen, habe mir hier und da was angesehen und mit das passenste für mein eigenes Paradigma heraussucht. Bzgl. Softwareentwicklung habe ich nie irgend eine Schulbank gedrückt und mir hat man nie eine Sprache offiziell und vollständig beigebracht, wie man sie heute als Schüler oder Student vermutlich beigebracht bekommt. Als ich angefangen habe, gab es diese Bereiche in der schulischen / beruflichen Ausbildung noch gar nicht.

Insofern bin ich für folgendes gern zu haben: :)
Zitat:
Für weitere Programmierstil-Tipps sollten wir am besten einen neuen Thread aufmachen.

btw: Kann es sein, dass du in deinem letzten Beitrag einen link auf dein IDE Tool hattest? Also so eine "mal eben kurz programmiert" Tool bzgl. der ungenutzten Variablen. Ich habe den BEitrag vor ein paar tagen von Smartphone aus schon einmal gelesen und war der Meinung, dass du in deinem Beitrag einen link auf ein GitHub Projekt drin hattest, unter dem das Tool zu finden sein sollte. Jetzt ist jedenfalls kein link mehr zu sehen.

_________________
"Never run a changing system!"
PB 5.62, OS: Windows 7 Pro x64, Desktopscaling: 125%, CPU: I7 6500, RAM: 16 GB, GPU: Intel Graphics HD 520
Ich bin Baujahr 1968, also aktuell 51.


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags: Re: Suche IDE Tool. Deklarierte, aber ungenutzte Vars, Konst
BeitragVerfasst: 12.04.2019 18:10 
Offline
Benutzeravatar

Registriert: 11.08.2005 19:08
Kurzer hat geschrieben:
Prozeduren, die länger (höher) als eine Bildschirmseite sind, finde ich dann nicht schlimm, wenn sich ein Teil des Inhalts aufgrund von Wiederverwendbarkeit *nicht* auslagern lässt. Was ich meine ist, dass ich keinen Code aus einer Prozedur auslagern würde, *nur* weil er die ursprüngliche Prozedur zu lang macht. Anders sieht es aus, wenn der ausgelagerte Codeteil auch von anderen Prozeduren nutzbar wäre - es also eine Wiederverwendbarkeit innerhalb des Projekts gäbe.
Ich halte die Procedures vertikal kurz, weil ich so den kompletten Code im Blick habe und so permanent sehe, welche lokalen Variablen vorhanden sind. Der PureBasic-Editor beachtet bei Variablen nämlich nicht immer den Scope: Auto-completion should observe the scope

Kurzer hat geschrieben:
Allerdings bin ich auch offen für Neues und eigene mir gern aktuelle Standards an, wenn sie mir sinnvoll erscheinen. Ich kenne ich deinen Background in puncto Programmierung nicht - nur meinen eigenen. Ich selbst bin bis dato immer Autodidakt gewesen, habe mir hier und da was angesehen und mit das passenste für mein eigenes Paradigma heraussucht. Bzgl. Softwareentwicklung habe ich nie irgend eine Schulbank gedrückt und mir hat man nie eine Sprache offiziell und vollständig beigebracht, wie man sie heute als Schüler oder Student vermutlich beigebracht bekommt. Als ich angefangen habe, gab es diese Bereiche in der schulischen / beruflichen Ausbildung noch gar nicht.
Genau so sieht es bei mir auch aus. Alles bezüglich Computer habe ich mir selbst beigebracht. Beruflich habe ich mit Computern auch nichts zu tun.

Kurzer hat geschrieben:
btw: Kann es sein, dass du in deinem letzten Beitrag einen link auf dein IDE Tool hattest? Also so eine "mal eben kurz programmiert" Tool bzgl. der ungenutzten Variablen. Ich habe den BEitrag vor ein paar tagen von Smartphone aus schon einmal gelesen und war der Meinung, dass du in deinem Beitrag einen link auf ein GitHub Projekt drin hattest, unter dem das Tool zu finden sein sollte. Jetzt ist jedenfalls kein link mehr zu sehen.
Das Tool habe ich wieder offline genommen, weil ich empfand, dass es noch nicht ausgereift genug war, um es schon zu veröffentlichen.

Hier kann es nun wieder heruntergeladen werden: PureBasic-CodeArchiv-Rebirth (Dev-Zweig)
Das Changelog kann hier eingesehen werden: Klick

Das Tool hat zwei Codes vom Code-Archiv als Abhängigkeiten, deshalb ist es einfacher das komplette Archiv herunterzuladen, weil es so direkt kompiliert werden kann.
Zu finden ist es in PB-IDE-Tools/SearchForUnusedIdentifiers.pb.
Den Code einfach kompilieren und das resultierende Programm über die Tool-Verwaltung der PureBasic-IDE einbinden:
Code:
; Tool Settings:
; - Arguments: "%HOME" "%FILE" "%TEMPFILE"
; - Event:     Menu Or Shortcut

Nach dem Aufrufen des Tools, legt es sofort los, den Code im aktuellen Tab der PureBasic-IDE zu analysieren.

  • Sucht nach ungenutzten Bezeichnern – weiß also nicht, ob der Bezeichner eine Variable, Procedure usw. ist
  • Ein Bezeichner, der nur einmal im Code vorkommt, wird als ungenutzt interpretiert
  • Scopes werden noch nicht berücksichtigt
  • Import...EndImport- und Structure...EndStructure-Blöcke werden nicht verarbeitet
  • Direkter ASM-Code (Zeilen, die mit einem Ausrufezeichen beginnen) werden nicht verarbeitet
  • Code wird vorher vom PB-Compiler verarbeitet (Macros auflösen, Includes einbinden usw.)

Wichtig: Der PBLexer wird so eingestellt, dass er nur Token-Werte mit maximal 200 Zeichen unterstützt. Hast du Strings ("...") oder Kommentare, die mehr Zeichen pro Zeile verbrauchen, dann kannst du die Erstellung des PBLexers in der Zeile 120 anpassen:
Code:
*lexer = PBLexer::Create(code$, 400) ; Unterstützt z. B. Token-Werte mit maximal 400 Zeichen
Zu hohe Werte verlangsamen den PBLexer aber ziemlich schnell.

Trotz den Einschränkungen hat sich das Tool bei mir aber bereits mehrfach als hilfreich herausgestellt.

_________________
Bild
Warum OpenSource eine Lizenz haben sollte
PureBasic-CodeArchiv-Rebirth: Git-Repository / Download -- Jede Hilfe ist willkommen!
Manjaro Xfce x64 (Hauptsystem) :: WindowsXP/Xubuntu x86 (VirtualBox) :: PureBasic (Linux: x86/x64, Windows: x86) :: jeweils neueste Version


Nach oben
 Profil  
Mit Zitat antworten  
Beiträge der letzten Zeit anzeigen:  Sortiere nach  
Ein neues Thema erstellen Auf das Thema antworten  [ 19 Beiträge ]  Gehe zu Seite Vorherige  1, 2

Alle Zeiten sind UTC + 1 Stunde [ Sommerzeit ]


Wer ist online?

Mitglieder in diesem Forum: 0 Mitglieder und 7 Gäste


Sie dürfen keine neuen Themen in diesem Forum erstellen.
Sie dürfen keine Antworten zu Themen in diesem Forum erstellen.
Sie dürfen Ihre Beiträge in diesem Forum nicht ändern.
Sie dürfen Ihre Beiträge in diesem Forum nicht löschen.

Suche nach:
Gehe zu:  

 


Powered by phpBB © 2008 phpBB Group | Deutsche Übersetzung durch phpBB.de
subSilver+ theme by Canver Software, sponsor Sanal Modifiye