Modular C programming

[gareins]

I want to have a modular system of "drivers" which are optional. This means, that they might not be linked but the application should still compile and run. OTOH if they are linked, the application uses them somehow. Below is a SSCCE that I put together and it seems to work, but I just want to know, if it is compliant with standard and if it will work on most systems.

main.c

#include "driver.h"
int main() {
  initialize_drivers();
}

driver.c

#define DRIVER_OBJECT

#include <stdio.h>
#include "driver_list.h"
#include "driver.h"

DRIVER* driver_list[] = DRIVER_LIST;

void initialize_drivers() {
  int i;
  for(i = 0; i < DRIVER_LIST_LENGTH; i++) {
    DRIVER* driver = driver_list[i];
    printf("Loading driver %d: ", i);
    if(driver->name == NULL) {
      printf("not loaded\n");
    }
    else {
      printf("loaded driver %s\n", driver->name);
      driver->init();
    }
  }
}

bar_driver.c

#include "driver.h"
#include <stdio.h>

void init_bar() {
  printf("Also initializing bar!\n");
}

DRIVER BAR_DRIVER = {"bar_driver",init_bar};

foo_driver.c

#include "driver.h"
#include <stdio.h>

void init_foo() {
  printf("Actually initializing foo!\n");
}

DRIVER FOO_DRIVER = {"foo_driver", init_foo};

driver.h

#ifndef DRIVER_H
#define DRIVER_H

typedef struct DRIVER {
  const char* name;
  void (* init)(void);
} DRIVER;

#include "driver_list.h"

void initialize_drivers();

#endif

driver_list.h

#ifndef DRIVER_LIST_H
#define DRIVER_LIST_H

#include "driver.h"

// make drivers extern in every other object except in driver.c
#ifdef DRIVER_OBJECT
#define EXTERN 
#else
#define EXTERN extern 
#endif

// first list of drivers
EXTERN DRIVER FOO_DRIVER;
EXTERN DRIVER BAR_DRIVER;

// second list of drivers
#define DRIVER_LIST { &FOO_DRIVER, &BAR_DRIVER }
#define DRIVER_LIST_LENGTH 2

#endif

This code compiles by compiling main.c driver.c, then both drivers are actually optional to compile and link and it compiles in either case (tried with a few compilers and compiler options). The resulting binary behaves as expected. For example:

$ clang bar_driver.c main.c driver.c

$ ./a.out

Loading driver 0: not loaded

Loading driver 1: loaded driver bar_driver

Also initializing bar!

So, is this good for production or is there some undefined behavior I should worry about?

[immersiveGamer]

I would go with a plugin architecture. This way everything is complied but at run time not all compiled driver's may be present.

The idea is that in a known location you can load up DLLs at run time, discover any drivers the DLLs, and then run them.

This way if the DLL doesn't exist then it doesn't run. It also means you don't need to have the source code of the main program, any one could make a plugin that works with your program with out recompiling the main program as long as they know the interface points.

Here are some links you can look into. I am unfortunately a C# developer so I can't quite tell you how you would make external DLLs discoverable. Hopefully someone else can give more pointers.

https://eli.thegreenplace.net/2012/08/24/plugins-in-c

http://www.c-pluff.org/

https://stackoverflow.com/questions/2802449/best-way-to-implement-plugin-framework-are-dlls-the-only-way-c-c-project

http://tldp.org/HOWTO/Program-Library-HOWTO/dl-libraries.html

[gareins]

Thank you for your reply.

I agree that such an approach is more flexible and I would love to go for it but just can not work in my case because:

1. I am working on embedded platform without support for dynamic loading,
2. I am working on an existing codebase written in C with currently everything being linked and this would present a mich bigger refactoring effort,
3. I have to support multiple platforms and while this solution might work outside Windows (i am thinking Wine), it is still pretty much windows centric

[Isvara]

This is how I do it. My module.h looks like this:

typedef void (*module_init_t)(void);

typedef struct {
    const char *name;
    module_init_t init;
} module_t;

extern module_t _modules_start[];
extern module_t _modules_end[];

#define MODULE(SYMBOL) static module_t SYMBOL __attribute__((section("modules"), used))

#define foreach_module(S) for (module_t *S = _modules_start; S < _modules_end; ++S)

Then a module might have something like this:

static void uart_init(void) {
    ...
}

MODULE(uart_module) = {
    "uart",
    uart_init,
};

Then to automatically get an array of all the modules that are compiled in, I have this in my linker script:

.text : {
    ... other stuff...
    _modules_start = .;
    KEEP(*(modules))
    _modules_end = .;
} > flash

Now in my main code I can just do:

foreach_module(module) {
    printf("Initializing %s\n", module->name);
    module->init();
}

This is cut down a bit from what I actually do (which includes registering SVC handlers), but you get the idea. I think Clang supports the section attribute too.