Parameter beim Kompilieren Prüfen

[N. G. (newgeneration)]

Hallo Forum,

mal wieder eine Frage von mir:
Ist es möglich beim Kompilieren direkt die Parameter zu prüfen?
Bsp: in den Kommentaren steht der Code wie ich es meine

void init(uint8_t reichweite, uint8_t genauigkeit)
{
  //#if reichweite < 50
  //#define small_range 43*reichweite+43
  //#warning eine Reichweite kann zu klein sein
  //#elif reichweite > 200
  //#warning die Reichweite kann zu gross sein
  //#endif
  unsigned char buffer[2];
  buffer[0]=two;
  buffer[1]=reichweite;
  send(buffer,2);
  sleep(50);
  //#if genauigkeit > 16
  //#error Die Analogverstaerkung liegt ausserhalb des vorgesehenen Bereichs
  //#endif
  buffer[0]=one;
  buffer[1]=genauigkeit;
  send(buffer,2);
}

Mir fällt auf die schnelle nur enums ein, aber ich will kein enum mit 
256 Werten erstellen; structs gehen vllt auch, sind aber meiner Meinung 
nach unkomfortabel.
Der Code ist aus einer Headerdatei, um den SRF10 zu bedienen.

Ich hoffe ich konnte meine Frage genau genug stellen ;)

PS: Zielhardware ist ein ATmega32

[Rufus Τ. F. (rufus)]

N. G. schrieb:
> Ist es möglich beim Kompilieren direkt die Parameter zu prüfen?

Nein.

[Johann L. (gjlayde)]

1) Der Compiler ist kein Hellseher. Woher bitte soll er den Wert von 
reichweite kennen?

2) Der Aufrufer von init() kennt die Werte wahrscheinlich, d.h. dort 
können sie überprüft werden:

/* header.h */
...
#ifndef MESSWERT
#error ...
#elif MESSWERT < 10
#warning ...
#endif

static inline void init (unsigned int messwert)
{ ... }


/* main.c */

#define MESSWERT 123 /* Oder per Commandline -DMESSWERT=123 */

#include "header.h"

int main (void)
{
    init (MESSWERT);
}

3) Im Compiler sind solche Tests nur bedingt möglich und abhängig von 
dem Optimierungsgrad.  Du willst deine Quelle nicht damit verunstalten:

__attribute__((__error__ ("x ist zu klein")))
extern void small_x (void);

__attribute__((__warning__ ("x ist zur Compilezeit nicht bekannt")))
__attribute__((__noinline__,__noclone__))
static void unknown_x (void)
{
   __asm ("");
}

static inline __attribute__((__always_inline__))
void init (const int x)
{
    if (!__builtin_constant_p (x))
        unknown_x();
    else if (x < 10)
        small_x();
}

void fx (int x)
{
    init (x);
}

void f1 (void)
{
    init (1);
}

void f10 (void)
{
    init (10);
}

Das wirft:

In function 'init',
    inlined from 'fx' at <stdin>:24:10:
<stdin>:17:18: warning: call to 'unknown_x' declared with attribute warning: x ist zur Compilezeit nicht bekannt [enabled by default]
         unknown_x();
                  ^
In function 'init',
    inlined from 'f1' at <stdin>:29:10:
<stdin>:19:16: error: call to 'small_x' declared with attribute error: x ist zu klein
         small_x();

[Robert (Gast)]

Du kannst dem Compiler beim Aufruf Parameter übergeben: -D__mySymbol. 
Hilft das?

[Robert (Gast)]

http://stackoverflow.com/questions/2410976/how-to-define-a-string-in-gcc-command-line