feat: Add native x64 code generation with in-memory execution

- Complete TinyPascal → native x64 machine code compilation
- Arithmetic operations (ADD, SUB, MUL, DIV) working
- Variable management with Windows x64 calling convention
- Runtime function calls (PrintLn, IntToStr) integrated
- In-memory execution of generated code
- Test case: "10 + 5" compiles to 97 bytes, executes natively, prints "15"
- Added debug output integration with TinyPascal.Common

Author: jarroddavis68

examples/testbed/Testbed.dpr

@@ -57,7 +57,9 @@ uses
   TinyPascal.VM in '..\..\src\TinyPascal.VM.pas',
   TinyPascal.BytecodeGen in '..\..\src\TinyPascal.BytecodeGen.pas',
   TinyPascal.Value in '..\..\src\TinyPascal.Value.pas',
-  TinyPascal.Runtime in '..\..\src\TinyPascal.Runtime.pas';
+  TinyPascal.Runtime in '..\..\src\TinyPascal.Runtime.pas',
+  TinyPascal.X64Gen in '..\..\src\TinyPascal.X64Gen.pas',
+  TinyPascal.Common in '..\..\src\TinyPascal.Common.pas';
 
 begin
   ReportMemoryLeaksOnShutdown := True;

examples/testbed/Testbed.dproj

@@ -4,7 +4,7 @@
         <ProjectVersion>20.3</ProjectVersion>
         <FrameworkType>None</FrameworkType>
         <Base>True</Base>
-        <Config Condition="'$(Config)'==''">Debug</Config>
+        <Config Condition="'$(Config)'==''">Release</Config>
         <Platform Condition="'$(Platform)'==''">Win64</Platform>
         <ProjectName Condition="'$(ProjectName)'==''">Testbed</ProjectName>
         <TargetedPlatforms>2</TargetedPlatforms>
@@ -126,6 +126,8 @@
         <DCCReference Include="..\..\src\TinyPascal.BytecodeGen.pas"/>
         <DCCReference Include="..\..\src\TinyPascal.Value.pas"/>
         <DCCReference Include="..\..\src\TinyPascal.Runtime.pas"/>
+        <DCCReference Include="..\..\src\TinyPascal.X64Gen.pas"/>
+        <DCCReference Include="..\..\src\TinyPascal.Common.pas"/>
         <BuildConfiguration Include="Base">
             <Key>Base</Key>
         </BuildConfiguration>

examples/testbed/UTestbed.pas

@@ -56,6 +56,7 @@ implementation
 procedure RunTestbed();
 begin
   RunTPTests(False);
+  Test_X64_ProofOfConcept();
   Pause();
 end;
 

src/TinyPascal.Common.pas

@@ -0,0 +1,98 @@
+{==============================================================================
+   _____ _          ___                  _ ™
+  |_   _(_)_ _ _  _| _ \__ _ ___ __ __ _| |
+    | | | | ' \ || |  _/ _` (_-</ _/ _` | |
+    |_| |_|_||_\_, |_| \__,_/__/\__\__,_|_|
+               |__/ Pascal in your Pocket!
+
+ Copyright © 2025-present tinyBigGAMES™ LLC
+ All Rights Reserved.
+
+ https://github.com/tinyBigGAMES/TinyPascal
+
+ BSD 3-Clause License
+
+ Copyright (c) 2025-present, tinyBigGAMES LLC
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice, this
+    list of conditions and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the copyright holder nor the names of its
+    contributors may be used to endorse or promote products derived from
+    this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+==============================================================================}
+
+unit TinyPascal.Common;
+
+{$I TinyPascal.Defines.inc}
+
+interface
+
+uses
+  System.SysUtils;
+
+// Debug output control - no global variables exposed
+procedure SetDebugOutput(const AEnabled: Boolean);
+function GetDebugOutput(): Boolean;
+
+// Debug output routines - automatically check enabled state
+procedure DebugWriteLn(const AMessage: string); overload;
+procedure DebugWrite(const AMessage: string);
+procedure DebugWriteLn(const AFormat: string; const AArgs: array of const); overload;
+
+implementation
+
+var
+  LDebugEnabled: Boolean = True; // Private to unit - default enabled for development
+
+{ Debug Control Functions }
+
+procedure SetDebugOutput(const AEnabled: Boolean);
+begin
+  LDebugEnabled := AEnabled;
+end;
+
+function GetDebugOutput(): Boolean;
+begin
+  Result := LDebugEnabled;
+end;
+
+{ Debug Output Functions }
+
+procedure DebugWriteLn(const AMessage: string);
+begin
+  if not LDebugEnabled then Exit; // Early exit for performance
+  WriteLn(AMessage);
+end;
+
+procedure DebugWrite(const AMessage: string);
+begin
+  if not LDebugEnabled then Exit; // Early exit for performance
+  Write(AMessage);
+end;
+
+procedure DebugWriteLn(const AFormat: string; const AArgs: array of const);
+begin
+  if not LDebugEnabled then Exit; // Early exit for performance
+  WriteLn(Format(AFormat, AArgs));
+end;
+
+end.

src/TinyPascal.Runtime.pas

@@ -60,7 +60,7 @@ interface
     rtError        // General runtime error
   );
 
-// Runtime functions - simple approach
+// VM Runtime functions - simple approach
 function Runtime_Print(const AValue: TValue; const AStringPool: TStringList): TRuntimeResult;
 function Runtime_PrintLn(const AValue: TValue; const AStringPool: TStringList): TRuntimeResult;
 function Runtime_PrintLn_Empty(): TRuntimeResult;
@@ -71,8 +71,19 @@ function Runtime_FloatToStr(const AValue: TValue; const AStringPool: TStringList
 function Runtime_StrToFloat(const AValue: TValue; const AStringPool: TStringList): TValue;
 function Runtime_ResultToString(const AResult: TRuntimeResult): string;
 
+// Native X64-callable runtime functions
+procedure Runtime_Print_X64(const AValue: Int64); cdecl;
+procedure Runtime_PrintLn_X64(const AValue: Int64); cdecl;
+procedure Runtime_PrintLn_Empty_X64(); cdecl;
+function Runtime_IntToStr_X64(const AValue: Int64): PAnsiChar; cdecl;
+function Runtime_StrToInt_X64(const AString: PAnsiChar): Int64; cdecl;
+procedure Runtime_PrintString_X64(const AString: PAnsiChar); cdecl;
+procedure Runtime_PrintLnString_X64(const AString: PAnsiChar); cdecl;
+
 implementation
 
+{ VM Runtime Functions - Original Implementation }
+
 function Runtime_Print(const AValue: TValue; const AStringPool: TStringList): TRuntimeResult;
 var
   LText: string;
@@ -199,4 +210,86 @@ function Runtime_ResultToString(const AResult: TRuntimeResult): string;
   end;
 end;
 
+{ Native X64 Runtime Functions }
+
+procedure Runtime_Print_X64(const AValue: Int64); cdecl;
+begin
+  try
+    System.Write(IntToStr(AValue));
+  except
+    // Ignore errors in native calls
+  end;
+end;
+
+procedure Runtime_PrintLn_X64(const AValue: Int64); cdecl;
+begin
+  try
+    System.WriteLn(IntToStr(AValue));
+  except
+    // Ignore errors in native calls
+  end;
+end;
+
+procedure Runtime_PrintLn_Empty_X64(); cdecl;
+begin
+  try
+    System.WriteLn;
+  except
+    // Ignore errors in native calls
+  end;
+end;
+
+procedure Runtime_PrintString_X64(const AString: PAnsiChar); cdecl;
+begin
+  try
+    if Assigned(AString) then
+      System.Write(string(AnsiString(AString)));
+  except
+    // Ignore errors in native calls
+  end;
+end;
+
+procedure Runtime_PrintLnString_X64(const AString: PAnsiChar); cdecl;
+begin
+  try
+    if Assigned(AString) then
+      System.WriteLn(string(AnsiString(AString)));
+  except
+    // Ignore errors in native calls
+  end;
+end;
+
+var
+  LTempStringBuffer: array[0..255] of AnsiChar;
+
+function Runtime_IntToStr_X64(const AValue: Int64): PAnsiChar; cdecl;
+var
+  LStr: AnsiString;
+begin
+  try
+    LStr := AnsiString(IntToStr(AValue));
+    if Length(LStr) < Length(LTempStringBuffer) then
+    begin
+      StrPCopy(LTempStringBuffer, LStr);
+      Result := @LTempStringBuffer[0];
+    end
+    else
+      Result := nil;
+  except
+    Result := nil;
+  end;
+end;
+
+function Runtime_StrToInt_X64(const AString: PAnsiChar): Int64; cdecl;
+begin
+  try
+    if Assigned(AString) then
+      Result := StrToInt64(string(AnsiString(AString)))
+    else
+      Result := 0;
+  except
+    Result := 0;
+  end;
+end;
+
 end.

src/TinyPascal.Tests.pas

@@ -49,6 +49,8 @@ interface
 procedure RunTPTests(const APause: Boolean=True);
 procedure Pause(const APause: Boolean=True);
 
+procedure Test_X64_ProofOfConcept();
+
 implementation
 
 uses
@@ -61,7 +63,8 @@ implementation
   TinyPascal.AST,
   TinyPascal.Value,
   TinyPascal.Bytecode,
-  TinyPascal.VM;
+  TinyPascal.VM,
+  TinyPascal.X64Gen;
 
 procedure Pause(const APause: Boolean);
 begin
@@ -323,6 +326,119 @@ procedure Test15_AdvancedIfElseChain();
   ExecuteProgram(LSource, 'Test 15');
 end;
 
+procedure Test_X64_ProofOfConcept();
+var
+  LParser: TParser;
+  LProgram: TProgramNode;
+  LBytecodeGen: TBytecodeGenerator;
+  LGenResult: TBytecodeGenResult;
+  LX64Compiler: TX64Compiler;
+  LX64Result: TX64CompileResult;
+  LSource: UTF8String;
+begin
+  WriteLn('=== X64 PROOF OF CONCEPT TEST ===');
+  WriteLn('Testing native compilation with REAL runtime calls...');
+  WriteLn;
+
+  // Test with PrintLn to see actual output!
+  LSource := 'program X64RuntimeTest; var result: Int; begin result := 10 + 5; PrintLn(IntToStr(result)); end.';
+
+  WriteLn('Source: ', string(LSource));
+  WriteLn('Expected: Should print "15" from native x64 code!');
+  WriteLn;
+
+  try
+    // Parse (same as always)
+    LParser := TParser.CreateFromSource(LSource);
+    try
+      LProgram := LParser.Parse();
+      WriteLn('✓ Parsed successfully');
+    finally
+      LParser.Free();
+    end;
+
+    // Generate bytecode (same as always)
+    LBytecodeGen := TBytecodeGenerator.Create();
+    try
+      LGenResult := LBytecodeGen.Generate(LProgram);
+      try
+        if LGenResult.Success then
+        begin
+          WriteLn('✓ Generated bytecode successfully');
+          WriteLn('  Instructions: ', LGenResult.Program_.GetInstructionCount());
+          WriteLn('  Constants: ', LGenResult.Program_.GetConstantCount());
+          WriteLn('  Variables: ', LGenResult.Program_.GetVariableCount());
+          WriteLn;
+
+          // X64 compilation with REAL function calls!
+          LX64Compiler := TX64Compiler.Create();
+          try
+            WriteLn('--- ATTEMPTING X64 COMPILATION WITH RUNTIME CALLS ---');
+            LX64Result := LX64Compiler.CompileProgram(LGenResult.Program_);
+            try
+              if LX64Result.Success then
+              begin
+                WriteLn('🎉 X64 RUNTIME COMPILATION SUCCESS!');
+                WriteLn('Generated ', LX64Result.GeneratedCodeSize, ' bytes of x64 machine code');
+                WriteLn;
+
+                if LX64Result.CanExecuteInMemory then
+                begin
+                  WriteLn('🚀 ATTEMPTING IN-MEMORY EXECUTION...');
+                  WriteLn('This should actually print "15" from native x64 code!');
+                  WriteLn;
+
+                  if LX64Compiler.ExecuteInMemory() then
+                  begin
+                    WriteLn;
+                    WriteLn('🔥🔥🔥 COMPLETE SUCCESS! 🔥🔥🔥');
+                    WriteLn('You just executed compiled TinyPascal code natively!');
+                  end
+                  else
+                  begin
+                    WriteLn('❌ In-memory execution failed: ', LX64Compiler.ErrorMessage);
+                  end;
+                end
+                else
+                begin
+                  WriteLn('Code compiled but not ready for in-memory execution');
+                end;
+              end
+              else
+              begin
+                WriteLn('❌ X64 compilation failed: ', LX64Result.ErrorMessage);
+              end;
+            finally
+              LX64Result.Free();
+            end;
+          finally
+            LX64Compiler.Free();
+          end;
+
+        end
+        else
+        begin
+          WriteLn('❌ Bytecode generation failed: ', LGenResult.ErrorMessage);
+        end;
+      finally
+        LGenResult.Free();
+      end;
+    finally
+      LBytecodeGen.Free();
+      LProgram.Free();
+    end;
+
+  except
+    on E: Exception do
+    begin
+      WriteLn('❌ Exception: ', E.Message);
+    end;
+  end;
+
+  WriteLn;
+  WriteLn('=== END X64 RUNTIME TEST ===');
+end;
+
 procedure RunTPTests(const APause: Boolean);
 begin
   WriteLn('TinyPascal - COMPLETE LANGUAGE TEST SUITE');