Compiler-Anweisungen

Compiler-Anweisungen Verwendung von Compiler-Anweisungen

Über Compiler-Anweisungen wird die Übersetzung der Prozedur gesteuert. Alle Compileranweisungen beginnen mit dem Zeichen @ und müssen in der ersten Spalte einer Zeile stehen.

@A+ oder @A-

Diese Anweisung schaltet auf den A+ Compiler um (@A+). Im Designer wird standardmäßig der A+ Compiler verwendet.

@I:<Name>

Mit dieser Anweisung wird ein anderer Prozedurtext an der entsprechenden Stelle zur Übersetzungszeit eingebunden. <Name> ist dabei der Name der einzubindenden Prozedur. Die Anzahl von @I-Anweisungen ist nicht beschränkt.

Eine eingebundene Prozedur kann wiederum @I-Anweisungen enthalten. Die maximale Verschachtelungstiefe beträgt dabei 16 Ebenen. Sofern mehrmals dieselbe Prozedur angegeben ist, wird die Prozedur tatsächlich nur einmal eingebunden, da wiederholte Einbindungen ignoriert werden.

@C+ oder @C-

In den Prozeduren kann mit zwei unterschiedlichen 'Styles' gearbeitet werden. Dabei gibt es zum einen den Pascal-Style, bei dem die Syntax ähnlich der Sprache Pascal ist. Dieser Stil entspricht dem der 4.0 Prozeduren und ist standardmäßig eingestellt. Mit @C+ wird der C-Style aktiviert, bei dem die Syntax eher der Sprache C ähnelt.

Im Wesentlichen wirkt sich das auf den Standardsprachumfang aus. Zum Beispiel wird aus dem if-Konstrukt

IF <Bedingung>
THEN <Befehl>

im PASCAL-Style,

if (<Bedingung>)
  <Befehl>

im C-Style. Weitere Unterschiede sind im Kapitel Style-Unterschiede beschrieben.

Innerhalb des Prozedurtextes können Bereiche in Abhängigkeit von Bedingungen übersetzt werden. Dazu können verschiedene Compileranweisungen verwendet werden.

@define und @undef

Mit der Anweisung @define kann eine Metavariable definiert werden. Die Anzahl der Metavariablen ist nicht beschränkt. Die Variable kann mit @undef wieder entfernt werden.

Syntax:

@define <Name>
@undef <Name>

Im weiteren Verlauf der Prozedur kann mit den Anweisungen @ifdef und @ifndef die Existenz der Metavariablen abgefragt werden. Innerhalb der Prozedur kann eine Variable wieder entfernt werden. Auf diese Weise kann zum Beispiel ein Debugmodus für nur eine Funktion aktiviert werden.

@ifdef oder @ifndef ... @else ... @endif

Mit diesen Anweisungen kann die Existenz bzw. die Nicht-Existenz einer Metavariablen geprüft werden.

Syntax:

@ifdef <Name>        @ifndef <Name>
  <Prozedurtext>       <Prozedurtext>
[@else               [@else
  <Prozedurtext>]      <Prozedurtext>]
@endif               @endif

Ist die Metavariable mit @define definiert, wird mit @ifdef der Prozedurtext nach der Anweisung übersetzt. Gibt es eine @else-Anweisung, wird der Prozedurtext im ELSE-Fall übersetzt, wenn die Metavariable nicht definiert ist.

Im Falle der Compileranweisung @ifndef wird der Prozedurtext nach der Anweisung nur dann übersetzt, wenn die angegebene Metavariable nicht definiert ist.

Der Prozedurtext kann beliebigen Text beinhalten, insbesondere weitere Compiler-Anweisungen. @ifdef und @ifndef können in bis zu 30 Ebenen geschachtelt werden.

Beispiele

Im folgenden Beispiel wird gezeigt, wie Debug-Anweisungen auch nach der Fehlersuche im Prozedurtext stehen bleiben können, um die relevanten Informationen auch noch bei einer späteren Fehlersuche ausgeben zu können.

@A+
@C+

@define debugmode

main
{
@ifdef debugmode
  DbgConnect('*', false, false);
@endif
  ...
}

sub Funktion1
(
  aParameter : int
) : int;

  local
  {
    tRetValue : int;
  }

{
@ifdef debugmode
@ifndef debugsilent
  DbgTrace('Funktion Funktion1 aufgerufen');
  DbgTrace('Parameter: ' + CnvAI(aParameter));
@endif
@endif
  ...
  // Debugmodus abschalten
@undef debugmode
  ...
@ifdef debugmode
@ifndef debugsilent
  DbgTrace('Rückgabewert: ' + CnvAI(tRetValue));
@endif
@endif
  return(tRetValue);
}

Es können auch innerhalb einer Include-Prozedur mehrere Varianten implementiert werden. In den Prozeduren müssen lediglich vor dem Include die entsprechenden Meta-Variablen definiert werden.

@A+
@C+

@ifdef ungenau
define
{
  mPi : 3.14
}
@endif

@ifdef genau5
define
{
  mPi : 3.14159
}
@endif

@ifdef genau20
define
{
  mPi : 3.14159265358979323846
}
@endif

In folgender Prozedur wird die Definition eingebunden:

@A+
@C+

@define genau5

@I:PI.def

...