da ich keine Lust habe meine Prozeduren alle per Hand zu deklarieren
und außerdem Makros und Konstanten dahin schreiben möchte wo ich will,
habe ich mir einen kleines Programm geschrieben, das automatisch solchen Kram erledigt.
Bei der Gelegenheit hab ich gleich noch ein par Escape-Sequenzen eingebaut.
Was allerdings nicht Funktioniert, ist dass bei includeten Dateien bei Fehlern nicht meine veränderte Datei sondern die Originaldatei geöffnet wird.
Hab dazu auch nicht wirklich eine Idee. Das ist etwas schade, denn für den Haupt-Quellcode macht er es schon so.
Vielleicht braucht ja jemand was in der Richtung.
Müsst ihr euch eigentlich nur ne exe draus machen und als Werkzeug konfigurieren.
declare-creator.pb
Code: Alles auswählen
;**********************************************************************************************************************
;*{ Declare-Creator *
;* ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯ *
;* Name: Declare-Creator *
;* Copyright: 2011 - Batze *
;* *
;* Hiermit werden Declares zu allen Funktionen erstellt und in "declares.pbi" (oder sowas) gespeichert. *
;* Bei Bedarf werden auch Makros und Strukturen auskommentiert und in declares gespeichert. *
;* *
;* Aufruf z.B.: *
;* C:\Programme\PureBasic\Tools\declare-creator.exe "%COMPILEFILE" "%PATH" -i=declares.pbi -M *
;* oder: *
;* C:\PureBasic\delclare-creator.exe "%COMPILEFILE" "%PATH" -* *
;* oder sowas in der Richtung. *
;* *
;* Mögliche zusätzliche Parameter sind: *
;* -A "->" durch "_\" ersetzen (wenn Wort danach klein), sonst "->" durch "_" *
;* Das kann z.B. nützlich sein um Unter-Variablen "gruppenname_\strukturfeld" und *
;* Unter-Funktionen "gruppenname_Funktion()" zu benennen. *
;* -C Konstanten an den Anfang verschieben, sodass Sie von Anfang an verfügbar sind *
;* -G Globale Variablen an den Anfang verschieben *
;* -L "{'irgendeintext'}" durch "language_texts\irgendeintext" ersetzen *
;* Das ergibt natürlich für niemanden außer mich Sinn, aber man kann sich ja auch sowas bauen *
;* -M Macros an den Anfang verschieben *
;* -S Strukturen an den Anfang verschieben *
;* -V Variablen-Definitionen an den Anfang verschieben (es sind nur die mit "Define" gemeint) *
;* -* Alle anschalten. Die Optionen verhalten sich alle XOr-Mäßig, also wird, wenn man eine noch mal angibt *
;* wird die Option wieder abgeschaltet. *
;* *
;* -e Escape-Sequenzen in Strings ersetzen: *
;* \\ durch \, \t durch "+#TAB$+" *
;* \d durch "+#DQUOTE$+", "" durch "+#DQUOTE$+" *
;* \n durch "+#CRLF$+" *
;* \$?? durch "+Chr($??)+" \??? durch "+Chr(???)+" *
;* \sonstiges durch nichts (!) *
;* -i Aufzurufen als -i=dateiname, ersetzt den Standard-Dateinamen "delcares.pbi" durch einen anderen *
;* -m Multiline-Support anschalten *
;* Gekennzeichnet wird eine neue Zeile mit [[+L]]. Das wird (wie auch alles danach) entfernt, also sollte *
;* man das nicht "in" sondern "vor" einen möglichen Kommentar setzen. *
;* Die nächste Zeile wird dann einfach angehängt (theoretisch kann man also sogar mitten im Wort trennen, *
;* aber das macht ja keiner) *
;* Mit "-m=neuesschlüsselwort" kann man auch statt "[[+L]]", "neuesschlüsselwort" verwenden. *
;* -o Am Anfang im Ausgeschalteten Modus starten *
;* *
;* Zu beachten ist noch dass man aus *
;* IncludeFile "declares.pbi" *
;* die modifiziert Zeile *
;* IncludeFile "declares.pbi" ;[[Declares]] *
;* machen sollte, damit er die nicht auch nochmal zu parsen versucht. *
;* Man muss die Include aber selbst einfügen. *
;* *
;* Man kann auch noch im Code ein par Sachen festlegen. Dazu werden in Kommentare Modifier gesetzt *
;* Mögliche-Incode-Modifier: *
;* [[1234]] Gibt dem extrahieren die Priorität "1234". Je höher die Priorität desto früher *
;* wird das extrahierte eingefügt. *
;* [[Declares]] Das ist die eingefügte-Declare-Datei *
;* [[Ignore]] Garnicht extrahieren, sondern da lassen wo es ist *
;* [[DisableDeclareCreator]] Ab jetzt abschalten *
;* [[EnableDeclareCreator]] Ab jetzt anschalten (Am Anfang ist Standardmäßig an) *
;* *
;* Programmiert in PureBasic 4.51 *
;* Copyright © 2011 : Batze *
;* Letzte Änderung: Mo 11.04.2011 - 11:04 *
;* ToDo: *
;* • Zeilenumbruch-Verhinder-Code *
;*} *
;**********************************************************************************************************************
EnableExplicit
#MoveMacros = %000000000000001
#MoveStructures = %000000000000010
#MoveGlobals = %000000000000100
#MoveConstants = %000000000001000
#MoveVariables = %000000000010000
#MoveAll = %000000000011111
#Debug = %000001000000000
#EnableEscape = %000010000000000 ; Escapesequenzen an
#ReplaceArrow = %000100000000000 ; '->' durch '_\' oder '__' ersetzen (das andere sieht halt echt blöde aus)
#ReplaceLText = %001000000000000
#EnableMultiline = %010000000000000 ; Multiline an
#Off = %100000000000000 ; Tool ist gerade aus
#I_DontExtract = -$FFFFFFF ; So unwichtig, dass es nicht extrahiert wird
#I_DontEscape = -$FFFFFFE ; Keine Escape-Caractere
#LB = #CRLF$
Macro DQ
+Chr('"')+
EndMacro
Define tempFile$ = ProgramParameter() ; Deklarierter Name
Global tempPath$ = GetPathPart(tempFile$) ; Pfad
Global sourcePath$ = ProgramParameter() ; Pfad zu den richtigen Sources
Define declareFile$ = "declares.pbi" ; Source-Code für die Declares
Global mode.i, multiLineStr$
Define param$
param$ = ProgramParameter()
While param$ ; Parameter ermitteln
Select Left(param$, 2)
Case "-M" : mode ! #MoveMacros
Case "-S" : mode ! #MoveStructures
Case "-G" : mode ! #MoveGlobals
Case "-V" : mode ! #MoveVariables
Case "-C" : mode ! #MoveConstants
Case "-*" : mode ! #MoveAll ; Alle
Case "-i" : declareFile$ = Mid(param$, 4) ; Dateinamen ermitteln
Case "-d" : mode ! #Debug
Case "-e" : mode ! #EnableEscape
Case "-m" : mode ! #EnableMultiline
multiLineStr$ = LCase(Mid(param$, 4)) ; Zeichenfolge ermitteln
If multiLineStr$ = ""
multiLineStr$ = "[[+L]]"
EndIf
Case "-o" : mode ! #Off
Case "-A" : mode ! #ReplaceArrow
Case "-L" : mode ! #ReplaceLText
EndSelect
param$ = ProgramParameter()
Wend
;**********************************************************************************************************************
Structure replacement
text$
line.i
file$
importance.i
EndStructure
Global NewList procedures.replacement() ; gefundene Prozeduren
Global NewList macros.replacement() ; gefundene Makros
Global NewList constants.replacement() ; gefundene Konstanten
Global NewList globals.replacement() ; globale Variablen
Global NewList defines.replacement() ; normales Variablen
Global NewList structures.replacement() ; gefundene Strukturen
;**********************************************************************************************************************
IncludeFile "replace.pb"
IncludeFile "functions.pb"
If mode & #Debug
OpenConsole()
EndIf
CopyFile("test_main.pb", tempFile$) ; Test
If mode & #Debug
PrintN("Start Declare-Creator ...")
PrintN(" tempFile$ = " DQ tempFile$ DQ "")
PrintN(" tempPath$ = " DQ tempPath$ DQ "")
PrintN(" declareFile$ = " DQ declareFile$ DQ "")
PrintN(" sourcePath$ = " DQ sourcePath$ DQ "")
PrintN(" mode = %" + RSet(Bin(mode), 15, "0"))
PrintN(" multiLineStr$ = " DQ multiLineStr$ DQ "")
EndIf
RenameFile(tempFile$, tempFile$+".tmp") ; Fürs das lesen umbenennen
parseFile(tempFile$+".tmp", tempFile$) ; Datei verarbeiten
DeleteFile(tempFile$+".tmp") ; Die wird nicht mehr gebraucht
CreateReplacementFile(tempPath$ + declareFile$)
If mode & #Debug
PrintN("Ende Declare-Creator")
PrintN("Es wurden extrahiert:")
PrintN(" "+Str(ListSize(procedures()))+" Procedure-Declares")
PrintN(" "+Str(ListSize(structures()))+" Strukturen")
PrintN(" "+Str(ListSize(macros())) +" Makros")
PrintN(" "+Str(ListSize(globals())) +" globale Variablen")
PrintN(" "+Str(ListSize(defines())) +" Variablen-Definitionen")
PrintN(" "+Str(ListSize(constants())) +" Konstanten und Enumerationen")
PrintN("")
PrintN("Soll der temporäre Ordner geöffnet werden? (j/n)")
If Left(Input(), 1) = "j"
RunProgram(tempPath$)
EndIf
EndIfCode: Alles auswählen
Macro IsProcedureEnd(str)
( str = " " Or str = "." Or str = "" )
EndMacro
Macro IsVariableEnd(str)
( str = " " Or str = "." Or str = "" Or str = "=" )
EndMacro
Macro IsEnd(str)
( str = " " Or str = "" Or str = ";" )
EndMacro
Macro IsAlpha(str)
( Asc(LCase(str)) => 'a' And Asc(LCase(str)) <= 'z' )
EndMacro
Macro IsNum(str)
( Asc(LCase(str)) => '0' And Asc(LCase(str)) <= '9' )
EndMacro
Macro IsAlphaNum(str)
( IsAlpha(str) Or IsNum(str) Or str = "_" )
EndMacro
Macro AddLineInfo(obj)
obj\line = lineNr
obj\file$ = GetFilePart(newFile$)
EndMacro
Procedure.i GetImportance(text$)
Protected pos.i, endPos.i
Protected str$
pos = FindString(text$, "[[", 1)
If pos
endPos = FindString(text$, "]]", pos+1)
str$ = Mid(text$, pos+2, endPos-pos-2)
If LCase(str$) = "ignore"
ProcedureReturn #I_DontExtract
Else
ProcedureReturn Val(str$)
EndIf
Else
ProcedureReturn 0
EndIf
EndProcedure
Procedure IsProcedure(text$) ; Überprüft ob das eine Prozedur ist und trägt sie gegebenenfalls ein
Protected found.i = 0
Protected importance.i
text$ = Trim(text$)
If LCase(Left(text$, 9)) = "procedure"
If IsProcedureEnd(Mid(text$, 10, 1)) ; Richtige Prozedur
importance = GetImportance(text$)
If importance <> #I_DontExtract
found = 1
AddElement(procedures())
procedures()\text$ = Mid(text$, 10)
procedures()\importance = importance
EndIf
EndIf
EndIf
ProcedureReturn found
EndProcedure
Procedure IsMacro(text$, *iMode.integer) ; Überprüft ob das ein Makro ist und trägt es gegebenenfalls ein
Static inMacro.i = 0
Protected found = 0
Protected ttext$ ; getrimter Text
Protected importance.i
*iMode\i = 0
ttext$ = Trim(text$)
If inMacro = 0
If LCase(Left(ttext$, 5)) = "macro"
If Mid(ttext$, 6, 1) = " " ; Richtiges Makro
importance = GetImportance(text$)
If importance <> #I_DontExtract
inMacro = 1
*iMode\i = 1
AddElement(macros())
macros()\text$ = text$ + #LB
macros()\importance = importance
EndIf
EndIf
EndIf
Else
macros()\text$ + text$ + #LB
If LCase(Left(ttext$, 8)) = "endmacro"
If IsEnd(Mid(ttext$, 9, 1)) ; Makro zu Ende
inMacro = 0
found = 1
EndIf
EndIf
EndIf
ProcedureReturn inMacro + found
EndProcedure
Procedure IsEnumeartion(text$, *iMode.integer) ; Überprüft ob das eine Enumeration ist und trägt sie gegebenenfalls ein
Static inEnumeration.i = 0
Protected found = 0
Protected ttext$ ; getrimter Text
Protected importance.i
*iMode\i = 0
ttext$ = Trim(text$)
If inEnumeration = 0
If LCase(Left(ttext$, 11)) = "enumeration"
If IsEnd(Mid(ttext$, 12, 1)) ; Richtige Enumeration
importance = GetImportance(text$)
If importance <> #I_DontExtract
inEnumeration = 1
*iMode\i = 1
AddElement(constants())
constants()\text$ = text$ + #LB
constants()\importance = importance
EndIf
EndIf
EndIf
Else
constants()\text$ + text$ + #LB
If LCase(Left(ttext$, 14)) = "endenumeration"
If IsEnd(Mid(ttext$, 15, 1)) ; Makro zu Ende
inEnumeration = 0
found = 1
EndIf
EndIf
EndIf
ProcedureReturn inEnumeration + found
EndProcedure
Procedure IsStructure(text$, *iMode.integer) ; Überprüft ob das eine Enumeration ist und trägt sie gegebenenfalls ein
Static inStructure.i = 0
Protected found = 0
Protected ttext$ ; getrimter Text
Protected importance.i
*iMode\i = 0
ttext$ = Trim(text$)
If inStructure = 0
If LCase(Left(ttext$, 9)) = "structure"
If IsEnd(Mid(ttext$, 10, 1)) ; Richtige Struktur
importance = GetImportance(text$)
If importance <> #I_DontExtract
inStructure = 1
*iMode\i = 1
AddElement(structures())
structures()\text$ = text$ + #LB
structures()\importance = importance
EndIf
EndIf
EndIf
Else
structures()\text$ + text$ + #LB
If LCase(Left(ttext$, 12)) = "endstructure"
If IsEnd(Mid(ttext$, 13, 1)) ; Struktur zu Ende
inStructure = 0
found = 1
EndIf
EndIf
EndIf
ProcedureReturn inStructure + found
EndProcedure
Procedure IsConstant(text$) ; Überprüft ob das eine Konstante ist und trägt sie gegebenenfalls ein
Protected found.i = 0
Protected importance.i
text$ = Trim(text$)
If Left(text$, 1) = "#"
If IsAlphaNum(Mid(text$, 2, 1)) ; Richtige Variable
importance = GetImportance(text$)
If importance <> #I_DontExtract
found = 1
AddElement(constants())
constants()\text$ = text$
constants()\importance = importance
EndIf
EndIf
EndIf
ProcedureReturn found
EndProcedure
Procedure IsGlobal(text$) ; Überprüft ob das eine Globalendefinition ist und trägt sie gegebenenfalls ein
Protected found.i = 0
Protected importance.i
text$ = Trim(text$)
If LCase(Left(text$, 6)) = "global"
If IsVariableEnd(Mid(text$, 7, 1)) ; Richtige Variable
importance = GetImportance(text$)
If importance <> #I_DOntExtract
found = 1
AddElement(globals())
globals()\text$ = text$
globals()\importance = importance
EndIf
EndIf
EndIf
ProcedureReturn found
EndProcedure
Procedure IsVarialbe(text$) ; Überprüft ob das eine Globalendefinition ist und trägt sie gegebenenfalls ein
Protected found.i = 0
Protected importance.i
text$ = Trim(text$)
If LCase(Left(text$, 6)) = "define"
If IsVariableEnd(Mid(text$, 7, 1)) ; Richtige Variable
importance = GetImportance(text$)
If importance <> #I_DontExtract
found = 1
AddElement(defines())
defines()\text$ = text$
defines()\importance = importance
EndIf
EndIf
EndIf
ProcedureReturn found
EndProcedure
Procedure.s IsIncludeFile(text$) ; Überprüft ob das ein IncludeFile ist und trägt sie gegebenenfalls ein
Protected pos.i, endPos.i
Protected importance.i
text$ = Trim(text$)
If LCase(Left(text$, 11)) = "includefile"
If Mid(text$, 12, 1) = " " Or Mid(text$, 12, 1) = ""DQ"" ; Richtige Prozedur
importance = GetImportance(text$)
If importance <> #I_DontExtract
pos = FindString(text$, ""DQ"", 1)
endPos = FindString(text$, ""DQ"", pos+1)
Debug pos
Debug endPos
Debug "Include File '" + Mid(text$, pos+1, endpos-pos-1) + "'"
ProcedureReturn Mid(text$, pos+1, endpos-pos-1)
EndIf
EndIf
EndIf
ProcedureReturn ""
EndProcedure
Procedure.s ReplaceEscapes(text$)
Protected pos.i, endPos.i
Protected ePos.i
Protected begin$, middle$
pos = FindString(text$, "[[", 1)
If pos
endPos = FindString(text$, "]]", pos+1)
If LCase(Mid(text$, pos+2, endPos-pos-2)) = "dontescape"
ProcedureReturn text$
EndIf
EndIf
Repeat
pos = FindString(text$, Chr('"'), 1)
If pos
endPos = FindString(text$, Chr('"'), pos+1)
If endPos
begin$ + Left(text$, pos) ; Anfang des Textes
middle$ = Mid(text$, pos+1, endPos-pos-1) ; Teil in '"'
Debug "<" + middle$ + ">"
ePos = FindString(middle$, "\", 1)
While ePos
Select Asc(Mid(middle$, ePos+1, 1))
Case '\' : middle$ = Left(middle$, ePos) + Mid(middle$, ePos+2) ; Nur 1 Backslash übrig lassen
Case 't' : middle$ = Left(middle$, ePos-1) DQ "+#TAB$+" DQ Mid(middle$, ePos+2) ; TAB einfügen
Case 'd' : middle$ = Left(middle$, ePos-1) DQ "+#DQUOTE$+" DQ Mid(middle$, ePos+2) ; '"' einfügen
Case 'n' : middle$ = Left(middle$, ePos-1) DQ "+#CRLF$+" DQ Mid(middle$, ePos+2) ; '#CRLF$' einfügen
Case '$' : middle$ = Left(middle$, ePos-1) DQ "+Chr(" + Mid(middle$, ePos+1, 3)+ ")+" DQ Mid(middle$, ePos+4) ; Hex-Zahl
Case '0' To '9' : middle$ = Left(middle$, ePos-1) DQ "+Chr(" + Mid(middle$, ePos+1, 3)+ ")+" DQ Mid(middle$, ePos+4) ; Dezimal-Zahl
Default : middle$ = Left(middle$, ePos-1) + Mid(middle$, ePos+2) ; Rest löschen
EndSelect
ePos = FindString(middle$, "\", ePos)
Wend
begin$ + middle$ DQ ""
If Mid(text$, endPos+1, 1) = Chr('"') ; Wenn '""' -> '" +Chr('"')+ "'
Debug "'' ''"
begin$ + "+#DQUOTE$+" ; Hinten anhängen
EndIf
text$ = Mid(text$, endPos+1) ; Rest als neuen Text
Else
pos=0
EndIf
EndIf
Until pos=0
ProcedureReturn begin$ + text$
EndProcedure
Procedure.s CheckForMultiline(text$, *mMode.integer)
Protected pos.i, endPos.i
pos = FindString(text$, multiLineStr$, 1) ; Wenn das ein Multiline ist ...
If pos
*mMode\i = 1 ; weitere Multiline
text$ = Left(text$, pos-1) ; Nur das davor zurückgeben
Else
*mMode\i = 0 ; Kein Multiline
EndIf
ProcedureReturn text$
EndProcedure
Procedure.s ReplaceArrow(text$)
Protected pos.i = 0
Repeat
pos = FindString(text$, "->", pos) ; "->" suchen
If pos
If Asc(Mid(text$, pos+2, 1)) < 'a' ; Großbuchstabe ...
text$ = Left(text$, pos-1) +"_"+ Mid(text$, pos+2) ; mit "_" ersetzten
Else ; Kleinbuchstabe ...
text$ = Left(text$, pos-1) +"_\"+ Mid(text$, pos+2) ; mit "_\" ersetzten
EndIf
EndIf
Until pos = 0
ProcedureReturn text$
EndProcedure
Procedure.s ReplaceLText(text$)
Protected pos.i = 0
Protected endPos.i = 0
Repeat
pos = FindString(text$, "{'", pos) ; "{'" suchen
endPos = FindString(text$, "'}", pos+2) ; Ende suchen
If pos And endPos
text$ = Left(text$, pos-1) + "language_texts\" + Mid(text$, pos+2, endPos-Pos-2) + Mid(text$, endPos+2)
EndIf
Until pos = 0
ProcedureReturn text$
EndProcedureCode: Alles auswählen
Procedure ParseFile(file$, newFile$) ; Geht die Datei durch und packt gefundenes in die Listen
Static parseNumber = 0
Protected f.i, g.i
Protected line$
Protected lineNr.i = 0
Protected newName$
Protected inMode.i
Protected multilineMode.i
Debug file$
Debug newFile$
If mode & #Debug
PrintN("'"+file$+"' wird verarbeitet ...")
If Inkey() = "a"
PrintN("Wollen Sie das Programm abbrechen? (j/n)")
If Left(Input(), 1) = "j"
End
EndIf
EndIf
EndIf
f = ReadFile(#PB_Any, file$)
g = CreateFile(#PB_Any, newFile$)
If f And g
Repeat
line$ + ReadString(f)
lineNr + 1
If mode & #off
If FindString(line$, "[[EnableDeclareCreator]]", 1)
mode ! #off ; Wieder anschalten
EndIf
ElseIf FindString(line$, "[[DisableDeclareCreator]]", 1)
mode | #off
Else
; Seltsame eigene Replaces
If mode & #EnableMultiline
line$ = CheckForMultiline(line$, @multilineMode)
EndIf
If mode & #EnableEscape
line$ = ReplaceEscapes(line$)
EndIf
If mode & #ReplaceArrow ; '->' durch '_\' ersetzen
line$ = ReplaceArrow(line$)
EndIf
If mode & #ReplaceLText ; "{'...'}" durch "language_texts\..."
line$ = ReplaceLText(line$)
EndIf
newName$ = IsIncludeFile(line$)
If newName$
line$ = ReplaceString(line$, newName$, tempPath$+newName$) ; Pfad mit speichern
If FindString(LCase(line$), "[[declares]]", 1) = 0 ; Wenn das ok ist
ParseFile(sourcePath$+newName$, tempPath$+newName$)
EndIf
ElseIf IsProcedure(line$)
AddLineInfo(procedures())
ElseIf mode & #MoveMacros And IsMacro(line$, @inMode)
line$ = "; " + line$
If inMode = 1
line$ + " ; (verschoben!)"
AddLineInfo(macros())
Debug macros()\text$ + " '" + macros()\file$ + "' (" + Str(lineNr) + ")"
EndIf
ElseIf mode & #MoveConstants And IsEnumeartion(line$, @inMode)
line$ = "; " + line$
If inMode = 1
line$ + " ; (verschoben!)"
AddLineInfo(constants())
EndIf
ElseIf mode & #MoveStructures And IsStructure(line$, @inMode)
line$ = "; " + line$
If inMode = 1
line$ + " ; (verschoben!)"
AddLineInfo(structures())
EndIf
ElseIf mode & #MoveConstants And IsConstant(line$) ; Muss nach Enumeration kommen
AddLineInfo(constants())
line$ = "; " + line$ + " ; (verschoben!)"
ElseIf mode & #MoveGlobals And IsGlobal(line$)
AddLineInfo(globals())
line$ = "; " + line$ + " ; (verschoben!)"
ElseIf mode & #MoveVariables And IsVarialbe(line$)
AddLineInfo(defines())
line$ = "; " + line$ + " ; (verschoben!)"
EndIf
EndIf
If multilineMode
WriteStringN(g, "; Multiline (!)")
Else
WriteStringN(g, line$)
line$ = ""
EndIf
Until Eof(f)
CloseFile(f)
CloseFile(g)
Else
If mode & #Debug = 0
OpenConsole()
EndIf
PrintN("Fehler!")
PrintN(" '"+file$+"' konnte nicht verarbeitet werden.")
PrintN("Wollen Sie das Programm abbrechen? (j/n)")
If Left(Input(), 1) = "j"
End
EndIf
If mode & #Debug = 0
CloseConsole()
EndIf
EndIf
EndProcedure
Procedure CreateReplacementFile(file$)
; Listen nach wichtigkeit sortieren
If CreateFile(3, file$)
WriteStringN(3, "; Automatisch von Declare-Creator erstellte Declare-Datei.")
WriteStringN(3, "; Diese sollte alle Funktionen korrekt zur Verfügung stellen.")
WriteStringN(3, "")
If mode & #MoveConstants
SortStructuredList(constants(), #PB_Sort_Descending, OffsetOf(replacement\importance), #PB_Sort_Integer)
WriteStringN(3, "")
WriteStringN(3, ";*********************************************************************************")
WriteStringN(3, ";- Definieren von Konstanten" + #LB)
ForEach constants()
;If constants()\importance = #I_DontExtract : Break : EndIf
WriteStringN(3, constants()\text$ + " ; '"+ constants()\file$ +"' ("+ Str(constants()\line) +")")
Next
EndIf
If mode & #MoveStructures
SortStructuredList(structures(), #PB_Sort_Descending, OffsetOf(replacement\importance), #PB_Sort_Integer)
WriteStringN(3, "")
WriteStringN(3, ";*********************************************************************************")
WriteStringN(3, ";- Anlegen von Strukturen" + #LB)
ForEach structures()
;If structures()\importance = #I_DontExtract : Break : EndIf
WriteStringN(3, "; '"+ structures()\file$ +"' ("+ Str(structures()\line) +")")
WriteStringN(3, structures()\text$)
Next
EndIf
SortStructuredList(procedures(), #PB_Sort_Descending, OffsetOf(replacement\importance), #PB_Sort_Integer)
WriteStringN(3, "")
WriteStringN(3, ";*********************************************************************************")
WriteStringN(3, ";- Deklarieren von Funktionen" + #LB)
ForEach procedures()
;If procedures()\importance = #I_DontExtract : Break : EndIf
WriteStringN(3, "Declare"+procedures()\text$ +" ; '"+ procedures()\file$ +"' ("+ Str(procedures()\line) +")")
Debug "Declare"+procedures()\text$
Next
If mode & #MoveMacros
SortStructuredList(macros(), #PB_Sort_Descending, OffsetOf(replacement\importance), #PB_Sort_Integer)
WriteStringN(3, "")
WriteStringN(3, ";*********************************************************************************")
WriteStringN(3, ";- Anlegen von Makros" + #LB)
ForEach macros()
;If macros()\importance = #I_DontExtract : Break : EndIf
WriteStringN(3, "; '"+ macros()\file$ +"' ("+ Str(macros()\line) +")")
WriteStringN(3, macros()\text$)
Next
EndIf
If mode & #MoveGlobals
SortStructuredList(globals(), #PB_Sort_Descending, OffsetOf(replacement\importance), #PB_Sort_Integer)
WriteStringN(3, "")
WriteStringN(3, ";*********************************************************************************")
WriteStringN(3, ";- Definieren von Globalen Variablen" + #LB)
ForEach globals()
;If globals()\importance = #I_DontExtract : Break : EndIf
WriteStringN(3, globals()\text$ + " ; '"+ globals()\file$ +"' ("+ Str(globals()\line) +")")
Next
EndIf
If mode & #MoveVariables
SortStructuredList(defines(), #PB_Sort_Descending, OffsetOf(replacement\importance), #PB_Sort_Integer)
WriteStringN(3, "")
WriteStringN(3, ";*********************************************************************************")
WriteStringN(3, ";- Definieren von allgemeinen Variablen" + #LB)
ForEach defines()
;If defines()\importance = #I_DontExtract : Break : EndIf
WriteStringN(3, defines()\text$ + " ; '"+ defines()\file$ +"' ("+ Str(defines()\line) +")")
Next
EndIf
CloseFile(3)
EndIf
EndProcedureEdit Code aktualisiert. Ist leider etwas unpraktikabel mein Tool.
