Declare `@ccall` only when asked by the user

[czgdp1807]

So as of now any function declared with @ccall in LPython code is always declared in the generated C code. However if someone has already declared their function in some other .h file (and included this file by editing the generated code) then function decorated with @ccall shouldn't be re-declared in the generated code. So we have to make the declaration of @ccall functions optional. Some options,

1. ccall(static=true).
2. ccall(declare=false).

An example:

@ccall
def foo(a: i16):
    pass

def myfunc():
    a: i16 = 1
    foo(a)

Generated C code:

#include <inttypes.h>
#include <foo_header.h> # foo already declared in foo_header.h
#include <stdlib.h>
#include <stdbool.h>
#include <stdio.h>
#include <string.h>
#include <lfortran_intrinsics.h>

#define ASSERT(cond)                                                           \
    {                                                                          \
        if (!(cond)) {                                                         \
            printf("%s%s", "ASSERT failed: ", __FILE__);                       \
            printf("%s%s", "\nfunction ", __func__);                           \
            printf("%s%d%s", "(), line number ", __LINE__, " at \n");          \
            printf("%s%s", #cond, "\n");                                       \
            exit(1);                                                           \
        }                                                                      \
    }
#define ASSERT_MSG(cond, msg)                                                  \
    {                                                                          \
        if (!(cond)) {                                                         \
            printf("%s%s", "ASSERT failed: ", __FILE__);                       \
            printf("%s%s", "\nfunction ", __func__);                           \
            printf("%s%d%s", "(), line number ", __LINE__, " at \n");          \
            printf("%s%s", #cond, "\n");                                       \
            printf("%s", "ERROR MESSAGE:\n");                                  \
            printf("%s%s", msg, "\n");                                         \
            exit(1);                                                           \
        }                                                                      \
    }


struct dimension_descriptor
{
    int32_t lower_bound, length;
};
// Forward declarations
void _lpython_main_program();
#ifndef IGNORE_DECLARATION
void foo(int16_t a);
#endif
void myfunc();

// Implementations
void _lpython_main_program()
{
    myfunc();
}

void myfunc()
{
    int16_t a;
    a = 1;
    foo(a);
}

int main(int argc, char* argv[])
{
    _lpython_main_program();
    return 0;
}

As you can see foo is declared but I have added foo_header.h on my own in the generated C code. So I will receive a re-declaration from C compiler. That's why an option should be provided to make declaration of @ccall generated functions optional.

[czgdp1807]

@certik @rebcabin

[rebcabin]

Too bad there isn't an #ifndef foo ... or maybe there is? It might be interesting to turn this issue inside out: put the burden on the person declaring foo in the .h file instead of on LPython? What I mean is that the declaration of foo in the .h file comes with something like #define FOO_PREDECLARATION, then the declaration emitted by LPython is something like

#ifndef FOO_PREDECLARATION
void foo(int_16t a);
#endif

[czgdp1807]

I see. If there are large number of such functions then adding flags for each function in the .h would be difficult for the user. Also if the .h file is uneditable due to some reasons then ifndef approach may not work.

[czgdp1807]

So after discussion with @rebcabin we figured that all the ccall decorated functions can go into #ifndef IGNORE_REDECLARATIONS … #endif block. If the user defines IGNORE_REDECLARATIONS in their headers or in a build file then all the redeclarations in LPython’s generated C code will be ignored.

[czgdp1807]

Well seems like C compiler doesn't raise an error when we declare a function which is already declared in some header we have included.

Example 1

See https://github.com/czgdp1807/lpython/commit/4fa09ae9be3e34ece9a9e6fdc8c01c1a6525c8ac

Instructions (assuming you are in project root already)

• cd integration_tests
• mkdir b3
• cmake -DKIND=c ..
• make bindc_05 (succeeds)
• ./bindc_05

Example 2

#include <math.h>
#include <stdio.h>

// redeclaring pow function from math.h
double pow(double, double);

int main() {
    double a = 2.0, b = 2.0;
    double ans = pow(a, b);
    printf("%lf\n", ans);
    return 0;
}

Succeeds and gives 4.0000 as output.

So I am unable to re-produce an example which causes the problem as speculated in the issue description. @ronnuriel If you have any re-producer of the problem then please feel free to share it.

[ronnuriel]

@czgdp1807 the compile did raise an error but I will check that again and get back to you
Btw We are not using Make file we are using Meson

[czgdp1807]

Sure. Send me an example of the problem (with the code, the instructions to run the code and the error you get). In the second example (where I re-declare pow) I simply used my compiler to generate the executable (no build systems of any kind). AFAICT, C compiler ignores the forward declarations if you are already providing it in a header file.

[Smit-create]

Well seems like C compiler doesn't raise an error when we declare a function which is already declared in some header we have included.

I also didn't get any error/warning for the same example.