meson/test cases/common/152 shared module resolving.../prog.c

#include <stdio.h>
#include <assert.h>
#ifdef _WIN32
#include <windows.h>
#else
#include <dlfcn.h>
#endif

#if defined _WIN32 || defined __CYGWIN__
  #define DLL_PUBLIC __declspec(dllexport)
#else
  #if defined __GNUC__
    #define DLL_PUBLIC __attribute__ ((visibility("default")))
  #else
    #pragma message ("Compiler does not support symbol visibility.")
    #define DLL_PUBLIC
  #endif
#endif

typedef int (*fptr) (void);

int DLL_PUBLIC
func_from_executable(void)
{
  return 42;
}

int main(int argc, char **argv)
{
  int expected, actual;
  fptr importedfunc;

  if (argc=0) {};  // noop

#ifdef _WIN32
  HMODULE h = LoadLibraryA(argv[1]);
#else
  void *h = dlopen(argv[1], RTLD_NOW);
#endif
  assert(h != NULL);

#ifdef _WIN32
  importedfunc = (fptr) GetProcAddress (h, "func");
#else
  importedfunc = (fptr) dlsym(h, "func");
#endif
  assert(importedfunc != NULL);
  assert(importedfunc != func_from_executable);

  actual = (*importedfunc)();
  expected = func_from_executable();
  assert(actual == expected);

#ifdef _WIN32
  FreeLibrary(h);
#else
  dlclose(h);
#endif

  return 0;
}
Support implibs for executables on Windows Add a boolean 'implib' kwarg to executable(). If true, it is permitted to use the returned build target object in link_with: On platforms where this makes sense (e.g. Windows), an implib is generated for the executable and used when linking. Otherwise, it has no effect. (Rather than checking if it is a StaticLibrary or SharedLibary, BuildTarget subclasses gain the is_linkable_target method to test if they can appear in link_with:) Also install any executable implib in a similar way to a shared library implib, i.e. placing the implib in the appropriate place Add tests of: - a shared_module containing a reference to a symbol which is known (at link time) to be provided by the executable - trying to link with non-implib executables (should fail) - installing the implib (This last one needs a little enhancement of the installed file checking as this is the first install test we have which needs to work with either MSVC-style or GCC-style implib filenames) 8 years ago			`#include <stdio.h>`
			`#include <assert.h>`
			`#ifdef _WIN32`
			`#include <windows.h>`
			`#else`
			`#include <dlfcn.h>`
			`#endif`

			`#if defined _WIN32 \|\| defined __CYGWIN__`
			`#define DLL_PUBLIC __declspec(dllexport)`
			`#else`
			`#if defined __GNUC__`
			`#define DLL_PUBLIC __attribute__ ((visibility("default")))`
			`#else`
			`#pragma message ("Compiler does not support symbol visibility.")`
			`#define DLL_PUBLIC`
			`#endif`
			`#endif`

			`typedef int (*fptr) (void);`

			`int DLL_PUBLIC`
			`func_from_executable(void)`
			`{`
			`return 42;`
			`}`

use '-Werror=unused-parameter' for gcc/clang on project tests and -fimplicit-none on fortran Fortran: check for undeclared variables by forcing implicit none everywhere C/C++: check for unused parameters and return types removed unused variables from test cases ci: do missing return and unused arg check with Github Actions 5 years ago			`int main(int argc, char **argv)`
Support implibs for executables on Windows Add a boolean 'implib' kwarg to executable(). If true, it is permitted to use the returned build target object in link_with: On platforms where this makes sense (e.g. Windows), an implib is generated for the executable and used when linking. Otherwise, it has no effect. (Rather than checking if it is a StaticLibrary or SharedLibary, BuildTarget subclasses gain the is_linkable_target method to test if they can appear in link_with:) Also install any executable implib in a similar way to a shared library implib, i.e. placing the implib in the appropriate place Add tests of: - a shared_module containing a reference to a symbol which is known (at link time) to be provided by the executable - trying to link with non-implib executables (should fail) - installing the implib (This last one needs a little enhancement of the installed file checking as this is the first install test we have which needs to work with either MSVC-style or GCC-style implib filenames) 8 years ago			`{`
			`int expected, actual;`
			`fptr importedfunc;`

use '-Werror=unused-parameter' for gcc/clang on project tests and -fimplicit-none on fortran Fortran: check for undeclared variables by forcing implicit none everywhere C/C++: check for unused parameters and return types removed unused variables from test cases ci: do missing return and unused arg check with Github Actions 5 years ago			`if (argc=0) {}; // noop`

Support implibs for executables on Windows Add a boolean 'implib' kwarg to executable(). If true, it is permitted to use the returned build target object in link_with: On platforms where this makes sense (e.g. Windows), an implib is generated for the executable and used when linking. Otherwise, it has no effect. (Rather than checking if it is a StaticLibrary or SharedLibary, BuildTarget subclasses gain the is_linkable_target method to test if they can appear in link_with:) Also install any executable implib in a similar way to a shared library implib, i.e. placing the implib in the appropriate place Add tests of: - a shared_module containing a reference to a symbol which is known (at link time) to be provided by the executable - trying to link with non-implib executables (should fail) - installing the implib (This last one needs a little enhancement of the installed file checking as this is the first install test we have which needs to work with either MSVC-style or GCC-style implib filenames) 8 years ago			`#ifdef _WIN32`
			`HMODULE h = LoadLibraryA(argv[1]);`
			`#else`
			`void *h = dlopen(argv[1], RTLD_NOW);`
			`#endif`
			`assert(h != NULL);`

			`#ifdef _WIN32`
			`importedfunc = (fptr) GetProcAddress (h, "func");`
			`#else`
			`importedfunc = (fptr) dlsym(h, "func");`
			`#endif`
			`assert(importedfunc != NULL);`
			`assert(importedfunc != func_from_executable);`

			`actual = (*importedfunc)();`
			`expected = func_from_executable();`
			`assert(actual == expected);`

			`#ifdef _WIN32`
			`FreeLibrary(h);`
			`#else`
			`dlclose(h);`
			`#endif`

			`return 0;`
			`}`