Interpret-Syntax
Zurück Nach oben

Hauptmenü Aufbau Variablen In/Out Zuweisungen Konstanten Kontrollfluß Streams
Funktionen...

Aufbau der Syntax
Deklarationen Variablen
In-/Outputs (Ein-/Ausgänge)
Zuweisungen
Funktionen Einfache void-Funktionen, keine Parameterübergabe
Sektionen Init {Block}
Execute {Block}
Done {Block}
Block Einzelnes Statement
Folge von Statements innerhalb geschweifter Klammern ({statement_1, ..., statement_n})
Statement Leeres Statement (;)
Zuweisung (siehe auch Deklarationen)
Kontrollfluß-Anweisung
Ausgabe auf Stream.
Funktionsaufruf
 
Konventionen Ein leeres Programm (keine Eingabe im Editfeld des Dialogs) wird akzeptiert.
Vor der ersten Sektion muß mindestens eine Variable oder ein Port definiert werden.
Sektionen sind optional, deklarierte Sektionen dürfen aber nicht leer sein.
In Funktionen können keine Parameter übergeben und keine Rückgabewerte erhalten werden.
Variablen
Datentypen int (ganze Zahl),
double (Komma-Zahl)
char (Zeichen)
als Skalar oder Vektor fester Länge
int name; double name; char name;
int name[size]; double name[size]; char name[size];
Name Bezeichner für Variable: mit Buchstaben beginnende Zeichenkette aus Buchstaben, Zahlen und '_'.
Länge Arraygröße (ganze Zahl > 0)
für Strings: Stringlänge+1
char c[3]; c="abc"; // falsch: Arraygröße zu klein
 
Konventionen keine Trennung mit Kommas
Länge > 0
Länge für Strings = Länge+1
Variablen im Deklarationsteil

Variablen sind global
Keine Initialisierung während der Deklaration.
int i, j, k; //falsch
double d[0]; //falsch
char c[3]; c="abc"; // falsch: Arraygröße zu klein
int i; execute {...}
int i = 22; // falsch
In-/Output
Syntax input trigger name(TITyp,TIBezeichner,Datentyp,Bezeichner)
input trigger name(Datentyp,Bezeichner)
input name(TITyp,TIBezeichner,Datentyp,Bezeichner)
input name(Datentyp,Bezeichner)
output name(TITyp,TIBezeichner,Datentyp,Bezeichner)
output name(Datentyp,Bezeichner)
input trigger Control("SWORD","BIN");
input trigger Data("TYPEINFO","..","DOUBLE[]","..");
input Parameter("SWORD","Param1");
output Data("TYPEINFO","TypeInfo","SWORD[]","BIN");
output Parameter("DOUBLE","Frequenz");
name Bezeichner für Ein-/Ausgang
(mit Buchstaben beginnende Zeichenkette aus Buchstaben, Zahlen und '_')
TITyp Datentyp für Typinformation "TYPEINFO" Typinformation: Signalname, Einheit, Bereich, Samplerate, Zeitstempel, Status
TI
Bezeichner
Bezeichner für Typ-Information "TypeInfo"
Datentyp für Daten, Parameter
Vorsicht: Ausgangsdatentypen benötigen unbekannte Länge SWORD[],DOUBLE[],UBYTE[]
int
"SWORD"
"SWORD[1]"
"SWORD[]
double
"DOUBLE"
"DOUBLE[1]"
"DOUBLE[]"
char


"UBYTE[]"
Daten
Bezeichner
Bezeichner für Datentyp definiert (BIN, Bin_VEC, TIME_DOMAIN, FREQUENCY_DOMAIN, ...) oder beliebig (Frequenz, Spannung, ...)
 
Konventionen Ein- und Ausgänge werden im Deklarationsteil festgelegt
Datentyp + Bezeichner sind obligatorisch
Zuweisungen
Syntax name=ausdruck
name Bezeichner für Ein-/Ausgang
(mit Buchstaben beginnende Zeichenkette aus Buchstaben, Zahlen und '_')
(mathemat.) Ausdruck: besteht aus Werten, Variablen (Skalar bzw. Array), Konstanten, Operatoren und Funktionsaufrufen int i; i=99; i=!i; i++; double d[10]; double e[10];
output out("TYPEINFO","TypeInfo","DOUBLE[]","TIME_DOMAIN");
execute
{
for ( i=0; i<10; i++) d[i]=i/10.0;
e=d; out << d;
out[8] = 1.234     // Einzelwerte werden mit = ausgegeben !!!
}
Operatoren logisch, Vergleich, arithmetisch, bitweise, Inkrementierung, Dekrementierung
vordefinierte Konstanten
const int TRUE; 1
const int true;  1
const int FALSE; 0
const int false; 0
const double = PI; 3.14159265358979323846264338327950288
const double = E; exp(1.0) = 2.718282     Eulersche Zahl
const int START;    0 = Paketstatus - Paketanfang
const int BUSY; 1 = Paketstatus - Paketmitte
const int STOP; 2 = Paketstatus - Paketende
const int START_STOP; 3 = Paketstatus - komplettes Paket
Kontrollfluß-Anweisungen
// Kommentar geht bis zum Zeilenende
if (expression) block  
if (expression) block else block if (i<1) print( "<" ); else print( ">=" );
while (expression) block while (i<5) {i=i+1; printInt(i);}
for ([init-expr]; [cond-expr]; [loop-expr]) block for (i=1;i<5;i=i+2) printInt(i);
break Beenden der innersten Schleife (while, for)
for (i=0;i<5;i++) {if (i>6) break;}
Streams
<<  Stream I/O zum Anhängen von Einzelwerten oder Vektoren des Ausgangsdatentyps an die zum  Ausgangs-Stream gehörende Variable.
Es können auch Daten an einen Eingang angefügt und anschließend am Ausgang ausgegeben werden.

input  inD ("TYPEINFO", "TypeInfo", "DOUBLE[]", "TIME_DOMAIN");
output outD("TYPEINFO", "TypeInfo", "DOUBLE[]", "TIME_DOMAIN");
double d[8]; int j[8];
execute
{
for ( i=0; i<4; i++) d[i]=i*1.0;
outD << inD; // Inhalt von inD wird an outD
outD << d;   // Vektor d wird an outD geschickt
inD  << d;   // Vektor d wird an inD angefügt
outD << inD; // Inhalt von inD wird an outD
}

inD seien 3 Werte: 6.6 7.7 8.8
Resultat an Ausgang outD: 14 6.6 7.7 8.8 0.0 1.0 2.0 3.0 6.6 7.7 8.8 0.0 1.0 2.0 3.0 (14=Arraygröße)