Release v0.4.0: Real-World Usage

NitroPascal v0.4.0 delivers the features that matter for building real
applications in production: function pointers for callbacks, structured RTL
modules (Types, SysUtils, StrUtils, DateUtils), static library linking
(demonstrated with raylib), comprehensive benchmarking suite, and dramatically
expanded runtime capabilities.

KEY MILESTONE:
NitroPascal now demonstrates REAL-WORLD VIABILITY. Static link raylib for game
development. Compare performance against Delphi with included benchmarks.
Structure your code with standard Pascal RTL modules. Build production software
with a mature, organized runtime library.

FUNCTION POINTERS (PROCEDURAL TYPES):
- Procedural type declarations (type TCallback = procedure(X: Integer))
- Function variable assignments
- Callback patterns for event handling
- Higher-order functions and functional programming
- Framework integration hooks
- Plugin architectures
- Event-driven programming patterns

STRUCTURED RTL MODULES:
- System.Types - Base type declarations and utilities
- System.SysUtils - System utilities and conversions
- System.StrUtils - String manipulation utilities
- System.DateUtils - Date/time functions (foundation)
- Organized, discoverable API surface
- Standard Pascal module structure
- Clear separation of concerns
- Professional codebase organization

STATIC LIBRARY LINKING:
- Link against static libraries (.lib/.a files)
- Demonstrated with raylib game development library
- Zero-overhead integration with C/C++ libraries
- Single-executable deployment (no DLL dependencies)
- Complete control over dependencies
- Simplified distribution

ENHANCED STRING LIBRARY:
- StringOfChar(Ch, Count) - Create repeated character strings
- UniqueString(S) - Ensure unique string reference
- SetString(S, Buffer, Len) - Direct buffer to string
- Val(S, V, Code) - String to numeric with error code
- Str(X, S) - Numeric to string (legacy compatibility)
- UpCase(Ch) - Single character uppercase
- WideCharLen(S) - Wide string length
- WideCharToString(S) - Convert wide to string
- StringToWideChar(S, Buf, BufSize) - String to wide buffer
- WideCharToStrVar(S, Dest) - Wide to string variable
- Complete wide character support for Unicode

EXPANDED MATH LIBRARY:
- Logarithms: Ln(X), Log10(X), Log2(X), LogN(Base, X)
- Exponential: Exp(X), Power(Base, Exponent)
- Integer/fractional: Int(X), Frac(X)
- Hyperbolic trig: Sinh(X), Cosh(X), Tanh(X)
- Inverse hyperbolic: ArcSinh(X), ArcCosh(X), ArcTanh(X)
- Mathematical constant: Pi
- ArcTan2(Y, X) for proper angle calculations
- Scientific computing capabilities
- Complete mathematical toolkit

ENHANCED FILE I/O:
- Read(F, Var) - Read from text file to variable
- Eoln(F) - Test for end of line in text file
- SeekEof(F) - Skip whitespace, test for EOF
- SeekEoln(F) - Skip whitespace, test for EOL
- Flush(F) - Force write buffer to disk
- Truncate(F) - Truncate file at current position
- Erase(F) - Delete closed file
- Rename(F, NewName) - Rename closed file
- IOResult - Get last I/O error code
- Complete Delphi file I/O compatibility

ENHANCED MEMORY FUNCTIONS:
- AllocMem(Size) - Allocate zero-filled memory
- FillByte(Dest, Count, Value) - Fill byte array
- FillWord(Dest, Count, Value) - Fill word array
- FillDWord(Dest, Count, Value) - Fill dword array
- Efficient bulk memory operations
- Type-specific fill operations

ENHANCED ORDINAL FUNCTIONS:
- Odd(X) - Test if integer is odd
- Swap(X) - Swap byte order (endianness)
- Byte manipulation utilities

PLATFORM SERVICES:
- RunError(ErrorCode) - Terminate with error code
- Abort - Terminate with exception
- Enhanced program control

CODE GENERATION IMPROVEMENTS:
- Line number directives (#line) for debugging
- Source position tracking in generated code
- Better debuggability
- Improved error messages with source locations

COMPILER DIRECTIVES:
- {$include_header 'filename'} - Include C/C++ headers directly
- Seamless integration with native libraries
- Direct access to platform APIs

BENCHMARK SUITE:
- Comprehensive performance comparison: NitroPascal vs Delphi
- Real-world test scenarios
- Quantifiable performance metrics
- Optimization validation
- Demonstrates competitive performance

ENHANCED C++ RUNTIME:
- Expanded standard library wrappers
- More complete RTL implementation
- Better Delphi compatibility
- Optimized performance paths

BUILD SYSTEM ENHANCEMENTS:
- Static library linking support
- Improved dependency management
- Better library path resolution
- Cross-platform static linking

REAL-WORLD DEMONSTRATIONS:
- Raylib integration example (static linking)
- Game development capabilities
- High-performance graphics
- Professional library integration
- Production-ready examples

This release proves NitroPascal's real-world viability. With function pointers
for callbacks, structured RTL modules for organization, static linking for
deployment simplicity, and comprehensive benchmarks showing competitive
performance, you can confidently build production applications.

THE REAL-WORLD MILESTONE:
NitroPascal isn't just production-ready - it's production-proven. Static link
libraries like raylib. Write callbacks and event handlers with function
pointers. Structure your code with standard Pascal modules. Compare performance
directly against Delphi. Ship real applications with confidence.

Write once in pure Delphi. Link static libraries. Ship single executables. Run
everywhere.

Version: 0.4.0

Author: jarroddavis68

.gitignore

@@ -84,8 +84,8 @@ modules/
 # NitroPascal
 bin/res/*
 !bin/res/.gitkeep
-bin/projects/*
-!bin/projects/.gitkeep
+#bin/projects/*
+#!bin/projects/.gitkeep
 checkpoint.zip
 _checkpoint.cmd
 bin/run_unittests.cmd
@@ -99,3 +99,8 @@ src/TASK.md
 src/TASK0.md
 src/TASK2.md
 checkpoint_base.zip
+docs/BENCHMARK.pdf
+docs/COVERAGE.pdf
+docs/DESIGN.pdf
+docs/MANUAL.pdf
+bin/tests/*

bin/projects/NPBench/build.zig

@@ -0,0 +1,47 @@
+const std = @import("std");
+
+pub fn build(b: *std.Build) void {
+    const target = b.standardTargetOptions(.{});
+    const optimize = .ReleaseFast;
+
+    // Create module for C++ sources
+    const module = b.addModule("NPBench", .{
+        .target = target,
+        .optimize = optimize,
+        .link_libc = true,
+    });
+
+    // C++ compiler flags
+    const cpp_flags = [_][]const u8{
+        "-std=c++20",
+    };
+
+    // Add all generated C++ files
+    module.addCSourceFile(.{
+        .file = b.path("generated/NPBench.cpp"),
+        .flags = &cpp_flags,
+    });
+    module.addCSourceFile(.{
+        .file = b.path("generated/UNPBench.cpp"),
+        .flags = &cpp_flags,
+    });
+
+    // Add runtime source
+    module.addCSourceFile(.{
+        .file = b.path("runtime/runtime.cpp"),
+        .flags = &cpp_flags,
+    });
+
+    module.addIncludePath(b.path("runtime"));
+
+    // Create executable
+    const exe = b.addExecutable(.{
+        .name = "NPBench",
+        .root_module = module,
+    });
+
+    // Link C++ standard library
+    exe.linkLibCpp();
+
+    b.installArtifact(exe);
+}

bin/projects/NPBench/runtime/runtime.cpp

@@ -0,0 +1,28 @@
+/**
+ * NitroPascal Runtime Library - Implementation
+ * 
+ * This file includes all implementation modules.
+ * Each module contributes implementation as needed.
+ * 
+ * Version: 1.0
+ * Date: 2025-10-15
+ */
+
+#include "runtime.h"
+
+// ============================================================================
+// MODULE IMPLEMENTATIONS IN DEPENDENCY ORDER
+// ============================================================================
+
+#include "runtime_string.cpp"
+#include "runtime_console.cpp"
+#include "runtime_control.cpp"
+#include "runtime_operators.cpp"
+#include "runtime_ordinal.cpp"
+#include "runtime_containers.cpp"
+#include "runtime_memory.cpp"
+#include "runtime_math.cpp"
+#include "runtime_file.cpp"
+#include "runtime_exceptions.cpp"
+#include "runtime_cmdline.cpp"
+#include "runtime_format.cpp"

bin/projects/NPBench/runtime/runtime.h

@@ -0,0 +1,79 @@
+/**
+ * NitroPascal Runtime Library
+ * 
+ * This is the C++ Runtime Library (RTL) that provides Delphi/Object Pascal
+ * semantics in C++20. The code generator emits calls to these functions
+ * and classes, making code generation trivial.
+ * 
+ * Key Design Principles:
+ * - All Delphi semantics are wrapped in C++ functions/classes
+ * - Code generator just emits function calls (simple syntax translation)
+ * - All complexity lives here (written once, correct once)
+ * - Uses C++20 features (fold expressions, concepts, etc.)
+ * 
+ * Module Organization:
+ * - runtime_types.h: Core type aliases
+ * - runtime_operators_custom.h: Custom output operators (before namespace)
+ * - runtime_string.h/cpp: String class and utilities
+ * - runtime_console.h/cpp: Console I/O
+ * - runtime_control.h/cpp: Control flow (for, while, repeat)
+ * - runtime_operators.h/cpp: Arithmetic operators (div, mod, shl, shr)
+ * - runtime_ordinal.h/cpp: Ordinal functions (Ord, Chr, Succ, Pred, Inc, Dec)
+ * - runtime_containers.h/cpp: DynArray<T>, Set<T>
+ * - runtime_memory.h/cpp: Memory management (New, Dispose, GetMem, Move)
+ * - runtime_math.h/cpp: Math functions (Abs, Sqrt, Sin, Cos, etc.)
+ * - runtime_file.h/cpp: File I/O (Text, Binary files)
+ * - runtime_exceptions.h/cpp: Exception handling
+ * - runtime_cmdline.h/cpp: Command line parameters
+ * - runtime_format.h/cpp: String formatting
+ * 
+ * Version: 1.0
+ * Date: 2025-10-15
+ */
+
+#pragma once
+
+// ============================================================================
+// GLOBAL INCLUDES (required before np namespace)
+// ============================================================================
+
+#include <iostream>
+#include <string>
+#include <functional>
+#include <cstdint>
+#include <vector>
+#include <unordered_set>
+#include <memory>
+#include <sstream>
+#include <iomanip>
+#include <stdexcept>
+#include <cassert>
+#include <array>
+#include <cstring>
+#include <cmath>
+#include <cstdlib>
+#include <ctime>
+#include <fstream>
+#include <sys/stat.h>
+#include <algorithm>
+
+
+
+// ============================================================================
+// MODULAR INCLUDES IN DEPENDENCY ORDER
+// ============================================================================
+
+#include "runtime_types.h"
+#include "runtime_operators_custom.h"
+#include "runtime_string.h"
+#include "runtime_console.h"
+#include "runtime_control.h"
+#include "runtime_operators.h"
+#include "runtime_ordinal.h"
+#include "runtime_containers.h"
+#include "runtime_memory.h"
+#include "runtime_math.h"
+#include "runtime_file.h"
+#include "runtime_exceptions.h"
+#include "runtime_cmdline.h"
+#include "runtime_format.h"

bin/projects/NPBench/runtime/runtime_cmdline.cpp

@@ -0,0 +1,11 @@
+/**
+ * NitroPascal Runtime - Command Line Implementation
+ */
+
+#include "runtime_cmdline.h"
+
+namespace np {
+
+// Command line functions are header-only
+
+} // namespace np

bin/projects/NPBench/runtime/runtime_cmdline.h

@@ -0,0 +1,35 @@
+/**
+ * NitroPascal Runtime - Command Line Parameters
+ */
+
+#pragma once
+
+#include "runtime_types.h"
+#include "runtime_string.h"
+
+namespace np {
+
+// ============================================================================
+// COMMAND LINE PARAMETERS
+// ============================================================================
+
+inline int _argc = 0;
+inline char** _argv = nullptr;
+
+inline void InitCommandLine(int argc, char* argv[]) {
+    _argc = argc;
+    _argv = argv;
+}
+
+inline Integer ParamCount() {
+    return _argc - 1;
+}
+
+inline String ParamStr(const Integer AIndex) {
+    if (AIndex < 0 || AIndex >= _argc) {
+        return String(u"");
+    }
+    return String(_argv[AIndex]);
+}
+
+} // namespace np

bin/projects/NPBench/runtime/runtime_console.cpp

@@ -0,0 +1,32 @@
+/**
+ * NitroPascal Runtime - Console I/O Implementation
+ */
+
+#include "runtime_console.h"
+
+#ifdef _WIN32
+#include <windows.h>
+#include <io.h>
+#include <fcntl.h>
+#endif
+
+namespace np {
+
+void InitializeConsole() {
+#ifdef _WIN32
+    SetConsoleOutputCP(CP_UTF8);
+    SetConsoleCP(CP_UTF8);
+    _setmode(_fileno(stdout), _O_BINARY);
+    _setmode(_fileno(stderr), _O_BINARY);
+    HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
+    if (hOut != INVALID_HANDLE_VALUE) {
+        DWORD dwMode = 0;
+        if (GetConsoleMode(hOut, &dwMode)) {
+            dwMode |= ENABLE_VIRTUAL_TERMINAL_PROCESSING;
+            SetConsoleMode(hOut, dwMode);
+        }
+    }
+#endif
+}
+
+} // namespace np

bin/projects/NPBench/runtime/runtime_console.h

@@ -0,0 +1,52 @@
+/**
+ * NitroPascal Runtime - Console I/O
+ */
+
+#pragma once
+
+#include "runtime_types.h"
+#include "runtime_operators_custom.h"
+#include "runtime_string.h"
+#include <iostream>
+
+namespace np {
+
+// ============================================================================
+// CONSOLE INITIALIZATION
+// ============================================================================
+
+void InitializeConsole();
+
+// ============================================================================
+// I/O FUNCTIONS
+// ============================================================================
+
+template<typename... Args>
+void Write(Args&&... args) {
+    std::cout << std::boolalpha;
+    (std::cout << ... << std::forward<Args>(args));
+}
+
+template<typename... Args>
+void WriteLn(Args&&... args) {
+    std::cout << std::boolalpha;
+    (std::cout << ... << std::forward<Args>(args));
+    std::cout << std::endl;
+}
+
+inline void WriteLn() {
+    std::cout << std::endl;
+}
+
+template<typename T>
+void ReadLn(T& value) {
+    std::cin >> value;
+}
+
+inline void ReadLn(String& value) {
+    std::string line;
+    std::getline(std::cin, line);
+    value = String(line);
+}
+
+} // namespace np

bin/projects/NPBench/runtime/runtime_containers.cpp

@@ -0,0 +1,11 @@
+/**
+ * NitroPascal Runtime - Containers Implementation
+ */
+
+#include "runtime_containers.h"
+
+namespace np {
+
+// Containers are header-only (templates)
+
+} // namespace np