The Project | About Us | Contribute | Donations | License
HOME My courses Completed
◄ Previous
◄

Interfacing with Other Languages

Next ►
►

Interfacing with other programming languages is a powerful feature of Ada that allows you to leverage existing codebases, libraries, and systems written in different languages. This capability is particularly useful for integrating Ada into larger, multi-language projects or for utilizing specialized libraries that are not available in Ada.

Key Concepts

  1. Foreign Language Interface (FLI):

    • Ada provides mechanisms to interface with other languages, commonly C, through the use of pragmas and attributes.
    • The pragma Import, pragma Export, and pragma Convention are essential for interfacing.

  2. Pragma Import:

    • Used to call functions or procedures written in another language from Ada.
    • Syntax: pragma Import (Convention, Ada_Name, External_Name);

  3. Pragma Export:

    • Used to make Ada functions or procedures available to other languages.
    • Syntax: pragma Export (Convention, Ada_Name, External_Name);

  4. Pragma Convention:

    • Used to specify the calling convention for a subprogram or type.
    • Syntax: pragma Convention (Convention, Entity);

  5. C Interfacing:

    • The most common use case is interfacing with C due to its widespread use and compatibility.
    • Ada provides predefined conventions for C, making it easier to interface with C functions and libraries.

Practical Example

Interfacing with a C Function

Suppose we have a simple C function that adds two integers:

// add.c
int add(int a, int b) {
    return a + b;
}

To call this function from Ada, follow these steps:

  1. Declare the C function in Ada:
-- add.ads
package Add_C is
   function Add (A, B : Integer) return Integer;
   pragma Import (C, Add, "add");
end Add_C;
  1. Use the C function in an Ada program:
-- main.adb
with Ada.Text_IO; use Ada.Text_IO;
with Add_C;

procedure Main is
   Result : Integer;
begin
   Result := Add_C.Add(5, 7);
   Put_Line("The result is: " & Integer'Image(Result));
end Main;
  1. Compile and link the Ada and C code:
gcc -c add.c
gnatmake main.adb add.o

Explanation

  • Package Declaration:

    • The Add_C package declares the Add function and uses pragma Import to link it to the C function add.
    • The C convention is specified to indicate that the function follows the C calling convention.

  • Main Procedure:

    • The Main procedure calls the Add function from the Add_C package and prints the result.

  • Compilation:

    • The C code is compiled to an object file (add.o).
    • The Ada code is compiled and linked with the C object file using gnatmake.

Exercises

Exercise 1: Interfacing with a C Library

Task: Write an Ada program that interfaces with a C library function to calculate the square of a number.

C Code:

// mathlib.c
int square(int x) {
    return x * x;
}

Ada Code:

  1. Declare the C function in Ada:
-- mathlib.ads
package Math_Lib is
   function Square (X : Integer) return Integer;
   pragma Import (C, Square, "square");
end Math_Lib;
  1. Use the C function in an Ada program:
-- main.adb
with Ada.Text_IO; use Ada.Text_IO;
with Math_Lib;

procedure Main is
   Result : Integer;
begin
   Result := Math_Lib.Square(6);
   Put_Line("The square of 6 is: " & Integer'Image(Result));
end Main;
  1. Compile and link the Ada and C code:
gcc -c mathlib.c
gnatmake main.adb mathlib.o

Solution:

  • Follow the steps to declare the C function in Ada, use it in the Ada program, and compile and link the code as shown in the example.

Exercise 2: Exporting an Ada Function to C

Task: Write an Ada function that multiplies two integers and make it available to a C program.

Ada Code:

  1. Declare the Ada function and export it:
-- multiply.ads
package Multiply is
   function Multiply (A, B : Integer) return Integer;
   pragma Export (C, Multiply, "multiply");
end Multiply;
  1. Implement the Ada function:
-- multiply.adb
package body Multiply is
   function Multiply (A, B : Integer) return Integer is
   begin
      return A * B;
   end Multiply;
end Multiply;

C Code:

// main.c
#include <stdio.h>

extern int multiply(int a, int b);

int main() {
    int result = multiply(3, 4);
    printf("The result is: %d\n", result);
    return 0;
}
  1. Compile and link the Ada and C code:
gnatmake -c multiply.adb
gcc -c main.c
gnatbind multiply.ali
gnatlink multiply.ali main.o -o main

Solution:

  • Follow the steps to declare and implement the Ada function, use it in the C program, and compile and link the code as shown in the example.

Common Mistakes and Tips

  • Mismatch in Calling Conventions:

    • Ensure that the calling conventions match between Ada and the other language. Use pragma Convention if necessary.

  • Name Mangling:

    • Be aware of name mangling issues, especially when interfacing with C++. Use extern "C" in C++ to prevent name mangling.

  • Data Type Compatibility:

    • Ensure that the data types used in Ada and the other language are compatible. Use Ada's predefined types like Interfaces.C.int for better compatibility.

Conclusion

Interfacing with other languages in Ada allows you to extend the functionality of your Ada programs and integrate them with existing systems and libraries. By understanding and using pragmas like Import, Export, and Convention, you can effectively call functions across language boundaries. Practice with the provided exercises to solidify your understanding and explore more complex interfacing scenarios as you advance.

◄ Previous
◄
Next ►
►
The Project | About Us | Contribute | Donations | License
© Copyright 2024. All rights reserved