Inline Funktionen mit NC30

[Andre Groß (Gast)]

Hi !!
Ich versuche im Moment einen Standard für Module und Schnittstellen zu
entwerfen, der mit verschiedenen Prozessoren/Compilern verwendbar ist.

Leider habe ich Probleme bei der Verwendung von Inline-Funktionen.
Ich würde gerne folgende Struktur verwenden :

/*  modul.c  */

#include "modul.h"

int x;
inline void setX (int value)
{
x = value;
}

/*  modul.h  */

inline void setX (int value);

/*  modul_interface.h  */

extern inline void setX (int value);

/*  using_modul.c  */

include "modul_interface.h"

int main (void)
{
setX (5);

return 0;
}

Leider erlaubt NC30 anscheinend keine Verwendung der Schlüsselwörter
'extern' und 'inline' gemeinsam.
Alternativ könnte meine Schnittstelle so aussehen:

extern int x;
inline void setX (int value)
{
x = value;
}

In diesem Fall würde mir aber die Zugriffseinschränkung auf x
verlorengehen, was dem ganzen den Sinn raubt...


Jetzt bin ich entweder auf der Suche nach einer Möglichkeit es doch zu
verwenden, oder einem sinnvollen Ersatz.

Ich bin für jeden noch so kleinen Tipp dankbar.

Andre

[Stefan (Gast)]

Hi Andre,

wofür brauchst Du die Inline-Deklaration?
Die erzeugt statt einem Funktionsaufruf direkten Code in Deinem
Hauptprogramm. Zugegeben, das geht schneller.

In Zusammenhang mit "extern" kann das aber (meiner Meinung nach)
nicht funktionieren:
Wenn Du bei einer Funktion "extern" benutzt, dann teilst Du dem
Compiler mit, dass es woanders diese Funktion gibt und welche Parameter
sie hat. Die Adresse, die der Compiler noch nicht wissen kann, setzt
dann der Linker ein.
Wenn Du bei Inline-Code "extern" benutzt, hat der Compiler leider
keine Ahnung, welchen Inline-Code er stattdessen einsetzen kann.
Deshalb funktioniert "extern" wohl nur mit Funktionsaufrufen,
Variablen, alles wo nachträglich eine Adresse eingesetzt werden muss.
Alles andere überfordert den Linker.

Übrigens würde ich "inline" auch aus einem anderen Grund nicht
benutzen: im Standard ist es nicht definiert, also ungeeignet für
Deine Intention, portabel zu bleiben.

Inline-Code kannst Du übrigens schön mit Makros erzeugen, allerdings
nicht in Deiner Anwendung (Kapselung von x).

Gruß Stefan

[Matthias (Gast)]

Hi

inline ist AFAIK schon ein gültiges Schlüsselwort das auch im
C-Standard definiert ist. Aber der Compiler muß es nicht
gezwungenermaßen als inline Funktion in den Code einbauen. Je nach
eingestellter Optimierrung kann also was anderes dabei rauskommen. Aber
Jörg wird das gleich genauer erklären. Wenn nicht hilft eine Nachfrage
in dclc

Matthias

[Andre Groß (Gast)]

Hi Stefan,

Ich habe die ersten Überlegungen/Experimente mit
Visual C ausgetestet. Zugegeben vielleicht
nicht optimal, aber dort funktionierte es :-)

Ich hätte gerne Funktionen, die es mir erlauben den
Zugriff einzuschränken z.B. nur lesen.
(Das System soll von 5 bis n Mitarbeitern verwendet
werden, so das damit mögliche Fehler eingeschränkt
werden. Nicht jeder kann eine Doku lesen. ;-))

Um die Anzahl der Funktionsaufrufe zu veringern wollte
ich inline verwenden, da ein System aus einer größeren
Anzahl Module aufgebaut sein kann und die Performance
merklich zurückgehen könnte.

Die Funktionen können unter umständen auch komplexer sein,
wobei "große" Funktionen mit sicherheit nicht inline werden.

Da ich keine bessere Lösung gefunden habe, werde ich es wahrscheinlich
so machen, dass ich die inline-Funktion und die extern-Deklaration
zusammen in das Header-File packe. Nicht optimal, aber was will man
machen...

Gruß,
      Andre

[Stefan (Gast)]

@Matthias:
Sorry, kann sein, dass meine C-Doku da nicht auf dem neuesten Stand
ist. In Crosscompilern würde ich aber nicht von einer Unterstützung
ausgehen.

@Andre:
Wie wäre es, wenn Du einen Debug-Schalter in Dein Projekt aufnimmst? In
modul.h verwendest Du dann abhängig vom Schalter entweder externe
Funktions-Deklarationen (bei Debug=1) oder inline-Funktionen.
Während der Entwicklung kann dann niemand Deine internen Variablen
benutzen, und in der endgültigen Fassung macht der Inline Dein Programm
fix.

Stefan

[Andre Groß (Gast)]

@Stefan
Die Idee mit dem Intern, bzw. extern ist net schlecht...
Problem ist nur, das inline-Funktion komplett im Header sein muss,
während bei extern-Funktionen der Body in einer Source ist...
und jede Funktion 2x in der Source haben ist net so toll..

trotzdem ist das ganze eine Überlegung wert. Danke für den Tipp

Andre

[Andre Groß (Gast)]

Mal eine andere Frage..
welche Adressierungsarten kennt ihr ??
Da meine Module für verschiedene Prozessoren sein sollen,
sollten alle Arten der Adressierung (durch defines) beachtet werden.
Die Folgenden fallen mir auf Anhieb ein:

- keine Besonderheit (wie bei PC)
- near, far
- xdata, idata, ..

Andre