PBXB64 - Compiler Werkstatt
V18 — Nativer x86-64 Multi-Frontend-Compiler

PBXB64 V18 RELEASE

PBXB64 V18 ist ein nativer Windows-x64-Compiler in reinem C17. PowerBASIC/BASIC, B64, C, ASM, COBOL, FORTH, Logo, PILOT, Rust und SPR nutzen eine gemeinsame Pipeline für native PE32+-Programme. Das Paket enthält aktuelle deutsche und englische CHM-Hilfe, 400 getestete Beispiele, 354 qualifizierte PowerBASIC-Includes und 34 C17-Header inklusive H-Lib.

V18-Release-Paket 10 Sprach-Frontends 62,5 MB All-in-One 8-Stage Pipeline Win64 Native Signed

Was V18 neu bringt

V18 verteilt und qualifiziert den V17-Featurestand: eine vollständig grüne 157-Lane-Validierungsmatrix auf Make und CMake, reparierte -O2/-O3-Backend-Regressionen, stabiles Forth CATCH/THROW, gehärtete TCP/UDP-Laufzeitpfade und Erweiterungen in allen Frontends — von MCP/JSON-Adapterrouten über wissenschaftliche Operatoren bis zur erneuerten zweisprachigen Hilfe.

157-Lane-Validierungsmatrix
Vollständige Make- und CMake-Matrizen ohne unerwartete Fehler: pb_linkrun 1.306/1.306, c_linkrun 55/55, forth_linkrun 67/67, assembly 1.996/1.996, c23_verify 137/137.
Reparierte -O2/-O3-Backend-Regressionen
Die Incoming-Argument-Kopie bleibt am Funktionseinstieg; Peephole und Registerallokation verschieben oder falten sie nicht mehr, und Float-Parameter behalten ihre ABI-XMM-Register.
Stabiles Forth catch/throw
Leaf-Wörter mit Laufzeitaufrufen erhalten jetzt einen Frame-Zeiger — der Stack-Misalignment-Segfault bei CATCH/THROW ist behoben.
Gehärtetes TCP/UDP NOTIFY
Zufällige Ports vermeiden Kollisionen bei paralleler Validierung in den TCP/UDP-NOTIFY-Regressionsspuren.
MCP/JSON-Befehlsadapter
Lokale MCP-Protokoll-Erweiterungen, Katalog-Parser, HTTP/JSON-RPC-Adapter, JSON-Tiefenkopie, Pfadabfragen, Crypto-Vektoren und Typkonvertierungen.
Wissenschaftliche Erweiterungen V18–V24
Unäre Operationen, Zahlentheorie, Spezialfunktionen, Wahrscheinlichkeit, Polynome, exakte Dezimalzahlen und komplexe Zahlen über die PB-Schnittstelle.
PowerBASIC-Kommunikationsstack
TCP OPEN SERVER/CLIENT, TCP SEND/RECV, UDP OPEN/SEND/RECV, NOTIFY-Events mit WSAAsyncSelect, HOST ADDR/NAME und PB-Dateinummern-Tracking.
Erneuerte zweisprachige Referenzhilfe
3.135 Themen pro Sprache, CHMs für EN und DE, aktualisiert für alle zehn Frontends inklusive Wissenschaft, MCP/JSON und 174 Forth-Primitiven.
Per-Frontend-Schnappschuss
COBOL-Subset 176/176, SPR-Textkommandos 164/164, C17-Header mit stdbit.h/stdckdint.h, C-Include-Auflösung, PB DIALOG/GRAPHIC/XPRINT, StringX/UN-Familie.
Vollständiges signiertes Release-Paket
Digital signierter Compiler, zweisprachige CHM-Hilfe, 400 getestete Beispiele, 354 qualifizierte PB-Includes und 34 C17-Header.
Alle Features
PBX-Compiler V2 herunterladen (ZIP) All-in-One: PBXA32, PBXA64, PBXB64, ScharffBasic und PBX-Editor Vorgänger-Bundle: V1 (optional) Online-Hilfe Alle Features Bundle-Downloads: --

PBX-Compiler-V2-Paket: 62,5 MB (ZIP) — PBXA32, PBXA64, PBXB64 und ScharffBasic inklusive PBX-Editor, CHM-Hilfe (DE+EN), 400 getestete Beispiele, 354 qualifizierte Includes und 34 C17-Header

Digital signiert von Theo Robert Gottwald — Authenticode gültig

Release-Paket für native Windows-x64-Entwicklung vorbereitet

10Sprach-Frontends von BASIC und C bis COBOL, FORTH, Logo, Rust und SPR
400Getestete Beispiele über alle unterstützten Frontends
354Qualifizierte PowerBASIC-Include-Dateien
34C17-Header inklusive öffentlicher H-Lib-Schnittstelle

V18 in echtem Code

Diese kompakten Beispiele gehören weiterhin zum ausgelieferten Fixture-Korpus: Laufzeit-Auswertung und StringX in PowerBASIC, begrenzte COBOL-Linkage sowie FORTH-Fehlerbehandlung.

PowerBASIC - EVAL, BUILD$ und REGEX$
LOCAL value AS DOUBLE, result AS STRING value = EVAL("(10 - 4) * 2") result = BUILD$("value=", EVAL$("1 + 2")) result = REGEX$("([A-Z]+)-(\d+)", "ITEM-42", 2)
COBOL - gebundener PB-Puffer
#COBOL USING buf DATA DIVISION. LINKAGE SECTION. 01 BUF PIC X(20). PROCEDURE DIVISION USING BUF. MOVE "from COBOL" TO BUF. STOP RUN. #ENDCOBOL
FORTH - CATCH und THROW
: may-fail 1 THROW ; : safe-run ['] may-fail CATCH . CR ; safe-run
StringX - Wildcards und Ersetzung
IF LIKE$("Report-2026", "report-*") <> "" THEN PRINT REPLACES$("alpha-beta", "-", " ") END IF
Befehle zum Ausprobieren

Befehlsatlas

Die neuen Befehlsfamilien sind direkt in der ausgelieferten PBXB64-Referenz und im Testkorpus wiederzufinden. Die Detailseiten erklären Syntax, Typen und Grenzen mit weiteren Beispielen.

Zahlentheorie

GCD, GCD$, LCM, LCM$, FACT, FACT$, BINOM, BINOM$, MODPOW, MODPOW$, MODINV, MODINV$, ISPRIME

Spezialfunktionen

BESSELJ0, BESSELJ1, BESSELI0, BESSELI1, BETA, LBETA, DIGAMMA, TRIGAMMA, SINC, LOGISTIC, LOGIT

Wahrscheinlichkeit

NORMPDF, NORMCDF, NORMINV, POISSONPMF, POISSONCDF, BINOMPMF, BINOMCDF

Polynome und exakte Werte

CHEBYSHEV, LEGENDRE, LAGUERRE, HERMITE sowie UNFSQRT$, UNFIPOW$, UNFABS$, UNFNEG$ und UNFTRUNC$

Komplexe Komponenten

CADD$, CSUB$, CMUL$, CDIV$, CCONJ$, CREAL$, CIMAG$, CMAG, CPHASE und weitere Komponentenfunktionen

MCP, HTTP und JSON

MCP_CatalogList, MCP_CatalogGet, MCP_CatalogSearch, MCP_CatalogCall, Sessions, Tasks, HTTP_Execute sowie Deep-Merge-, Prune-, Sortier- und Serialisierungsfunktionen für JSON

Exakte Mathematik im PBXB64-Testkorpus
LOCAL gcd AS STRING, root AS STRING gcd = GCD$(84, 30) ' 6 root = UNFSQRT$(144) ' 12 IF ISPRIME(97) THEN PRINT "prime" LOCAL c AS UNC c = VALUNC("3;4") PRINT CADD$(c, VALUNC("2;0")) ' 5;4
Lokaler MCP/HTTP-Adapter
LOCAL source AS STRING, response AS STRING MCP_CatalogList("tools/list", source) response = HTTP_Execute("GET", _ "http://127.0.0.1:55457/chunked", "") ' JSON_DeepMerge, JSON_PruneNulls and JSON_SerializePretty ' are available for the following transformation step.
Wissenschaftliche Befehle im Detail V18-Referenzhilfe

Warum PBXB64?

Echter nativer x64-Code

PBXB64 nutzt eine eigene mehrstufige native x64-Pipeline: Frontend, IR, Codegenerierung, COFF/PE32+-Ausgabe und Link-Schritte bleiben unter der Kontrolle des Compilers.

Multi-Frontend: 10 Sprachen

PowerBASIC/BASIC, B64, C, ASM, COBOL, FORTH, Logo, PILOT, Rust und SPR nutzen eine gemeinsame native Compiler-Pipeline.

Maßgeschneidertes x64-Backend

Instruktionsauswahl, Registerzuweisung, Peephole-Optimierung und PE32+-Erzeugung sind in C17 implementiert. Die ausgelieferte Pipeline bringt ihre qualifizierten H-Lib- und Include-Bausteine mit.

Maßgeschneiderter PE32+-Linker

Der integrierte Linker verarbeitet COFF-Objekte, Importtabellen, Relocations, TLS und Exception-Daten und erzeugt native PE32+-Programme für die unterstützte Windows-x64-Zielumgebung.

Schnellbeispiele

Derselbe Algorithmus - Summe 1 bis 5 - in jedem Frontend.

B64

fn main(): i64 { let sum: i64 = 0; let i: i64 = 1; while i <= 5 { sum = sum + i; i = i + 1; } return sum; // 15 }

PowerBASIC

FUNCTION PBMAIN() AS LONG LOCAL sum AS LONG LOCAL i AS LONG sum = 0 FOR i = 1 TO 5 sum = sum + i NEXT FUNCTION = sum ' = 15 END FUNCTION

C

#include <stdio.h> int main(void) { int sum = 0; for (int i = 1; i <= 5; i++) { sum += i; } return sum; /* 15 */ }

LOGO

MAKE "sum 0 MAKE "i 1 REPEAT 5 [ MAKE "sum :sum + :i MAKE "i :i + 1 ] PRINT :sum

FORTH

5 4 + 3 + 2 + 1 + . \ 15

SPR

VAR.$$SUM=0 FOR.$$III|1|5|1 VIC.$$SUM|$$III NEX. ENR.

ASM

FUNCTION PBMAIN() AS LONG LOCAL sum AS LONG #ASM xor eax, eax ; sum = 0 mov ecx, 5 ; counter = 5 add_loop: add eax, ecx ; sum += counter dec ecx ; counter-- jnz add_loop ; loop until 0 mov %sum, eax ; store result #ENDASM FUNCTION = sum ' = 15 END FUNCTION

PILOT

T: "Sum 1 to 5" C: #sum=1+2+3+4+5 E:

COBOL

IDENTIFICATION DIVISION. PROGRAM-ID. QuickSum. DATA DIVISION. WORKING-STORAGE SECTION. 01 TOTAL PIC 9(2). PROCEDURE DIVISION. COMPUTE TOTAL = 1 + 2 + 3 + 4 + 5 DISPLAY TOTAL STOP RUN.

RUST

fn main() -> i64 { let mut sum: i64 = 0; let mut i: i64 = 1; loop { sum = sum + i; if i >= 5 { break; } i = i + 1; } return sum; // 15 }
Ein Programm, mehrere Sprachen, gemeinsamer Speicher

Variablen zwischen Frontends teilen

PBXB64 V18 verbindet die Frontends auf Symbolebene. BRIDGE EXPORT legt typisierten globalen Speicher an, BRIDGE IMPORT bindet fremden Speicher ein. C und Rust erhalten passende Deklarationen; ASM und Forth greifen über das veröffentlichte Symbol zu. COBOL, SPR und PILOT besitzen zusätzlich direkte, getestete Bindings.

PowerBASIC ↔ C, Rust, ASM, Forth

PowerBASIC exportiert
BRIDGE EXPORT bridge_counter AS LONG _ ALIAS "bridge_counter" bridge_counter = 41
C nutzt dasselbe Symbol
extern int bridge_counter; bridge_counter += 1; /* jetzt 42 */

PBXB64 erzeugt typgeprüfte Bridge-Deklarationen für die Nebeneingaben desselben Builds.

COBOL ↔ PowerBASIC

COBOL besitzt den Wert
01 SHARED-COUNT PIC S9(9) VALUE 41 GLOBAL.
PowerBASIC bindet und ändert ihn
BRIDGE IMPORT shared_count AS QUAD _ ALIAS "SHARED-COUNT" PRINT shared_count shared_count = 42

Das exakte COBOL-Objektsymbol bleibt erhalten; BASIC liest und schreibt denselben Speicher.

SPR und PILOT ↔ PB-Globals

SPR: bidirektionale Live-Bindings
VIP.$$NUM|spr_vip_num|QUAD VIP.$$TXT|spr_vip_txt|STRING VIC.$$NUM|1
PILOT: dieselbe Idee mit V:
V: #NUMBER|pilot_number|QUAD C: #NUMBER = 42

Änderungen sind sofort in der jeweils anderen Sprache sichtbar, ohne Serialisierung oder Hilfs-DLL.

Aktuell getesteter Vertrag: skalare Integer- und Gleitkommatypen, Pointer, BOOL, CURRENCY sowie feste STRINGZ * n-Puffer. Dynamische Strings, beliebige Arrays, UDTs und untypisierte Aggregat-Schreibzugriffe benötigen einen eigenen Bridge-Vertrag.

Produktive Textverarbeitung ohne zusätzliche DLL

Eine hervorragende integrierte REGEX-Engine

PBXB64 V18 stellt die integrierte REGEXPR-1.25-Laufzeit über PB-kompatible Anweisungen und StringX-Helfer bereit. Strukturierte Texte lassen sich mit Gruppen, Rückverweisen, begrenzten Quantifizierern, Wortgrenzen, kürzesten Treffern und binärsicheren Zielstrings suchen, prüfen, erfassen, umformen und ersetzen.

Nutzen Sie PB-kompatible REGEXPR/REGREPL-Statements, wenn Positionen wichtig sind, oder die kompakten StringX-Funktionen REGEX$/REGEXREPLACE$, wenn das Textergebnis im Mittelpunkt steht.

REGEX-Beispiele und Details
Namen erfassen und alle Treffer umformatieren
FUNCTION PBMAIN() AS LONG LOCAL source AS STRING, pattern AS STRING LOCAL captured AS STRING, result AS STRING source = "User: Ada Lovelace, ID: 1843" pattern = "User: ([A-Za-z]+ [A-Za-z]+)" captured = REGEX$(pattern, source, 1) PRINT captured ' Ada Lovelace result = REGEXREPLACE$("([A-Za-z]+) ([A-Za-z]+)", _ "Ada Lovelace and Grace Hopper", "$2, $1") PRINT result ' Lovelace, Ada and Hopper, Grace FUNCTION = 0 END FUNCTION
Wenn 64 Bit und feste Präzision nicht ausreichen

Sechs erstklassige UN-Zahlentypen

UNL verarbeitet vorzeichenbehaftete Ganzzahlen mit beliebiger Präzision, UNF beliebig präzise Dezimalzahlen und UNB große Gleitkommawerte. UNC, UNI und UNQ halten komplexe, Intervall- und Quaternion-Komponenten als verwaltete Werte zusammen.

Sie sind überlegen, wenn native Typen überlaufen, benötigte Präzision verlieren oder mehrere Komponenten manuell verwaltet werden müssten. Deklaration, Arithmetik, Vergleiche, Aufrufe, Rückgaben, Globals, Arrays, Konvertierung und Bereinigung bleiben in der Sprache.

Alle sechs UN-Beispiele ansehen
Große Ganzzahlen, präzise Dezimalwerte und komplexe Zahlen
LOCAL huge AS UNL, squared AS UNL LOCAL price AS UNF, tax AS UNF, total AS UNF LOCAL leftValue AS UNC, rightValue AS UNC, product AS UNC huge = VALUNL("999999999999999999999999999999") squared = huge * huge price = VALUNF("19.95") : tax = VALUNF("3.79") total = price + tax leftValue = VALUNC("1;2") : rightValue = VALUNC("3;4") product = leftValue * rightValue PRINT UNL$(squared) PRINT UNF$(total) ' 23.74 PRINT UNC$(product) ' -5;10

19 Feature-Kategorien

Entdecken Sie jedes Feature im Detail mit Code-Beispielen und Erklärungen.

Architecture

Zehn Frontends, einheitliche IR, eigenes x64-Backend, integrierter Assembler, COFF-Writer und PE32+-Linker.

Explore →

Data Types

Standard-PB-Typen plus die vollständige UN-Familie, native H-Lib-Typen, GUID/VARIANT/COM-Interoperabilität und breite Ganzzahlen.

Explore →

Containers

22 native Kernfamilien plus Safe, mit Auto-Init/Final, Methoden-Dispatch und UDT-Nutzlasten.

Explore →

Science & Math

Wissenschaftliche Funktionen von ATN2, HYPOT, DET und DOT bis GCD, NORMCDF, CHEBYSHEV und exakter UNF-Arithmetik.

Explore →

Control Flow

FOR (7 types, negative STEP), WHILE, SELECT CASE, GOSUB/RETURN, ON KEY CALL.

Explore →

Networking

TCP, UDP, COMM serial, HOST ADDR/NAME. Real Win32 socket API.

Explore →

Graphics & GUI

GRAPHIC WINDOW, LINE, BOX, GUI NEW, DIALOG, CONTROL, DISPLAY.

Explore →

Inline Assembly

x64 assembly directly in PB and B64. Dokumentierter Instruktionsumfang, Register und Speicheradressierung.

Explore →

B64 Language

C-like systems language with types, structs, arrays, pointers, inline asm.

Explore →
Alle 19 Kategorien anzeigen

Download-Entwicklung

Tägliche Abrufe aller angebotenen Downloads der letzten 28 Tage (rollierend). Jede Download-Datei ist dauerhaft durch eine eigene Farbe gekennzeichnet.