• Zitat


    Der Programmierer von XPSE ist derzeit verschollen...

    Hmmm.., die Arbeitstelle einfach so verlassen... :(
    Er hat doch eigentlich viel Zeit in sein XPSE-Projekt gesteckt.
    Die Fahnenflucht verstehe ich nicht...?

    Bei XPIA wird ja der MASM nicht mehr gebraucht.
    Dann werden ja die speziellen 64Bit-Befehle in den ASM-Routinen nicht umgesetzt mit XPIA ?

    Zitat


    wären unter 64bit native schnelle 64bit-API-Routinen verwendbar, ein leistungsfähigeres und mit mehr Registern ausgestattetes CPU-Modell...


    Die neuen Register würde ich dann auch gerne mit XPIA nutzen.
    Wird diese Baustelle denn weitergehen? Wenn ja wann ...?

    Ich möchte bei vielen Projekten nicht nur mit der reinen Runtime arbeiten, außer wenn Roland es schafft reine EXE-Dateine zu produzieren, die ohne Runtime auskommen im 64Bit-System.

    Danke.
    Gruss

    2 Mal editiert, zuletzt von funkheld (29. März 2014 um 09:26)

    • Anzeige

    Hallo!

    Wenn du gerade an deiner Website arbeitest oder dein aktuelles Hosting überdenkst: Wir betreiben mit NetzLiving eine Hosting-Plattform, die speziell auf Performance, Sicherheit und einfache Verwaltung ausgelegt ist.

    • ✔️ Schnelle Ladezeiten (optimiert für WordPress, WoltLab & Co.)
    • ✔️ Deutsche Server & DSGVO-konform
    • ✔️ Persönlicher Support (kein 0815-Ticket-System)

    Mehr erfahren

  • FreeProfan32 ohne Runtime? Erde an Mars?


    Folgendes ist hier zwar im falschen Forums-Teil, aber nötig zur Klarstellung bzgl. Preprozessoren:

    Erstens: Der XPIA-Preprocessor (Programmierer: Frank Abbing aka frabbing, oft online weil hier Admin) benötigt selbstverständlich auch JWasm, sobald du ASMSTART/ASMEND und dazwischen Maschinensprache verwenden willst. XPIA hat daneben ca. 25000 Symbolwerte von Windows eingespeichert und kann Inline-Assemblercode automatisch in dein Programm einfügen. Via Net wird XPIA nach meinem Kenntnisstand nicht mehr angeboten, erlaubt aber händisch optimierte, höllisch schnelle Algorithmen zu implementieren.

    Wir sprachen aber von...

    Zweitens: xpse (Programmierer David Strutz aka "iF", dzt. anderweitig beschäftigt - aka "verschollen", aber keineswegs "fahnenflüchtig") hat ein anderes Forum - Details siehe dort. Es handelt sich zwar ebenfalls um einen Preprocessor, der auf den Profan-Sourcetext arbeitet. Für sogenannte "native" (= eigene) Befehle ("nProc") verwendet xpse ebenfalls JWasm, weil Microsofts MASM seit Version 9 nicht mehr als "freeware" verfügbar ist. Der Programmierer hat dabei aber seine eigenen Wünsche, etwa dass man XProfan stark in Richtung C/C++ weiterentwickeln möge, in xpse eingebracht, damit aber gleichzeitig eine Art Insellösung mit deutlich anderen Sprachregeln geschafften. Die muß man erst mal lernen, Vorteil ist, daß xpse-nProcs dann trotz Hochsprachennähe nur wenig langsamer als optimierter Assemblercode ist.

    Die Frage nach einem 64bit-xpse habe ich vor ca. 2 1/2 Jahren gestellt, damals wurde eine vorsichtige Zusage gegeben, die aber mangels breiter (u.a. finanzieller??) Unterstützung durch die Profan-Gemeinde vermutlich noch länger auf Eis liegt.


    Drittens: Als weitere Beschleunigungsmöglichkeit existieren für frühere Profan-Versionen auch noch einige ältere entgeltliche bzw. Shareware-Preprozessoren, z.B. Profan2CPP, diverse Ressourcenmanager etc.

    Gruss

    P.S.: Die beiden Preprozessoren (beide 32 bit) sind derzeit ebenso wie deren Programmierer*) nicht kompatibel ;)
    _____
    *) Dass deshalb in xpse und XPIA Befehle wie HSC (Halt and set on fire) und XCPR (Execute programmer) eingebaut wurden, bleibt mein unbestätigtes Gerücht :D

    HP255G7:Win10pro2.004,4*AMD Ryzen3200U@2.60GHz,6+2GB-RadeonVega/237GBSSD:intlDVDRW,3xUSB3 ext4TB-HDX,XProfanX3+Xasm/Xpse

    6 Mal editiert, zuletzt von p. specht (29. März 2014 um 20:13)

  • Profan2CPP
    Der ist jetzt mit den vielen neuen Befehlen im FreeProfan32 ins alter gekommen und wird manchmal Bockig. Wird ja nicht mehr angepasst. Auch XPSE scheitert mit den neu hinzugekommenden Befehlen von FreeProfan32, wird nicht angepasst.

    Bleibt nur noch XPIA übrig ...., ist eine gute Lösung für das Profan, sollte nicht vernachlässigt werden.

    FreeProfan32 ohne Runtime? Erde an Mars?
    Man schleppt beim kleinsten Programm 2MB mit.

    Danke.
    GRuss

  • Als .PRC kompilierte Profanprogramme teilen sich alle diese Runtime, das spart viel Platz! Ausserdem kann jede beliebige XProfan-EXE einer .PRC-Datei als Runtime dienen! Ist doch super!
    Gruss

    P.S.: Wenn ich ab sofort ohne zu schlafen stündlich ein XProfan-Programm (2 MB kompiliert) schreibe, geht mir doch glatt in 57 Jahren der Plattenplatz aus! Zugegeben, bei Mikroprozessoren sieht das natürlich anders aus.

    HP255G7:Win10pro2.004,4*AMD Ryzen3200U@2.60GHz,6+2GB-RadeonVega/237GBSSD:intlDVDRW,3xUSB3 ext4TB-HDX,XProfanX3+Xasm/Xpse

  • @MoveStrToList() funktioniert nicht richtig.

    Bringt in der FreeProfan32 - Version nur ein Eintrag.
    Sowohl in der ListboxListe als auch im Funktionsergebnis.
    In den anderen Versionen (X64 + Vollversion) ist das
    Ergebnis auch falsch.
    Dort bringt die Funktion 5 statt 3, wie im obigen Code.

    Nachtrag :

    scheint wohl eher am Bereich# zu liegen.

    Code
    Declare a$
    Cls
    ClearList 0
    a$ = "Hallo ,du ,da !"
    Print @MoveStrToList(a$, ",")
    @Listbox$("", 1)
    Waitkey
    End

    Trotzdem müßte hier 3 statt 2 als Funktionsergebnis

    rauskommen.

    Wir sind die XProfaner.

    Sie werden von uns assimiliert.

    Widerstand ist zwecklos!

    Wir werden alle ihre Funktionen und Algorithmen

    den unseren hinzufügen.

    Einmal editiert, zuletzt von H.Brill (17. August 2014 um 08:20)

  • Das Funktionsergebnis ist nicht richtig. Char$(Mem, Start, Anzahl) liest ja ab Start die vorgegebene Anzahl Zeichen, also auch mehrere nachfolgende Nullbytes. Die liefern dann jeweils einen Leerstring. Ich habe die Funktion nochmal etwas abgeändert:

    Code
    Def @MoveMemToList(2) @MoveStrToList(Trim$(Char$(@&(1), 0, @&(2))), Chr$(0))


    Nun stimmt der Rückgabewert. Trim$ schneidet überflüssige Nullbytes aus dem mit Char$ gelesenen String ab. Was bleibt, ist in FreeProfan32 ein Rückgabewert 0 und nur der erste Teilstring wird übertragen. Die Funktion scheint beim ersten Nullbyte einfach abzubrechen. Stringzerlegung an Leerzeichen funktioniert.

    Gruß Volkmar

  • Es ist soweit: FreeProfan ist auf den Stand von XProfan X3 angehoben worden. Die aktuelle Betaversion ist 0.9 und wird hoffentlich demnächst zur überfälligen 1.0!

    Viel Spaß beim Ausprobieren.

    Nähere Infos hier im letzten Beitrag: FreeProfan32 + 64

    Gruß
    Roland

    Fujitsu Esprimo G5011 - Intel Core i5-10500T / 16 GB RAM / 500 + 2000 GB SSD / Windows 11pro - XProfan X4a

    Als Backup: Molegar Notebook - Intel Celeron N5095 / 16 GB RAM / 1000 GB HDD / Windows 11pro - XProfan X4a

    http://www.xprofan.de

  • Warum läuft dieser Code mit Franks Listview.dll in FreeProfan32 nicht ?

    Läuft prima in der aktuellen X3.
    ImportDLL erzeugt mal ein gültiges Handle.
    Ab CreateListview() kracht es.
    Hab noch eine andere Version, in der ein Fenster mit Create("Window",...) erzeugt
    wurde und dieses Handle bei der DLL verwendet wird. Da scheint es zu gehen.
    Von daher habe ich %HWnd in Verdacht.

    Oder gibt es da bei Freeprofan Einschränkungen, die nicht in der Hilfe stehen ?

    Wir sind die XProfaner.

    Sie werden von uns assimiliert.

    Widerstand ist zwecklos!

    Wir werden alle ihre Funktionen und Algorithmen

    den unseren hinzufügen.

  • Habe den Fehler gefunden.
    Eine Bereichsvariable wurde zu klein dimensioniert.
    (statt 16 Bytes nur 12 Bytes für 3 Stringadressen).

    Da bei FreeProfan keine anständige Fehlermeldung kommt,
    außer daß der Integer Speicher erschöpft ist, muß man halt
    etwas suchen bzw. Breakpoints setzen.

    Was bei den Versionen X2 und X3 funktioniert hat, braucht
    nicht unbedingt bei FreeProfan zu funktionieren.

    Warum dem so war, muß ich noch rausfinden.
    Vielleicht geben die Move - Funktionen andere
    Werte zurück, als in der X3 Vollversion.

    Wir sind die XProfaner.

    Sie werden von uns assimiliert.

    Widerstand ist zwecklos!

    Wir werden alle ihre Funktionen und Algorithmen

    den unseren hinzufügen.


  • Da bei FreeProfan keine anständige Fehlermeldung kommt,
    außer daß der Integer Speicher erschöpft ist, muß man halt
    etwas suchen bzw. Breakpoints setzen.

    So eine Fehlermeldung gibt es in XProfan oder FreeProfan nicht. Welche Entwicklungsumgebung nutzt Du?

    Gruß
    Roland

    Fujitsu Esprimo G5011 - Intel Core i5-10500T / 16 GB RAM / 500 + 2000 GB SSD / Windows 11pro - XProfan X4a

    Als Backup: Molegar Notebook - Intel Celeron N5095 / 16 GB RAM / 1000 GB HDD / Windows 11pro - XProfan X4a

    http://www.xprofan.de

  • Ich nutze den XProfEd vom 30.6.2015.

    Mich hat ja nur gewundert, daß der gleiche Code in
    X2 und in X3 problemlos läuft und in der FreeProfan
    Version nicht.

    Es sind ja keine Sachen im Code, die FreeProfan nicht
    unterstützt.

    Es ist ja auch denkbar, daß FreePascal/Lazarus bestimmte
    Dinge, wie z.B. Speicherverwaltung, etwas anders behandelt.

    Wie gesagt, da muß ich mal durchtesten.

    Wir sind die XProfaner.

    Sie werden von uns assimiliert.

    Widerstand ist zwecklos!

    Wir werden alle ihre Funktionen und Algorithmen

    den unseren hinzufügen.

  • Habe den Fehler gefunden.
    Eine Bereichsvariable wurde zu klein dimensioniert.
    (statt 16 Bytes nur 12 Bytes für 3 Stringadressen).

    Ist der Bereich zufälligerweise zugewiesen, in den geschrieben werden soll, passiert kein Fehler. Ob ein Fehler passiert oder nicht, hängt natürlich auch von der Sprache ab, mit der die XProfanversion programmiert wurde.
    Nicht immer passiert ein Fehler, wenn Bereiche falsch dimensioniert sind. Das hatten wir hier schon: XProfan-Programme starten nicht...

    Ob ein Bereich falsch dimensioniert ist, fällt allerhöchsten beim Debuggen auf - das aber nur, wenn auch wirklich ein Fehler passiert, der Bereich also nicht zufälligerweise zugewiesen ist, in den da geschrieben werden soll. Wie soll eine Programmiersprache zuverlässig feststellen, ob du was falsch dimensionierst?

    Beispiel:
    Deine Struktur ist 20 Bytes groß - du reservierst aber nur 16 Bytes.
    Die Reservierung (Zuweisung) erfolgt mal an Adresse 0x28471B0.
    Bis Adresse 0x28471C0 ist dann was reserviert für deine Struktur. Jetzt kann es aber sein, dass Adresse 0x28471C0 bis 0x28471D0 zum Beispiel bereits anderweitig verwendet wird. Ist das der Fall, überschreibt deine Struktur andere Daten und es passiert nicht unbedingt ein Fehler. Es passoert erst auf jeden Fall ein Fehler, wenn der Speicher ab Adresse 0x28471C0 gar nicht genutzt wird. Virtueller Speicher, der nicht genutzt wird, ist keinem realem Speicherblock zugeordnet - er ist nicht zugewiesen. In Speicher, der keinem realem Block zugeordnet ist, kann nichts geschrieben werden. Es passiert eine Zugriffsverletzung. Ist der Nachfolgende Block mit MEM_COMMIT zugewiesen, passiert erst mal nichts.

    Ich hoffe, das ist so verständlich.

    Hier Code dazu:

    Code: Speicherüberlauf.prf
    Declare Bereich#, Zahl&, Zahl2&
    DIM Bereich#,2
    Zahl& = $FFFFFFFF ' = -1
    Zahl2& = 0
    External("Kernel32", "RtlMoveMemory", Bereich#, addr(Zahl&), 4) '4 Bytes werden in einen Bereich geschrieben, der mit 2 Bytes dimensioniert wurde.
    External("Kernel32", "RtlMoveMemory", addr(Zahl2&), Bereich#, 4) 'Vier bytes werden in eine Zahl zurückgeschrieben.
    Print Zahl2&
    waitinput

    Zuweisungen erfolgen übriegens nicht in Form von Bytes, sondern von Speicherseiten (sind in der Regel 4KB groß).
    Das nachfolgende Bereiche also bereits in Verwendung sind und Fehldimensionierungen gar nicht auffallen, ist gar nicht so unwahrscheinlich. Das nur am Rande.

    3 Mal editiert, zuletzt von AxT (5. Dezember 2015 um 09:15)

  • So genau wollte ich das gar nicht wissen, bzw. interessiert
    wohl auch keinen Einsteiger, was dahinter passiert.

    Daß man bei den Bereichen aufpassen muß, bzw. richtig
    dimensionieren muß, ist mir natürlich klar.

    Aber ich hatte ja nichts Sonderliches gemacht :
    Im Hauptprogramm einen Bereich deklariert und
    mit Dim 12 Bytes für 3 Stringaddressen dimensioniert.

    Da ein Long 4 Bytes groß ist (3 x 4 = 12) sollten 12
    Bytes genügen. Anders sieht es bei Strings aus, da
    man dort das Nullbyte mitrechnen muß.

    Wenn man die Größen der Zahlenwerte kennt
    (Word, Long, Int usw.) sollte es ja reichen.

    Mehr muß man ja auch nicht als Nutzer von XProfan
    darüber wissen. Wie Roland bzw. Windows das verwaltet,
    ist mir egal. Hauptsache, es funktioniert so, wie auch in
    der Hilfe beschrieben.

    Wir sind die XProfaner.

    Sie werden von uns assimiliert.

    Widerstand ist zwecklos!

    Wir werden alle ihre Funktionen und Algorithmen

    den unseren hinzufügen.

    Einmal editiert, zuletzt von H.Brill (5. Dezember 2015 um 11:13)

  • So genau wollte ich das gar nicht wissen, bzw. interessiert
    wohl auch keinen Einsteiger, was dahinter passiert.

    Warum eigene Fehler gar keine Fehler produzieren müssen, sollte man schon wissen. Ansonsten sucht man sie (wie du) erst mal ganz wo anders, wenn sie denn durch Zufall doch passieren.

    Sich für Fehler, die man macht, nicht ausgesprochen stark zu interessieren, halte ich für falsch - früher oder später rächt sich das im Leben.

    Eine Bereichsvariable wurde zu klein dimensioniert.
    (statt 16 Bytes nur 12 Bytes für 3 Stringadressen).

    Für 3 Stringadressen reichen 12 Bytes unter 32Bit aus. Der Fehler dürfte an einer anderen Ecke liegen. Ohne Code lässt sich das aber nicht sagen - womit wir wieder an der Ecke sind.
    Aus dem was oben steht folgt auch, dass Fehler eventuell auch erst später zu einem Fehlverhalten des Programms führen können (oder, wie gesagt, gar kein Fehlverhalten produzieren).
    Um das zu durchblicken, muss man sich aber für Sachen interessieren - ansonsten bleibt man eben hilflos.

    5 Mal editiert, zuletzt von AxT (5. Dezember 2015 um 13:03)

  • Da hast du was falsch verstanden.
    Ich wollte damit sagen, wie das ein XProfan-Befehl oder
    Funktion macht, ist für den Endnutzer nicht interessant.

    Wenn z.B.
    Window 600, 800
    ein Fenster aufmacht, interessiert keinen was dahinter
    geschieht. Der Nutzer braucht nur zu wissen, daß er die
    zwei Größen für das Fenster anzugeben hat. Das ist ja
    das Schöne in solchen Programmiersprachen, daß z.B.die
    API, die dahinter steckt, vorm Endnutzer verborgen wird
    und er keine Klimmzüge machen muß, um ein Fenster
    zu erzeugen.

    Ich kann ja auch nichts dafür, daß z.B.
    Move("ListToStr", S) einen Delimitter zuviel dranhängt.
    Ob jetzt Bug oder nicht, ändern kann das nur Roland.
    Wie er die Funktion nun gemacht hat, interessiert mich
    nicht. Nur sollte das richtige Ergebnis rauskommen.

    Ich selber nutze ja auch mal DLLs und weiß nicht, was intern
    in denen abgeht. Also einfach Doku lesen und die Funktionen
    nutzen, Punkt.

    Und der Quellcode, der das Fehlverhalten nur bei Freeprofan produziert,
    habe ich ja am Anfang dieses Posts für alle zur Verfügung gestellt.

    Insofern sprachen wir die ganze Zeit leider an uns vorbei.

    Wir sind die XProfaner.

    Sie werden von uns assimiliert.

    Widerstand ist zwecklos!

    Wir werden alle ihre Funktionen und Algorithmen

    den unseren hinzufügen.

  • Ich kann dir auch gerne ein Beispiel geben.

    Da kommt zwar in X3 die Fehlermeldung, daß die Bereichsgrenze
    überschritten wurde, aber man knabbert zuerst eine Weile daran,
    weil man nicht weiß, daß Move("StrToList", S, D) der Übeltäter ist.

    Erst wenn man irgendwann mal das Ergebnis von Move("StrToList",...)
    ausprintet, kommt man dahinter und entdeckt, daß diese Funktion
    1 zuwenig zurück gibt.

    Fazit :
    Wenn man einen Bereich mit irgendwelchen Funktions-Rückgabewerten
    dimt, sollte man vorsichtig sein. Besser ist es, die Funktion auf ihre
    Richtigkeit abzuklopfen und gegebenfalls den Rückgabewert manuell
    korrigieren. In diesem Falle wäre es dann (anz + 1) * 4.

    Paßt zwar von der Logik her nicht, aber was soll man machen ?

    Wir sind die XProfaner.

    Sie werden von uns assimiliert.

    Widerstand ist zwecklos!

    Wir werden alle ihre Funktionen und Algorithmen

    den unseren hinzufügen.

  • Da beim Programmieren in der Regel nullbasierend gezählt wird, steckt da durchaus eine gewisse Logik drin. Ich denke, hier ist der Fehler eher in der Hilfe zu sehen, die von Anzahl spricht aber vergisst, die nullbasierende Zählweise zu erwähnen.
    %getcount gibt ja auch Anzahl - 1 zurück. Ich vermute mal, dass das daher kommt.

  • Um ehrlich zu sein: Der Designfehler lag schom beim %GetCount. Der Name der Systemvariablen lässt hier tatsächlich die Vermutung zu, dass es sich um die Anzahl der Elemente handelt, was eigentlich auch so gedacht war. Tatsächlich liefert sie aber die Nummer des letzten Elementes zurück und diese ist, da nullbasierend, natürlich eins niedriger. Aus Kompatibilitätsgründen wurde das dann aber nicht mehr geändert, sondern nur in der Hilfe angepasst.

    Von daher ist statt %GetCount auch besser die Funktion GetCount(0) zur Ermittlung der Anzahl der Elemente in der Listboxliste zu verwenden. (Ich sollte das unseelige %GetCount zu den veralteten Funbktionalitäten verschieben.)

    Was das Problem von H.Brill betrifft, scheint da wohl noch eine Ungenauigkeit vorzuliegen. Ich werde mal nachschauen ...

    Gruß
    Roland

    Fujitsu Esprimo G5011 - Intel Core i5-10500T / 16 GB RAM / 500 + 2000 GB SSD / Windows 11pro - XProfan X4a

    Als Backup: Molegar Notebook - Intel Celeron N5095 / 16 GB RAM / 1000 GB HDD / Windows 11pro - XProfan X4a

    http://www.xprofan.de

  • Laut Jörg wäre dann aber

    Code
    Move("MemToList", b, Chr$(0))
    Move("FileToList", d)


    falsch. Das gibt mir die tatsächlichen gemovten Strings
    bzw. die Anzahl gemovter Zeilen der Datei zurück.
    Auch die anderen Move-Funktionen geben die tatsächlich
    kopierten Elemente zurück.
    Deshalb denke ich, daß Move("StrToList",..) das dann auch
    machen sollte.

    Ich finde, daß die richtige Anzahl zurück gegeben werden soll.
    Besonders bei der autom. Weiterverarbeitung, wie ein Dim
    oder sonstiges laufen dann nicht fehl.

    Daß die Listen und Arrays nullbasierend sind, wird ja in der
    Hilfe genügend beschrieben. Deshalb macht man ja dann
    ein
    GetCount(0) - 1
    in einer WhileLoop - Schleife.

    Roland :
    Ich würde es an deiner Stelle so lassen und Move("StrToList", s, d)
    korrigieren. Dann wird es einheitlich.

    Wir sind die XProfaner.

    Sie werden von uns assimiliert.

    Widerstand ist zwecklos!

    Wir werden alle ihre Funktionen und Algorithmen

    den unseren hinzufügen.

    Einmal editiert, zuletzt von H.Brill (7. Dezember 2015 um 18:14)

  • Rechtzeitig zum Fest eine neue Version!

    Was ist neu in dieser Version?


    Einfache numerische und String-Variablen können nun einfacher in Strings eingebunden werden. Hierzu gibt es den Doppelpunkt als neues Ersatzzeichen:

    Code
    var String Name = "Hugo"
    var Int Alter = 38
    Print "Mein Name ist einmal \:Name; und ich bin \:Alter; Jahre alt!"

    Das ist ähnlich der embedded Variablen in db("SQLExec",...) , nur das dort der Backslash fehlt. Es gibt aber einen kleinen aber feinen Unterschied: Während die die Ersetzung bei der Zuweisung (bzw. beim PRINT im obigen Beispiel) erfolgt, ist die Variante ohne Backslash nur bei db("SQLExec",...) wirksam und wird grundsätzlich erst beim SQLExec ausgewertet, auch wenn der String mit der Ersetzung in einer Variablen steht.


    Es gibt neue Operatoren:


    $: Zusammenfügung von Strings. Hier werden beide Operatoren grundsätzlich als Strings betrachtet. "Print 23 $ 56" würde also "2356" ausgeben. Vor und nach dem $ muss ein Leerzeichen sein.


    +%: "Ergebnis = A +% B" - Hier ist das Ergebnis A + B Prozent von A. Beispiel:

    Code
    Brutto = Netto +% Mehrwertsteuer

    -%: "Ergebnis = A -% B" - Das Ergebnis ist A - B Prozent von A
    *%: "Ergebnis = A *% B" - Das Ergebnis ist B Prozent von A
    /%: "Ergebnis = A /% B" - Das Ergebnis ist 100%, wenn A gleich B Prozent ist.


    Kurz: Rechnen wie mit der Prozenttaste des Taschenrechners!


    Außerdem gibt es die neue Systemvariable $CurrentDir für das aktuelle Verzeichnis.


    Viel Spaß damit, sowie ein frohes und gesegnetes Weihnachtsfest und einen guten Start ins Neue Jahr 2016!


    Roland


    PS: Die nächste XProfan-Version wird diese neuen Features auch haben.

    Fujitsu Esprimo G5011 - Intel Core i5-10500T / 16 GB RAM / 500 + 2000 GB SSD / Windows 11pro - XProfan X4a

    Als Backup: Molegar Notebook - Intel Celeron N5095 / 16 GB RAM / 1000 GB HDD / Windows 11pro - XProfan X4a

    http://www.xprofan.de

Jetzt mitmachen!

Sie haben noch kein Benutzerkonto auf unserer Seite? Registrieren Sie sich kostenlos und nehmen Sie an unserer Community teil!