Ungenutze Variablen

[Jan]

Gibt es eigentlich die Möglichkeit, deklarierte aber nicht genutzte Variablen festzustellen?

Jan

[Martin Altmann]

Ja.
Allerdings nicht mit einem Compilerschalter, sondern mit externen Tools.
Ich muss mal eine Weile stöebrn, da mir der Name nicht einfällt - aber es gab mal sowas für Clipper....

Viele Grüße,
Martin

[Martin Altmann]

Vergiss' es - schau Dir mal den Schalter /wu an...

Viele Grüße,
Martin

[Martin Altmann]

1744 deklarierte, aber nicht genutzte Variablen in meinen Sourcen - tja, "Cut and Paste" halt...
Wobei - ich arbeite ja in meinem Code auch mit Compilerdirektiven (#ifdef...) - somit habe ich auch durchaus Variablen deklariert, die ich bei meinem gerade durchgeführten Compilerlauf nicht nutze, aber bei einem anderen vielleicht...
Naja, wenn ich mal ganz viel Langeweile habe, kann ich das ja vielleicht mal aufräumen...

Viele Grüße,
Martin

[Jan]

Vergiss' es - schau Dir mal den Schalter /wu an...

Manchmal ist das Leben so einfach ... Danke.

Ja, das aufräumen. Das ist ja gerade der Punkt. Ich habe keine Lust, mich ständig durch überflüssigen Code zu wühlen. Der im einfachsten Fall einfach nur Zeilen produziert, die die Aufmerksamkeit von den wichtigen Teilen ablenken. Und dazu gehören auch die endlos langen Deklarationen am Anfang jeder Funktion, wo die Hälfte der Variablen aus alten Testzeiten oder weggefallenen Punkten stammen.

Jetzt müsste es nur noch den entsprechenden Compilerschalter für unbenutzte Funktionen und Prozeduren geben ...

Jan

[Martin Altmann]

Nun,
ich glaube, dafür gibt es aber das gute alte Clipper-Tool - das Dir auch den Sourcecode formatieren kann (mit Einrückungen etc.)
Ich wühle mal ...

Viele Grüße,
Martin

[Manfred]

Hi,

dieser Compilerschalter meldet sich aber auch, wenn man eine Variable deklariert und etwas reinschreibt, mehr aber nicht. Das sieht er als nicht benutzt an.

[Martin Altmann]

Hallo Manfred,
ist ja auch richtig - außer das Du was reinschreibst nutzt Du sie ja auch nicht - also wozu was reinschreiben??

Viele Grüße,
Martin

[Manfred]

Hi Martin,

ich weiß, die Antwort kam auch vom Support, aber ich muß mal nachsehen, irgendwo war es ein Sonderfall, bei dem der Compiler auch gemeckert hatte, aber eigentlich nicht sollte. Mal schauen, ob ich das irgendwo wiederfinde.

[brandelh]

Hallo,

eine Variable wird erst beim Lesen benutzt, das Zuweisen ist erst eine Vorbereitung. Also schön den Schalter so lassen wie er ist, man muss ihn ja nicht benutzen.

[Martin Altmann]

Hallo Jan,

Jetzt müsste es nur noch den entsprechenden Compilerschalter für unbenutzte Funktionen und Prozeduren geben ...

tut mir leid, dass es soo lange gedauert hat - aber war nicht einfach, SNAP wieder zu finden.
Probier mal mit dem Tool Dein Glück - es tut genau dies, indem es für jede Funktion und Prozedur aufführt, welche andere Funktion bzw. Prozedur diese aufruft.
Gibt es keine, dann steht dort, dass diese Funktion nirgendwo verwendet wird
Aber ich denke mal, dass wird jetzt unter Xbase++ nicht mehr so richtig funktionieren, da es sich anhand des Hauptpgrogrammes durch alle Funktionen hangelt (bedenke: unter Clipper war jedes PRG eine eigene Funktion/Prozedur, bzw. man band die gewünschten mittels SET PROCEDURE TO ... ein...)
Einfach mal ausprobieren.
Ansonsten gibt es noch Click! von Phil Barnett (The Oasis) - aber inwieweit Dir das weiterhilft, weiß ich nicht...

Viele Grüße,
Martin

[Martin Altmann]

So,
Mark Carew hat gerade in der Alaska Newsgroup public.xbase+++.wishcollector in dem Thread Suggestion: Unused procedures, Function list. am 07.10.2006 um 08:39 ein selbstgestricktes Programm gepostet, das ungenutzte Prozeduren und Funktionen in den prgs findet.

Viele Grüße,
Martin

[Jan]

Hallo Martin,

habe ich gesehen, bekomme ich aber nicht zum laufen. Weil die .lib fehlt.

Jan

[brandelh]

Welche LIB fehlt denn, eventuell kann ich es compilieren.

[Jan]

mjcarew9dbf.lib
planxlib.lib
plandll1.lib

Jan

[brandelh]

Hi Jan,

sorry, die habe ich noch nie gesehen.

[Martin Altmann]

Hallo Jan,
inzwischen hat auch Wolfgang Ciriack entsprechend angefragt. Mark nutzte wohl auch noch eine (ältere) Express++-Version...
Aber im Prinzip kann man sich seinen Source als Vorlage nehmen und das ganz (recht schnell) selber umsetzen. Folgender Vorschlag (quick and dirty):
Scanne das prg nach dem Begriff "procedure " und merke Dir den Teil, der zwischen dem Leerzeichen und der "(" steht. Diesen Begriff schreibst Du in die DBF (oder ein Array).
Das gleiche erneut mit dem Begrif "function ".
Wenn Du alle prgs durch hast, scannst Du in allen prgs nach den Begriffen, die Du Dir vorher in der DBF (oder dem Array) gemerkt hast. Wenn Du den Begriff in allen prgs nur ein Mal findest, wird die Funktion bzw. Prozedur nicht genutzt!
Zum Lesen kannst Du MemoRead() nehmen und zum Zählen At(), (wiederholt, bis der String komplett durch ist).

Viele Grüße,
Martin

[Koverhage]

Habe das Programm laufen gelassen. Ist allerdings derzeit nur beschränkt auf FUNCTION 's. Diese auch nur dann, wenn sie nicht als static deklariert
sind.

Hier das Prog:
*
* Author Mark J Carew
* 25/10/04 05:18
* Examines
* 1. One prg
* grok myprog.prg
* 2. All Prgs
* grok
* 3. One xpj file's programs
* grok myproj.xpj
* 4. All Prgs in all Xpjs
* grok *.xpj
*
* Create a file - grok.dbf that contains the number of
* times a function that is in the above prg(s) is called
* If hitcount == 0 then the function is ceated but never called
*
#INCLUDE "common.ch"
#INCLUDE "directry.CH"
#INCLUDE "dbfdbe.CH"
#INCLUDE "fileio.CH"
#INCLUDE "deldbe.CH"

#define GROK_EXCEPTIONS ;
{"LAYOUT_AU","NAMETITLE","USEPREFIX_A1","ADDRLINEONE"}

#define CRLF chr( 13 ) + chr( 10 )
#define CR chr( 13 )
#define LF chr( 10 )

static aChs
static aProgsToCheck
static cFunction
static cPrg
static cCh
static cShortProg
static nAsteriskSlash
static nLineNo
static nSlashAsterisk
*
function main(cInPrg)
*
local aDirXpj
local aGrokExceptions
local aPrgs
local aThisXpj
local cEachException
local cString
local nHandleCfg
local nLen
local nPtr
local nTotalLines
*
nTotalLines := 0
*
aGrokExceptions := GROK_EXCEPTIONS
*
aProgsToCheck := {}
clear screen
*
loadCDxDbe()
*
ferase("grok.dbf")
ferase("grok.cdx")
*
dbcreate(;
"grok.dbf",;
{{"fnctn","C",45,0},;
{"hitCount","N",6,0},;
{"program","C",12,0},;
{"info","C",200,0}},;
"DBFCDX")
*
use grok alias grok new exclusive via "DBFCDX"
*
ordcreate("grok.cdx","fnctn","fnctn")
ordcreate("grok.cdx","program","program+fnctn")
ordcreate("grok.cdx","hitcount","str(hitcount,6,0)+fnctn+program")
*
dbcloseALL()
*
use grok alias grok new exclusive via "DBFCDX"
grok->(ordlistadd("grok.cdx"))
grok->(ordsetfocus("fnctn","grok.cdx"))
*
IF cInPrg == nil
aPrgs := directory("*.prg")
ELSE
*
cInPrg := upper(alltrim(cInPrg))
*
do case
case cInPrg == "*.XPJ"
*
aDirXpj := directory(cInPrg)
*
aThisXpj := {}
*
nLen := len(aDirXpj)
*
FOR nPtr := 1 TO nLen
*
xpjPrgsArray(aDirXpj[nPtr][1],aThisXpj)
*
NEXT
*
aPrgs := aThisXpj
*
case at(".XPJ",cInPrg) > 0
*
aThisXpj := {}
*
xpjPrgsArray(cInPrg,aThisXpj)
*
aPrgs := aThisXpj
*
otherwise
*
IF at(".PRG",cInPrg) > 0
*
cInPrg += ".PRG"
*
ENDIF
*
aPrgs := {}
*
aadd(aPrgs,{cInPrg})
*
end case
*
ENDIF

nLen := len(aPrgs)
*
FOR nPtr := 1 TO nLen
*
cPrg := upper(alltrim(aPrgs[nPtr][1]))
*
IF cPrg == "GROK.PRG" .OR. ;
cPrg == "PROGCOMP.PRG" .OR. ;
cPrg == "DOCUPRG.PRG"
LOOP
ENDIF
*
* select programs
*
aadd(aProgsToCheck,cPrg)
*
nLineNo := 0
*
nSlashAsterisk := 0
*
nHandleCfg := mcTxtOpen(cPrg)
*
if nHandleCfg > 0
*
DO WHILE TRUE
*
// IF mcTxtEof(nHandleCfg)
// EXIT
// ENDIF
*
cString := mcTxtLine(nHandleCfg)
if len(cString) < 1
exit
endif
*
cString := strtran(cString,chr(09),space(4))
*
nTotalLines ++
*
processPrg(cString)
*
// mcTxtSkip(nHandleCfg,1)
*
ENDDO
*
mcTxtCLOSE(nHandleCfg)
*
endif
*
next
*
updateHitCount()
updateChCount()
*
nLen := len(aGrokExceptions)
*
FOR nPtr := 1 TO nLen
*
cEachException := aGrokExceptions[nPtr]
*
IF grok->(dbseek(padr(cEachException,45)))
*
grok->hitcount := 99999
*
ENDIF
*
NEXT
*
dbcloseall()
?
? 'total lines read ', nTotalLines
?
WAIT
*
return nil
*
*
*
function xpjPrgsArray(cXpjName,aThisXpj)
*
local nScan
local cXpjString
local nHandle
*
nHandle := fOpen(cXpjName,FO_READ)
*
IF nHandle <> -1
*
* what are the prgs in this xpj
*
do while TRUE
*
// if ft_feof(nHandle)
// exit
// endif
*
cXpjString := mcTxtLine(nHandle)
if len(cXpjString) < 1
exit
endif
*
cXpjString := upper(alltrim(cXpjString))
*
IF at(".PRG",cXpjString) > 0
*
IF AT("/" + "/",cXpjString) == 0
*
IF empty(aThisXpj)
*
aadd(aThisXpj,{cXpjString})
*
? cXpjString
*
else
*
nScan := ;
aScan(aThisXpj,{|e|e[1]==cXpjString })
*
IF nScan == 0
*
aadd(aThisXpj,{cXpjString})
*
? cXpjString
*
ENDIF
*
ENDIF
*
ENDIF
*
ENDIF
*
// ft_fskip(nhandle)
*
enddo
*
mcTxtClose(nHandle)
*
ENDIF
*
return aThisXpj
*
*
*
function processPrg(cString)
*
local cFirstTwo
local cFunct
local cUpper
local cUpperString
local nFunctionCol
*
cUpper := upper(cString)
*
cUpperString := alltrim(cUpper)
*
cFirstTwo := left(cString,2)
*
if cUpperString == "*" .OR. ;
cFirstTwo == "/" + "/"
*
else
*
nLineNo ++
*
nFunctionCol := at("FUNCTION ",cUpperString)
*
if nSlashAsterisk == 0
*
nSlashAsterisk := at('/*',cUpperString)
*
endif
*
* time to turn off slash asterisk
*
if nSlashAsterisk > 0
*
nAsteriskSlash := at('*/',cUpperString)
*
if nAsteriskSlash > 0
*
nSlashAsterisk := 0
nAsteriskSlash := 0
*
endif
*
endif
*
* if commenting is off
*
IF nSlashAsterisk == 0
*
do case
case nFunctionCol == 1
*
cFunction := cString
*
cFunct := substr(cFunction,1,at("(",cFunction)-1)
cFunct := upper(cFunct)
cFunct := strtran(cFunct,"FUNCTION ","")
cFunct := padr(cFunct,45)
*
IF grok->(dbseek(cFunct))
*
? '* ---------------->>>>>>>>>>>>>>>>>>'
? 'Function Occurrs Twice',alltrim(cFunct)
? '* ---------------->>>>>>>>>>>>>>>>>>'
*
else
*
? 'Added Function ',cPrg,alltrim(cFunct)
*
grok->(dbappend())
grok->fnctn := cFunct
grok->program := cPrg
*
ENDIF
*
nSlashAsterisk := 0
nAsteriskSlash := 0
*
end case
*
ENDIF
*
endif
*
return nil
*
*
*
function updateHitCount()
*
local cString
local cUpperString
local nFunctionCol
local nHandleCfg
local nLen
local nPtr
local nReturnCol
*
nLen := len(aProgsToCheck)
*
? "Look at for Hit Count ?"
*
FOR nPtr := 1 TO nLen
*
cPrg := aProgsToCheck[nPtr]
cShortProg := strtran(cPrg,".PRG","")
*
? "Looking at",cPrg
*
nHandleCfg := mcTxtOpen(cPrg)
*
if nHandleCfg > 0
*
DO WHILE TRUE
*
// IF mcTxtEof(nHandleCfg)
// EXIT
// ENDIF
*
cString := mcTxtLine(nHandleCfg)
if len(cString) < 1
exit
endif
if empty(cString)
loop
endif
*
cString := strtran(cString,chr(09),space(4))
cUpperString := upper(alltrim(cString))
*
if cUpperString == "*"
else
*
* look for slash Asterisk
*
if nSlashAsterisk == 0
nSlashAsterisk := at("/*",cUpperString)
ENDIF
*
* time to turn off slash asterisk
*
if nSlashAsterisk > 0
*
nAsteriskSlash := at("*/",cUpperString)
*
if nAsteriskSlash > 0
*
nSlashAsterisk := 0
nAsteriskSlash := 0
*
endif
*
endif
*
* if commenting is off
*
IF nSlashAsterisk == 0
*
* assumes that only one function is found per line
* we are realy looking for no hits
*
nFunctionCol := at("FUNCTION ",cUpperString)
nReturnCol := at("RETURN",cUpperString)
*
do case
case nFunctionCol == 1
case nReturnCol == 1
*
otherwise
*
* looking for functions only
*
IF at("(",cUpperString) > 0
*
lookForHits(cUpperString)
*
ENDIF
*
end case
*
endif
*
endif
*
// mcTxtSkip(nHandleCfg,1)
*
ENDDO
*
mcTxtCLOSE(nHandleCfg)
*
endif
*
NEXT
*
return nil
*
*
*
function lookForHits(cString)
*
grok->(dbgotop())
*
do while TRUE
*
IF grok->(eof())
exit
ENDIF
*
cFunction := alltrim(grok->fnctn) + "("
*
IF at(cFunction,cString) > 0
*
grok->hitcount ++
*
IF at(cShortProg,grok->info) == 0
*
grok->info := ;
alltrim(grok->info) + ;
cShortProg + ;
"|"
*
ENDIF
*
ENDIF
*
grok->(dbskip())
*
enddo
*
return nil

function updateChCount()
*
local cString
local nHandleCfg
local nLen
local nPtr
local cUpperString
*
aChs := directory("*.ch")
*
nLen := len(aChs)
*
FOR nPtr := 1 TO nLen
*
cCh := upper(alltrim(aChs[nPtr][1]))
*
? "Looking at",cCh
*
nHandleCfg := mcTxtOpen(cCh)
*
if nHandleCfg > 0
*
DO WHILE TRUE
*
// IF mcTxtEof(nHandleCfg)
// EXIT
// ENDIF
*
cString := mcTxtLine(nHandleCfg)
if len(cString) < 1
exit
endif
if empty(cString)
loop
endif
*
cString := strtran(cString,chr(09),space(4))
cUpperString := upper(alltrim(cString))
*
* looking for functions only
*
IF at("(",cUpperString) > 0
*
lookForChHits(cUpperString)
*
endif
*
// mcTxtSkip(nHandleCfg,1)
*
ENDDO
*
mcTxtCLOSE(nHandleCfg)
*
endif
*
NEXT
*
return nil
/*
function updateBBBCount()
*
local cString
local nHandleCfg
local nLen
local nPtr
local cUpperString
*
aBBBs := directory("*.bbb")
*
nLen := len(aBBBs)
*
FOR nPtr := 1 TO nLen
*
cBBB := upper(alltrim(aBBBs[nPtr][1]))
*
? "Looking at",cBBB
*
nHandleCfg := mcTxtOpen(cBBB)
*
if nHandleCfg > 0
*
DO WHILE TRUE
*
// IF mcTxtEof(nHandleCfg)
// EXIT
// ENDIF
*
cString := mcTxtLine(nHandleCfg)
if len(cString) < 1
exit
endif
if empty(cString)
loop
endif
*
cString := strtran(cString,chr(09),space(4))
cUpperString := upper(alltrim(cString))
*
* looking for functions only
*
IF at("(",cUpperString) > 0
*
lookForBBBHits(cUpperString)
*
endif
*
// mcTxtSkip(nHandleCfg,1)
*
ENDDO
*
mcTxtCLOSE(nHandleCfg)
*
endif
*
NEXT
*
return nil

function updateTXBCount()
*
local cString
local nHandleCfg
local cUpperString
*
cTXB := SYSPREFIX + "SCRN.TXB"
*
? "Looking at",cTXB
*
nHandleCfg := mcTxtOpen(cTXB)
*
if nHandleCfg > 0
*
DO WHILE TRUE
*
// IF mcTxtEof(nHandleCfg)
// EXIT
// ENDIF
*
cString := mcTxtLine(nHandleCfg)
if len(cString) < 1
exit
endif
if empty(cString)
loop
endif
*
cString := strtran(cString,chr(09),space(4))
cUpperString := upper(alltrim(cString))
*
* looking for functions only
*
IF at("(",cUpperString) > 0
*
lookForTXBHits(cUpperString)
*
endif
*
// mcTxtSkip(nHandleCfg,1)
*
ENDDO
*
mcTxtCLOSE(nHandleCfg)
*
endif
*
cTXB := SYSPREFIX + "DDICT.TXB"
*
? "Looking at",cTXB
*
nHandleCfg := mcTxtOpen(cTXB)
*
if nHandleCfg > 0
*
DO WHILE TRUE
*
// IF mcTxtEof(nHandleCfg)
// EXIT
// ENDIF
*
cString := mcTxtLine(nHandleCfg)
if len(cString) < 1
exit
endif
if empty(cString)
loop
endif
*
cString := strtran(cString,chr(09),space(4))
cUpperString := upper(alltrim(cString))
*
* looking for functions only
*
IF at("(",cUpperString) > 0
*
lookForTXBHits(cUpperString)
*
endif
*
mcTxtSkip(nHandleCfg,1)
*
ENDDO
*
// mcTxtCLOSE(nHandleCfg)
*
endif
*
return nil
*/
function lookForChHits(cString)
*
grok->(dbgotop())
*
do while TRUE
*
IF grok->(eof())
exit
ENDIF
*
cFunction := alltrim(grok->fnctn) + "("
*
IF at(cFunction,cString) > 0
*
grok->hitcount ++
*
IF at(cCh,grok->info) == 0
grok->info := ;
alltrim(grok->info) + ;
cCh + "|"
ENDIF
*
ENDIF
*
grok->(dbskip())
*
enddo
*
return nil
/*
function lookForBBBHits(cString)
*
grok->(dbgotop())
*
do while TRUE
*
IF grok->(eof())
exit
ENDIF
*
cFunction := alltrim(grok->fnctn) + "("
*
IF at(cFunction,cString) > 0
*
grok->hitcount ++
*
IF at(cBBB,grok->info) == 0
grok->info := ;
alltrim(grok->info) + ;
cBBB + "|"
ENDIF
*
ENDIF
*
grok->(dbskip())
*
enddo
*
return nil
*/
/*
function lookForTXBHits(cString)
*
grok->(dbgotop())
*
do while TRUE
*
IF grok->(eof())
exit
ENDIF
*
cFunction := alltrim(grok->fnctn) + "("
*
IF at(cFunction,cString) > 0
*
grok->hitcount ++
*
IF at(cTXB,grok->info) == 0
grok->info := ;
alltrim(grok->info) + ;
cTXB + "|"
ENDIF
*
ENDIF
*
grok->(dbskip())
*
enddo
*
return nil
*/

function loadCDxDbe()
*
IF ! DbeLoad( "CDXDBE",.T.)
msgBox( "Database-Engine CDXDBE not loaded" ,"Message Box" )
ENDIF

IF ! DbeBuild( "DBFCDX", "DBFDBE", "CDXDBE" )
msgBox( "DBFCDX Database-Engine;Could not build engine" , "Message Box" )
ENDIF
*
dbeSetDefault("DELDBE")
*
dbeinfo(COMPONENT_DATA, DELDBE_MODE, DELDBE_SINGLEFIELD)
dbeinfo(COMPONENT_DATA, DELDBE_DELIMITER_TOKEN, CHR(0))
*
return nil


function posFirstNonBlank(cString)
*
local cChar
local nLen
local nPtr
*
nLen := len(cString)
*
FOR nPtr := 1 TO nLen
*
cChar := cString[nPtr]
*
IF !empty(cChar)
exit
ENDIF
*
NEXT
*
return nPtr

/***
*
* FReadLn( <nHandle>, [<nLines>], [<nLineLength>], [<cDelim>] ) --> cLines
*
* Read one or more lines from a text file
*
* NOTES:
* Line length includes delimiter, so max line read is
* (nLineLength - LEN( cDelim ))
*
* Return value includes delimiters, if delimiter was read
*
* nLines defaults to 1, nLineLength to 80 and cDelim to CRLF
*
* FERROR() must be checked to see if FReadLn() was successful
*
* FReadLn() returns "" when EOF is reached
*
*/
STATIC FUNCTION mcTxtLine( nHandle, nLines, nLineLength, cDelim )

LOCAL nCurPos // Current position in file
LOCAL nFileSize // The size of the file
LOCAL nChrsToRead // Number of character to read
LOCAL nChrsRead // Number of characters actually read
LOCAL cBuffer // File read buffer
LOCAL cLines // Return value, the lines read
LOCAL nCount // Counts number of lines read
LOCAL nEOLPos // Position of EOL in cBuffer

DEFAULT nLines TO 1
DEFAULT nLineLength TO 80
DEFAULT cDelim TO ( CHR(13) + CHR(10) )

nCurPos := FilePos( nHandle )
nFileSize := FileSize( nHandle )

// Make sure no attempt is made to read past EOF
nChrsToRead := MIN( nLineLength, nFileSize - nCurPos )

cLines := ''
nCount := 1
DO WHILE (( nCount <= nLines ) .AND. ( nChrsToRead != 0 ))

cBuffer := SPACE( nChrsToRead )
nChrsRead := FREAD( nHandle, @cBuffer, nChrsToRead )

// Check for error condition
IF !(nChrsRead == nChrsToRead)
// Error!
// In order to stay conceptually compatible with the other
// low-level file functions, force the user to check FERROR()
// (which was set by the FREAD() above) to discover this fact
//
nChrsToRead := 0
ENDIF

nEOLPos := AT( cDelim, cBuffer )

// Update buffer and current file position
IF ( nEOLPos == 0 )
cLines += LEFT( cBuffer, nChrsRead )
nCurPos += nChrsRead
ELSE
cLines += LEFT( cBuffer, ( nEOLPos + LEN( cDelim ) ) - 1 )
nCurPos += ( nEOLPos + LEN( cDelim ) ) - 1
FSEEK( nHandle, nCurPos, FS_SET )
ENDIF

// Make sure we don't try to read past EOF
IF (( nFileSize - nCurPos ) < nLineLength )
nChrsToRead := ( nFileSize - nCurPos )
ENDIF

nCount++

ENDDO

RETURN ( cLines )

/***
*
* FilePos( <nHandle> ) --> nPos
*
* Report the current position of the file pointer in a binary file
*
*/
STATIC FUNCTION FilePos( nHandle )
RETURN ( FSEEK( nHandle, 0, FS_RELATIVE ) )



/***
*
* FileSize( <nHandle> ) --> nBytes
*
* Return the size of a binary file
*
*/
STATIC FUNCTION FileSize( nHandle )

LOCAL nCurrent
LOCAL nLength

// Get file position
nCurrent := FilePos( nHandle )

// Get file length
nLength := FSEEK( nHandle, 0, FS_END )

// Reset file position
FSEEK( nHandle, nCurrent )

RETURN ( nLength )


STATIC FUNCTION mcTxtOpen(cFilename)
return FOpen( cFilename , FO_READ )

STATIC FUNCTION mcTxtClose(nHandle)
FClose( nHandle )
return FError()


und hier die xpf


[PROJECT]
COMPILE = xpp
COMPILE_FLAGS = /b /q /p /w /wu /v /rxppui2.lib /dDBFFILES
DEBUG = YES
GUI = yes
LINKER = alink
RC_COMPILE = arc
RC_FLAGS = /v
PROJECT.XPJ

[PROJECT.XPJ]
GROK.EXE
// DOCUPRG.EXE

[GROK.EXE]
grok.prg
// mjcarew9dbf.lib
// planxlib.lib
// plandll1.lib

//[DOCUPRG.EXE]
// docuprg.prg
// mjcarew9dbf.lib

[brandelh]

Hi,

nicht vergessen, dass auch PROC und FUNC erlaubt sind...

Ich habe übrigens jede Menge unbenützte Funktionen in meinen Programmen, da ich immer einige PRG mit allgemeinen Sachen mit compiliere. Das ist auch bei weitem nicht so tragisch wie eine unbenutzte Variable (die ist nur schlimm, wenn sie durch einen Tippfehler entstanden ist, was ja zu Fehlern führen wird.).

[Manfred]

Hi,

wenn wir nun gerade dabei sind, was passiert eigentlich intern mit Funktionen, die z.B. Static gemacht werden? Bei Vars gibt es ja Unterschiede, ob Public, Private, Local, oder Static

[brandelh]

Hallo Manfred,

eine STATIC Funktion ist nur in der aktuellen PRG Datei sichtbar, d.h.
man kann im Projekt mehrere gleichnamige Funktionen haben, wenn zumindest bis auf eine alle STATIC sind und sich in verschiedenen PRGs befinden.

OB das wirklich SINN macht sollte man sich aber gut überlegen !

[Manfred]

Hi Hubert,

das mit Static und dann welches Verhalten, ist mir klar, aber....

Dein 2.Satz: was meinst Du damit? Das wäre nämlich meine eigentliche Frage gewesen.

[brandelh]

Wenn ich z.B. verschiedene Druckprogramme habe und immer eine Adresse aus einer Funktion ermitteln lasse - sehr weit hergeholt - dann könnte ich den gleichen Namen in jeder der PRGs mit unterschiedlichem Rückgabewert (Adresse unterscheidet sich auch im Aufbau) erreichen.

Aber wenn ich im Quellcode dann eine solche Funktion aufrufe, sehe ich NICHT, dass es eine STATIC ist. Habe ich eben gerade eine gleichnamige im anderen PRG bearbeitet - eventuell eine ohne STATIC - komme ich gar nicht auf die Idee es könnte noch eine in der aktuellen Datei geben und wundere mich - eventuell - warum das Ergebnis nicht zur Funktion passt ... das wäre ein mögliches Problem.

Ich denke dass die STATIC Function aus Zeiten der 'alten' proceduralen Programmierung stammt und in heutigen OOP Zeiten besser über Klassen gehandhabt werden sollte.

Wenn aber jemand weiß warum er das so und so erledigen will, ist auch gegen STATIC Funktionen nichts einzuwenden.

[Koverhage]

Hubert, das hatte ich vergessen zu sagen PROC und FUNC geht auch nicht. aber das zu erweitern dürfte alles kein Problem sein.
Es gibt sicherlich auch STATIC function oder procedure die man mal eingebaut hat, aber nie benutzt. Wenn ich schon so ein Teil habe, dann bitte alles
Optimal wäre noch die Auswertung der DBF Datei, sodas gleich angezeigt wird, wo der Counter auf 0 steht

[Koverhage]

Hubert, das macht schon Sinn, OOP was ist das ?