Parameter beim Kompilieren Prüfen

N. G. Persönliche Seite #3631327
Lesenswert?
• ▲
▼ 
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
1
void init(uint8_t reichweite, uint8_t genauigkeit)

2
{

3
  //#if reichweite < 50

4
  //#define small_range 43*reichweite+43

5
  //#warning eine Reichweite kann zu klein sein

6
  //#elif reichweite > 200

7
  //#warning die Reichweite kann zu gross sein

8
  //#endif

9
  unsigned char buffer[2];

10
  buffer[0]=two;

11
  buffer[1]=reichweite;

12
  send(buffer,2);

13
  sleep(50);

14
  //#if genauigkeit > 16

15
  //#error Die Analogverstaerkung liegt ausserhalb des vorgesehenen Bereichs

16
  //#endif

17
  buffer[0]=one;

18
  buffer[1]=genauigkeit;

19
  send(buffer,2);

20
}

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
Antwort Zitieren Bearbeiten Thread verschieben Thread sperren Anmeldepflicht aktivieren Anpinnen Thread löschen Thread mit anderem zusammenführen Beitrag melden
Johann L. Persönliche Seite #3631397
Lesenswert?
• ▲
▼ 
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:

1
/* header.h */

2
...

3
#ifndef MESSWERT

4
#error ...

5
#elif MESSWERT < 10

6
#warning ...

7
#endif

8


9
static inline void init (unsigned int messwert)

10
{ ... }

11


12


13
/* main.c */

14


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

16


17
#include "header.h"

18


19
int main (void)

20
{

21
    init (MESSWERT);

22
}



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

1
__attribute__((__error__ ("x ist zu klein")))

2
extern void small_x (void);

3


4
__attribute__((__warning__ ("x ist zur Compilezeit nicht bekannt")))

5
__attribute__((__noinline__,__noclone__))

6
static void unknown_x (void)

7
{

8
   __asm ("");

9
}

10


11
static inline __attribute__((__always_inline__))

12
void init (const int x)

13
{

14
    if (!__builtin_constant_p (x))

15
        unknown_x();

16
    else if (x < 10)

17
        small_x();

18
}

19


20
void fx (int x)

21
{

22
    init (x);

23
}

24


25
void f1 (void)

26
{

27
    init (1);

28
}

29


30
void f10 (void)

31
{

32
    init (10);

33
}


Das wirft:

1
In function 'init',

2
    inlined from 'fx' at <stdin>:24:10:

3
<stdin>:17:18: warning: call to 'unknown_x' declared with attribute warning: x ist zur Compilezeit nicht bekannt [enabled by default]

4
         unknown_x();

5
                  ^

6
In function 'init',

7
    inlined from 'f1' at <stdin>:29:10:

8
<stdin>:19:16: error: call to 'small_x' declared with attribute error: x ist zu klein

9
         small_x();
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Thread beobachten

Antwort schreiben

Bitte melde dich an, um einen Beitrag zu schreiben.

Bestehender Account

oder

Mit Google-Account einloggen

Noch kein Account?

Die Registrierung ist kostenlos und dauert nur eine Minute.

Jetzt registrieren