🔄 DevLog: Seamless Pascal + C++ Mixing - Write Both Languages in One Statement

[jarroddavis68]

Version: JetPascal 0.2.0+

🎉 What's New

JetPascal now lets you mix Pascal and C++ code freely in the same program, the same statement, even the same expression. No mode switches. No declarations. No wrapper code.

Just write both languages together.

💡 What This Means

You can now:

✅ Call C++ standard library functions from Pascal
✅ Call Pascal runtime functions from C++ code
✅ Mix both languages in a single expression
✅ Use C++ math, string, and I/O functions directly
✅ Debug with accurate line numbers pointing to your Pascal source

And it all happens automatically.

📝 Example: Mixing Pascal and C++

Here's what you can write now:

program MixDemo;
begin
  // Pascal output
  writeln('Hello from Pascal!');
  
  // C++ output
  std::cout << "Hello from C++!" << std::endl;
  
  // Mix them in one statement!
  writeln('Pascal writeln with C++ math: ', std::sqrt(16.0));
  
  // C++ calling Pascal functions
  std::cout << "Args: " << ParamCount() << std::endl;
  printf("Program: %s\n", ParamStr(0));
  
  // Both in same expression
  writeln('Result: ', ParamCount() + 100);
end.

This just works. No special setup. No mode switches. No declarations.

🔬 Real Examples We Tested

We verified this with 8 different mixing scenarios:

1. Pure Pascal

writeln('Hello from Pascal!');
writeln('Program: ', ParamStr(0));

Standard Pascal code works as always.

2. Pure C++

std::cout << "Hello from C++!" << std::endl;
printf("Direct C printf\n");

Write C++ directly in your Pascal program.

3. Pascal Calling C++

writeln('C++ string: ', std::string("test"));
writeln('C++ math: ', std::sqrt(16.0));
writeln('Simple math: ', 2 + 2);

Use C++ standard library functions inside Pascal statements.

4. C++ Calling Pascal

std::cout << "Count: " << ParamCount() << std::endl;
printf("Name: %s\n", ParamStr(0));

Call Pascal runtime functions from C++ code - they automatically get the jp:: namespace.

5. Pascal Calling Pascal

writeln('Program: ', ParamStr(0));
writeln('Args: ', ParamCount());

Normal Pascal code continues to work perfectly.

6. Mixed Expressions

std::cout << "Mixed: " << ParamCount() + 100 << std::endl;

C++ I/O with Pascal functions and C++ math operators.

7. Complex Nesting

writeln('Result: ', std::sqrt(16.0));
std::cout << "Info: " << ParamStr(0) << std::endl;

Nested function calls work correctly with proper parenthesis matching.

8. Multiple Arguments

writeln('Count: ', ParamCount(), ' Name: ', ParamStr(0), ' Calc: ', 3 * 7);

Mix Pascal functions, literals, and expressions in one call.

🎯 What Makes This Special

No Mode Switches
You don't need to enable "C++ mode" or switch between languages. Just write what you need.

No Declarations
You don't need to declare C++ functions. Just use them. The C++ compiler handles everything.

No Namespace Confusion
Pascal functions automatically get the right namespace when called from C++ code.

No Mental Overhead
Write Pascal where Pascal makes sense. Write C++ where C++ makes sense. Mix them where mixing makes sense.

💻 Generated C++ Output

When you write:

writeln('Math: ', std::sqrt(16.0));
std::cout << "Count: " << ParamCount() << std::endl;

JetPascal generates:

#line 4 "YourFile.pas"
  jp::writeln("Math: ", std::sqrt(16.0));
#line 5 "YourFile.pas"
  std::cout << "Count: " << jp::ParamCount() << std::endl;

Notice:

• Pascal writeln becomes jp::writeln
• C++ std::sqrt stays as-is
• Pascal ParamCount() becomes jp::ParamCount() in C++ context
• #line directives map back to your Pascal source

All automatic. All correct.

🔧 What This Opens Up

Access to C++ Standard Library

// String manipulation
writeln('Length: ', std::strlen("hello"));

// Math functions  
writeln('Sqrt: ', std::sqrt(16.0));
writeln('Abs: ', std::abs(-42));

// I/O
std::cout << "Direct output" << std::endl;
std::cerr << "Error output" << std::endl;

Use C/C++ Functions Directly

// Standard C library
printf("Value: %d\n", 42);
sprintf(buffer, "Formatted %s", "string");

// System calls
std::system("dir");

Mix in Complex Expressions

// All in one writeln
writeln('Total: ', ParamCount() + std::abs(-5) + 10);

// All in one cout
std::cout << "Result: " << (ParamCount() * 2) + std::sqrt(16.0) << std::endl;

🎓 How to Use It

Step 1: Write Pascal code as normal

Step 2: When you need C++ functionality, just use it:

• std::cout for output
• std::sqrt, std::abs for math
• printf, sprintf for C functions
• Any C++ standard library function

Step 3: Compile and run - it just works

Quick Start Example

Create test.pas:

program QuickTest;
begin
  writeln('Pascal says: ', ParamCount(), ' arguments');
  std::cout << "C++ says: " << ParamCount() << " arguments" << std::endl;
end.

Build and run:

jetpascal build
test arg1 arg2

Output:

Pascal says: 2 arguments
C++ says: 2 arguments

🚀 Why This Matters

For Pascal Developers:
You get instant access to the entire C++ ecosystem. Need string formatting? Use std::format. Need file I/O? Use std::filesystem. Need math? Use <cmath>. All available directly.

For C++ Developers:
You can write clean Pascal syntax where it makes sense, and drop into familiar C++ when needed. Best of both worlds.

For Everyone:
No more writing wrapper code. No more FFI declarations. No more "glue" between languages. Just write code.

📊 What Changed from Before

Before:

// Need to declare everything
function cpp_sqrt(x: Double): Double; cdecl; external;
function cpp_strlen(s: PChar): Integer; cdecl; external;

begin
  writeln('Result: ', cpp_sqrt(16.0));
end.

After:

begin
  writeln('Result: ', std::sqrt(16.0));
end.

From declaration hell to just writing code.

🎯 Current Status

What Works Now:

• ✅ Mixing Pascal and C++ statements
• ✅ Calling C++ from Pascal expressions
• ✅ Calling Pascal from C++ expressions
• ✅ Nested function calls (both languages)
• ✅ Complex expressions mixing both
• ✅ Accurate debugging with #line directives

🎬 Try It Yourself

Create this test program:

program FullTest;
begin
  // Test 1: Pascal basics
  writeln('=== Test 1: Pure Pascal ===');
  writeln('Hello from Pascal!');
  
  // Test 2: C++ basics
  writeln('=== Test 2: Pure C++ ===');
  std::cout << "Hello from C++!" << std::endl;
  
  // Test 3: Mix them
  writeln('=== Test 3: Mixed ===');
  writeln('Pascal with C++ math: ', std::sqrt(16.0));
  std::cout << "C++ with Pascal: " << ParamCount() << std::endl;
  
  // Test 4: Complex
  writeln('=== Test 4: Complex ===');
  writeln('Result: ', ParamCount() + std::abs(-10));
  
  writeln('=== All tests complete! ===');
end.

Build, run, and see both languages working together seamlessly!

💭 Final Thoughts

This feature represents a fundamental shift in how Pascal interoperates with C++. We're not "calling into" C++. We're not "wrapping" C++.

We're just using both languages naturally.

Write Pascal where Pascal is elegant. Use C++ where C++ is powerful. Mix them where mixing makes sense.

That's the JetPascal way.

---

JetPascal™ - Accelerate Your Code!