如何从C语言.h文件导入#define常量至Ada语言？

Hey there! I’ve tackled this exact problem before, so let me break down how to handle both named constant imports/exports between C and Ada, plus how to bring in those tricky #define values from a C header.

First, let's cover the straightforward case: importing a standard const from your C header into Ada.

Step 1: Export the Constant from C #

In your file.h, declare the constant as extern:

// file.h
extern const int MAX_BUFFER_SIZE;

Then define its value in a corresponding .c file:

// file.c
const int MAX_BUFFER_SIZE = 1024;

Step 2: Import the Constant into Ada #

In Ada, use pragma Import to link to the C constant. Make sure the type matches exactly (e.g., C's int maps to Ada's Integer for most systems):

package C_Constants is
   -- Import the C constant; note the name must match the C identifier
   pragma Import (C, MAX_BUFFER_SIZE, "MAX_BUFFER_SIZE");
   MAX_BUFFER_SIZE : Integer;
end C_Constants;

You can mark it as constant in Ada if you don't intend to modify it (though the C const already enforces immutability):

MAX_BUFFER_SIZE : constant Integer;

#define values are preprocessor directives, not actual variables in the compiled code—so you can't directly Import them like you do with const constants. You have two reliable options:

Option 1: Manual Mapping (Simple for Small Sets) #

If the number of #define values is small or rarely changes, just replicate them as Ada constants directly.

For example, if your file.h has:

#define MAX_CONNECTIONS 5
#define DEFAULT_TIMEOUT 3000
#define PI 3.14159f

Create an Ada package with matching constants:

package C_Defines is
   MAX_CONNECTIONS : constant Integer := 5;
   DEFAULT_TIMEOUT : constant Integer := 3000;
   PI : constant Float := 3.14159;
end C_Defines;

This is quick and avoids extra build steps, just make sure to keep them in sync if the C values change.

Option 2: C Wrapper (Best for Large/Dynamic Sets) #

If you have lots of #defines or they change frequently, wrap them in C as const variables first, then import those into Ada.

Step 1: Create a C Wrapper #

Make a new .c file to convert #defines to const variables:

// wrapper_constants.c
#include "file.h"

// Wrap each #define as an extern const
const int MAX_CONNECTIONS_WRAPPER = MAX_CONNECTIONS;
const int DEFAULT_TIMEOUT_WRAPPER = DEFAULT_TIMEOUT;
const float PI_WRAPPER = PI;

Then declare these wrapped constants in a header:

// wrapper_constants.h
extern const int MAX_CONNECTIONS_WRAPPER;
extern const int DEFAULT_TIMEOUT_WRAPPER;
extern const float PI_WRAPPER;

Step 2: Import the Wrapped Constants into Ada #

Now you can use pragma Import just like with regular C constants:

package C_Wrapper_Constants is
   pragma Import (C, MAX_CONNECTIONS_WRAPPER, "MAX_CONNECTIONS_WRAPPER");
   MAX_CONNECTIONS_WRAPPER : constant Integer;

   pragma Import (C, DEFAULT_TIMEOUT_WRAPPER, "DEFAULT_TIMEOUT_WRAPPER");
   DEFAULT_TIMEOUT_WRAPPER : constant Integer;

   pragma Import (C, PI_WRAPPER, "PI_WRAPPER");
   PI_WRAPPER : constant Float;
end C_Wrapper_Constants;

This way, any changes to the original #defines in file.h will automatically propagate to Ada when you recompile the wrapper.

• Always ensure type compatibility between C and Ada types (e.g., C's unsigned long maps to Ada's Unsigned_64 on 64-bit systems). Mismatched types can cause runtime errors.
• If you're using GNAT, there are some compiler-specific tricks (like using gnatprep for preprocessing), but the wrapper method is portable across all Ada compilers.

内容的提问来源于stack exchange，提问作者Sterisk