:Revision=24
:HTML
<<
1
Syntaxhilfe cPCI Interpreter
$NoSort;Open
--
>>

<<
1.1 - 1
berblick
$NoSort
--
>>

<<
1.1.1 - 1.1
Syntaktische Elemente|Elemente
$NoSort
--
Der Interpreter verwendet den ASCII-Zeichensatz mit den Buchstaben <!CW>A bis <!CW>Z und <!CW>a bis <!CW>z, den Ziffern <!CW>0 bis <!CW>9 und weiteren Standardzeichen. Die Sprache unterscheidet nicht zwischen Gro- und Kleinschreibung. 

Das Leerzeichen (ASCII 32) und die Steuerzeichen (ASCII 0 bis 31 einschlielich ASCII 13 fr Zeilenvorschub) werden als Blanks oder WhiteSpace bezeichnet.

Kombinationen, die sich aus den grundlegenden syntaktischen Elementen (den sogenannten Token) zusammensetzen, ergeben <a href="1.1.7.1">Anweisungen</a>, Ausdrcke und Deklarationen . 

Eine Anweisung beschreibt eine algorithmische Aktion, die innerhalb eines  Programms ausgefhrt werden kann. 

Ein Ausdruck ist eine syntaktische Einheit, die in einer Anweisung enthalten ist und einen Wert beschreibt. 

Eine Deklaration definiert einen Bezeichner (z.B. den Namen einer Funktion oder Variablen), der in Ausdrcken und Anweisungen verwendet wird. Sie weist dem Bezeichner bei Bedarf auch Speicherplatz zu.
>>

<<
1.1.1.1 
Kommentare
--
Kommentare sind Quelltextteile, die von Interpreter ignoriert werden. Sie dienen zur Erluterung des Codes oder knnen dazu verwendet werden, einzelne Quelltextteile 'lahmzulegen'. 

Es existieren zwei Arten von Kommentaren:

<ol indent=12>
<li>Blockkommentare
Alle Zeichen nach einer ffnenden geschweiften Klammer <!CW>'{' bis zur ersten folgenden schlieenden geschweiften Klammer <!CW>'}' werden ignoriert. Ein Schachteln dieser Kommentare ist nicht mglich.

</li>
<li>Zeilenkommentare
Alle Zeichen nach einem doppelten Schrgstrich <!CW>'//' bis zum Zeilenende werden ignoriert.
</li>
</ol>
>>

<<
1.1.1.2
White-Spaces - Zwischenrume|White-Spaces
--
Einzelne Elemente der Interpretersprache werden durch Zwischenrume getrennt. 

Dies knnen sein : 
<ul indent=12>
<li>Leerzeichen</li>
<li>Tabulatorzeichen</li>
<li>Zeilenende</li>
</ul>
oder beliebige Kombinationen davon.

Ist das Ende eines Elementes eindeutig, so muss kein Zwischenraum eingefgt werden.
>>

<<
1.1.1.3
Reservierte Worte
--
Reservierte Worte sind Elemente der IP-Sprache, die vordefinert sind und fr den Interpreter ohne weitere vorherige Vereinbarung eine festgelegte Bedeutung haben.

Reservierte Worte sind unter anderem die Steuerelemente wie <!RW>begin, <!RW>end, <!RW>step sowie die Namen der IP-Objekte und deren Methoden. 

Reservierte Wrter drfen nicht als Bezeichner verwendet werden.

Wie auch bei den Bezeichnern wird nicht zwischen Gro- und Kleinschreibung unterschieden.
>>

<<
1.1.1.4
Bezeichner
--
Bezeichner werden fr Parameter, Variablen, Prozeduren, Funktionen verwendet. 

Obwohl ein Bezeichner beliebig lang sein darf, sollte die Lnge aus Grnden der Lesbarkeit und Geschwindigkeit maximal etwa 20 Zeichen lang sein.

Ein Bezeichner mu mit einem Buchstaben oder einem Unterstrich (_) beginnen und darf keine Leerzeichen enthalten. Auf das erste Zeichen knnen Buchstaben, Ziffern und Unterstriche folgen. Umlaute und sonstige Zeichen mit Akzenten etc. sind nicht erlaubt.

Reservierte Wrter drfen nicht als Bezeichner verwendet werden.

Da die Gro-/Kleinschreibung im Interpreter nicht bercksichtigt wird, sind beispielsweise fr den Bezeichner <CW!>CalculateValue folgende Schreibweisen zulssig:

<ul indent=12>
<li><!CW>CalculateValue</li>
<li><!CW>calculateValue</li>
<li><!CW>calculatevalue</li>
<li><!CW>CALCULATEVALUE</li>
</ul>
>>

<<
1.1.1.5
Literale
--
Literale sind Werte die 'fix-und-fertig' im Quellcode stehen und direkt vom Interpreter verstanden werden.

Beispiele sind Zahlen und Zeichenketten.
>>

<<
1.1.1.5.1
Zahlen
--
Der Interpreter versteht Zahlen in 3 Zahlensystemen:
<h4>Dezimal:</h4>
Zahlen ohne besondere Kennzeichnung werden als Dezimalwerte betrachtet. Sie drfen aus folgenden Teilen bestehen:
<ul indent=12>
<li>ein Vorzeichen (+/-) -> Zahlen ohne Vorzeichen werden als positive Werte betrachtet</li>
<li>dem ganzzahligen Anteil (bestehend aus den Ziffern 0..9)</li>
<li>optional einem Dezimalpunkt und dem Nachkommaanteil (bestehend aus den Ziffern 0..9)</li>
<li>optional ein Exponent in wissenschaftlicher Notation ('E' oder 'e' gefolgt von einem Exponenten). Diese wird dann als &quot;mal 10 hoch&quot; gelesen</li>
</ul>

Beispiele:
<!CODE>
  123
  123.45
  -123.45
  +123E2       // = 12300
  -123.45e-4   // = -0.012345
<!TXT>

<!REM>
Hinweis: 
Dezimaltrennzeichen ist immer der Punkt. Tausendertrennzeichen sind nicht erlaubt.
<!TXT>
<h4>Hexadezimal:</h4>
Das Dollarzeichen ($) als Prfix kennzeichnet eine hexadezimale Zahl, beispielsweise $8F.

Gltige Hexadezimalziffern sind 0..9 und A..F, bzw. a..f.

Hexadezimalzahlen mssen im Bereich von $00000000 bis $FFFFFFFF liegen.

Beispiele:
<!CODE>
  $00
  $7B    // = 123  dezimal
  $ABFE3
<!TXT>

<!REM>
Hinweis: 
Hexadezimalzahlen mssen immer ganze Zahlen sein.
<!TXT>
<h4>Binr:</h4>
Das Paragraphenzeichen () als Prfix kennzeichnet eine binre Zahl, beispielsweise 101.

Gltige Binrziffern sind 0 und 1.

Binrwerte mssen im Bereich von 0..2<sup>32</sup>-1 liegen und sind immer ganze Zahlen.

Beispiele:
<!CODE>
1111011  // = 123 dezimal
<!TXT>
>>

<<
1.1.1.5.2
Zeichenketten
--
Eine Zeichenkette ist eine Folge von null oder mehr Zeichen des erweiterten ASCII (8-Bit) Zeichensatzes. Sie kann aus einem String in Anfhrungszeichen, einem Steuerzeichen-String oder einer Kombination aus beiden bestehen.
Eine solche Zeichenkette muss in einer Quelltextzeile stehen und in halbe Anfhrungszeichen (') eingeschlossen sein. Ein String in Anfhrungszeichen, der zwischen den halben Anfhrungszeichen kein Zeichen enthlt, ist ein Leer-String. Zwei in einem String in Anfhrungszeichen unmittelbar aufeinanderfolgende halbe Anfhrungszeichen stehen fr ein einzelnes Anfhrungszeichen. Einige Beispiele:

<!CODE>
'MCD-Elektronik'  -> MCD-Elektronik
'Mller''s Bro'  -> Mller's Bro
''''              -> '
''                -> Ein Leer-String, 0 Zeichen lang
' '               -> Ein Leerzeichen
<!TXT>

Ein Steuerzeichen-String ist eine Folge von einem oder mehreren Steuerzeichen. Jedes dieser Steuerzeichen besteht aus einem #-Symbol und einer vorzeichenlosen Integer-Konstante zwischen 0 und 255 (dezimal oder hexadezimal), die das entsprechende ASCII-Zeichen bezeichnet. Der Steuerzeichen-String

<!CODE>
#77#67#68
<!TXT>

entspricht dem folgenden String in Anfhrungszeichen:

<!CODE>
'MCD'
<!TXT>

Strings in Anfhrungszeichen und Steuerzeichen-Strings knnen miteinander kombiniert werden und damit lngere Strings bilden. Beispielsweise wird mit dem folgenden String das Zeichen fr ein Wagenrcklauf/Zeilenvorschub zwischen Zeile 1 und Zeile 2 eingefgt:

<!CODE>
'Zeile 1'#13#10'Zeile 2'
<!TXT>

Strings in Anfhrungszeichen lassen sich allerdings nicht auf diese Weise miteinander verbinden, weil ein Paar aufeinanderfolgender einfacher Anfhrungszeichen als ein einzelnes Zeichen interpretiert wird. Fr das Zusammenfgen von Strings in Anfhrungszeichen steht der Operator +. Sie knnen die betreffenden Strings aber auch einfach zu einem einzigen String in Anfhrungszeichen kombinieren.

Die Lnge eines Zeichen-Strings entspricht der Anzahl der Zeichen im String.
>>

<<
1.1.1.5.3
Vektoren/StringVektoren
--
Ein Vektor-Literal besteht aus dem Elementen des Vektors, durch Kommas getrennt und in eckige Klammern eingefasst.
Jeder Vektor-literal kann nur elemente gleichen Typs enthalten, strings oder Real Werte.
Ein Vektor-Element kann ein Zahlenliteral, Stringliteral, ein numerischer Ausdruck oder ein string Ausdruck sein.

Beispiele:
<!CODE>
[]         		-> leerer Vektor, 0 Elemente gilt fr numerische als auch string vektoren
[1]        		-> Vektor mit einem numerischen Element des Wertes 1
['hello']  		-> Vektor mit einem string Element des Wertes 'hello'
[1,2,3,4]  		-> Vektor mit 4 Elementen
['Hello','World']	-> Vektor mit den 2 Elementen 'Hello' und 'World'. 
[1+2, 3*4] 		-> Vektor mit 2 Elementen (3 und 12)
['Hello'+'World'+'!']	-> Vektor mit 1 Element ('Hello World!')
<!TXT>
>>

<<
1.1.2
Datentypen
--
Der Interpreter unterscheidet 3 echte Datentypen:

<ul indent=12>
<li><a href="1.1.2.1">REAL</a></li>
<li><a href="1.1.2.2">STRING</a></li>
<li><a href="1.1.2.3">VECTOR</a></li>
<li><a href="1.1.2.5">STRINGVECTOR</a></li>
</ul>

und die Pseudo-Datentypen

<ul indent=12>
<li><a href="1.1.2.4">ComObject</a></li>
<li><a href="1.1.2.6">NetObject</a></li>
</ul>

Es ist nicht mglich, weitere Datentypen zu deklarieren.
>>

<<
1.1.2.1
Datentyp REAL|Real
!1.1.6.3
--
Der Datentyp <!RW>REAL wird fr alle numerischen Werte verwendet.
Er wird nicht nur fr Float-Werte, sondern auch fr Ganzzahl-Werte und Logische Werte eingesetzt. Eine Umwandlung erfolgt intern automatisch.

<!STBL>
<!>CPU-Datentyp<!>IEEE Double<!>
<!>Wertebereich<!> (5.0 * 10<sup>-324</sup> .. 1.7 * 10<sup>308</sup>)<!>
<!>Genauigkeit<!>15 signifikante Stellen</pre><!>
<!ETBL>

Wird ein <!RW>REAL Wert intern in eine Ganzzahl umgewandelt, so ist der Wertebereich entsprechend der aufgerufenen Funktion eingeschrnkt.

Fr die Umwandlung logischer Werte (<!RW>True, <!RW>False) in und aus <!RW>REAL Werten gilt:

<pre>Logisch -> <!RW>REAL             <!RW>REAL -> Logisch
   <!RW>TRUE ->  1         ungleich 0 -> <!RW>TRUE  
  <!RW>FALSE ->  0                  0 -> <!RW>FALSE</pre>
>>
<<
1.1.2.2
Datentyp STRING|String
!1.1.6.4
--
Der Datentyp <!RW>STRING wird fr alle Zeichenketten verwendet.

Ein String kann zwischen 0 und ca 2 Millionen Zeichen (genau: 2<sup>31</sup>-8) enthalten.

Jedes Zeichen belegt 1 Byte (8-Bit Zeichensatz). Ein String kann auch Nullbytes enthalten, diese dienen nicht als Stringende, da die Lnge des Strings separat verwaltet wird.
>>

<<
1.1.2.3
Datentyp VECTOR|Vector
!1.1.6.5
--
Der Datentyp <!RW>VECTOR realisiert ein eindimensionales Array von Realwerten.

Die Anzahl Elemente kann zwischen 0 und 65535 liegen. Jedes Element stellt einen Realwert dar.

Die Lnge eines Vectors wird nicht vordefiniert, sondern durch seine Benutzung festgelegt.
>>

<<
1.1.2.4
Pseudo-Datentyp COMOBJECT|COMObject
!1.1.7.4
--
Der Pseudo-Datentyp <!RW>COMOBJECT wird benutzt, um dem Interpreter einen Bezeichner fr die Verwendung als COM-Object (ActiveX-Object) bekannt zu machen.

<!RW>COMOBJECT Werte sind nicht direkt zuweisbar, sondern werden durch Aufrufe des Interpreterobjektes <a href="128.118">COM</a> belegt und danach hnlich wie eingebaute Interpreterobjekte eingesetzt.
>>

<<
1.1.2.5
Datentyp STRINGVECTOR|StringVector
!1.1.6.5
--
Der Datentyp <!RW>STRINGVECTOR realisiert ein eindimensionales Array von Strings.

Die Anzahl Elemente kann zwischen 0 und 65535 liegen. Jedes Element stellt einen String dar.

Die Lnge eines Vectors wird nicht vordefiniert, sondern durch seine Benutzung festgelegt.
>>

<<
1.1.2.6
Pseudo-Datentyp NETOBJECT|NETObject
!1.1.7.11
--
Der Pseudo-Datentyp <!RW>NETOBJECT wird benutzt, um dem Interpreter einen Bezeichner fr die Verwendung einer .Net Klasse bekannt zu machen.

Beim erstellen einer NetObject variable knnen gleich Parameter mit angegeben werden.
Jede <!SW>Variablendefinition hat folgenden Aufbau:
<!SYN>
<a href="1.1.1.4">Bezeichner</a> [, Bezeichner ..] : NetObject [([Namespaces.Class][,ClassSourcecode][,InstanceName])];
<!TXT>
Das Feld <b>'Bezeichner'</b> gibt einen beliebigen Namen an der den Bezeichner Regeln des Interpreters folgen muss.
Das Feld <b>'Namespace.Class'</b> steht fr den kompletten .NET bezeichner der Klasse (Komplette Namspace Pfad + dem Klassen Namen)
Das Feld <b>'ClassSourcecode'</b> gibt den Pfad und den Dateinamen indem der Quellcode fr die Klasse enthalten ist.
Das Feld <b>'InstanceName'</b> gibt den Instanzen Name der Klasse an. Dies ermglicht von einer Klasse mehrere instanzen anzulegen.

Die erstellungs parameter 'Namespace.Class', 'ClassSourcecode' und 'InstanceName' sind optionale Paramter. Um Jedoch den 2 bzw. 3 Parameter anzugeben mssen auch die vorherigen angegeben werden.
Wenn der 1 Parameter angegeben ist, wird jeglicher .Net Quellcode Kompeliert der sich im Verzeichnis IPSteps (Verzeichnis aller Interpreter Steps *.IPH Dateien) und in einem Unterverzeichnis befindet, dessen Name sich aus dem Namespace ergibt. In diesen kompilierten Quellcode muss sich die angegebene Klasse im angegebenen Namespace befinden.
Sind die ersten beiden Parameter angegeben wird an den selben stellen nach Quellcode gesucht und kompiliert wie zuvor und zustzlich in dem Verzeichnis wo die Quellcode Datei durch den 2 Parameter angegeben ist.

<!CODE>
noToolCtrl : NetObject;							// NetObject Variable mit dem Namen 'noToolCtrl', jedoch noch nicht verwendbar da nicht instanziert.
noToolCtrl : NetObject ('tool.ctrl');					// Wie zuvor, jedoch verwendbar da mit der Klasse Ctrl instanziert. 
noToolCtrl : NetObject ('tool.ctrl', 'c:\code\tool\ctrl.cs');		// Wie zuvor, nur mit Pfad zum quellcode. 
noToolCtrl : NetObject ('tool.ctrl', 'c:\code\tool\ctrl.cs', 'ctrl1');	// Wie zuvor, nur mit selbstvergebenen instanz namen. 
<!TXT>
>>

<<
1.1.3
Interpretersteps|Steps
$NoSort
--
Ein Interpreterschritt (auch Interpreterstep oder kurz Schritt bzw. Step genannt) besteht aus folgenden Elementen:
<!SYN>
[<a href="1.1.3.1">Parameterliste</a>]
[<a href="1.1.3.2">Variablen-/Konstantenliste/n</a>]
[<a href="1.1.3.3">Bibliothekseinbindung</a>]
[<a href="1.1.3.4">Prozedur/FunktionsDefinitionen</a>]
STEP
  [ <a href="1.1.7">Anweisung</a>; ..]
END.
<!TXT>
Zwingend erforderlich sind nur die reservierten Worte <b>STEP</b> und <b>END.</b>, bitte den Punkt hinter END beachten, es ist die einzige Stelle, an der hinter END ein Punkt folgt!

Alle anderen Elemente sind optional, mssen aber, wenn sie vorkommen, in der angegebenen Reihenfolge stehen.
>>
<<
1.1.3.1
Parameterliste
--
Die Parameterliste legt fest, welche Parameter aus der Prfschritt-Parameterdatenbank der Interpreterschritt verwendet. Die Parameterliste kann daher nur in echten Prfsteps benutzt werden, nicht aber in System-Steps.

Die Parameterliste beginnt mit dem reservierten Wort <!RW>PARAMETER und enthlt bis zu 32 Parameterdefinitionen.

Jede Parameterdefinition hat folgenden Aufbau:
<!SYN>
<a href="1.1.1.4">Bezeichner</a>  : (Nr, Typ, Information, Maske):
<!TXT
<b>'Bezeichner' </b>
ist der im weiteren Interpreterstep benutzte Bezeichner fr diesen Parameter. 
Der Bezeichner ist, sofern er nicht mit reservierten Worten kollidiert, frei whlbar. Es hat sich jedoch als sinnvoll erwiesen, Parameterbezeichner, abhngig vom Datentyp des Parameters, mit den Buchstaben <!SW>'ps' bei Stringparametern und <!SW>'pr' bei Realparametern einzuleiten.

<b>'Nr'</b>
gibt an, der wievielte Parameter (1..32) dem Bezeichner zugeordnet wird. Jeder Parameter darf in der Parameterliste nur einmal aufgerufen werden. Die Reihenfolge innerhalb der Parameterliste ist beliebig, es hat sich jedoch aus Grnden der Lesbarkeit als sinnvoll erwiesen, die Liste aufsteigend zu halten.

<b>'Typ'</b>
gibt den Datentyp des Parameters an. Erlaubt sind nur die Datentypen <!RW>STRING und <!RW>REAL.

<b>'Information'</b>
ist ein Stringliteral, das Informationen zur Verwendung des Parameters enthlt. Der Wert wird an den Parametereditor bergeben und auch in die Prschrittparametertabelle eingetragen, vom Interpreter aber ignoriert.

<b>'Maske'</b>
ist ein Stringliteral, das eine Maske zur berprfung des Wertes aus der Parametertabelle darstellt.Der Wert wird zum einen an den Parametereditor bergeben, sowie vom Interpreter beim Laden der Parameterwerte benutzt.
Folgende Maskenarten knnen verwendet werden:
<ul indent=12>
 <li>leere Maske
  ein leerer String, keine Maske, keine Prfung
  Beispiel : <!CW>''<!TXT></li>
 <li>Aufzhlung gltiger Werte
  alle gltigen Werte werden, von '/' getrennt aufgezhlt
  Beispiel : <!CW>'Apfel/Birne/Citrone'<!TXT></li>
 <li>Wertebereich
  Unter- und Obergrenze (jeweils inklusive), durch '..' getrennt
  Nur fr <!RW>REAL Parameter
  Beispiel : <!CW>'0..10'<!TXT></li>
</ul>

Unabhngig von der Arte der Maske wird bei REAL Parametern geprft, ob der Wert in der Datenbank in einen Zahlwert gewandelt werden kann.
  
Beispiel fr eine Parameterliste:
<!CODE>
PARAMETER
  prKanal  : ( 1, Real,   'Kanal (1..4)',   '1..4');
  prMittel : ( 2, Real,   'Avgs  (1..100)', '1..100');
  psText   : ( 5, String, 'Meldung',        '');
<!TXT>
>>
<<
1.1.3.2
Variablen-/Konstantenliste/n
--
Die Variablen- und Konstantenlisten geben dem Interpreter bekannt, welche Bezeichner Variablen und Konstanten darstellen. Variablen- und Konstantenlisten drfen in beliebiger Anzahl und Reihenfolge aufgefhrt werden.

<!REM>
Hinweis: 
Konstanten, vorbelegte Variable und die Mglichkeit, mehrere Listen zu verwenden, wurde erst ab V1.2.5 eingefhrt.
<!TXT>

Die im Step global definierten und die in den eingebundenen Libraries global definierten Variablen und Konstanten sind untereinander gleichwertig, was ihre Sichtbarkeit angeht. D.h. sie alle knnen von allen Libraries und dem Step verwendet werden. Da sie sich einen Namensraum teilen, mssen alle verschiedene Namen haben.

<!REM>
Hinweis: 
Die Mglichkeit, Variable und Konstante in Libraries global zu definieren, wurde erst inV1.2.10, Build 978 eingefhrt.
<!TXT>

>>

<<
1.1.3.2.1
var (Variablenliste)/ static (Statische Variblenliste)
--
Die Variablenliste legt fest, welche Variablen der Interpreter im folgenden benutzen soll.

Die Variablenliste beginnt mit dem reservierten Wort <!RW>VAR und enthlt beliebig viele Variablendefinitionen.
<!SYN>
<!RW>VAR
  [<!SW>VariablenDefinition; ..]
<!TXT>
Eine Sonderform ist die Statischevariablenliste, sie beginnt mit dem reservierten Word <!RW>STATIC und enthlt beliebig viele Variablendefinitionen. Im Gegensatz zur normalen Variablenliste sind die so definierten Variablen statisch. (siehe unten)
<!SYN>
<!RW>STATIC
  [<!SW>VariablenDefinition; ..]
<!TXT>
Statische Variable knnen nicht vom Typ <!RW>ComObject oder <!RW>NetObjectsein.

Jede <!SW>Variablendefinition hat folgenden Aufbau:
<!SYN>
<a href="1.1.1.4">Bezeichner</a> [, Bezeichner ..] : <a href="1.1.2">Typ</a> [= Wert];
<!TXT>
<b>'Bezeichner' </b> definiert den Namen fr eine Variable des nachfolgenden Typs.
Der Bezeichner ist, sofern er nicht mit reservierten Worten oder zuvor definierten Parameter-Bezeichnern kollidiert, frei whlbar.
Es hat sich jedoch als sinnvoll erwiesen, Variablenbezeichner, abhngig vom Datentyp mit folgenden Buchstaben einzuleiten:
<!STBL>
<!r>Real :<!><!SW>r<!>
<!r>String :<!><!SW>s<!>
<!r>Vector :<!><!SW>v<!>
<!r>StringVector :<!><!SW>sv<!>
<!r>ComObject :<!><!SW>co<!>
<!r>NetObject :<!><!SW>no<!>
<!ETBL>
Einzelne Bezeichner werden durch Komma getrennt.

<b>'Typ'</b> gibt den Datentyp fr die zuvor aufgefhrten Variablen an. Erlaubt sind <!RW>REAL, <!RW>STRING, <!RW>VECTOR, <!RW>STRINGVECTOR, <!RW>COMOBJECT und <!RW>NETOBJECT.

<b>'Wert'</b> ist der Wert, mit dem die Variable vorbelegt wird. Er muss vom Typ her zum Datentyp der Variable passen. ComObjekte knnen nicht vorbelegt werden. Alle Variable innerhalb einer Variablendefinition werden auf denselben Vorbelegungswert gesetzt.
Fr 'Wert' kann jeder Ausdruck angegeben werden, der zu diesem Zeitpunkt vom Interpreter berechnet werden kann, also auch Konstanten, Variable, interne Funktionen, aber keine Step-lokalen Funktionen oder Funktionen in Bibliotheken. Vorbelegte Variable knnen im Step genauso verwendet werden wie nicht vorbelegte.
Ist 'Wert' nicht angegeben, so werden die Variablen wie folgt gesetzt:
<!STBL>
<!r>Real :<!><!CW>0<!>null<!>
<!r>String :<!>''<!>Leerstring<!>
<!r>Vector :<!>[]<!>leerer Vektor, null Elemente Lnge<!>
<!r>StringVector :<!>[]<!>leerer Vektor, null Elemente Lnge<!>
<!r>ComObject :<!>leer<!>nicht zugewiesen, kann so nicht benutzt werden<!>
<!r>NetObject :<!>leer<!>nicht zugewiesen, kann so nicht benutzt werden<!>
<!ETBL>

<!CODE>
Beispiel:
VAR
  rEinzel, rSumme : real;			// zwei Realvariable, beide 0
  rAnzahl : real = 10;				// Realvariable, vorbelegt mit 10
  sCRLF   : string = #13#10;			// String, vorbelegt mit CarriageReturn+LineFeed
  rLen    : real = len(sCRLF);			// Realvariable, vorbelegt mit 2
  svNamen : stringvector = ['Hans', 'Otto'];	// StringVector vorbelegt mit Namen
  vZahlen : vector = [7, 2];			// Vector vorbelegt mit Zahlen
  vZahlen : vector = [7, 2];			// Vector vorbelegt mit Zahlen
  ncClass : NetObject ( 'TestNC.TestC');	// Instanziert ncClass mit der Klasse TestC aus dem Namespace TestNC
<!TXT>

<h3>Normale Variable &lt;&gt; Statische Variable</h3>
Normale Variable werden vergessen, sobald der Interpreterschritt beendet wurde. Ihr alter Wert geht verloren und sie werden (wie oben angegeben) erneut vorbelegt, wenn der Schritt bzw. die Library erneut benutzt wird.

Der Wert Statischer Variable bleibt auch zwischen den Ausfhrungen eines Schrittes bzw. dem Benutzen der Library erhalten. Ihr Wert wird bei Ende des Schrittes gespeichert und der Wert wird ihnen bei der nchsten Verwendung wieder zugeweisen. Eine Zuweisung bei der Definition wirkt sich nur beim ersten Erzeugen der Variable aus. Danach wird immer der letzte gesetzte Wert wieder hergestellt.
Statische Variablen hneln daher im Verhalten den Globalen Variablen.
 <!REM>Hinweis:
Statische Variable wurden in Version V1.3.1 implementiert.
<!TXT>
>>

<<
1.1.3.2.2
const (Konstantenliste)
--
Die Konstantenliste legt fest, welche Konstanten der Interpreter im folgenden benutzen soll.
Der Wert einer Konstanten kann im Gegensatz zu dem einer Variable nicht mehr gendert werden. Konstante knnen daher nicht links von einer Zuweisung oder als <!RW>VAR Parameter in einem Funktion- oder Prozeduraufruf auftreten.

Die Konstantenliste beginnt mit dem reservierten Wort <!RW>CONST und enthlt beliebig viele Konstantendefinitionen.
<!SYN>
<!RW>CONST
  [<!SW>Konstantendefinition; ..]
<!TXT>
Jede Konstantendefinition hat folgenden Aufbau:
<!SYN>
<a href="1.1.1.4">Bezeichner</a> : [<a href="1.1.2">Typ</a>] = Wert;
<!TXT>
 <!REM>Anmerkung: 
Es ist syntaktisch erlaubt, mehrere Bezeichner anzugeben: In diesem Fall werden zwei Konstanten mit demselben Wert erzeugt. Da der Wert einer Konstante nicht nderbar ist, sollte in diesem Fall aus Grnden der bersichlichkeit, entweder auf eine der Konstanten verzichtet werden oder, falls die Konstanten fr den Einsatz in verschiedenen Kontexten gedacht sind, die Definition auf zwei Definitionen aufgeteilt werden.
<!SYN>
Bezeichner1 [, Bezeichner2 ..] [: Typ] = Wert;
<!TXT>
 <B>'Bezeichner' </b>
definiert den Namen fr eine Konstante des nachfolgenden Typs.
Der Bezeichner ist, sofern er nicht mit reservierten Worten oder zuvor definierten Parameter-Bezeichnern kollidiert, frei whlbar. 
hnlich wie Variablen sollten jedoch auch Konstante durch Kennbuchstaben eingeleitet werden:
<!STBL>
<!r>Real :<!><!SW>cr <!>
<!r>String :<!><!SW>cs <!>
<!r>Vector :<!><!SW>cv <!>
<!r>StringVector :<!><!SW>csv <!>
<!ETBL>

<!CODE>
Beispiel:
const
  crReal = 7;
  csString = 'text';
  cvConstVector = [0.017, 0.999];
  csvConstStringVector = ['Sinus', 'Cosinus'];
<!TXT>

 <b>'Typ'</b> (optional)
gibt den Datentyp fr die zuvor aufgefhrten Variablen an. Erlaubt sind <!RW>REAL, <!RW>STRING, <!RW>VECTOR oder <!RW>STRINGVECTOR. Der Datentyp wird aus dem Wert ermittelt. Die Datentypen COMOBJECT und NETOBJECT sind nicht erlaubt. 

 <b>'Wert' </b> 
ist der Wert, mit dem die Konstante belegt wird. Fr 'Wert' kann eine Konstante oder jeder andere Ausdruck angegeben werden, der zu diesem Zeitpunkt vom Interpreter berechnet werden kann, also auch Konstanten, Variable, interne Funktionen, aber keine Step-lokalen Funktionen oder Funktionen in Bibliotheken. 

Ist ein Typ angegeben, so muss Wert zu diesem Typ passen, andernfalls wird der Datentyp der Konstanten durch den Typ von 'Wert' bestimmt.

>>

<<
1.1.3.3
Bibliothekseinbindung|Uses
--
Mit Hilfe der <!RW>Uses Klausel werden Bibliotheken (Libraries) eingebunden.

Die Auswirkung einer <!RW>Uses Klausel ist etwa dieselbe, als wrde der Inhalt der Library an der entsprechenden Stelle im Interpreterschritt eingefgt.

Die <!RW>Uses Klausel hat folgenden Aufbau

<!SYN>
<!RW>USES 
  LibraryName [, LibraryName] ;
<!TXT>
<b>LibraryName</b> ist der Dateiname der Datei, die die Bibliotheksroutinen enthlt, als <a href="1.1.1.5.2">Stringliteral</a>. 

ber die Interpreteraliasse kann eine automatische Umsetzung der Librarynamen bewirkt werden.
>>
<<
1.1.3.4
Prozedur-/Funktionsdefinitionen|Prozeduren/Funktionen
$NoSort
--
Beim Deklarieren einer <!SW>Prozedur oder <!SW>Funktion wird der Namen, die Anzahl und den Typ der Parameter und - wenn es sich um eine Funktion handelt - den Typ des Rckgabewertes angegeben. 

Dieser Teil der Deklaration wird auch Prototyp, Einleitung oder Kopf genannt. Anschlieend folgt der Code, der beim Aufrufen der Prozedur oder Funktion ausgefhrt werden soll. Dieser Teil wird auch als Rumpf oder Block der Routine bezeichnet.

Die Standardprozedur <a HREF="120.2.5">Return</a> kann jederzeit im Rumpf einer Funktion oder Prozedur aufgerufen werden. Return beendet die Ausfhrung der betreffenden Routine und gibt die Steuerung wieder an die Routine zurck, die diese Funktion oder Prozedur aufgerufen hat.
>>
<<
1.1.3.4.1
Procedure (Prozedurdefinition)
--
Eine Prozedurdeklaration hat folgende Form:

<!SYN>
<!RW>PROCEDURE Prozedurname [(<a href="1.1.3.4.3">AufrufParameterListe</a>)] ; 
[<a href="1.1.3.4.4">LokaleVarConstListe</a>]
<!RW>BEGIN
  [Anweisungen;]
<!RW>END;
<!TXT>
 <b>Prozedurname</b> ist ein beliebiger, gltiger, bisher unbenutzter <a href="1.1.1.4">Bezeichner</a>.

Mit der LokaleVarConstListe werden lokale Variablen und Konstante erzeugt, die nur innerhalb dieser Prozedur gltig sind.  Sie drfen auch bereits verwendete Variablen/Konstanten-Namen benutzten, sie 'berdecken' dann quasi die externen Variablen/Konstanten.

 <b>Anweisungen</b> ist eine Folge von <a href="1.1.7">Anweisungen</a>, die beim Aufruf der Prozedur ausgefhrt werden. 

Prozeduren drfen sich auch selbst aufrufen (Rekursion). Es wird dann jeweils ein neuer Satz lokaler Variablen erzeugt.

Die <a href="1.1.3.4.3">AufrufParameterListe</a> und die <a href="1.1.3.4.4">LokaleVarConstListe</a> sind optional.

Beispiel fr eine Prozedur:
<!CODE>
procedure WaitForDDEIdle (rTimeout : real);
var
  sRecv : string;
  rEnde : real;
begin
  rEnde:=DateTime.ReadTimer+rTimeout;
  repeat    
    DDEClient.Request (2, 'Run', sRecv);
    sRecv := Copy(sRecv, 1, 1);  // 0=Idle, 1=Busy, 2=Ok, 3=Error
  until (sRunState <> '1') or (DateTime.ReadTimer>rEnde);
end;
<!TXT>

Nach dieser Deklaration knnen Sie die Prozedur WaitForDDEIdle folgendermaen aufrufen:
<!CODE>
WaitForDDEIdle (1000);
<!TXT>

Dieser Prozeduraufruf wartet fr 1 Sekunde oder bis der DDE-Server nicht mehr 'Busy' meldet, je nach dem, was zuerst eintritt.

Im Anweisungsblock einer Prozedur knnen die lokal definierten Variablen benutzt werden, sowie alle Parameter und Variablen des Steps. Auerdem knnen alle zuvor definierten Prozeduren und Funktionen (auch die in Bibliotheken) aufgerufen werden.
>>
<<
1.1.3.4.2
Function (Funktionsdefinition)
--
Eine Funktionsdeklaration entspricht einer Prozedurdeklaration, definiert aber zustzlich einen Rckgabetyp. 

Funktionsdeklarationen haben folgende Form:
<!SYN>
<!RW>FUNCTION Funktionsname [(<a href="1.1.3.4.3">AufrufParameterListe</a>)] : Rckgabetyp; 
[<a href="1.1.3.4.4">LokaleVarConstListe</a>]
<!RW>BEGIN
  [Anweisungen;]
<!RW>END;
<!TXT>
 <b>Funktionsname</b> ist ein beliebiger, gltiger, bisher unbenutzter <a href="1.1.1.4">Bezeichner</a>.

 <b>RckgabeTyp</b> ist entweder <!RW>REAL, <!RW>STRING, <!RW>VECTOR oder <!RW>STRINGVECTOR.

Mit der LokaleVarConstListe werden lokale Variablen und Konstante erzeugt, die nur innerhalb dieser Prozedur gltig sind.  Sie drfen auch bereits verwendete Variablen/Konstanten-Namen benutzten, sie 'berdecken' dann quasi die externen Variablen/Konstanten.

 <b>Anweisungen</b> ist eine Folge von <a href="1.1.7">Anweisungen</a>, die beim Aufruf der Prozedur ausgefhrt werden. 

Funktionen drfen sich auch selbst aufrufen (Rekursion). Es wird dann jeweils ein neuer Satz lokaler Variablen erzeugt.

Die <a href="1.1.3.4.3">AufrufParameterListe</a> und die <a href="1.1.3.4.4">LokaleVarConstListe</a> sind optional.

<!REM>
Hinweis: 
In lteren Programmversionen muss bei Funktionen ohne Parameter eine leere AufrufParameterListe () angegeben werden. Neuer Programmversionen enthalten diesen Fehler nicht mehr, akzeptieren aber noch die Syntax der alten Version. 
<!TXT>

Automatisch wird eine lokale Variable mit dem Namen <!CW>Result und dem Rckgabedatentyp definiert. Diese Variable nimmt den Wert entgegen, den die Funktion zurckgeben soll.
Alternativ kann der Rckgabewert auch an die Aussprungprozedur <a HREF="120.2.5">Return</a> bergeben werden.

Im Anweisungsblock einer Funktion knnen die lokal definierten Variablen benutzt werden, sowie alle Parameter und Variablen des Steps. Auerdem knnen alle zuvor definierten Prozeduren und Funktionen (auch die in Bibliotheken) aufgerufen werden.

Beispiele fr eine ganz einfache Funktion:
<!CODE>
function Three : real; 
begin
  Result:=3;
end;

// in alten Programmversionen:
function Three2 () : real;
begin
  Result:=3;
end;

// mit Return realisiert
function Three3 () : real;
begin
  Return (3);
end;
<!TXT>

Alle diese Funktionen geben immer 3 zurck.

Funktionen knnen sich selbst aufrufen (Rekursion):
<!CODE>
function Fakultaet (r : real) : real;
begin
  r:=abs(int(r));       // Fakultaet nur fr natrliche Zahlen!
  if r<=1 then begin
    return (r);         // r selbst zurckgeben
                        // die Funktion wird hier verlassen!
  end;
  Result := r * Fakultaet (r-1);
end;
<!TXT>
>>
<<
1.1.3.4.3
Aufruf-Parameter-Liste|Parameter
--
Die meisten Prozedur- und Funktions-Header enthalten eine Aufrufparameterliste. Im Header
<!CODE>
function Power (X: real; Y: real): real;
<!TXT>

lautet die Aufrufparameterliste beispielsweise <!CW>(X: <!RW>real; <!CW>Y: <!RW>real).

Syntax:
<!SYN>
Aufrufparameterliste :=
  ( [Parameterdeklaration [; Parameterdeklaration ..] )

Parameterdeklaration :=
  [<!RW>VAR] Bezeichner [, Bezeichner ..] : Datentyp
<!TXT>
Eine Aufrufparameterliste ist eine Folge von Parameterdeklarationen, die durch Semikolons voneinander getrennt und in Klammern eingeschlossen werden. Jede Deklaration besteht aus einer Reihe von Parameternamen, die durch Kommas voneinander getrennt werden. Hinter den Parameternamen steht ein Doppelpunkt und ein Typbezeichner. Parameternamen mssen gltige Bezeichner sein. 

Einer Deklaration kann das reservierte Wort <!RW>VAR vorangestellt sein. 

Deklarationen mit <!RW>VAR werden als <a href="1.1.3.4.3.2">Variablenparameter</a>, solche ohne <!RW>VAR als <a href="1.1.3.4.3.1">Werteparameter</a> bezeichnet (siehe dort).

Einige Beispiele:
<!CODE>
(X, Y : Real)
(var S : string; X : real)
(HWnd : real; Text, Caption : string; Flags : vector)
<!TXT>

Die Parameterliste gibt Anzahl, Reihenfolge und Typ der Parameter an, die beim Aufruf an die Routine bergeben werden mssen. Wenn eine Routine keine Parameter entgegennimmt, wird in der Deklaration weder die Bezeichnerliste noch die Klammern angeben:
<!CODE>
procedure UpdateRecords;
begin
        ...
end;
<!TXT>

(Eine Ausnahme bilden alte Programmstnde im Zusammenhang mit Funktionen, hier muss eine leere Liste mit <!CW>() angegeben werden)

Im Rumpf der Prozedur oder Funktion knnen die Parameternamen (X und Y im ersten Beispiel) wie lokale Variablen eingesetzt werden. Sie drfen im Abschnitt mit den lokalen Deklarationen nicht erneut als Bezeichner verwendet werden.
>>
<<
1.1.3.4.3.1
Werteparameter (call-by-value)|Werteparameter
--
Werteparameter werden in der Aufrufparameterliste <b>ohne</b> <!RW>VAR angegeben.
<!CODE>
function Power (X: real; Y: real): real;
<!TXT>

Ein Wertparameter verhlt sich wie eine lokale Variable, die durch den im Aufruf der Funktion oder Prozedur bergebenen Wert initialisiert wird. Wenn Sie eine Variable als Wertparameter bergeben, erstellt die Prozedur oder Funktion eine Kopie dieser Variablen. nderungen des Wertes dieser Variablen wirken sich nicht auf die ursprngliche Variable aus. Sie werden verworfen, sobald die Steuerung wieder an den Aufrufer zurckgegeben wird.

Fr Werteparameter knnen beim Aufruf beliebige (typkompatible) Ausdrcke angegeben werden.
<!CODE>
function DoubleByValue (X : real) : real;     
// X ist hier ein Wertparameter
begin
  X := X * 2;   // wirkt sich extern nicht aus
  Result := X;
end;
<!TXT>

Die Funktion gibt den doppelten Wert des Aufrufparameters zurck. Der Wert des Aufrufparameters wird nicht gendert, da intern eine eigene Variable X existiert.

Beispiel fr den Aufruf:
<!CODE>
var
  i, j : real;
step
  i:=4;
  j:=DoubleByValue (i); // i=4, j=8
  j:=DoubleByValue (6); // j=12
  j:=DoubleByValue (1+2+3+4);   // j=20
end.
<!TXT>
>>
<<
1.1.3.4.3.2
Variablenparameter (call-by-reference)|Variablenparameter
--
Variablenparameter werden in der Aufrufparameterliste <b>mit</b> <!RW>VAR angegeben.
<!CODE>
function Power (VAR X: real; VAR Y: real): real;
<!TXT>

Ein Variablenparameter ist einem Verweis auf eine externe Variable vergleichbar (daher im Englischen call-by-reference). nderungen des Parameters im Rumpf einer Prozedur oder Funktion bleiben deshalb erhalten und wirken sich auf die externe Variable aus, wenn die Programmausfhrung wieder dem Aufrufer bergeben wird.

Fr Variablenparameter mssen beim Aufruf passende (typkompatible) Variablen angegeben werden.
<!CODE>
function DoubleByRef (var X : real) : real;     
// X ist hier ein Variablenparameter
begin
  X := X * 2;   // wirkt sich extern aus
  Result := X;
end;
<!TXT>

Die Funktion gibt den doppelten Wert des Aufrufparameters zurck. Der Wert des Aufrufparameters wird dabei auch gendert.

Beispiel fr den Aufruf:
<!CODE>
var
  rA, rB : real;
step
  rA:=4;
  rB:=DoubleByRef (rA); // rA=8, rB=8
  rB:=DoubleByRef (6);  // Syntaxfehler!
end.
<!TXT>

Mit Variablenparametern knnen Prozeduren und Funktionen mehrere Werte des aufrufenden Steps ndern. 

Auch wenn dieselbe Variable in mehreren var-Parametern bergeben wird, werden keine Kopien erstellt. Dieses Merkmal wird im folgenden Beispiel illustriert:
<!CODE>
procedure AddOne(var rA, rB : real);
begin
  rA := rA + 1;
  rB := rB + 1;
end;

var 
  rC: real;
step
  rC := 1;
  AddOne(rC, rC);
end;
<!TXT>
Nachdem dieser Code ausgefhrt wurde, enthlt die Variable rC den Wert 3.
>>

<<
1.1.3.4.4
Lokale Variablen und Konstanten Liste|LokaleVarConstListe 
--
Die Lokale Variablen- und Konstanten-Liste ist hnlich zu der <a href="1.1.3.2">Globalen Variablen und Konstanten Liste</a>. 

Der Unterschied liegt darin, dass die lokalen Definition nur innerhalb der jeweiligen Funktion oder Prozedur gelten.

Zustzlich gibt es noch ein paar kleinere Einschrnkungen (Berechnung von Konstanten, keine vordefinierten Variablem)

 <!REM>Hinweis:
Lokale Konstante wurden in Version V1.2.6 implementiert.
<!TXT>
>>

<<
1.1.3.4.4.1
Lokale Variablenliste|LokaleVarListe
--
Die Lokale Variablenliste legt fest, welche Variablen der Interpreter in der Prozedur bzw. Funktion benutzen soll.

Die Variablenliste beginnt mit dem reservierten Wort <!RW>VAR und enthlt beliebig viele Variablendefinitionen.
<!SYN>
<!RW>VAR
  [<!SW>VariablenDefinition; ..]
<!TXT>
Eine Sonderform ist die Statischevariablenliste, sie beginnt mit dem reservierten Word <!RW>STATIC und enthlt beliebig viele Variablendefinitionen. Im Gegensatz zur normalen Variablenliste sind die so definierten Variablen statisch. (siehe unten)
<!SYN>
<!RW>STATIC
  [<!SW>VariablenDefinition; ..]
<!TXT>
Statische Variable knnen nicht vom Typ <!RW>ComObject oder <!RW>NetObject sein.

Jede <!SW>Variablendefinition hat folgenden Aufbau:
<!SYN>
<a href="1.1.1.4">Bezeichner</a> [, Bezeichner ..] : <a href="1.1.2">Typ</a> [= Wert];
<!TXT>

 <b>'Bezeichner' </b>
definiert den Namen fr eine Variable des nachfolgenden Typs.
Der Bezeichner ist, sofern er nicht mit reservierten Worten, frei whlbar. 
Er kann auch mit dem Namen von bereits (in anderem Kontext) definierten Variablen oder Konstanten bereinstimmen, dann werden diese 'berdeckt'.

Es hat sich jedoch als sinnvoll erwiesen, Variablenbezeichner, abhngig vom Datentyp mit folgenden Buchstaben einzuleiten:
<!STBL>
<!r>Real :<!><!SW>r<!>
<!r>String :<!><!SW>s<!>
<!r>Vector :<!><!SW>v<!>
<!r>StringVector :<!><!SW>sv<!>
<!r>ComObject :<!><!SW>co<!>
<!r>NetObject :<!><!SW>no<!>
<!ETBL>
Einzelne Bezeichner werden durch Komma getrennt.

 <b>'Typ'</b>
gibt den Datentyp fr die zuvor aufgefhrten Variablen an. Erlaubt sind <!RW>REAL, <!RW>STRING, <!RW>VECTOR, <!RW>COMOBJECT und <!RW>NETOBJECT.

Variable sind wie folgt belegt:
<!STBL>
<!r>Real :<!>0<!>null<!>
<!r>String :<!>''<!>Leerstring<!>
<!r>Vector :<!>[]<!>leerer Vektor, null Elemente Lnge<!>
<!r>StringVector :<!>[]<!>leerer Vektor, null Elemente Lnge<!>
<!r>ComObject :<!>leer<!>nicht zugewiesen, kann so nicht benutzt werden<!>
<!r>NetObject :<!>leer<!>nicht zugewiesen, kann so nicht benutzt werden<!>
<!ETBL>

Es ist nicht mglich, lokale, vordefinierte Variable zu erzeugen.

<h3>Normale Variable &lt;&gt; Statische Variable</h3>
Normale Variable werden vergessen, sobald die Prozedur oder Funktion, in der sie definiert wurden, verlassen wird. Ihr alter Wert geht verloren und sie werden (wie oben angegeben) erneut vorbelegt, wenn die Prozedur oder Funktion neu aufgerufen wird. Bei rekursiven Aufrufen wird jedesmal eine neue Variable erzeugt und vorbelegt. Diese Variable berdeckt fr die Zeit des Aufrufs eine bereits bestehende Variable des selben Namens. 

Statische Variable behalten ihren Wert auch zwischen zwei Aufrufen. Ihr Wert wird bei Verlassen der Prozedur gespeichert und der Wert wird ihnen beim nchsten Aufruf der Prozedur wieder zugeweisen. Auch bei einem rekursiven Aufruf existiert daher quasi nur ein Exemplar der Variable.
Die Statische Variable (bzw. ihr Wert) bleibt auch dann erhalten, wenn der Interpreterschritt beendet wurde. Wird der Schritt oder die Library erneut geladen, so wird der alte Wert der Variablen wieder hergestellt. 
Statische Variablen hneln daher im Verhalten den Globalen Variablen.
 <!REM>Hinweis:
Statische Variable wurden in Version V1.3.1 implementiert.
<!TXT>
>>

<<
1.1.3.4.4.2
Lokale Konstantenliste|LokaleConstListe
--
Die Lokale Konstantenliste legt fest, welche Konstanten der Interpreter in der Prozedur bzw. Funktion benutzen soll.

Der Wert einer Konstanten kann im Gegensatz zu dem einer Variable nicht mehr gendert werden. Konstante knnen daher nicht links von einer Zuweisung oder als <!RW>VAR Parameter in einem Funktion- oder Prozeduraufruf auftreten.

Die Konstantenliste beginnt mit dem reservierten Wort <!RW>CONST und enthlt beliebig viele Konstantendefinitionen.
<!SYN>
<!RW>CONST
  [<!SW>Konstantendefinition; ..]
<!TXT>
Jede Konstantendefinition hat folgenden Aufbau:
<!SYN>
<a href="1.1.1.4">Bezeichner</a> : [<a href="1.1.2">Typ</a>] = Wert;
<!TXT>
 <!REM>Anmerkung: 
Es ist syntaktisch erlaubt, mehrere Bezeichner anzugeben: In diesem Fall werden zwei Konstanten mit demselben Wert erzeugt. Da der Wert einer Konstante nicht nderbar ist, sollte in diesem Fall aus Grnden der bersichlichkeit, entweder auf eine der Konstanten verzichtet werden oder, falls die Konstanten fr den Einsatz in verschiedenen Kontexten gedacht sind, die Definition auf zwei Definitionen aufgeteilt werden.
<!SYN>
Bezeichner1 [, Bezeichner2 ..] [: Typ] = Wert;
<!TXT>
 <B>'Bezeichner' </b>
definiert den Namen fr eine Konstante des nachfolgenden Typs.

Der Bezeichner ist, sofern er nicht mit reservierten Worten, frei whlbar. 

Er kann auch mit bereits definierten Variablen oder Konstanten bereinstimmen, dann werden diese 'berdeckt'.

hnlich wie Variablen sollten jedoch auch Konstante durch Kennbuchstaben eingeleitet werden:
<!STBL>
<!r>Real :<!><!SW>cr<!>
<!r>String :<!><!SW>cs<!>
<!r>Vector :<!><!SW>cv<!>
<!r>StringVector :<!><!SW>csv<!>
<!ETBL>
Einzelne Bezeichner werden durch Kommas getrennt.

 <b>'Typ'</b> (optional)
gibt den Datentyp fr die zuvor aufgefhrten Variablen an. Erlaubt sind <!RW>REAL, <!RW>STRING, <!RW>VECTOR. Der Datentyp wird aus dem Wert ermittelt. Die Datentypen COMOBJECT und NetObject sind nicht erlaubt. 

 <b>'Wert' </b>
ist der Wert, mit dem die Konstante belegt wird. Fr 'Wert' kann eine Konstante oder jeder andere Ausdruck angegeben werden, der zu diesem Zeitpunkt vom Interpreter berechnet werden kann, also auch Konstanten, Variable, interne und selbst definierte Funktionen.

Ist ein Typ angegeben, so muss Wert zu diesem Typ passen, andernfalls wird der Datentyp der Konstanten durch den Typ von 'Wert' bestimmt.
>>

<<
1.1.4
Bibliotheken - Libraries|Libraries
$NoSort
--
Eine Bibliothek (Library) dient dazu, Routinen aufzunehmen, die in mehreren Interpreterschritten bentigt werden. 
Anstatt die Prozeduren in jeden einzelnen Interpreterschritt hineinzuschreiben, wird der Code nur einmal in einer Library definiert und diese Library ber das <!RW>USES Kommando in allen Steps eingebunden, die den Code bentigen.
Auf diese Weise muss der Code nur einmal entwickelt und nur an einer Stelle gepflegt werden. 
Libraries knnen ihrerseits wieder Libraries benutzen. Lediglich ein Rckwrtsbezug ist nicht mglich, d.h. wenn eine <!SW>LibraryA die <!SW>LibraryB benutzt, dann kann <!SW>LibraryB ihrerseits nicht <!SW>LibraryA verwenden.

Eine Library hat foolgenden Aufbau:
<!SYN>
LIBRARY;
[<a href="1.1.3.2">Variablen-/Konstantenliste/n</a>]
[<a href="1.1.3.3">Bibliothekseinbindung</a>]
[<a href="1.1.3.4">Prozedur/FunktionsDefinitionen</a>]
END.
<!TXT>

Zwingend erforderlich sind nur die reservierten Worte <b>LIBRARY</b> und <b>END.</b>, bitte den Punkt hinter END beachten, es ist die einzige Stelle, an der hinter END ein Punkt folgt (auer im Step selber)!

Alle anderen Elemente sind optional, mssen aber, wenn sie vorkommen, in der angegebenen Reihenfolge stehen.

Die Mglichkeit, Konstanten und Variable in einer Library, aber auerhalb einer Funktion oder Prozedur zu definieren besteht erst seit Build 978.

Da die Variablen vor weiteren Bibliothekseinbindungen definiert werden, stehen sie sowohl untergeordneten als auch bergeordneten (also solche, die die aktuelle Library einbinden) Libraries zur Verfgung.

Prozeduren und Funktionen, die in der Library definiert werden stehen nur den bergeordneten Libraries zur Verfgung, die sie zum Zeitpunkt der Einbindung der untergeordneten Libraries noch nicht definiert sind.
>>

<<
1.1.6
Operatoren
$NoSort
--
Wenn nichts anderes angegeben ist, sind die Operatoren nur fr numerische Operanden definiert
>>
<<
1.1.6.1
Operatoren mit numerischem Ergebnis|numerisch
$NoSort
--
Diese Operatoren liefern als Ergebnis eine REAL-Zahl zurck.
>>
<<
1.1.6.1.1
- numerische Negation| (unr)
--
Dreht das Vorzeichen des Operanden
<!CODE>
 rA:=3;
 rB:=-rA;   // Ergebnis : rB = -3
>>
<<
1.1.6.1.2
+ Addition|+
--
Addiert zwei numerische Werte:

<!CODE>
 rA:=3;  rB:=4;
 rC:=rA + rB;   // Ergebnis : rC = 7
>>
<<
1.1.6.1.3
- Substraktion|-
--
Subtrahiert den zweiten Operanden vom ersten

<!CODE>
 rA:=3;  rB:=4;
 rC:=rA - rB;   // Ergebnis : rC = -1;
>>
<<
1.1.6.1.4
* Multiplikation|*
--
Multipliziert die beiden Operanden

<!CODE>
 rA:=3;  rB:=4;
 rC:=rA * rB;   // rC = 12;
>>
<<
1.1.6.1.5
/ Division |/
--
Dividiert den ersten Operanden durch den zweiten

<!CODE>
 rA:=3;  rB:=4;
 rC:=rA / rB;   // rC = 0.75;
<!TXT>

<!REM>
Achtung: der zweite Operand darf nicht 0 sein!
>>
<<
1.1.6.1.6
DIV Ganzzahlige Division|DIV
--
Dividiert den ersten Operanden durch den zweiten (wie /), aber liefert nur den ganzzahligen Teil des Ergebnisses.

<!CODE>
 rA:=7;  rB:=3;
 rC:=rA DIV rB; // rC = 2; (7/3=2 Rest 1)
<!TXT>

<!REM>
Achtung:
Der zweite Operand darf nicht 0 sein.
>>
<<
1.1.6.1.7
MOD Rest der ganzzahligen Division|MOD
--
Dividiert den ersten Operanden ganzzahlig durch den zweiten und liefert den Rest zurck.

<!CODE>
 rA:=7;  rB:=3;
 rC:=rA MOD rB; // rC = 1; (7/3=2 Rest 1)
<!TXT>

<!REM>
Achtung:
Der zweite Operand darf nicht 0 sein.
>>

<<
1.1.6.2
bitweise Operatoren|bitweise
$NoSort
--
Diese Operatoren liefern als Ergebnis eine 32 BIT Ganzzahl zurck.
Die Operanden werden automatisch in eine 32 Bit Ganzzahl gewandelt.
                
<h4>Wichtig!</h4>
Zwischen den bitweisen Operationen wie <!SW>!, <!SW>&, <!SW>| und <!SW>^ und den binren Operationen <!SW>NOT, <!SW>AND, <!SW>OR und <!SW>XOR besteht ein wichtiger Unterschied. 

Bei den bitweisen Operationen werden die Operanden in 32-Bit Werte umgewandelt und diese wie der Name schon sagt bitweise miteinander verknpft. 

Bei den logischen Operationen werden die Operanden nur im Hinblick auf 0 oder nicht-0 (false oder true) betrachtet und verknpft.

Beispiel 
<!CODE>
var
  rA : real = 3;
  rB : real = 4;
  rC : real;
begin
  // UND - Verknpfung
  rC := rA & rB;        // bitweise rC=0
  rC := rA AND rB;      // logisch  rC=1 (true)

  // ODER - Verknpfung
  rC := rA | rB;        // bitweise rC=7
  rC := rA OR rB;       // logisch  rC=1 (true)

  // NOT - Verknpfung
  rC := !rA;            // bitweise rC=$FFFFFFF8
  rC := NOT rA;         // logisch  rC=0 (false)
<!TXT>
>>
<<
1.1.6.2.1
! binre Negation|!
--
Liefert das Einerkomplement des Operanden als 32 Bit Ganzzahl

<!CODE>
rA:=$00000001;
rB:=!rA;   // rB = $FFFFFFFE
>>
<<
1.1.6.2.2
Binres UND|&
--
Fhrt ein bitweises UND der beiden Operanden duch

<!CODE>
rA:=6;  rB:=5;
rC:=rA & rB;   // rC = 4;
>>
<<
1.1.6.2.3
Binres ODER||
--
Fhrt ein bitweises ODER der beiden Operanden durch

<!CODE>
rA:=6;  rB:=5;
rC:=rA | rB;   // rC = 7;
>>
<<
1.1.6.2.4
^ Binres XOR |^
--
Fhrt ein bitweises Exklusiv Oder der beiden Operanden durch

<!CODE>
rA:=6;  rB:=5;
rC:=rA ^ rB;   // rC = 3;
>>
<<
1.1.6.2.5
SHL Shift-Left - binres Linksschieben|SHL
--
Verschiebt den ersten Operanden um soviele Bit nach links, wie der zweite Operand angibt. Die 'neuen', hereingeschobenen Bits sind 0. Entspricht pro Bit einer Multiplikation mit 2, solange keine Bits links herausgeschoben werden. Beim Herausschieben tritt kein Fehler auf (stiller berlauf). Ist der zweite Operand grer als 31, so ist das Ergebnis garantiert 0. Der zweite Operand muss grer oder gleich 0 sein.

<!CODE>
rA:=6;  rB:=2;
rC:=rA SHL rB;   // rC = 24;  (6 *2 *2)
>>
<<
1.1.6.2.6
SHR Shift-Right - binres Rechtsschieben|SHR
--
Verschiebt den ersten Operanden um soviele Bit nach rechts, wie der zweite Operand angibt. Die 'neuen', hereingeschobenen Bits sind 0. Entspricht pro Bit einer Division durch 2, ganzzahlig. Ist der zweite Operand grer als 31, so ist das Ergebnis garantiert 0. Der zweite Operand muss grer oder gleich 0 sein.

<!CODE>
rA:=6;  rB:=2;
rC:=rA SHR rB;   // rC = 1;  ((6 DIV 2) DIV 2)
>>
<<
1.1.6.3
logische Operatoren|logisch
$NoSort
--
Diese Operatoren liefern als Ergebnis einen logischen Wert <!RW>TRUE oder <!RW>FALSE zurck. 
Da nur <!RW>REAL-Werte als Datentyp zur Verfgung stehen, liefern die Operatoren 1 fr <!RW>TRUE und 0 fr <!RW>FALSE.

Die Operanden werden automatisch in einen logischen Wert gewandelt. Hierbei gilt: 0 = FALSE, <b>jeder(sic!)</b> andere Wert gilt als TRUE.

Eine Sonderform der logischen Operatoren sind die relationalen Operatoren, die getrennt beschrieben sind.
>>
<<
1.1.6.3.1
NOT logische Negation|NOT
--
Liefert das logische Gegenteil des Operanden

<!CODE>
rA:=TRUE;
rB:=NOT rA;   // rB = FALSE
>>
<<
1.1.6.3.2
AND logische Und-Verknpfung|AND
--
Betrachtet die Operanden als logische Werte und fhrt ein UND durch.

<!CODE>
rA:=6;  rB:=5;
rC:=rA AND rB;   // rC = 1; (TRUE)
>>
<<
1.1.6.3.3
OR logische Oder-Verknpfung|OR
--
Betrachtet die Operanden als logische Werte und fhrt ein ODER durch.

<!CODE>
rA:=6;  rB:=5;
rC:=rA OR rB;   // rC = 1; (TRUE)
>>
<<
1.1.6.3.3
XOR logische Exklusiv-Oder-Verknpfung|XOR
--
Betrachtet die Operanden als logische Werte und fhrt eine Exklusiv-Oder-Verknpfung durch

<!CODE>
rA:=6;  rB:=5;
rC:=rA XOR rB;   // rC = 0; (FALSE)
>>

<<
1.1.6.4
String Operatoren|String
$NoSort
--
Diese Operatoren liefern als Ergebnis einen String.
>>
<<
1.1.6.4.1
+ Verkettung|+
--
Hngt zwei Strings aneinander

<!CODE>
sA:='Hallo';  sB:='Welt';
sC:=sA + ' '+ sB;   // sC = 'Hallo Welt'
>>
<<
1.1.6.4.2
[ ] Elementzugriff auf String|[ ]
--
Liefert ein Zeichen eines Strings. Die Zeichen des Strings werden ber ihren Index (ihre Position im String) angesprochen. Das erste Zeichen hat den Index 1.
Zugriffe ber das Ende eines Strings hinaus ergeben lesend immer ''. Schreibende Zugriffe ber das Ende des Strings werden ignoriert.

<!CODE>
sA:='Hund';
sC:=sA[2];     // sC = 'u' (das 2. Element des Strings)
sC:=sA[7];      // sc = ''  (leer, da hinter dem Ende gelesen)
sA[2]:='a';    // sA = 'Hand' (2. Element des Strings gendert)
sA[7]:='a';    // sA = 'Hand' (keine nderung, da hinter dem Ende)
>>


<<
1.1.6.5
Vector / StringVector Operatoren|Vector / StringVector
$NoSort
--
Diese Operatoren liefern als Ergebnis einen Vector oder StringVector.
>>
<<
1.1.6.5.1
+ Verkettung|+
--
Hngt zwei Vectoren / StringVectoren aneinander

<!CODE>
vA:=[1,2,3];  vB:=[4,5];
vC:=vA + vB;   // vC = [1,2,3,4,5]

svA:=['Hello','World'];  svB:=['with','cPCI'];
svC:=vA + vB;   // svC = ['Hello','World','with','cPCI']
>>
<<
1.1.6.5.2
[ ] Elementzugriff auf Vector / StringVector |[ ]
--
Liefert ein Element eines Vectors / StringVectors. Die Elemente des Vectors / StringVectors werden ber ihren Index (ihre Position im Vector / StringVector) angesprochen. Das erste Element hat den Index 1.
Zugriffe ber das Ende eines Vector / StrngVectors hinaus ergeben lesend immer 0 / ''. Schreibende Zugriffe ber das Ende des Vectors / StringVectors erweitern den Vector / StringVector auf die passende Lnge.

<!CODE>
vA:=[1,2,4,8,16];
rC:=vA[3];      // rC = 4 (das 3. Element des Vectors)
rC:=vA[7];      // rC = 0 (ber das Ende hinausgelesen)
vA[3]:=12;      // vA = [1,2,12,8,16] (3. Element ist jetzt 12)
vA[7]:=12;      // vA = [1,2,12,8,16,0,12] (7. Element ist jetzt 12, neue Elemente sind 0)

svA:=['Hello','World','with','cPCI'];
rC:=svA[3];     // rC = 'with' (das 3. Element des Vectors)
rC:=svA[6];     // rC = '' (ber das Ende hinausgelesen)
svA[3]:='in';   // vA = ['Hello','World','in','cPCI'] (3. Element ist jetzt 'in')
svA[6]:='now';  // vA = ['Hello','World','in','cPCI','','now'] (6. Element ist jetzt 'now', neue Elemente sind '')
>>

<<
1.1.6.6
relationale Operatoren|relational
$NoSort
--
Diese Operatoren vergleichen die zwei Operanden und liefern als Ergebnis einen logischen Wert TRUE (1) oder FALSE (0) zurck.

Verglichen werden knnen nur Operanden vom gleichen Datentyp (Real mit Real, String mit String etc.)

Strings werden zeichenweise basierend auf der Reihenfolge des erweiterten ASCII-Zeichensatzes verglichen.  
>>
<<
1.1.6.6.1
= Gleich|=
--
Liefert TRUE (1), wenn der linke Operand gleich dem rechten ist, sonst FALSE (0)

Numerisch 
<!CODE>
 rA:=3;  rB:=4;
 rC:=rA = rB;   // rC = FALSE (0)
<!TXT>

String 
<!CODE>
 sA:='Hallo';  sB:='Welt';
 rC:=sA = sB;   // rC = FALSE (0)
<!TXT>
 
Vector
<!CODE>
vA:=[1,2];  vB:=[3,4];
rC:=vA = vB;   // rC = FALSE (0)
<!TXT>

StringVector
<!CODE>
svA:=['Hello','World'];  svB:=['Hans','Otto'];
rC:=vA = vB;   // rC = FALSE (0)
<!TXT>
>>
<<
1.1.6.6.2
&lt;> Ungleich|<>
--

Liefert TRUE (1), wenn der linke Operand ungleich dem rechten ist, sonst FALSE (0)

numerisch
<!CODE>
rA:=3;  rB:=4;
rC:=rA &lt;&gt; rB;   // rC = TRUE (1)
<!TXT>

String
<!CODE>
sA:='Hallo';  sB:='Welt';
rC:=sA &lt;&gt; sB;   // rC = TRUE (1)
<!TXT>

Vector
<!CODE>
vA:=[1,2];  vB:=[3,4];
rC:=vA &lt;&gt; vB;   // rC = TRUE (1)
<!TXT>

StringVector
<!CODE>
vA:=['Hello','World'];  vB:=['Hans','Otto'];
rC:=vA &lt;&gt; vB;   // rC = TRUE (1)
<!TXT>
>>
<<
1.1.6.6.3
&lt; Kleiner als|<
--

Liefert TRUE (1), wenn der linke Operand kleiner als der rechte ist, sonst FALSE (0)

numerisch
<!CODE>
rA:=3;  rB:=4;
rC:=rA &lt; rB;   // rC = TRUE (1)
<!TXT>

String
<!CODE>
sA:='Hallo';  sB:='Welt';
rC:=sA &lt; sB;   // rC = TRUE (1)
<!TXT>

Vector und StringVector sind nicht erlaubt
>>
<<
1.1.6.6.4
<= Kleiner als oder gleich|<=
--

Liefert TRUE (1), wenn der linke Operand kleiner als der rechte oder gleich ist ist, sonst FALSE (0)

numerisch
<!CODE>
rA:=3;  rB:=4;
rC:=rA &lt;= rB;   // rC = TRUE (1)
<!TXT>

String
<!CODE>
sA:='Hallo';  sB:='Welt';
rC:=sA &lt;= sB;   // rC = TRUE (1)
<!TXT>

Vector und StringVector sind nicht erlaubt
>>
<<
1.1.6.6.5
&gt; Grer als|>
--

Liefert TRUE (1), wenn der linke Operand grer als der rechte ist ist, sonst FALSE (0)

numerisch
<!CODE>
rA:=3;  rB:=4;
rC:=rA &gt; rB;   // rC = FALSE (0)
<!TXT>

String
<!CODE>
sA:='Hallo';  sB:='Welt';
rC:=sA &gt; sB;   // rC = FALSE (0)
<!TXT>

Vector und StringVector sind nicht erlaubt
>>
<<
1.1.6.6.5
&gt;= Grer als oder gleich|>=
--

Liefert TRUE (1), wenn der linke Operand kleiner als der rechte oder gleich ist ist, sonst FALSE (0)

numerisch
<!CODE>
rA:=3;  rB:=4;
rC:=rA &gt;= rB;   // rC = FALSE (0)
<!TXT>

String
<!CODE>
sA:='Hallo';  sB:='Welt';
rC:=sA &gt;= sB;   // rC = FALSE (0)
<!TXT>

Vector und StringVector sind nicht erlaubt
>>

<<
1.1.6.7
Bedingungsoperator ?:|Bedingungsoperator
$NoHelpDebug
--
Der ternre Bedingungoperator wird folgendermaen notiert:
<!SYN>
Condition <!TW>? TrueValue <!TW>: FalseValue
<!TXT>
Wenn die <!PW>Condition <!RW>True ist, liefert der Operator den <!PW>TrueValue zurck, ansonsten den <!PW>FalseValue. Dieser Operator wurde von der Programmiersprache C bernommen.

 <!PW>TrueValue und <!PW>FalseValue knnen unterschiedlichen Datentyps sein, wenn der Empfnger des Wertes des Ausdrucks dies untersttzt.

Dieser Operator wirkt also in etwa wie folgende (hypothetische) Funktion:
<!CODE>
function ConditionOperator (Condition : real; TrueValue, FalseValue : real|string|vector|stringvector) : real|string|vector|stringvector;
begin
  if Condition then return (TrueValue)
               else return (FalseValue);
end;
<!TXT>
        
<!REM>
Implementiert ab Build 1003.
<!TXT>
>>

<<
1.1.7
Anweisung
$NoSort
--
<h3>Anweisungen</h3>
Anweisungen definieren die Aktionen in einem Interrpeterschritt.
Der Interpreter fhrt die angegebenen Anweisungen nacheinander aus.

Mehrere Anweisungen (z.B. Zuweisungen und Prozeduraufrufe) knnen kombiniert werden. Auf diese Weise lassen sich Schleifen, bedingte Anweisungen und andere strukturierte Anweisungen erzeugen.

Mehrere Anweisungen werden durch Strichpunkte voneinander getrennt.

Syntaktisch lassen sich Anweisung wie folgt notieren:

<!SYN>
Anweisung :=
   EinfacheAnweisung |
   StrukturierteAnweisung

EinfacheAnweisung :=
   <a HREF="1.1.7.1">Zuweisung</a> |
   <A HREF="1.1.7.2">VOIDZuweisung</a> |
   <A HREF="1.1.7.3">ProzedurAufruf</a> |
   <A HREF="1.1.7.4">COMAnweisung</a> |
   <A HREF="1.1.7.11">NetAnweisung</a>

StrukturierteAnweisung :=
   <A HREF="1.1.7.5">RepeatUntilSchleife</a> |
   <A HREF="1.1.7.6">WhileDoSchleife</a> |
   <A HREF="1.1.7.7">ForSchleife</a> |
   <A HREF="1.1.7.8">CaseVerzweigung</a> |
   <A HREF="1.1.7.9">IfVerzweigung</a> |
   <A HREF="1.1.7.10">BeginEndBlock</a>
<!TXT>
>>
<<
1.1.7.1
Zuweisung
--
<h3>Zuweisungen</h3>
Mit Hilfe einer Zuweisung wird eine Variable oder ein Element einer Variablen auf einen neuen Wert gesetzt.

Eine Zuweisung hat folgendes Format:
<!SYN>
Variable := Ausdruck
<!TXT>
Hierbei ist Variable ein beliebiges Element, dessen Wert gendert werden kann. Dies kann eine 'echte' mit VAR definierte Variable, ein Element einer mehr-elementgen Variable oder eine Eigenschaft eines COM- oder NET- Objektes sein. 
Ausdruck muss vom Datentyp zu der linken Seite passen.

Das Symbol <b><!CW>:=</b> wird als Zuweisungsoperator bezeichnet.
Eine Zuweisung ersetzt den aktuellen Wert von Variable durch den Wert von Ausdruck. Die folgende Zuweisung ersetzt beispielsweise den aktuellen Wert der Variable I durch den Wert 3:
<!CODE>
rI := 3;
<!TXT>

Die Variablenreferenz auf der linken Seite der Zuweisung kann auch im Ausdruck auf der rechten Seite enthalten sein:
<!CODE>
rI := rI + 1;
<!TXT>
Diese Zuweisung erhht den Wert von rI um 1. 

Einige weitere Beispiele fr Zuweisungen:
<!CODE>
rX := rY + rZ;
rDone := (rI &gt;= 1) and (I &lt; 100);
I := Sqr(J) - I  * K;
MyString := 'A';
SomeVector[I + 1] := P;
MyCOMObject.SomeProperty := True;
MyNetObject.SomeProperty := True;
<!TXT>
>>
<<
1.1.7.2
VOID Zuweisung|VOID
--
Mit Hilfe einer <!RW>VOID Zuweisung kann das Ergebnis eines Funktionsaufrufes ignoriert werden.

Eine VOID Zuweisung hat folgendes Format:
<!SYN>
<!RW>VOID Ausdruck
<!TXT>
Diese Form kann benutzt werden, wenn die aufgerufene Funktion einen gewnschten Effekt auslst, der Rckgabewert der Funktion aber nicht benutzt wird. Aus der Funktion wird so praktisch eine Prozedur. 

 <b>Ausdruck</b> muss nicht unbedingt ein Funktionsaufruf sein, eine <!RW>VOID Anweisung wie:
<!CODE>
VOID 1+2*3+4;
<!TXT>
ist syntaktisch gltig, macht aber wenig Sinn.
>>
<<
1.1.7.3
ProzedurAufruf
--
Ein Prozeduraufruf besteht aus dem Namen einer Prozedur (wenn ntig, mit Interpreter-Object-Namen) und (falls erforderlich) einer <a href="1.1.3.4.3">Parameterliste</a>. 
Die Anzahl und der Datentyp der Parameter muss zu der aufgerufenen Prozedur passen. Die an eine Routine bergebenen Parameter werden auch als tatschliche Parameter bezeichnet - im Gegensatz zu den formalen Parametern in der Deklaration der Routine.

Hier einige Beispiele fr Prozeduraufrufe:
<!CODE>
StartTest;
SetValue (rMW);
ME3000.ADC.Sample.Setup (10000, 1000, 0);
<!TXT>

Wenn eine Prozedur aufgerufen wird, so wird die Steuerung vom Punkt des Aufrufs an den Rumpf der Routine bergeben, die Prozedur wird bis zu ihrem Ende oder einem Return bearbeitet und danach wird die nchste Anweisung nach dem Prozeduraufruf bearbeitet.
>>
<<
1.1.7.4
COMAnweisung
!128.118
--
Mit Hilfe von ComAnweisungen knnen Eigenschaften von in COMObject Variablen referenzierten COM-Objekten gendert oder Methoden dieser Objekte aufgerufen werden. 
Die genaue Syntax dieser Zugriff hngt vom jeweiligen COM-Objekt ab.

Zuweisung an Eigenschaft:
<!SYN>  
ComVariable[.UnterObjekt[...]].Property := Ausdruck
<!TXT>
Die Eigenschaft des COM-Objektes (oder eines seiner Unterobjekte) wird also hnlich wie eine Variable benutzt.

Aufruf einer Methode:
<!SYN>
ComVariable[.UnterObjekt[...]].Methode [(ParameterListe)]
<!TXT>
>>
<<
1.1.7.5
Repeat-Until Schleife|Repeat Until
--
Die Syntax fr eine <!RW>Repeat-Anweisung lautet
<!SYN>
<!RW>REPEAT 
  Anweisung1; 
  ...; 
  AnweisungN; 
<!RW>UNTIL Ausdruck
<!TXT
 <b>Ausdruck</b> gibt einen Real-Wert zurck, der logisch (0=<!RW>false, Nicht-0=<!RW>true) ausgewertet wird. Alle Anweisungen zwischen repeat und until werden der Reihe nach ausgefhrt. Nach jedem Durchlauf wird der angegebene Ausdruck ausgewertet. Liefert Ausdruck den Wert True, wird die repeat-Anweisung beendet. Da Ausdruck erst am Ende der ersten Iteration ausgewertet wird, wird die Anweisungsfolge mindestens einmal durchlaufen.

Hier einige Bespiele fr <!RW>REPEAT-Anweisungen:
<!CODE>
 repeat
   rK := rI mod rJ;
   rI := rJ;
   rJ := rK;
 until rJ = 0;

 repeat
   SetValue (ME3000.ADC.Get (1));
 until StepContinue;
<!TXT>

Leere Repeat-Schleife, wartet nur bis <a href="128.10.2.1">StepContinue</a> <!RW>true wird.
<!CODE>
 repeat
 until stepcontinue;
<!TXT>
in dieser leeren <!RW>Repeat <!RW>Until Schleife wird automatisch ein <a href="128.10.3.17">Doze</a> ausgefhrt, die Schleife entspricht also eigentlich folgender Schleife
<!CODE>
 repeat
   Doze;
 until stepcontinue;
<!TXT>
>>

<<
1.1.7.6
While-Do Schleife |While Do
--
Eine <!RW>While-Anweisung hnelt in vieler Hinsicht einer <a href="1.1.7.5">Repeat-Anweisung</a>. Die Bedingung wird aber bereits vor der ersten Ausfhrung der Anweisungsfolge ausgewertet. Wenn das Ergebnis der Bedingung False ist, wird die Anweisungsfolge nicht ausgefhrt.

Die Syntax einer <!RW>While-Anweisung lautet
<!SYN>
<!RW>WHILE Ausdruck <!RW>DO Anweisung
<!TXT>
<b>Ausdruck</b> gibt einen Real-Wert zurck, der logisch (0=<!RW>false, Nicht-0=<!RW>true) ausgewertet wird.

Bei <b>Anweisung</b> sollte es sich aus Grnden der Lesbarkeit und Wartbarkeit immer um eine Verbundanweisung (<a href="1.1.7.10">Begin-End</a>) handeln. 
Die <!RW>While-Anweisung fhrt <b>Anweisung</b> wiederholt aus und wertet vor jedem neuen Durchlauf den angegebenen Ausdruck aus. Solange der Ausdruck den Wert True ergibt, wird die Ausfhrung fortgesetzt.

Hier einige Bespiele fr while-Anweisungen:
<!CODE>
while vData[rI] <> rX do Inc(rI);

while rI > 0 do begin
  if Odd(rI) then rZ := rZ * rX;
  rI := rI div 2;
  rX := Sqr(rX);
end;

MeasData.First;
while not MeasData.Eof do begin
  ProcessMeasValue;
  MeasData.Next;
end;
<!TXT>

Leere While-Do Schleife, wartet nur auf <a href="128.10.2.1">StepContinue</a>=<!RW>TRUE:
<!CODE>
while not StepContinue do;
<!TXT>
>>

<<
1.1.7.7
For-To-Do Schleife|For To Do
--
Im Gegensatz zur <!RW>Repeat- und <!RW>While-Anweisung wird bei einer <!RW>For-Anweisung im Voraus angegeben, wie oft die Schleife durchlaufen werden soll. 

Die Syntax einer <!RW>For-Anweisung lautet
<!SYN>
<!RW>FOR Zhler := Anfangswert <!RW>TO Endwert [<!RW>STEP Schrittweite] <!RW>DO Anweisung
<!TXT>

<b>Zhler</b> ist eine lokale Real-Variable. 

 <b>Anfangswert</b>, <b>Endwert</b> und die optionale <b>Schrittweite</b> sind Real-Ausdrcke. 

 <b>Anweisung</b> ist eine einfache oder eine strukturierte Anweisung. Aus Grnden der Lesbarkeit und Wartbarkeit sollte immer ein <a href="1.1.7.10">Begin-End</a> Block benutzt werden.

Die <!RW>For-Anweisung weist Zhler den angegebenen Anfangswert zu und fhrt anschlieend wiederholt Anweisung aus. Nach jedem Durchlauf wird der Wert zu der Zhlvariable die Schrittweite (1, wenn nicht angegeben) addiert. Sobald der Wert von Zhler den Endwert berschreitet (bzw. unterschreitet, wenn Schrittweite negativ ist), wird die <!RW>For-Anweisung beendet. Anweisung wird also einmal fr jeden Wert ausgefhrt, der im Bereich von Anfangswert bis Endwert liegt. Ist Anfangswert mit Endwert identisch, wird Anweisung genau einmal ausgefhrt. Wenn Anfangswert in einer for-Anweisung mit positiver Schrittweite grer als Endwert ist, wird Anweisung kein einziges Mal ausgefhrt. Dasselbe gilt fr eine <!RW>For-Anweisung mit negativer Schrittweite, in der Anfangswert kleiner als Endwert ist. Eine Schrittweite von 0 ist nicht erlaubt.

Die Ausdrcke Anfangswert und Endwert werden zur Steuerung der Schleifenausfhrung nur einmal ausgewertet, und zwar vor Beginn der Schleife. Die <!RW>For-Anweisung hat starke hnlichkeit mit dem folgenden <!RW>While-Konstrukt:
<!CODE>
 begin
   Zhler := Anfangswert;
   while Zhler &lt;= Endwert do begin
     Anweisung;
     Zhler := Zhler+Schrittweite;
   end;
 end
<!TXT>

Im Unterschied zur <!RW>For-Anweisung wird Endwert aber in der <!RW>While-Schleife vor jedem Durchlauf erneut ausgewertet. Wenn Endwert ein komplexer Ausdruck ist, kanndies eine Verlangsamung der Ausfhrungsgeschwindigkeit zur Folge haben. Auerdem knnen sich von Anweisung verursachte nderungen an Endwert auf die Ausfhrung der Schleife auswirken.

Hier einige Beispiele fr for-Anweisungen:
<!CODE>
 for rI := 2 to 63 do begin
   if vData[rI] > rMax then begin
     rMax := vData[rI];
   end;
 end;

 rSum:=0;
 for rI := 1 to prMittelwerte do begin
   rSum:=rSum+sqr(ME3000.ADC.Get(1));
 end;
 SetValue (sqrt(rSum/prMittelwerte));
<!TXT>
>>

<<
1.1.7.8
Case Verzweigung|Case
--
Die <!RW>CASE-Anweisung ist eine Alternative zur <!RW>IF-Anweisung, die aufgrund der besseren Lesbarkeit bei komplexen Verschachtelungen eingesetzt werden sollte. 

Die Syntax einer <!RW>CASE-Anweisung lautet
<!SYN>
<!RW>CASE Selektor <!RW>OF
  CaseListe : Anweisung;
 [CaseListe : Anweisung; 
  ..]
 [<!RW>ELSE Anweisung;]
<!RW>END
<!TXT>

Hierbei ist Selektor ein beliebiger Ausdruck vom Typ Real oder String. 

Fr <!SW>CaseListe kann folgendes angegeben werden:

Wenn Ausdruck vom Typ <!RW>REAL ist:
<ul indent=12>
<li>ein RealAusdruck</li>
<li>ein Zahlenbereich, angegeben durch RealAusdruck .. RealAusdruck</li>
<li>eine Liste der beiden vorgenannten Mglichkeiten, durch Komma getrennt</li>
</ul>

Wenn Ausdruck vom Typ <!RW>STRING ist:
<ul indent=12>
<li>ein StringAusdruck</li>
<li>eine Liste von StringAusdrcken, durch Komma getrennt</li>
</ul>

Findet der Interpreter eine <!RW>CASE-Anweisung, so wird der Wert von Selektor einmalig berechnet. Danach wird nach der die erste CaseListe gesucht, in der der Ausdruck enthalten ist. Fr diese Liste wird die Anweisung ausgefhrt. Danach wird die gesamte Case-Anweisung verlassen. 

Es wird also maximal eine Anweisung ausgefhrt (diese Anweisung kann selbstverstndlich ein <a href="1.1.7.10">Begin-End</a> Block sein)

Wird der Ausdruck in keiner der CaseListen gefunden, so wird die optionale <!RW>ELSE Anweisung ausgefhrt. Ist kein Else Zweig angegeben, so wird nichts ausgefhrt.

Die case-Anweisung
<!CODE>
case rI of
  1 .. 5      : sText := 'Low';
  6 .. 9      : sText := 'High';
  0, 10 .. 99 : sText := 'Out of range';
  else          sText := '';
end;
<!TXT>
ist mit der folgenden verschachtelten if...then...else-Anweisung identisch:
(aber viel einfacher zu verstehen und zu pflegen)
<!CODE>
if (rI&gt;=1) and (rI&lt;=5) then begin
  sText := 'Low';
end
else begin
 if (rI&gt;=6) and (rI&lt;=10) then begin
    sText := 'High'
  end
  else begin
    if (rI=0) or ((rI&gt;=10) and (rI&lt;=99)) then begin
      sText := 'Out of range'
    end
    else begin
      sText := '';
    end;
  end;
end;
<!TXT>

Ein weiteres Beispiel:
<!CODE>
case sData[1] of
  'P' : Result:=1;
  'F' : Result:=2;
  'I' : Result:=3;
  else  Result:=0;
end;
<!TXT>
>>
<<
1.1.7.9
If-Then / If-Then-Else Verzweigung|If Then
--
Die Syntax einer <!RW>IF-Anweisung lautet:
<!SYN>
<!RW>IF LogikAusdruck <!RW>THEN TrueAnweisung [<!RW>ELSE FalseAnweisung]
<!TXT>
Das Ergebnis von LogikAusdruck muss ein Wert vom Typ <!RW>REAL sein, der logisch (0=false, nicht-0=true) ausgewertet wird. 
 <b>TrueAnweisung</b> wird nur ausgefhrt, wenn der LogikAusdruck <!RW>TRUE ergibt. 
 <b>FalseAnweisung</b> (bzw. der <!RW>ELSE-Zweig) wird nur ausgefhrt, wenn der LogikAusdruck <!RW>FALSE ergibt.

Nach <!RW>THEN und <!RW>ELSE darf jeweils nur eine Anweisung stehen. Dies darf - und sollte - eine <a href="1.1.7.10">BEGIN-END</a> Anweisung sein.
<!CODE>
if J <> 0 then begin
  Result := I/J;
  Count := Count + 1;
end
else begin
  if Count = Last then begin
    Done := True
  end;
end;
<!TXT>

Zwischen der <!RW>THEN-Klausel und dem Wort <!RW>ELSE <u>darf kein</u> Strichpunkt stehen. Nach einer vollstndigen <!RW>IF-Anweisung mssen Sie einen Strichpunkt verwenden, um sie von der nchsten Anweisung innerhalb des Blocks zu trennen. Zwischen der <!RW>THEN- und der <!RW>ELSE-Klausel wird nur ein Leerzeichen oder ein Wagenrcklaufzeichen bentigt. 

Das Einfgen eines Strichpunkts vor dem Wort <!RW>ELSE (in einer <!RW>IF-Anweisung) stellt einen der hufigsten Programmierfehler dar, da hiermit die kurze Form der <!RW>IF-Anweisung beendet wrde und der Interpreter versucht, das <!RW>ELSE als eigene Anweisung abzuarbeiten.

Auch verschachtelte <!RW>IF-Anweisungen (ohne <!RW>BEGIN-<!RW>END Blcke) bergen die Gefahr von Programmierfehlern. Das Problem besteht darin, da fr bestimmte <!RW>IF-Anweisungen <!RW>ELSE-Klauseln existieren, fr andere jedoch nicht. Ansonsten ist die Syntax fr die beiden <!RW>IF-Konstrukte identisch. Wenn in einer Folge von Bedingungen weniger <!RW>ELSE-Klauseln als <!RW>IF-Anweisungen vorhanden sind, ist mglicherweise die Zuordnung der <!RW>ELSE-Klauseln zu den <!RW>IF-Anweisungen nicht eindeutig erkennbar. Die Anweisung 
<!CODE>
if Ausdruck1 then if Ausdruck2 then Anweisung1 else Anweisung2;
<!TXT>
knnte demnach auf zwei Arten interpretiert werden:
<!CODE>
if Ausdruck1 then [ if Ausdruck2 then Anweisung1 else Anweisung2 ];
<!TXT>
<font size=-1>oder</font>
<!CODE>
if Ausdruck1 then [ if Ausdruck2 then Anweisung1 ] else Anweisung2;
<!TXT>

Der Compiler verwendet immer die erste Interpretationsart. Dies bedeutet, da die Anweisung
<!CODE>
if Ausdruck1 then if Ausdruck2 then Anweisung1 else Anweisung2
<!TXT>
mit diesem Konstrukt identisch ist:
<!CODE>
if Ausdruck1 then begin
  if Ausdruck2 then begin
    Anweisung1;
  end
  else begin
    Anweisung2;
  end;
end;
<!TXT>

Die zweite Form ist jedoch einfacher verstndlich und erlaubt die Erweiterung der einzelnen Anweisungen.
>>
<<
1.1.7.10
Verbundanweisung / Begin-End Block|Begin End
--
Eine Verbundanweisung setzt sich aus einer Folge von anderen (einfachen oder strukturierten) Anweisungen zusammen, die in der genannten Reihenfolge ausgefhrt werden. Die in einer Verbundanweisung enthaltenen Teilanweisungen sind zwischen den reservierten Wrtern begin und end eingeschlossen und durch Strichpunkte voneinander getrennt. 

Syntax:
<!SYN>
<!RW>BEGIN
  [Anweisung; ..]
<!RW>END
<!TXT>
Verbundanweisungen sind wichtig, wenn die Syntax genau eine Anweisung verlangt. Sie knnen in Programm-, Funktions- und Prozedurblcke und in andere strukturierte Anweisungen (z.B. bedingte Anweisungen oder Schleifen) integriert werden:

<!CODE>
I := SomeConstant;
while I &gt; 0 do        begin
  ...
  I := I - 1;
end;
<!TXT>

Es gibt auch Verbundanweisungen, die nur eine einzelne Teilanweisung enthalten. Wie runde Klammen in einem komplexen Ausdruck tragen auch die Wrter begin und end zur Vermeidung von Mehrdeutigkeiten und zur Verbesserung der Lesbarkeit bei. 
<!CODE>
if i &lt; 10 then begin
  SendAndWait;
end;
<!TXT>  

Es ist auch mglich, mit einer leeren Verbundanweisung einen Block zu erzeugen, der keine Aktion ausfhrt:
<!CODE>
begin
end;
<!TXT>
>>
<<
1.1.7.11
NetAnweisung
!128.118
--
Mit Hilfe von NetAnweisungen knnen Eigenschaften und Methoden von .Net Klassen benutzt werden.
Die genaue Syntax dieser Zugriffe hngt vom den jeweiligen .Net Klassen ab.

Zuweisung an Eigenschaft:
<!SYN>  
NetVariable[.UnterObjekt[...]].Property := Ausdruck
<!TXT>
Die Eigenschaft des Net-Objektes (oder eines seiner Unterobjekte) wird also hnlich wie eine Variable benutzt.

Aufruf einer Methode:
<!SYN>
NetVariable[.UnterObjekt[...]].Methode [(ParameterListe)]
<!TXT>
>>

<<
128 
IP-Objekte
$Open
--
>>


<<
200
Fehlermeldungen
$NoSort
--
>>
<<
200.1
1 EXIT-Befehl
--
Der Step wurde mit dem <!RW>EXIT Befehl abgebrochen.
>>
<<
200.2
2 ABBRUCH
--
Der Schritt wurde manuell mit dem Abbruch-Knopf abgebrochen.
>>
<<
200.3
3 Unerwartete Exception
--
Es trat eine unerwartete Exception auf. Hierdurch wurde der Step abgebrochen. Bitte MCD informieren, wenn die Exception im Programm erzeugt wurde. 

Die Exception kann jedoch auch in einer externen DLL, einem COM Objekt oder einer .Net Klasse aufgetreten sein. Wenn die DLL, das COM Objekt oder die .Net Klasse nicht von MCD stammt, ist der jeweilige Hersteller zu benachrichtigen.
>>
<<
200.4
4 Testabbruch
--
Ein laufender Test wurde abgebrochen. Hierdurch wurde auch der laufende Interpreterschritt abgebrochen.
>>
<<
200.5
5 berlauf des Aufrufstacks
--
Der Interpreterschritt enthlt eine eine Gruppe von Prozeduren bzw. Funktionen, die sich selbst immer wieder gegenseitig aufrufen. (Stichwort: Rekursive Programmierung) 
Dies ist nur bis zu einer maximalen Aufruftiefe mglich. Vermutlich liegt ein Programmierfehler vor (z.B. eine vergessene Abbruchbedingung).

Beispiel:
<!CODE>
// Fakulttsberechnung  (hier fehlt die Abbruchbedingung!)
function FAK (r : real) : real;
begin
  Result:=FAK(r-1)*n;
end;

// korrekt wre:
// (jedoch auch hier auf die maximale Stacktiefe limitiert)
function FAK2 (r : real) : real;
begin
  if r&lt;=1 then return (r);
  Result:=FAK2(r-1)*n;
end;

// oder (besser und schneller, da ohne Rekursion)
// (nur auf Wertebereich der Variablen limitiert)
function FAK3 (r : real) : real;
begin
  Result:=1;
  for r:=2 to r do begin
    Result:=r*Result;
  end; 
end;
<!TXT>
>>
<<
200.11
11 Bezeichner wurde bereits als Variablenname verwendet
--
Der Bezeichner, der als Name einer Variablen verwendet werden sollte, wurde bereits fr einen Parameters oder eine Variablen verwendet.

Beispiel:
<!CODE>
parameter
  rDelay : (1, real, 'Pre-Step-Delay [ms]', '1..100');

var
  rLoop : real;
  <font color=red>rDelay</font> : real;

static
  <font color=red>rLoop</font> : real;
<!TXT>

Abhilfe:
<ul indent=12>
<li>anderen Namen verwenden</li>
<li>Namensschema verwenden (Variablen abhngig von Typ mit v, r, s oder co beginnen, Parameter mit ps, und pr)</li>
</ul>
>>

<<
200.12
12 Bezeichner wurde bereits als Parametername verwendet
--
Der Bezeichner, der als Name eines Parameters verwendet werden sollte, wurde bereits fr einen Parameter verwendet.

Beispiel:
<!CODE>
parameter
  psDelay : (1, real, 'Pre-Step-Delay [ms]', '1..100');
  <font color=red>psDelay</font> : (3, real, 'Repeat-Delay [ms]',   '10..1000');
<!TXT>

Abhilfe:
<ul indent=12>
<li>anderen Namen verwenden</li>
</ul>
>>

<<
200.13
13 Bezeichner ist ein reserviertes Wort
--
Der angegebene Bezeichner wird intern vom Interpreter verwendet.

Beispiel:
<!CODE>
parameter
  <font color=red>Delay</font> : (1, real, 'Pre-Step-Delay [ms]', '1..100');

procedure <font color=red>Option</font>;
begin
end;
<!TXT>

Dieser Fehler kann insbesondere dann eintreten, wenn der Interpreter erweitert wird und damit ein bisher nicht reserviertes Wort in der neueren Version reserviert ist.

Abhilfe:
<ul indent=12>
<li>anderen Namen verwenden</li>
</ul>

Vorbeugend:
<ul indent=12>
<li>Namensschema verwenden (Variablen abhngig von Typ mit v, r, s oder co beginnen, Parameter mit ps, und pr)</li>
<li>aussagekrftige Prozedur- und Funktionsnamen verwenden. Die reservierten Worte sind immer kurze und einfache Ausdrcke. Fr Funktionen und Prozeduren daher besser Doppelnamen verwenden.</li>
</ul>

Beispiel:
<!CODE>
parameter
  prDelay : (1, real, 'Pre-Step-Delay [ms]', '1..100');

procedure ReadOption;
begin
end;
<!TXT>
>>

<<
200.14
14 Symbol erneut definiert
--
Der Name wurde bereits fr etwas anderes verwendet oder ist ein intern benutzer Name.

Beispiel:
<!CODE>
var
  ReadData : string;

function <font color=red>ReadData</font> : string;
begin
end;
<!TXT>

Abhilfe:
<ul indent=12>
<li>anderen Namen verwenden</li>
</ul>

Vorbeugend:
<ul indent=12>
<li>Namensschema verwenden (Variablen abhngig von Typ mit v, r, s oder co beginnen, Parameter mit ps, und pr)</li>
<li>aussagekrftige Prozedur- und Funktionsnamen verwenden. Die reservierten Worte sind immer kurze und einfache Ausdrcke. Fr Funktionen und Prozeduren daher besser Doppelnamen verwenden.</li>
</ul>
>>

<<
200.15
15 Zirkulre USES-Aufrufe
--
Eine Library will sich selbst im <!RW>Uses Aufruf verwenden, oder mehrere Libraries verwenden sich gegenseitig in ihrem <!RW>Uses Aufrufen.

Beispiel:
Datei: <pre>LIB_ONE.IPS</PRE>
<!CODE>
library;

uses
  'LIB_TWO';
<!TXT>

Datei: <pre>LIB_TWO.IPS</PRE>
<!CODE>
library;

uses
  <font color=red>'LIB_ONE'</font>;
<!TXT>

Abhilfe:
Zirkulren Aufruf entfernen. 

Libraries drfen sich gegenseitig aufrufen, jedoch darf niemals eine aufgerufene Library eine der sie aufrufenden Libraries einbinden.

Wenn man also ein Diagramm der Aufrufe zeichnet, muss sich ein Baum ergeben ohne Schleifen.

Unter Umstnden mssen Routinen aus zwei Libraries, die sich gegenseitig benutzen sollen, in eine Library kopiert werden.
>>

<<
200.20
99 "Error" Befehl
--
Dieser Fehler tritt auf, wenn der Interpreter den Befehl <!RW>Error ausfhrt.

Dieser Fehler wird vom Syntaxcheck nicht erkannt!
>>

<<
200.41
2002 ':=' erwartet
--
Der Interpreter hat an dieser Stelle (hinter einer Variablen) ein Zuweisungsymbol erwartet.
>>
<<
200.42
2003 ';' erwartet
--
Der Interpreter hat an dieser Stelle (nach einer kompletten Anweisung) ein Semikolon erwartet.
>>
<<
200.43
2004 ':' erwartet
--
Der Interpreter hat an dieser Stelle einen Doppelpunkt erwartet.
>>
<<
200.44
2005 '[' erwartet
--
Der Interpreter hat an dieser Stelle einen ffnende eckige Klammer erwartet.
>>
<<
200.45
2006 ungltiges Symbol
--
Das Symbol ist nicht gltig. Vermutlich steht im Quellcode ein Zeichen, dass in der Interpretersprache nicht erlaubt ist, z.B. ein Umlaut.
>>
<<
200.46
2007 '(' erwartet
--
Der Interpreter hat an dieser Stelle einen ffnende runde Klammer erwartet.
>>
<<
200.47
2008 ')' erwartet
--
Der Interpreter hat an dieser Stelle einen schlieende rund Klammer erwartet.
>>
<<
200.48
2009 '.' erwartet
--
Der Interpreter hat einen Punkt erwartet.

Dies ist insbesondere der Fall nach dem letzten <!RW>END eines Steps oder einer Library und als Trennung des Namen eines Interpreterobjektes von dessen Methoden.
>>
<<
200.49
2010 '..' erwartet
--
Der Interpreter hat zwei direkt aufeinanderfolgende Punkte erwartet.
>>
<<
200.50
2011 Komma erwartet
--
Der Interpreter hat ein Komma als Trennung zweier Bezeichner oder Parameter erwartet.
>>
<<
200.51
2012 'STEP' erwartet
--
Der Interpreter sucht den Beginn des Steps und hat daher das reservierte Wort <!RW>STEP erwartet.
>>
<<
200.52
2013 'THEN' erwartet
--
Der Interpreter hat innerhalb einer <!RW>IF Anweisung das reservierte Wort <!RW>THEN erwartet.
>>
<<
200.53
2014 'DO' erwartet
--
Der Interpreter hat innerhalb einer <!RW>WHILE Anweisung das reservierte Wort <!RW>DO erwartet.
>>
<<
200.54
2015 'UNTIL' erwartet
--
Der Interpreter hat innerhalb einer <!RW>REPEAT Anweisung das reservierte Wort <!RW>UNTIL erwartet.
>>
<<
200.55
2016 'END' erwartet
--
Der Interpreter hat das reservierte Wort <!RW>END erwartet. Vermutlich wurde weiter oben ein <!RW>BEGIN-<!RW>END Block geffnet aber nicht wieder geschlossen.
>>
<<
200.56
2017 'TO' erwartet
--
Der Interpreter hat innerhalb einer <!RW>FOR Anweisung das reservierte Wort <!RW>TO erwartet.
>>
<<
200.57
2021 'OF' erwartet
--
Der Interpreter hat innerhalb einer <!RW>CASE Anweisung das reservierte Wort <!RW>OF erwartet.
>>
<<
200.58
2022 Adresse erwartet
--
Der Interpreter hat eine Adresse aus der <!SW>UMSCards.DAT oder <!SW>UMSAdres.DAT erwartet.
>>
<<
200.59
2023 ungltiger String
--
Der String ist nicht richtig abgelegt. Z.B. knnte das abschlieende <b>'</b> fehlen.
>>
<<
200.60
2024 Real-Ausdruck erwartet
--
Der Interpreter hat einen Ausdruck erwartet, der eine Zahl ergibt.
>>
<<
200.61
2025 Variable erwartet
--
Der Interpreter hat eine Variable erwartet.
>>
<<
200.62
2026 String-Ausdruck erwartet
--
Der Interpreter hat einen Ausdruck erwartet, der einen String ergibt.
>>
<<
200.63
2028 Ausdruck erwartet
--
Der Interpreter hat einen Ausdruck erwartet.
>>
<<
200.64
2029 Real-Variable erwartet
--
Der Interpreter hat eine Variable vom Typ <!RW>REAL erwartet.
>>
<<
200.65
2030 String-Variable erwartet
--
Der Interpreter hat eine Variable vom Typ <!RW>STRING erwartet.
>>
<<
200.66
2031 Parametername erwartet
--
Der Interpreter hat den Namen eines Parameters erwartet.
>>
<<
200.67
2032 Parametername bereits verwendet
--
Der Name des Parameters wird bereits verwendet.
>>
<<
200.68
2033 Boolscher Ausdruck erwartet
--
Der Interpreter hat einen Ausdruck erwartet, der einen boolschen Wert (<!RW>TRUE oder <!RW>FALSE) darstellt.
>>
<<
200.69
2034 Parameterliste erwartet
--
Der Interpreter hat die Parameterliste (<!RW>Parameter) erwartet.
>>
<<
200.70
2035 Typ-Bezeichner erwartet
--
Der Interpreter hat einen Typ-Bezeichner erwartet. (<!RW>REAL, <!RW>STRING, <!RW>VECTOR, <!RW>STRINGVECTOR)
>>
<<
200.71
2036 ParameterNummer wurde bereits verwendet
--
Dieser Parameternummer wurde bereits ein Parametername zugeordnet.

Beispiel:
<!CODE>
Parameter
  psWait  : (1, string, 'Delay', '');
  prDealy : (<font color=red>1</font>, real,   'Delay', '');
<!TXT>
>>
<<
200.72
2037 Leerstring nicht erlaubt
--
An dieser Stelle darf kein Ausdruck angegeben werden, der einen Leerstring ergibt.

Beispiel:
<!CODE>
var
  sAlpha, sBeta : string;
step
  sAlpha:='12345';
  sBeta:='';
  sAlpha[2]:=<font color=red>sBeta</font>;
  // Zuweisung eines Leerstrings an ein Zeichen ist nicht mglich.
<!TXT>
>>
<<
200.73
2038 String- oder Realwert erwartet
--
Der Interpreter hat einen Ausdruck erwartet, der einen Wert von Datentyp <!RW>STRING oder <!RW>REAL ergibt.
>>
<<
200.74
2039 ComObject Variable erwartet
--
Der Interpreter hat eine Variable vom Typ <!RW>ComObject erwartet.
>>
<<
200.75
2040 String-Literal erwartet
--
Der Interpreter hat ein String Literal (feste Zeichenkette in '') erwartet.

Beispiel:
<!CODE>
const
  sLib = 'MyLib';

uses
  <font color=red>sLib</font>;
<!TXT>
>>
<<
200.76
2041 Vector/StringVector Variable erwartet
--
Der Interpreter hat eine Variable vom Typ <!RW>Vector oder <!RW>StringVector erwartet.
>>
<<
200.77
2042 Falscher Variablentyp
--
Die angebene Variable hat einen hier nicht erlaubten Datentyp.
>>
<<
200.78
2048 Typkonflikt
--
Der angegebene Datentyp stimmt nicht mit dem erwarteten berein.

Im Besonderen tritt dieser Fehler bei der Zuweisung eines Ausdrucks an eine Variable auf, wenn beide unterschiedlichen Typs sind.

Beispiel:
<!CODE>
var
  sData : string;

step
  sData:=1;
<!TXT>
>>
<<
200.79
2049 Parameter auerhalb des zulssigen Bereiches
--
Der an dieser Stelle als Parameter angegeben Ausdruck hat einen nicht erlaubten Wert (zu gro, zu klein, nicht aus der erlaubten Werteliste).
>>
<<
200.80
2050 Step=0 nicht erlaubt
--
Die Schrittweite 0 ist in einer <!RW>FOR Schleife nicht erlaubt, da sich sonst eine Endlosschleife ergeben wrde.
>>
<<
200.81
2051 Befehl erwartet
--
Der Interpreter hat den Beginn einer Anweisung erwartet.
>>
<<
200.82
2052 Zeichen erwartet (Leerstring nicht erlaubt)
--
Der Stringausdruck ergibt einen String, der nicht exakt ein Zeichen lang ist.

An dieser Stelle ist weder ein lngerer String noch ein Leerstring erlaubt.
>>
<<
200.83
2053 Vector / StringVector zu gro
--
Die Anzahl Elemente im Vector/StingVector berschreitet das Maximum (65535)
>>
<<
200.84
2054 Vector erwartet
--
Der Interpreter hat einen Ausdruck erwartet, der einen <!RW>Vector Wert ergibt.
>>
<<
200.85
2055 Vector-Wert auerhalb des zulssigen Bereiches
--
Ein Element des Vectors liegt auerhalb des erlaubten Wertebereiches.
>>
<<
200.86
2056 String oder Vector erwartet
--
Der Interpreter hat einen Ausdruck erwartet, der einen Wert von Datentyp <!RW>STRING oder <!RW>VECTOR ergibt.
>>
<<
200.87
2057 Name der Adresse wird bereits verwendet
--
Dieser Bezeichner wird bereits als ein Name einer Adresse des UMS verwendet.
>>
<<
200.88
2058 Adressen sind nicht vom gleichen Typ
--
Die beiden UMS-Adressen, die hier verknpft werden sollen, sind nicht vom gleichen Typ.
>>
<<
200.89
2059 Adressen liegen nicht auf derselben Karte
--
Die beiden UMS-Adressen, die hier verknpft werden sollen, liegen nicht auf derselben Karte.
>>
<<
200.90
2060 CLR / SET / FLIP / NOP oder (0..3) erwartet
--
An dieser Stelle wird ein numerischer Wert (0/1/2/3) erwartet oder eines der reservierten Worte <!RW>CLEAR, <!RW>SET, <!RW>FLIP oder <!RW>NOP.
>>
<<
200.91
2061 STORE / SEND oder (0..1) erwartet
--
An dieser Stelle wird ein numerischer Wert (0/1) erwartet oder eines der reservierten Worte <!RW>STORE oder <!RW>SEND.
>>
<<
200.92
2062 Adresse ist nicht vom richtigen Typ
--
Die angegebene UMS Adresse ist vom falschen Typ (gehrt zu einer anderen Kartenart).
>>
<<
200.93
2063 Keine Karte an dieser Adresse vorhanden
--
Es ist keine UMS Karte definiert, die an der angegebenen Adresse liegt.
>>
<<
200.94
2067 Falscher Kartentyp an dieser Adresse
--
Die UMS Karte die an der angegebenen Adresse definiert wurde ist nicht vom erwarteten Kartentyp.
>>
<<
200.95
2068 OFF / ON oder (0..1) erwartet
--
An dieser Stelle wird ein numerischer Wert (0/1) erwartet oder eines der reservierten Worte <!RW>OFF oder <!RW>ON.
>>
<<
200.96
2069 Diese Adressen knnen nicht verknpft werden.
--
Die beiden Adressen knnen nicht in einem Befehl verknpft werden, z.B. weil sie von unterschiedlichem Typ sind oder auf verschiedenen Karten liegen oder diese Adressart keine Verknpfung zulsst.
>>
<<
200.97
2070 Ungltige Kombination/Anzahl von Parametern
--
Die Parameterliste passt nicht zum Befehl.
>>
<<
200.98
2071 LOW/ MID / HIGH oder (0..2) erwartet
--
An dieser Stelle wird ein numerischer Wert (0/1/2) erwartet oder eines der reservierten Worte <!RW>LOW, <!RW>MID oder <!RW>HIGH.
>>
<<
200.99
2072 ABS / REL oder (0..1) erwartet
--
An dieser Stelle wird ein numerischer Wert (0/1) erwartet oder eines der reservierten Worte <!RW>ABS oder <!RW>REL.
>>
<<
200.100
2073 CONST Wert hier nicht erlaubt
--
Es wurde eine Variable erwartet, aber eine Komnstante (definiert mit <!RW>const) gefunden.
>>
<<
200.101
2074 "=" erwartet
--
Der Interpreter hat ein Gleichheitszeichen erwartet.
>>
<<
200.102
2111 'BEGIN' erwartet
--
Der Interpreter hat das reserverierte Wort <!RW>BEGIN ererwartet.
>>
<<
200.103
2112 Datei nicht gefunden
--
Die angegeben Interpreterdatei (<!RW>STEP oder <!RW>LIBRARY) konnte nicht gefunden werden.
>>
<<
200.104
2113 Datei ist leer
--
Die angegeben Interpreterdatei (<!RW>STEP oder <!RW>LIBRARY) ist leer.
>>
<<
200.105
2114 Kann Library nicht als STEP ausfhren
--
Eine Library kann nicht als STEP ausgefhrt werden.

In den Prfschrittparametern einen Step aufrufen statt der Library bzw. im Editor beim Syntaxcheck als Hauptdatei einen Step definieren, der Routinen aus der Library aufruft.
>>
<<
200.106
2115 'LIBRARY' erwartet
--
Die Library beginnt nicht mit dem reservierten Wort <!RW>LIBRARY.
>>
<<
200.107
2116 Methode erwartet
--
  Der Interpreter hat ein Interpreterobjekt gefunden, nicht jedoch die Methode des Objektes, die aufgerufen werden soll.
>>
<<
200.108
2117 Im Hauptblock ist Return nicht erlaubt
--
 <!RW>Return ist nur in Funktionen oder Prozeduren erlaubt. Um den Hauptblock abzubrechen, kann <!RW>EXIT aufgerufen werden.
>>
<<
200.109
2118 Text hinter 'END.' ist nicht erlaubt
--
Quelltext hinter dem <!RW>END. ist nicht erlaubt. Er sollte entfernt oder in einen Kommentar umgewandelt werden.
>>
<<
200.111
2119 unbenutzte Variable
--
Die Variable wurde definiert, aber nie benutzt. Sie sollte entfernt werden.
>>
<<
200.112
2120 unbenutzter Parameter
--
Der Parameter wurde definiert, aber nie benutzt. Er sollte entfernt werden.
>>
<<
200.140
2410 Parameter fehlt
--
Das Feld in der Prfschrittparametertabelle, aus dem der Wert des Parameters geladen werden sollte, ist leer. Dies ist nur fr Strings erlaubt, nicht fr Realwerte.
>>
<<
200.141
2411 Parameter ist keine gltige Zahl
--
Das Feld in der Prfschrittparametertabelle, aus dem der Wert des Parameters geladen werden sollte, enthlt keine gltige Zahl.
>>
<<
200.142
2412 Parameter-Maske ist ungltig
--
Die Parametermaske in der Definition ist nicht gltig.
>>
<<
200.143
2414 Parameter auerhalb des erlaubten Bereiches
--
Der Wert in der Prfschrittparametertabelle liegt nicht in dem mit der Maske definierten Bereich.
>>
<<
200.144
2415 Parameter nicht in der Liste erlaubter Werte
--
Der Wert in der Prfschrittparametertabelle ist keiner der in der Maske arlaubten Werte.
>>
<<
200.145
2416 ungltiger Parameter
--
Der Wert in der Prfschrittparametertabelle ist ungltig.
>>
<<
200.146
4001 Exeception bei DLL.Call
--
Beim Aufruf von <!RW>DLL.Call trat ein Ausnahmefehler auf.

Unbedingt die Definition der Routine mit <!RW>DLL.Register prfen.
>>
<<
200.147
4002 DLL kann nicht geffnet werden
--
Die genannte DLL kann nicht geffnet werden. Dateinamen prfen.
>>
<<
200.148
4003 DLL ist nicht geffnet
--
Die DLL wurde nicht mit <!RW>DLL.Open geffnet.
>>
<<
200.149
4004 Fehler in der Parameterdefinition
--
Die Parameterdefinition fr <!RW>DLL.Register ist nicht gltig.
>>
<<
200.150
4005 Kein Alias angegeben
--
Wenn die DLL-Routine ber den Index aufgerufen wird, muss ein Alias vereinbart werden.
>>
<<
200.151
4006 Fehler beim Registrieren der Prozedur
--
Bei <!RW>DLL.Register ist ein Fehler aufgetreten. Evtl. ist die angegeben Routine nicht in der DLL enthalten.
>>
<<
200.152
4007 Prozedur nicht registriert
--
Die in <!RW>DLL.Call angegebene Routine wurde nicht mit <!RW>DLL.Register angemeldet.
>>
<<
200.153
4101 Kein Port mit diesem Namen vorhanden
--
Im System existiert kein Port mit dem angegebenen Namen.
>>
<<
200.154
4120 Kein Benutzerdefiniertes Feld mit diesem Namen
--
Im System existiert kein benutzerdefiniertes Feld mit dem angegebenen Namen.
>>
<<
200.155
5001 Globale Variable nicht definiert
--
Im System existiert keine Globale Variable mit dem angegebenen Namen und es wurde kein default-Wert angegeben.
>>
<<
200.156
5011 Im Anmeldeformular existiert kein Feld mit diesem Namen
--
Im Anmeldeformular existiert kein Feld mit dem angegebenen Namen und es wurde kein default-Wert angegeben.
>>
<<
200.157
5012 Feld im Anmeldeformular ist keine Combo-Box
--
Das Feld im Anmeldeformular ist keine Combobox, daher ist diese Operation nicht zulssig.
>>
<<
200.158
5101 Fehler beim Laden der KI-Liste
--
Beim Laden der KI-Liste trat ein Fehler auf.
Format der Datei prfen.
>>
<<
200.159
5201 Ungltige Framelnge (zu lang/kurz)
--
Der angegebene Frame ist zu kurz oder zu lang.
>>
<<
200.160
5202 Ungltiger CAN-Identifier
--
Der CAN Identifier liegt auerhalb des erlaubten Bereichs.
>>
<<
200.161
5203 CAN RTR-Flag ungltig (nicht 0 / 1)
--
Das CAN RTR-Flag liegt auerhalb des erlaubten Bereichs (0 / 1).
>>
<<
200.162
5204 Aufbau des CAN-RTR Frames ungltig
--
Der angegebene Frame ist kein gltiger CAN-Frame.
>>
<<
200.163
5205 CAN Datenbyte auerhalb des gltigen Bereichs
--
Die Datenbytefelder des angegebenen CAN-Frame liegen auerhalb des gltigen Bereichs (0..255 bzw. -1..255).
>>
<<
200.164
5301 Es ist kein synthetischer Messwert vorhanden. Zugriff/Speichern nicht mglich.
--
Es wurde kein synthetischer Messwert erzeugt, daher knnen weder seine Eigenschaften gendert noch derselbe gespeichert werden.

Zuerst einen synthetischen Messwert mit <!RW>MeasData.New erzeugen.
>>
<<
200.165
5302 Identifier des Messwertfeldes unbekannt.
--
Es existiert kein Messwertfeld mit dem angegebenen Namen.
>>
<<
200.166
5401 COM Server kann nicht erzeugt werden
--
Der gewnschte COM Server konnte nicht erzeugt werden.

Vielleicht wurde die Klasse noch nicht registriert bzw. ist auf diesem Rechner noch nicht installiert.
>>
<<
200.167
5402 Die ComObject Variablen ist nicht mit einem echten COM-Objekt verknpft
--
Die ComObject Variable ist leer, d.h. nicht mit einem COM.-Server verbunden. Daher ist es nicht mglich, Methoden aufzurufen.
>>
<<
200.168
5403 Name einer Methode oder Eigenschaft des COM Objektes erwartet
--
Der COM-Server besitzt keine Methode oder Eigenschaft mit dem angegeben Namen.
>>
<<
200.169
5404 Methode / Eigenschaft nicht gefunden
--
Der COM-Server besitzt keine Methode oder Eigenschaft mit dem angegeben Namen.
>>
<<
200.170
5405 Fehler im Ausdruck
--
Die Struktur des COM Aufrufes ist nicht mglich.
>>
<<
200.171
5406 Das COM Objekt besitzt kein Unterobjekt mit diesem Namen
--
Der COM-Server besitzt keine Unter-Objekt mit dem angegeben Namen.
>>
<<
200.172
5407 COM-Ausnahmefehler
--
Beim Aufruf des COM-Objektes trat ein Ausnahmefehler auf.
>>
<<
200.173
5408 Das COM Objekt liefert keinen Wert zurck
--
Der Aufruf des COM-Objektes lieferte keinen Wert zurck, der als Ergebnis des Ausdrucks verwendet werden kann.
>>
<<
200.174
5409 Verwendung von Arrays (Feldern) nicht mglich
--
Veraltet. Felder sind nun (eingeschrnkt) mglich.
>>
<<
200.175
5410 Verwendung von Reference-Bezgen  nicht mglich
--
Die Verwendung von Reference-Bezgen bei COM Aufrufen ist nicht mglich.
>>
<<
200.176
5411 Verwendung dieses Datentyps nicht mglich
--
Dieser Datentyp kann hier nicht verwendet werden.
>>
<<
200.177
5412 Unter diesem Namen wurde kein COM Object gespeichert.
--
In der globalen Liste wurde kein COM Objekt unter dem angegebenen Namen abgelegt.
>>
<<
200.178
5413 Arrays mit mehr oder weniger als einer Dimension sind nicht untersttzt
--
Arrays fr COM-Objekte mssen exakt eindimensional sein.
>>
<<
200.179
5414 Arrays mit diesem Datentyp werden nicht untersttzt
--
Es knnen nur folgende Datentypen in Arrays an COM Objekt bergeben werden:
<ul>
<li>Smallint</li>
<li>Integer</li>
<li>Single</li>
<li>Double</li>
<li>Currency</li>
<li>Byte</li>
</ul>
>>
<<
200.180
5415 Das Array hat zu viele Elemente
--
Es werden nur Arrays mit maximal 65535 Elementen untersttzt.
>>
<<
200.182
5416 Gre der Array-Elemente stimmt nicht mit der erwarteten Gre berein
--
Die Gre der Elemente des Arrays stimmt nicht mit der erwarteten Gre berein.
>>
<<
200.183
5415 Das Array hat zu viele Elemente
--
Es werden nur Arrays mit maximal 65535 Elementen untersttzt.
>>
<<
200.184
5417 Unzulssiger Befehl fr aktuellen Testmodus
--
Es wurde ein Interpreterbefehl aufgerufen, welcher auf Grund der aktuellen
Grundeinstellungen nicht zulssig ist.

Mgliche Befehle sind:

<!TW>System.SelectTestSequence : Nur erlaubt, wenn in den Grundeinstellungen fr den Testablauf der Wechsel der Ablaufnummer nicht verboten ist.
>>
