Extending Prolix with C/C++

Expanding the capabilities of Prolix through the integration of new modules is a straightforward endeavor for those proficient in C programming. This extensibility empowers developers to accomplish tasks within Prolix that might be challenging or impossible through native Prolix functionality alone. The augmentation of Prolix functionality via these modules encompasses two significant capabilities: the introduction of novel integrated objects and the invocation of C library functions and system calls.

When crafting extensions in C, developers can seamlessly introduce innovative types of integrated objects, broadening the repertoire of available tools within the Prolix programming environment. These new objects can be tailored to address specific needs or perform specialized tasks, enhancing the language's versatility and adaptability to diverse programming requirements.

Moreover, the integration of C modules allows developers to tap into the rich ecosystem of C libraries and leverage existing system calls. This not only facilitates the reuse of well-established and optimized functionality but also opens up avenues for interfacing with low-level system operations that might be crucial for certain applications.

The process of integrating these modules involves a harmonious synergy between Prolix and C, where the strengths of each language complement the other. Developers can seamlessly bridge the gap between Prolix's simplicity and C's robust capabilities, achieving a balance that caters to both high-level and low-level programming needs.

In essence, the extensibility offered by integrating new C modules into Prolix not only broadens the language's horizons by introducing diverse object types but also connects it with the powerful functionalities inherent in C libraries and system calls. This symbiotic relationship between Prolix and C provides developers with a flexible and potent environment for addressing a myriad of programming challenges.

Integrating C Code as Shared Library for Prolix with GCC

Let’s look at an example function in a file called square.c: 

int square(int i) {
    return i * i;
}

Let's elaborate on the compilation process, explaining each component of the command and providing additional details on the flags used: 

gcc -fPIC -shared -o libsquare.dll square.c -Wall -Werror -Wextra -pedantic

Breaking down the extended command:

  • gcc: As mentioned earlier, this invokes the GNU Compiler Collection, a vital tool for compiling C code.
  • -fPIC: This flag, short for Position Independent Code, is crucial when creating a shared library. It ensures that the compiled code can be loaded at any memory address, enhancing flexibility and compatibility.
  • -shared: This flag signifies that we are generating a shared library, also known as a dynamic link library (.dll on Windows or .so on Unix-like systems).
  • -o libsquare.dll: Here, we specify the output file's name using the -o option. In this case, it's a shared library named libsquare.so. Adjust the extension based on the platform (.dll for Windows, .so for Unix-like systems).
  • square.c: This is the C source code file that we intend to compile. Replace it with the actual name of your C source file.
  • -Wall -Werror -Wextra -pedantic: These flags, as discussed previously, activate various warning messages, treat warnings as errors, and enforce strict adherence to coding standards. They contribute to code quality and robustness.

Upon successful compilation, you will obtain a shared library file (e.g., libsquare.so or clib.dll) that contains the compiled code from the square.c file. This library can then be imported and utilized in the Prolix code.

Remember to place the compiled library file in a directory accessible to Prolix and adjust any necessary import statements or flags in the Prolix code to reference the newly compiled library. This meticulous approach ensures a smooth integration process, allowing the Prolix code to seamlessly leverage the functionality provided by the compiled C code.

Place Prolix Script and Compiled Library

Ensuring a smooth integration involves organizing your project directory. Follow these detailed steps:

Move the Compiled Library

Place the compiled library file (libsquare.dll) in the same directory as your Prolix script. This ensures convenient access during runtime. 

cp libsquare.dll /path/to/prolix/scripts/
Include Prolix Script

Ensure the Prolix script (square.prlx) is also in the same directory: 

cp square.prlx /path/to/prolix/scripts/

By consolidating both files in a single directory, you simplify the import process and enhance overall project organization.

Now that your project directory is well-organized, proceed to modify your Prolix script (square.prlx) to include the following import statement. This ensures access to the functionalities provided by the compiled C code: 

$cdll:open "libsquare.dll";

This $cdll:open opens the C library file, making its functions available for use in your Prolix script.

Now that the library is imported, you can call functions from it. Now you have a function named "square" with attributes 2 and 4, use the following syntax: 

$cdll:load "square" 2 4;

This statement loads the C function "square" with the specified attributes, allowing you to call and utilize its functionality in your Prolix script.

Here is a slight modification to the provided code for clarity: 

$cdll:open "libsquare.dll";
$cdll:load "square" 2 4;
$io:write $cdll:result; # Expected output: 16

Conclusion: Seamless Integration Achieved

By diligently following these comprehensive steps, you have successfully integrated your compiled C code into the Prolix codebase. Placing both the compiled library and Prolix script in the same directory streamlines the import process, allowing Prolix to effortlessly leverage the powerful functionalities provided by the C code. This organized approach ensures a robust and efficient development environment for your Prolix project.