FoxDev Studio

Het pakt precies op waar u bent gebleven

Wijs de software aan een map die u in jaren niet heeft geopend, en u krijgt precies terug wat er staat.

Uw project, zoals het is

Projecten, formulieren, klassenbibliotheken, menu's en rapporten worden direct geopend vanuit de bestanden die u al heeft. Er is geen migratie nodig en er blijft niets achter.

De designers die u kent

Formulieren, klassen, menu's en rapporten worden bewerkt op de plek waar u ze verwacht, naast de projectmanager, het opdrachtvenster (Command Window) en een debugger die stopt op uw regel.

Uw data blijft uw data

Tabellen, indexen, memo's en databases worden ter plekke gelezen en beschreven. Wat er daarna op de schijf staat, is precies hetzelfde type bestand als voorheen.

Compatibiliteit met externe systemen

Systeemoproepen, automatiseringsobjecten en de oude add-in bibliotheken waarop uw applicatie vertrouwt, blijven werken. Hierdoor blijven de onderdelen die niemand wil aanpassen, ongemoeid.

Visuele weergave van de IDE

De IDE is getoond met de eigen voorbeeldprojecten van Visual FoxPro. Elke afbeelding is een echte sessie:

  • De Solution sample van Visual FoxPro: Geïmporteerd en draaiend, met het launcher-formulier op het scherm, 123 formulieren, 7 menu's en 11 klassenbibliotheken in de explorer, terwijl de runtime wacht op events. De editor voert linting uit via de compiler van de runtime, waardoor fouten direct worden onderstreept.
  • Breakpoint in het hoofdprogramma: Gestopt één stap na een breakpoint in de Solution sample, met zicht op de call stack, lokale variabelen, watches en de huidige regel.
  • Tabelbrowser: Een databasecontainer met 8 velden, 17 records en memo's die met één klik bereikbaar zijn.
  • FoxScript: Lambda's die antwoorden op HTTP-routes, waarbij een 32-bit bibliotheek wordt aangeroepen vanuit een lambda die luistert op poort 8080.

Gebouwd op precisie, niet op benadering

Kleine verschillen zijn precies wat een oude applicatie kunnen breken: een getal dat een kolom te breed wordt geprint, een event dat een moment te laat arriveert, of een foutmelding met het verkeerde nummer. Daarom wordt het gedrag hier bepaald door Visual FoxPro zelf te raadplegen en het antwoord daarvan te matchen, in plaats van een referentiepagina te lezen en te hopen op het juiste resultaat.

Het resultaat is een runtime die vanaf nul is geschreven: snel opstartend, zelfvoorzienend en eerlijk over de hoekgevallen die nog niet zijn bereikt.

Status van de Visual FoxPro 9-taalreferentie in de runtime:

  • 1.722 elementen bekend bij de runtime.
  • 1.534 elementen getest door de antwoorden te vergelijken met het originele product.
  • 3 namen die nog niet zijn ontmoet; al het overige draait, wordt doelbewust genegeerd of wordt op basis van naam geweigerd.

Wat Visual FoxPro 10 zou zijn geweest

Visual FoxPro stopte bij versie 9 en bleef beperkt tot 32-bit. FoxDev Studio gebruikt dezelfde taal, maar is herbouwd op een fundering die sinds 2007 niet meer bevroren is. Dit wordt mogelijk gemaakt door vier componenten:

Architectuurvergelijking: 32-bit vs 64-bit

De 32-bit wereld (Visual FoxPro)

  • Interface: Tekent het hele formulier opnieuw bij een wijziging.
  • Objectboom: Beheert alle controls met eigenschappen en events (bijv. THISFORM.lblGreeting.Caption = cMsg).
  • Virtuele Machine: Code gecompileerd naar p-code.
  • Host: Bestanden, tabellen, COM en 32-bit bibliotheken in een 32-bit proces (bijv. .fll bestanden).

De moderne wereld (FoxDev Studio)

  • Interface: React tekent direct vanuit de boom; slechts één control wordt opnieuw getekend, niet het hele formulier.
  • Virtuele Machine: Uw code wordt gecompileerd naar bytecode en uitgevoerd in WebAssembly; dit genereert requests en blokkeert nooit.
  • Host: 64-bit bestanden, tabellen, COM en 64-bit bibliotheken in proces.

64-bit, van begin tot eind

Het plafond van 32-bit is verdwenen. In Visual FoxPro is de limiet van twee gigabyte voor tabellen en memobestanden geen bewuste licentiekeuze, maar een gevolg van signed 32-bit getallen in de bestandsverwerking.

FoxDev Studio is volledig 64-bit. Elke bestandsoffset is 64-bit en tabellen worden niet volledig in het geheugen geladen, waardoor dezelfde .dbf die voorheen vastliep, nu honderden gigabytes kan bereiken.

Let op: Een tabel die is gegroeid tot boven de twee gigabyte kan niet meer worden geopend in Visual FoxPro. Dit is een eenrichtingsweg.

Vergelijking van bestandsoffsets:

  • Visual FoxPro: 2.147.483.647 bytes (de tabel stopt bij 2 GB omdat het leidende bit het teken draagt).
  • FoxDev Studio: 9.223.372.036.854.775.807 bytes (de offset is nooit de beperkende factor; elke byte van elke lees- en schrijfactie wordt op deze manier geadresseerd).

Capaciteitsvoorbeeld: Waar een Visual FoxPro-tabel maximaal 2 GB kan bevatten, kan een FoxDev-tabel met records van 130 bytes tot 558 GB groeien. Bij records van 1 KB kan dit oplopen tot 4,4 TB. De enige beperking is nu de recordcount in de DBF-header.

De virtuele machine

Visual FoxPro compileerde programma's naar p-code en leverde een runtime om dit uit te voeren. FoxDev Studio hanteert dezelfde opzet: een compiler en een bytecode-interpreter geschreven in Rust en gecompileerd naar WebAssembly. Hierdoor draait de code op elke machine waar de applicatie wordt uitgevoerd. De editor gebruikt dezelfde compiler voor controle, waardoor er geen discrepantie kan ontstaan tussen wat de editor onderstreept en wat de runtime weigert.

Een draaiend programma is een 'fiber'. Wanneer er iets uit de buitenwereld nodig is (zoals een dialoogvenster of het volgende record), blokkeert het programma niet, maar 'yieldt' het. Het werk wordt gedaan terwijl de machine buiten de stack is, waarna het antwoord wordt teruggegeven. Dit verklaart waarom MESSAGEBOX() het programma stopt zonder het venster erachter te bevriezen, waarom READ EVENTS wacht zonder CPU-belasting, en waarom SetFocus en Init exact werken zoals in FoxPro.

Het scherm

Het formulier dat u ziet is de objectboom zelf, niet een afbeelding daarvan. Een draaiend formulier is een live boom van objecten. De interface wordt direct vanuit die boom getekend door React. Omdat elk object alleen zichzelf observeert, zorgt een wijziging zoals THISFORM.lblGreeting.Caption = cMsg ervoor dat slechts één label wordt hertekend.

Dezezelfde boom wordt door de designer bewerkt. Er is geen tweede model dat synchroon moet worden gehouden met het eerste, wat vaak de reden is dat formulieren en hun designers in andere software verschillende resultaten geven.

De 32-bit brug

Omdat een .fll een 32-bit image is en een 64-bit applicatie dit niet direct kan openen, start SET LIBRARY TO een klein, apart 32-bit proces dat uitsluitend bedoeld is om uw bibliotheek vast te houden. De runtime communiceert vervolgens met dit proces.

Deze oproepen zijn synchroon, omdat een programma midden in een expressie een bibliotheek kan aanroepen. Dit is getest met echte bibliotheken, waaronder de encryptiebibliotheek, FoxTools en bibliotheken gebouwd vanuit Microsoft API-samples.

Voor moderne bibliotheken is deze brug niet nodig: DECLARE ... DLL bereikt een moderne bibliotheek in hetzelfde proces, en automatiseringsobjecten worden bereikt via de gebruikelijke weg.

FoxScript: dezelfde taal, meer ruimte

Alles wat u heeft geschreven behoudt zijn oorspronkelijke betekenis. FoxScript voegt daar functies aan toe: blokken die u aan andere processen kunt overdragen om later uit te voeren, en een manier om webverzoeken te beantwoorden vanuit de code die uw businesslogica al kent.

Voorbeeld: server.prg / FoxScript

&& uw oude add-in bibliotheken laden zoals voorheen
SET LIBRARY TO "vfpencryption71.fll" ADDITIVE
LOCAL oServer
oServer = FoxScript.Http.CreateServer()
oServer.Get("/api/v1/customers/:id", LAMBDA(req, res)
    LOCAL lnId
    lnId = VAL(req.Params("id"))
    SELECT * FROM customer WHERE cust_id = lnId INTO CURSOR c_cust
    IF RECCOUNT("c_cust") > 0
        res.Status(200).Json(FoxScript.Data.CursorToJson("c_cust"))
    ELSE
        res.Status(404).Json('{"error": "Not found"}')
    ENDIF
    USE IN c_cust
ENDLAMBDA)
oServer.Listen(8080)
READ EVENTS

Elke regel van deze code draait op dezelfde runtime als uw formulieren. De queries, de cursor en de bibliotheekoproep zijn standaard FoxPro; de lambda en de server zijn de toevoegingen van FoxScript. Er is geen tweede taal of aparte service nodig.

Beschikbaarheid en Documentatie

De 'nightly' build wordt opnieuw opgebouwd bij elke push naar de main branch en gepubliceerd als pre-release op GitHub. Omdat deze niet is ondertekend, vraagt de eerste start om bevestiging.

  • Windows: Installer (.exe) en runtime (.zip), x64.
  • Ubuntu en overige Linux: AppImage en .deb, x64.
  • Broncode: Beschikbaar op GitHub (FoxDevCommunity/FoxDevStudio).

Documentatie-overzicht

  • Overview: Wat FoxDev Studio is en waar de verschillende onderdelen worden beschreven.
  • Getting started: Installatie van de IDE, openen van projecten, draaien van formulieren en het leveren van executables.
  • Required tooling: Benodigdheden om de IDE te draaien of vanaf broncode te bouwen.
  • The virtual machine: Uitleg over fibers, host requests en waarom de VM nooit blokkeert.
  • Bytecode: Het moduleformaat, compilatie en de structuur van een frame.
  • Instruction reference: Elke instructie met operanden en stack-effecten.
  • The new keywords: LAMBDA, ENDLAMBDA, de FoxScript-namespace en twee nieuwe waardetypen.
  • The HTTP API: FoxScript.Http en de Node-zijde hiervan.

Toekomstige ontwikkelingen

De volgende onderdelen staan op de planning:

  • Voltooiing van de taal: De laatste details van de taal worden afgerond en gecontroleerd tegen het origineel.
  • Rapporten: De rapport-designer en de report-engine worden band voor band opgebouwd.
  • Tabellen groter dan 2 GB als eigen formaat: De 64-bit offsets zijn aanwezig; een container die eerlijk is over de limieten van de DBF-header volgt.
  • Installer voor distributie: Een mogelijkheid om uw applicatie als één geheel aan gebruikers te leveren, zonder dat zij vooraf configuraties hoeven uit te voeren.

FoxDev Studio is een onafhankelijk en groeiend project. Visual FoxPro is een geregistreerd handelsmerk van Microsoft Corporation, hier enkel gebruikt om de geïmplementeerde taal aan te duiden.