Deutsch
SDK-Helfer/ Tools

JRPC neuer Präkompiler für XProfan X4 - JRPC3

 
- Seite 1 -



Jens-Arne
Reumschüssel
Guten Abend zusammen,

ich bin kürzlich über das Problem gestolpert, dass XPSE eine ziemlich große Quelldatei von mir nicht mehr verarbeiten konnte. Variablen wurden plötzlich als nicht definiert gemeldet und andere "erratische" Probleme mehr. Ich könnte mir vorstellen, dass dies daran liegt, dass XPSE Schlüsselworte in Windows-Atoms verwaltet. Da ist irgendwann Schluss (bei irgendwas zwischen 60.000 und 70.000 Stück, wobei man bedenken muss, dass XPSE die Windows-API mit vorhält). Vielleicht ist es aber auch etwas ganz anderes, ich kann ja nicht in den "Maschinenraum" von XPSE schauen.

Jedenfalls blieb mir, da XPSE nicht mehr gepflegt wird, nichts anderes übrig, als das nachzubauen. Das Ergebnis ist JRPC3.

----- Features:

*vernünftige Meldung von Fehlern
*direkte Anzeige des Programmablaufes in XProfEd (sofern der unten erhältliche aufgebohrte XProfEd verwendet wird)
*Umsetzung der alten Profan-Syntax für Operatoren und alte Containerfunktionen
*extrem schnelle native fbPROCs, sofern man FreeBasic installiert hat (kostenlos, siehe Hilfe)
*mit fbPROCs kann zudem Inline-Assembler auch vor XProfan X4 realisiert werden
*extrem schnelle native pbPROCs, sofern man PureBasic installiert hat
*Echtzeitverfolgung von Variableninhalten
*einfache Zeitmessungen im Programmablauf
*Profan-Kompilerdirektiven funktionieren endlich vernünftig (z.B. Verschachtelung)
*eingebettete Variablen funktionieren auch mit Arrays
*die meisten WIN32-API-Funktionen sind bereits vordefiniert mitgeliefert
*API-Aufrufe über @external(...) werden automatisch in @call(...)-Aufrufe umgesetzt
*Einrückungsanalyse zum Finden von vertrackten Verschachtelungsfehlern
*Klammeranalyse zum Finden von vertrackten Klammerfehlern
*ENUMERATE-Funktionalität
*Assert zur Fehlerkontrolle
*es können beliebige DLLs in die XProfan-EXE integriert werden, sodass sie nicht mit ausgeliefert werden müssen (siehe {$WrapDll})
*einfaches Killen von mit JRPC3 gestarteten Programmen (interpretiert, .prc gestartet, .exe gestartet)
*extrem schnell (und daher natürlich nicht in XProfan geschrieben, da eine interpretierte Sprache hierfür naturgemäß viel zu langsam ist)
*beim Start von JRPC3 bereits vorhandene .prc-Dateien können zum Starten und Linken genutzt werden (es wird ein Hinweis angezeigt, dass es sich um ein altes Kompilat handelt)
*der Profan-Compiler kann zur Beschleunigung mit hoher Prozessorpriorität aufgerufen werden
*eingebauter Update-Checker mit Download, falls es ein Update gibt (Hilfe --> online nach Updates suchen)
*64- oder 32-bit-Version verfügbar (einfach JRPC3_64.exe oder JRPC_32.exe als Interpreter in XProfEd hinterlegen [Optionen --> Allgemeine Einstellungen] und JRPC3 mit F7 starten) - Achtung, die 64-bit-Version erzeugt natürlich keine 64-bit-XProfan-Programme, da XProfan das nicht kann, sondern JRPC3 selbst wird als 64-bit-Programm ausgeführt
*XProfan X4-Syntax verfügbar (möglicherweise noch nicht alles, da ich vermutlich nicht alles davon benutze, aber ich habe mich um Vollständigkeit bemüht - jedenfalls sind z.B. HASH-Arrays und QUADINTs dabei)
*Interpreter, PRCs und EXEs können mit Kommandozeilenparametern ausgeführt werden
*Interpreter, PRCs, EXEs und XPSE können mit Administratorrechten ausgeführt werden
*Prozeduren, die in dem aktuellen Programm zwar enthalten sind, aber nicht verwendet werden, werden aus der umgesetzten Datei entfernt, um die Dateigröße des Kompilats möglichst klein zu halten
*Variablen, die in dem aktuellen Programm zwar enthalten sind, aber nicht verwendet werden, werden aus der umgesetzten Datei entfernt, um die Dateigröße des Kompilats möglichst klein zu halten und den Speicherverbrauch zu optimieren
*nPROCs aus XPSE werden automatisch mit XPE zu einer DLL umgesetzt und die Aufrufe der nPROCs im Programm entsprechend angepasst, sofern XPSE vorhanden ist
*fast alles aus XPSE funktioniert auch in JRPC3 ({$NOERR}, {$(PRE)BATCH}, {$PUSHKEYWORD}, Interpreter, Runtime und Compiler festlegen, Shorties, ...)
*XProfEd_JR mit Quelltext-AutoComplete
*XProfEd_JR mit Quelltext-Memory-Funktion (Markierungen, zu denen zurückgesprungen werden kann)

Einschränkungen:
-kein XPSE-Inline-Assembler, wohl aber XProfan-Inline-Assembler (darin allerdings keine Prüfungen auf Korrektheit des Codes)
-ABER: man kann XPSE aus JRPC3 heraus aufrufen, sodass diese Funktionalität weiterhin verfügbar ist, sofern man XPSE besitzt (neuer Shorty: {$x})
-Variablen, die in einer Prozedur nicht deklariert sind, sondern "aus der aufrufenden Prozedur übernommen werden", sind standardmäßig nicht zugelassen (XProfan erlaubt das, aber so etwas ist genauso tödlich wie GOTO-Anweisungen). Bitte alle zu nutzenden Inputs als Parameter übergeben, und wenn etwas aus dem aufrufenden Programmteil verändert werden muss, beim Aufruf als Parameter z.B. @addr(x&) verwenden und in der Prozedur parameters x# und LONG x#,0=y& nutzen.
Wenn man aber unbedingt "vererbte" Variablen nutzen möchte, kann man dies mit der Kompilerdirektive {$Declare...} tun.

*als Hommage an XPSE lautet die Endung der Ausgabedatei ".enh3"

Eine genauere Erläuterung der einzelnen Features ist der chm-Hilfedatei zu entnehmen, die im Programm unter Hilfe --> Hilfedatei anzeigen oder mit F1 verfügbar ist.

----- /Features

Herunterladen und installieren:
JRPC3 kann unten heruntergeladen werden (setup_jrpc3.exe oder als ZIP-Datei).
Als Installationsverzeichnis bitte das XProfan-Stammverzeichnis angeben, also dasjenige, in dem die Dateien PROFAN.EXE, PROFCOMP.EXE, PRFRUN32.EXE etc. liegen. Alternativ kann die ZIP-Datei heruntergeladen und deren Inhalt manuell ins XProfan-Stammverzeichnis kopiert werden.

Einrichtung:
JRPC3_64.exe oder JRPC_32.exe als Interpreter in XProfEd hinterlegen [Optionen --> Allgemeine Einstellungen] und JRPC3 mit F7 starten.

Alle Befehle sind mit dem Befehl "h" wie "Hilfe" abrufbar und sollten selbsterklärend sein.

Für viele erweitere Features, die XProfEd betreffen, wie z.B. jenes, die Zeile, in der ein Fehler auftrat, direkt in XProfEd anzeigen zu können, ist der mitinstallierte XProfEd_JR erforderlich. Dafür muss man also XProfEd_JR.exe statt XProfEd.exe als Editor benutzen. Als "goody" gibt es dazu, dass beim Auf- und Zufalten von Programmen ein Fortschrittsanzeiger integriert ist (das kann bei großen Programmen ja bekanntlich ein bisschen dauern).

Es mag sein, dass noch nicht alles perfekt funktioniert. Ich bitte hierfür um Nachsicht. Meine  Programme lassen sich umsetzen, aber das muss noch lange nicht heißen, dass dies mit Programmen anderer Autoren, die jeder so ihre Eigenheiten haben, auch funktioniert.

Fehlermeldungen und Verbesserungsvorschläge gerne an jreumsc@web.de oder hier im Forum.

Beste Grüße, Jens-Arne

2.584 kB
Bezeichnung:JRPC3
Version:10.29
Kurzbeschreibung: JRPC3-Installer
Hochgeladen:15.02.2021
Ladeanzahl363
Herunterladen
1.699 kB
Bezeichnung:XProfEd_JR
Version:5.2
Kurzbeschreibung: Alte Version ohne AutoComplete zur Sicherheit
Hochgeladen:15.02.2021
Ladeanzahl224
Herunterladen
3.777 kB
Bezeichnung:JRPC3
Version:10.29
Kurzbeschreibung: ZIP-Datei statt Installer
Hochgeladen:02.04.2021
Ladeanzahl291
Herunterladen
 
XProfan X4 * Prf2Cpp * XPSE * JRPC3 * Win11 Pro 64bit * PC i7-7700K@4,2GHz, 32 GB RAM
PM: jreumsc@web.de
16.02.2021  
 



 
- Seite 12 -


« Dieser Beitrag wurde als Lösung gekennzeichnet. »

- Seite 15 -



Jens-Arne
Reumschüssel
Es gibt eine neue Version, die anders mit dem internen Messagehandling umgeht. Bitte probier die mal aus. Vielleicht ist das Problem damit behoben.
 
XProfan X4
XProfan X4 * Prf2Cpp * XPSE * JRPC3 * Win11 Pro 64bit * PC i7-7700K@4,2GHz, 32 GB RAM
PM: jreumsc@web.de
24.09.2022  
 




p.specht

Peter Specht oder Peter Funkheld?
Bin momentan mit Umbauarbeiten etwas unter Druck, aber mal sehen ...
 
XProfan 11
Computer: Gerät, daß es in Mikrosekunden erlaubt, 50.000 Fehler zu machen, zB 'daß' statt 'das'...
19.01.2022  
 




Jens-Arne
Reumschüssel
Oh, ja, Entschuldigung, Peter Specht, weil Du sagtest, dass Du Assembler brauchtest.

FreeBasic kann übrigens auch inline assembler. Könnte man also in fbProcs nutzen, wenn man wollte.
 
XProfan X4 * Prf2Cpp * XPSE * JRPC3 * Win11 Pro 64bit * PC i7-7700K@4,2GHz, 32 GB RAM
PM: jreumsc@web.de
19.01.2022  
 




Jens-Arne
Reumschüssel
Ich habe jetzt festgestellt, dass es unter den Hochsprachen schon deutliche Unterschiede gibt (und FreeBasic da bei den beiden, die ich getestet habe, erheblich besser abschneidet, was bei anderen Funktionen als einem bloßen Hochzählen von Variablen aber andersherum ausfallen kann).

Ich habe mit PureBasic und mit FreeBasic eine DLL erzeugt, die eine Integervariable in einer For-Schleife jeweils um eins erhöht, und zwar 100.000.000 Mal. Werte auf meinem Computer (siehe Footer):

FreeBasic braucht inklusive DLL-Funktionsaufruf etwa 150ms.
PureBasic braucht inklusive DLL-Funktionsaufruf etwa 200ms.
XProfanX4 braucht kompiliert etwa 55.000ms (also 55 Sekunden).

Der letzte Wert sagt einem schon, was man gewinnt, wenn man native Funktionen verwendet. Ob einem handgeschriebenes Assembler da noch so viel bringt, wird der Test von Peter (S.) zeigen. Ich bin gespannt.

EDIT:
Habe noch C++ mit Borland 5.5-Compiler ausprobiert. Und siehe da: 45ms. Oh je... Dann ist "richtiges" Assembler sicher deutlich schneller als PureBasic und FreeBasic.

EDIT2:
Am schlechtesten schneidet erstaunlicherweise XPSE mit nProc ab: 360ms. Ich glaube, das liegt gar nicht so sehr an der Ausführungsgeschwindigkeit der Routine, sondern daran, wie nProcs aufgerufen werden. Genau das war ja auch das Problem, die in JRPC3 zu integrieren. Aber ich kann mich auch irren, vielleicht ist es doch der erzeugte Maschinencode an sich.

EDIT3:
Interessant wäre nach Edit2 also wohl auch einmal ein Vergleich zwischen XPSE-Inline-Assembler und XProfan-Inline-Assembler.

Hier die XProfan-Routine, die ich zum Testen benutzt und jeweils an die Sprachen angepasst habe:
declare i%,a%
a%=0
for i%,1,100000000
inc a%
endfor
 
XProfan X4 * Prf2Cpp * XPSE * JRPC3 * Win11 Pro 64bit * PC i7-7700K@4,2GHz, 32 GB RAM
PM: jreumsc@web.de
19.01.2022  
 




funkheld
Hallo Jens-Arne es sind Einhundertmillion die du geschrieben hast.
Und die Leistung von FreeBasic ist "Top" dabei.

Stell dir vor wir müssen 1Million rumschupsen mit unseren Heimwerkerprogrammen, was das bedeutet was wir da dann schon feines Programmiert haben in Xprofanx4.

Da braucht man noch nicht einmal eine Inline-ASM.
Wenn du dann noch ASM-Sprünge zählst zu bestimmten Adressen , da geht dann sogar das reine ASM in die Knie. Und die Sprünge über 128 quälen dass ASM noch mehr.

Da brauchts du in Xprofanx4 nur einen falschen Sprung machen mit einer While/For usw , "peng"
ist alles dahin.

Also für mich ist die FreeBasic-Leistung in XProfanx4 das Feinste vom Feinen.

FreeBasic :
--------------------------------------------
1000000 mal : a= sin(b)* 3.145678 / 0.345
Mehrmal gestoppt mit ca 43 Millisekunden
--------------------------------------------

So etwas könnte man in ASM probieren.

Gruss
 
19.01.2022  
 




p.specht

Oder macht doch mal das da: Randwert-Matrix erzeugen  [...] 
oder gleich eine echte xpse-Matrixmultiplikation  [...] 
 
Computer: Gerät, daß es in Mikrosekunden erlaubt, 50.000 Fehler zu machen, zB 'daß' statt 'das'...
19.01.2022  
 




funkheld
Danke für die Info.

Da ich jetzt dieses FreeBasic als Verstärkung für das XProfanx4 nehme habe ich bei mir XPIA und XPSE von der Liste gestrichen.

Gruss
 
20.01.2022  
 




Jens-Arne
Reumschüssel
Hallo zusammen,

fbPROCs: Bei der Nutzung von Headerdateien (*.ph) wurden die vordefinierten und insbesondere die mit SharedInFbProcs gepushten XProfan-Variablen an falschen Stellen an die FreeBasic-DLL übergeben (im schlimmsten Fall gar nicht oder mitten in einer XProfan-PROC). Das ist jetzt behoben.

Nach der letzten Header-Datei ($H xxx.ph) muss zwingend mindestens eine globale Variable definiert werden (nicht notwendigerweise gepusht), da die letzte globale Variablendefinition der Startpunkt für die Variablenübergabe an die FreeBasic-DLL ist und das nach der letzten Headerdatei passieren muss. Am einfachsten ist es, wenn man immer erst alle Include- und Headerdateien definiert und dann erst die globalen Variablen für das XProfan-Programm.

Bei den vordefinierten XProfan-Variablen ist der Fehler vermutlich nicht aufgefallen, weil die bei jedem cls und window neu übergeben werden (also ziemlich sicher nach der letzten Header-Datei), weil z.B. %HWnd vor dem ersten cls/window keinen definierten Inhalt besitzt.

Gruß, Jens-Arne
 
XProfan X4
XProfan X4 * Prf2Cpp * XPSE * JRPC3 * Win11 Pro 64bit * PC i7-7700K@4,2GHz, 32 GB RAM
PM: jreumsc@web.de
07.04.2022  
 




funkheld
Nach langer Zeit , danke für deinen Tip.

Was gibt es bitte neues auf der FreeBasic-Bühne ?

Danke.
Gruss
 
17.05.2022  
 




Jens-Arne
Reumschüssel
Anscheinend nicht viel... Daher habe ich mal ein Beispiel für selbst gezeichnete Buttons mittels OwnerDraw gebaut, das ohne Profan-Subclassing arbeitet (daher ist kein fastmode nötig) und als Subclassing-Prozedur eine fbPROC benutzt, damit es schön schnell geht.

'Ownerdrawn Buttons

declare _ende%
declare _hBrushNormal%,_hBrushClick%,_hBrushHover% SharedInFbProcs
declare _hPenNormal%,_hPenClick%,_hPenHover%,_hPenFocus%,_hF% SharedInFbProcs
declare _hB1%,_hB2%,_hB3%,_pMousetracking%,_pOB%,_AnzOwnerDrawButtons%,_pODBClicked% SharedInFbProcs
declare _MouseTracking%[100],_hODB%[100],_ODBClicked%[100]
declare hash _nODB[]
declare _hScDll&

'{ 'FreeBasic-Routinen
{$fbSYNTAX on}
{$SETFBDLLNAME ODButtons}

{$PUSHFBDLLGLOBALLINE Dim Shared As Any Ptr hComctl32}
{$PUSHFBDLLGLOBALLINE Dim Shared DefSubclassProc As Function (ByVal As HWND,ByVal As Integer,ByVal As WPARAM,ByVal As LPARAM) As Integer}

fbPROC fbInit() As Integer Export
hComctl32=DyLibLoad("Comctl32.dll")
DefSubclassProc=DyLibSymbol(hComctl32,"DefSubclassProc")
return 0
ENDPROC 'fbinit

fbPROC fbDeInit() As Integer Export
DyLibFree(hComctl32)
return 0
ENDPROC 'fbDeinit

fbPROC fbRePaintWindow(ByVal hW As Integer,ByVal bkmode As Integer) As Integer
'bkmode: 1=Hintergrund wird neu gezeichnet, 0=Hintergrund wird in Ruhe gelassen (weiß aber nicht, ob BOOL wirklich auch 4 Bytes hat, das steht im MSDN nicht drin)
dim As Byte Pointer b,wr
b=Allocate(6*4)
wr=Allocate(4*4)
GetWindowRect(hW,wr)
poke Integer,b+0,hW 'long b#,0=hW&
poke Integer,b+4,0 'long b#,4=0
poke Integer,b+8,0 'long b#,8=0
poke Integer,b+12,peek(Integer,wr+8)-peek(Integer,wr+0) 'long b#,12=@width(hW&)
poke Integer,b+16,peek(Integer,wr+12)-peek(Integer,wr+4) 'long b#,16=@height(hW&)
poke Integer,b+20,bkmode 'long b#,20=bkmode&
InvalidateRect(hW,b,0)
DeAllocate(b)
DeAllocate(wr)
ENDPROC 'fbRePaintWindow

fbPROC fbSubClassProc(ByVal sWnd As Integer,ByVal sMessage As Integer,ByVal swParam As Integer,ByVal slParam As Integer,ByVal uIdSubclass As Integer Pointer,ByVal dwRefData As Integer) As Integer Export
dim CallOrigWndProc As Integer
dim s as Byte Pointer
dim r as RECT
'dim DIS as DRAWITEMSTRUCT 'DRAWITEMSTRUCT=CtlType&,CtlID&,itemID&,itemAction&,itemState&,hwndItem&,hDC&,rcItemX1&,rcItemY1&,rcItemX2&,rcItemY2&,itemData&
dim TME as TRACKMOUSEEVENT 'TRACKMOUSEEVENT=cbSize&,dwFlags&,hwndTrack&,dwHoverTime&
dim as integer i,num,weiter,erg,hDC
erg=0
weiter=0
CallOrigWndProc=1
'{ 'WM_MOUSEMOVE
if smessage=WM_MOUSEMOVE
for i=1 to _AnzOwnerDrawButtons%
if swnd=peek(integer,_pOB%+(i*4))
num=i
weiter=1
exit for
endif
endfor
if weiter
'CallOrigWndProc=0
if peek(integer,_pMouseTracking%+(num*4))=0
'beep
TME.cbSize=16
TME.dwFlags&=TME_LEAVE
TME.hwndTrack=sWnd
TME.dwHoverTime=HOVER_DEFAULT
TrackMouseEvent(@TME)
poke integer,_pMouseTracking%+(num*4),1
fbrepaintwindow(sWnd,0)
endif
endif
'}
'{ 'WM_MOUSELEAVE
elseif smessage=WM_MOUSELEAVE
for i=1 to _AnzOwnerDrawButtons%
if swnd=peek(integer,_pOB%+(i*4))
num=i
weiter=1
exit for
endif
endfor
if weiter
'CallOrigWndProc=0
poke integer,_pMouseTracking%+(num*4),0
fbrepaintwindow(sWnd,0)
endif
'}
'{ 'WM_LBUTTONUP
elseif smessage=WM_LBUTTONUP
for i=1 to _AnzOwnerDrawButtons%
if swnd=peek(integer,_pOB%+(i*4))
num=i
weiter=1
exit for
endif
endfor
if weiter
poke integer,_pODBClicked%+(num*4),1
endif
'}
endif
if swnd=%HWnd
if smessage=WM_DRAWITEM
'in slparam ist der Pointer auf die DRAWITEMSTRUCT-Struktur gespeichert
if peek(Integer,slparam+0)=ODT_BUTTON
for i=1 to _AnzOwnerDrawButtons%
if peek(Integer,slparam+20)=peek(integer,_pOB%+(i*4))
num=i
weiter=1
exit for
endif
endfor
if weiter
hDC=peek(Integer,slparam+24)
SetBkMode(hDC,TRANSPARENT)
if (peek(Integer,slparam+16) and ODS_SELECTED)=0
if peek(integer,_pMouseTracking%+(num*4))=0 'bedeutet, dass der Mauszeiger nicht über dem Button steht (denn sonst würde die Maus getrackt, bis sie den Button verlässt)
selectobject(hDC,_hBrushNormal%)
selectobject(hDC,_hPenNormal%)
SetBkColor(hDC,rgb(200,200,200))
else
selectobject(hDC,_hBrushHover%)
selectobject(hDC,_hPenHover%)
SetBkColor(hDC,rgb(100,100,255))
endif
else
selectobject(hDC,_hBrushClick%)
selectobject(hDC,_hPenClick%)
SetBkColor(hDC,rgb(255,0,0))
endif
if (peek(Integer,slparam+16) and ODS_FOCUS)<>0
selectobject(hDC,_hPenFocus%)
endif
rectangle(hDC,peek(Integer,slparam+28),peek(Integer,slparam+32),peek(Integer,slparam+36),peek(Integer,slparam+40))
selectobject(hDC,_hF%)
r.left=peek(Integer,slparam+28)
r.top=peek(Integer,slparam+32)
r.right=peek(Integer,slparam+36)
r.bottom=peek(Integer,slparam+40)
s=Allocate(1002)
sendmessage(peek(Integer,slparam+20),WM_GETTEXT,1000,s)
drawtext(hDC,s,-1,@r,DT_SINGLELINE or DT_CENTER or DT_VCENTER)
DeAllocate(s)
CallOrigWndProc=0
endif
endif
endif
endif
if CallOrigWndProc<>0
return DefSubclassProc(sWnd,sMessage,swParam,slParam)
else
return erg
endif
ENDPROC 'fbSubClassProc
'}

PROC CreateODB
parameters hWparent%,text$,x1%,y1%,x2%,y2%
declare hODB%
hODB%:=~CreateWindowEx(0,"Button",text$,~WS_CHILD | ~WS_TABSTOP | ~BS_OWNERDRAW,x1%,y1%,x2%,y2%,hWparent%,0,%HInstance,0)
if hODB%
inc _AnzOwnerDrawButtons%
_hODB%[_AnzOwnerDrawButtons%]:=hODB%
_nODB[@str$(hODB%)]=_AnzOwnerDrawButtons%
@external("Comctl32.dll","SetWindowSubclass",hODB%,@external("kernel32.dll","GetProcAddress",_hScDll&,"FBSUBCLASSPROC@24"),577,1) 'Button subclassen (für Hover-Aktionen)
showwindow(hODB%,1) 'darf erst hier kommmen, weil erst hier das Owner-Drawing durch Subclassing abgedeckt ist
endif
return hODB%
ENDPROC 'CreateODB

PROC DestroyODB
parameters hB%
@external("Comctl32.dll","RemoveWindowSubclass",hB%,@external("kernel32.dll","GetProcAddress",_hScDll&,"FBSUBCLASSPROC@24"),577) 'Button-Subclassing beenden
_nODB[@str$(hB%)]=0
@destroywindow(hB%)
ENDPROC 'DestroyODB

PROC ODBClicked
parameters hB%
if _odbclicked%[_nODB[@str$(hB%])]
_odbclicked%[_nODB[@str$(hB%])]:=0
return 1
else
return 0
endif
ENDPROC 'ODBClicked


'{ ' *** Hauptprogramm
usermessages $10
windowstyle 1+2+4+8+512
window 500,400
@fbinit()
_AnzOwnerDrawButtons%:=0
_MouseTracking%[1]:=0
_MouseTracking%[2]:=0
_pMouseTracking%:=@addr(_MouseTracking%[0])
_pOB%:=@addr(_hODB%[0])
_pODBClicked%:=@addr(_ODBClicked%[0])
_hBrushNormal%:=~createsolidbrush(@rgb(200,200,200))
_hBrushClick%:=~createsolidbrush(@rgb(255,0,0))
_hBrushHover%:=~createsolidbrush(@rgb(100,100,255))
_hPenNormal%:=~createpen(~PS_SOLID,3,@rgb(200,200,200))
_hPenClick%:=~createpen(~PS_SOLID,3,@rgb(255,0,0))
_hPenHover%:=~createpen(~PS_SOLID,3,@rgb(100,100,255))
_hPenFocus%:=~createpen(~PS_SOLID,3,@rgb(0,0,0))
_hF%:=@create("FONT","Times New Roman",18,0,1,1,0)
_hScDll&:=@usedll("ODButtons.dll")
@external("Comctl32.dll","SetWindowSubclass",%HWnd,@external("kernel32.dll","GetProcAddress",_hScDll&,"FBSUBCLASSPROC@24"),577,1) '%HWnd subclassen (darin wird WM_DRAWITEM verarbeitet)
_hB1%:=createodb(%HWnd,"Testbutton 1 (Ende)",10,10,150,30)
_hB2%:=createodb(%HWnd,"Testbutton 2",190,10,150,30)
_hB3%:=@create("BUTTON",%HWnd,"normaler Button",10,70,150,30)
'{ 'Eingabehandling
_ende%:=0
whilenot _ende%
waitinput
if @iskey(27) or (%umessage=$10) or @odbclicked(_hB1%)
_ende%:=1
endif
endwhile
'}
@external("Comctl32.dll","RemoveWindowSubclass",%HWnd,@external("kernel32.dll","GetProcAddress",_hScDll&,"FBSUBCLASSPROC@24"),577) '%HWnd-Subclassing beenden
DestroyODB(_hB1%)
DestroyODB(_hB2%)
deleteobject _hBrushNormal%
deleteobject _hBrushClick%
deleteobject _hBrushHover%
deleteobject _hPenNormal%
deleteobject _hPenClick%
deleteobject _hPenHover%
deleteobject _hPenFocus%
deleteobject _hF%
freedll _hScDll&
@fbdeinit()
end
'}
 
XProfan X4
XProfan X4 * Prf2Cpp * XPSE * JRPC3 * Win11 Pro 64bit * PC i7-7700K@4,2GHz, 32 GB RAM
PM: jreumsc@web.de
19.06.2022  
 




funkheld
Hallo, guten Tag.

Danke für deine schöne Demo.

Gruss
 
20.06.2022  
 




Jens-Arne
Reumschüssel
Version 7.00

Die neue Version von JRPC3 entfernt deklarierte, aber nicht genutzte Variablen aus dem umgesetzten Programm (kann mit {$NOVAREXCLUDE} ausgeschaltet werden. Bitte sichert Euch die alte Version, da hiermit ein ziemlich großer Eingriff in den Code verbunden ist, der leider wie immer fehlerträchtig ist. Ich habe getestet, so gut ich konnte, aber man weiß ja nie.

Dieses neue Feature ist insbesondere sinnvoll, wenn man große Funktionsbibliotheken in einer INC-Datei zusammenfasst, wovon man später oft nur ganz wenige Funktionen in einem gegebenen Programm nutzt.

Die Startzeit von Programmen, aus denen ein großer Überhang von nutzlosen globalen Variablen entfernt wurde, verringert sich spürbar. Der Speicherverbrauch sieht natürlich ebenfalls viel besser aus.

Struktur- und Klassenvariablen werden nicht entfernt, auch wenn sie nicht benutzt werden.

Beste Grüße, Jens-Arne
 
XProfan X4 * Prf2Cpp * XPSE * JRPC3 * Win11 Pro 64bit * PC i7-7700K@4,2GHz, 32 GB RAM
PM: jreumsc@web.de
26.06.2022  
 




Jens-Arne
Reumschüssel
Version 7.03

Es werden nun auch mit DEF definierte API-Funktionen in external-Aufrufe konvertiert und damit, sofern nicht ausgeschaltet, in call-Aufrufe umgesetzt.

Das Feature kann mit {$NODEF2EXTERNALCONVERSION} ausgeschaltet werden.
 
XProfan X4
XProfan X4 * Prf2Cpp * XPSE * JRPC3 * Win11 Pro 64bit * PC i7-7700K@4,2GHz, 32 GB RAM
PM: jreumsc@web.de
17.07.2022  
 




Antworten


Thementitel, max. 100 Zeichen.
 

Systemprofile:

Kein Systemprofil angelegt. [anlegen]

XProfan:

 Beitrag  Schrift  Smilies  ▼ 

Bitte anmelden um einen Beitrag zu verfassen.
 

Themenoptionen

62.598 Betrachtungen

Themeninformationen



Admins  |  AGB  |  Anwendungen  |  Autoren  |  Chat  |  Datenschutz  |  Download  |  Eingangshalle  |  Hilfe  |  Händlerportal  |  Impressum  |  Mart  |  Schnittstellen  |  SDK  |  Services  |  Spiele  |  Suche  |  Support

Ein Projekt aller XProfaner, die es gibt!


Mein XProfan
Private Nachrichten
Eigenes Ablageforum
Themen-Merkliste
Eigene Beiträge
Eigene Themen
Zwischenablage
Abmelden
 Deutsch English Français Español Italia
Übersetzungen

Datenschutz


Wir verwenden Cookies nur als Session-Cookies wegen der technischen Notwendigkeit und bei uns gibt es keine Cookies von Drittanbietern.

Wenn du hier auf unsere Webseite klickst oder navigierst, stimmst du unserer Erfassung von Informationen in unseren Cookies auf XProfan.Net zu.

Weitere Informationen zu unseren Cookies und dazu, wie du die Kontrolle darüber behältst, findest du in unserer nachfolgenden Datenschutzerklärung.


einverstandenDatenschutzerklärung
Ich möchte keinen Cookie