NitroPascal v0.3.0

[jarroddavis68]

🚀 NitroPascal v0.3.0: Production-Ready Milestone

TL;DR

NitroPascal just crossed the threshold from "interesting experiment" to "actually useful tool". With exception handling, comprehensive string manipulation, file I/O, dynamic arrays, sets, external library integration, and conditional compilation, you can now build real, robust, working applications in pure Delphi syntax that compile to native, high-performance C++.

🎯 The Productivity Milestone

This isn't just another incremental update - v0.3.0 is the milestone where NitroPascal becomes production-ready. You can now:

✅ Handle errors gracefully - try..except..finally for robust error handling
✅ Manipulate strings - Copy, parse, search, format, convert
✅ Read and write files - Text files, binary files, complete file system access
✅ Use dynamic data structures - Dynamic arrays and sets that grow at runtime
✅ Call external libraries - Integrate with any Windows DLL or Unix shared library
✅ Target multiple platforms - Conditional compilation for Windows, Linux, macOS
✅ Build real applications - Not toy programs - actual, productive software

🔥 What's New in v0.3.0

Exception Handling - The Game Changer

This is the big one. Real applications need real error handling. NitroPascal now has full exception support:

function LoadConfig(const AFileName: String): Boolean;
var
  F: TextFile;
  Line: String;
begin
  Result := False;
  try
    Assign(F, AFileName);
    Reset(F);
    try
      while not Eof(F) do
      begin
        ReadLn(F, Line);
        ProcessConfigLine(Line);
      end;
      Result := True;
    finally
      Close(F);  // Always cleanup, even if exception occurs
    end;
  except
    on E: Exception do
    begin
      WriteLn('Error loading config: ', E.Message);
      Result := False;
    end;
  end;
end;

What you get:

• try..except - Catch and handle errors
• try..finally - Guaranteed resource cleanup (files, memory, etc.)
• try..except..finally - Both error handling and cleanup
• RaiseException(msg) - Throw exceptions
• GetExceptionMessage() - Retrieve exception message
• Proper stack unwinding and resource cleanup

This changes everything. You can now write production-quality code that handles errors gracefully, cleans up resources properly, and recovers from failures. No more crossing your fingers and hoping nothing goes wrong.

String Manipulation - Finally Complete

No more cobbling together workarounds - NitroPascal now has a complete string library:

var
  S, SubStr: String;
  Pos: Integer;
begin
  S := 'Hello, World!';
  
  // Extract substrings
  SubStr := Copy(S, 1, 5);  // 'Hello'
  
  // Search strings
  Pos := Pos('World', S);   // 8
  
  // Modify strings
  Delete(S, 8, 6);          // 'Hello, !'
  Insert('Delphi', S, 8);   // 'Hello, Delphi!'
  
  // Transform strings
  S := UpperCase('test');   // 'TEST'
  S := LowerCase('TEST');   // 'test'
  S := Trim('  hello  ');   // 'hello'
  
  // Convert types
  S := IntToStr(42);        // '42'
  Pos := StrToInt('123');   // 123
  S := FloatToStr(3.14);    // '3.14'
  
  // Format output
  S := Format('Value: %d, Percent: %.2f%%', [42, 85.5]);
end.

File I/O - Build Real Applications

Read configuration files. Parse data. Write logs. Generate reports. Do actual work:

procedure ProcessDataFile(const AFileName: String);
var
  F: TextFile;
  Line: String;
  Count: Integer;
begin
  if not FileExists(AFileName) then
    raise Exception.Create('File not found: ' + AFileName);
  
  Count := 0;
  Assign(F, AFileName);
  Reset(F);
  try
    while not Eof(F) do
    begin
      ReadLn(F, Line);
      if ProcessLine(Line) then
        Inc(Count);
    end;
    WriteLn('Processed ', Count, ' lines');
  finally
    Close(F);  // Guaranteed cleanup!
  end;
end;

Dynamic Arrays - Real Data Structures

Static arrays are fine for fixed-size data, but real applications need dynamic structures:

var
  Items: array of Integer;
  Names: array of String;
  I: Integer;
begin
  // Create and resize arrays at runtime
  SetLength(Items, 100);
  for I := 0 to High(Items) do
    Items[I] := I * 2;
  
  // Arrays grow as needed
  SetLength(Names, 10);
  Names[0] := 'Alice';
  Names[1] := 'Bob';
  
  WriteLn('Array has ', Length(Names), ' elements');
end.

Sets - Efficient Membership Testing

Need to track which options are enabled? Which days are selected? Use sets:

type
  TDayOfWeek = (Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday);
  TDays = set of TDayOfWeek;
var
  WorkDays: TDays;
begin
  WorkDays := [];
  Include(WorkDays, Monday);
  Include(WorkDays, Tuesday);
  Include(WorkDays, Wednesday);
  Include(WorkDays, Thursday);
  Include(WorkDays, Friday);
  
  if Monday in WorkDays then
    WriteLn('Monday is a work day');
  
  Exclude(WorkDays, Friday);  // Working 4-day week!
end.

External Library Integration - Use Any Library

Call Windows APIs. Use existing C libraries. Integrate with any native code:

// Call Windows MessageBox
function MessageBoxW(hWnd: Integer; lpText, lpCaption: PWideChar; 
  uType: Cardinal): Integer; stdcall; external 'user32.dll';

// Call C standard library
function strlen(str: PAnsiChar): Integer; cdecl; external 'msvcrt.dll';

begin
  // Automatic string conversion at call site
  MessageBoxW(0, 'Hello from NitroPascal!', 'Info', 0);
end.

The compiler automatically tracks external libraries and links them. It converts Pascal string types to C types at the call site. Zero friction interoperability.

Conditional Compilation - One Codebase, All Platforms

Write platform-specific code without breaking other platforms:

program CrossPlatform;

{$ifdef MSWINDOWS}
uses Windows;
{$endif}

{$ifdef POSIX}
uses Unix;
{$endif}

begin
  {$ifdef WIN64}
  WriteLn('Running on 64-bit Windows');
  {$endif}
  
  {$ifdef LINUX}
  WriteLn('Running on Linux');
  {$endif}
  
  {$ifdef DEBUG}
  WriteLn('Debug build');
  {$else}
  WriteLn('Release build');
  {$endif}
end.

Available defines:

• Platform: WIN32, WIN64, LINUX, MACOS, MSWINDOWS, POSIX
• Architecture: CPUX64, CPU386, CPUARM64
• Build mode: DEBUG, RELEASE
• App type: CONSOLE_APP, GUI_APP

Math Library - Scientific Computing

Trigonometry. Statistics. Numerical analysis. Now possible:

var
  Angle, Result: Double;
  X, Y: Integer;
begin
  // Trigonometry
  Angle := 45.0;
  Result := Sin(Angle);
  Result := Cos(Angle);
  Result := ArcTan(1.0);
  
  // Rounding
  Result := Round(3.7);   // 4
  Result := Trunc(3.7);   // 3
  Result := Ceil(3.2);    // 4
  Result := Floor(3.7);   // 3
  
  // Utilities
  X := Max(10, 20);       // 20
  Y := Min(10, 20);       // 10
  Result := Sqrt(16.0);   // 4.0
  Result := Abs(-42);     // 42
  
  Randomize;
  X := Random(100);       // 0..99
end.

Enhanced Control Flow

Better loop control and function declarations:

var
  I: Integer;
  Found: Boolean;
begin
  // Early exit from loops
  for I := 1 to 100 do
  begin
    if I = 50 then
      break;              // Exit loop
    if I mod 2 = 0 then
      continue;           // Skip to next iteration
    ProcessItem(I);
  end;
  
  // Early return from functions
  function FindValue(A: array of Integer; Target: Integer): Boolean;
  var
    I: Integer;
  begin
    for I := 0 to High(A) do
      if A[I] = Target then
        exit(True);       // Return immediately with value
    Result := False;
  end;
  
  // Forward declarations
  procedure Helper; forward;
  
  procedure Main;
  begin
    Helper();  // Can call before implementation
  end;
  
  procedure Helper;
  begin
    WriteLn('Helper called');
  end;
  
  // Simplified record access
  with MyRecord do
  begin
    Field1 := 10;
    Field2 := 'Hello';
    Method();
  end;
end.

💪 Why This Matters

This release closes the gap between "proof of concept" and "production tool". You now have:

• 🛡️ Real exception handling - robust error recovery and resource cleanup
• ✨ Real string handling - not just concatenation, actual manipulation
• 📁 Real file I/O - read configs, parse data, write logs
• 📊 Real data structures - dynamic arrays and sets that grow at runtime
• 🔗 Real interoperability - call any external library seamlessly
• 🌐 Real cross-platform - one codebase, multiple targets
• 🎯 Real productivity - build actual applications, not toy programs

🎁 The RTL Keeps Getting Better

The Runtime Library now includes:

• np::String - Complete string manipulation with Delphi semantics
• np::DynArray - Dynamic arrays that grow and shrink
• np::Set - Efficient set operations and membership testing
• File I/O wrappers - Maintain Delphi file handling semantics in C++
• Math functions - Comprehensive mathematical operations
• String conversions - Seamless type conversions
• Exception support - Full try..except..finally implementation

Everything maintains true Delphi semantics while generating optimal C++ code that compiles to native machine code via Zig's LLVM backend.

📚 Documentation

Want to see what's working RIGHT NOW?

• COVERAGE.md - Complete feature checklist showing all implemented features
• DESIGN.md - Deep dive into the RTL wrapping architecture
• MANUAL.md - User guide and getting started

Check the docs to see exactly what you can build today!

🚀 Getting Started

# Clone the repository
git clone https://github.com/tinyBigGAMES/NitroPascal
cd NitroPascal

# Build a real application
nitro init test01 -t program
cd test01
nitro build
nitro run

# Cross-compile for Linux
# Set the target compiler directive in your source
{$target "x86_64-linux-musl"}

nitro build

Example: A robust file processing utility with exception handling:

program FileStats;

var
  F: TextFile;
  Line: String;
  LineCount, WordCount: Integer;
  
begin
  if ParamCount < 1 then
  begin
    WriteLn('Usage: filestats <filename>');
    Halt(1);
  end;
  
  if not FileExists(ParamStr(1)) then
  begin
    WriteLn('Error: File not found');
    Halt(1);
  end;
  
  LineCount := 0;
  WordCount := 0;
  
  try
    Assign(F, ParamStr(1));
    Reset(F);
    try
      while not Eof(F) do
      begin
        ReadLn(F, Line);
        Inc(LineCount);
        WordCount := WordCount + CountWords(Line);
      end;
    finally
      Close(F);  // Always cleanup!
    end;
    
    WriteLn('Lines: ', LineCount);
    WriteLn('Words: ', WordCount);
  except
    on E: Exception do
    begin
      WriteLn('Error processing file: ', E.Message);
      Halt(1);
    end;
  end;
end.

This is a real, working, ROBUST program that compiles to native code. Not a demo. Not a toy. A production-quality utility with proper error handling.

🌐 Community

• GitHub: tinyBigGAMES/NitroPascal
• Discord: Join our community
• Issues: Found a bug? Report it
• Discussions: Share your projects in discussions

🔮 What's Next?

With the productivity foundation in place What features do YOU need for your projects? Let us know in the discussions!

🎊 The Bottom Line

NitroPascal v0.3.0 is ready for real work.

You can now build actual applications: file processors, data analyzers, system utilities, command-line tools, and more. With exception handling, you can write robust, production-quality code that handles errors gracefully and cleans up resources properly.

Stop waiting. Start building.

---

Write pure Delphi. Get native C++ performance. Ship everywhere. 🚀

File Integrity

Files are signed with minisign using this public key:
RWTqBYfsUOCQscb6ZeknLC0On3cvWCVzMzlHamtgXNaDOO4bNs3WCSkV

---

This discussion was created from the release NitroPascal v0.3.0.