:Revision=23
:HTML
<<
120
Interne Routinen ohne IP-Objekt|interne Routinen
$Open
--
Die internen Routinen gehren zu keinem Interpreter-Objekt (IP-Objekt), sondern werden direkt von Interpreterkern ausgefhrt.
>>
<<
120.1
Interne Funktionen ohne IP-Objekt|interne Funktionen
>>
<<
120.1.1
Interne numerische Funktionen|numerisch
>>
<<
120.1.1.1
Round
!120.1.1.99 - Beispiele
--
<!DEF>
function <!TW>Round (rX : real) : real;
<!TXT>
Rundet den Wert von <!PW>rX auf die nchste ganze Zahl. Liegt <!PW>rX genau zwischen zwei ganzen Zahlen, so wird zur vom Betrag hheren Zahl aufgerundet (0.5 -> 1, -0.5 -> -1).
>>
<<
120.1.1.2
Frac
!120.1.1.99 - Beispiele
--
<!DEF>
function <!TW>Frac (rX : real) : real;
<!TXT>
Liefert den Nachkommateil von <!PW>rX.
>>
<<
120.1.1.3
Int
!120.1.1.99 - Beispiele
--
<!DEF>
function <!TW>Int (rX : real) : real;
<!TXT>
Liefert den Vorkommateil von <!PW>rX
>>
<<
120.1.1.4
Abs
!120.1.1.99 - Beispiele
--
<!DEF>
function <!TW>Abs (rX : real) : real;
<!TXT>
Liefert <!PW>rX ohne Vorzeichen
>>
<<
120.1.1.5
Sign
!120.1.1.99 - Beispiele
--
<!DEF>
function <!TW>Sign (rX : real) : real;
<!TXT>
Liefert -1, wenn <!PW>rX negativ ist, 0, wenn <!PW>rX=0 und sonst 1
>>
<<
120.1.1.6
Ceil
!120.1.1.99 - Beispiele
--
<!DEF>
function <!TW>Ceil (rX : real) : real;
<!TXT>
Liefert die nchste ganze Zahl, die grer oder gleich <!PW>rX ist.
>>
<<
120.1.1.7
Floor
!120.1.1.99 - Beispiele
--
<!DEF>
function <!TW>Floor (rX : real) : real;
<!TXT>
Liefert die nchste ganze Zahl, die kleiner oder gleich <!PW>rX ist.
>>
<<
120.1.1.99
Beispiele fr die numerischen Funktionen|Beispiele
--
<!STBL>
<tr bgcolor=f0f0f0 align=center><td><b>rX</b><!><b>Round</b><!><b>Int</b><!><b>Frac</b><!><b>Abs</b><!><b>Sign</b><!><b>Ceil</b><!><b>Floor</b><!>
<tr align=right><td><b> 1.7</b><!> 2<!> 1<!> 0.7<!>1.7<!> 1<!> 2<!> 1<!>
<tr align=right><td><b> 1.5</b><!> 2<!> 1<!> 0.5<!>1.5<!> 1<!> 2<!> 1<!>
<tr align=right><td><b> 1.2</b><!> 1<!> 1<!> 0.2<!>1.2<!> 1<!> 2<!> 1<!>
<tr align=right><td><b> 1.0</b><!> 1<!> 1<!> 0.0<!>1.0<!> 1<!> 1<!> 1<!>
<tr align=right><td><b> 0.0</b><!> 0<!> 0<!> 0.0<!>0.0<!> 0<!> 0<!> 0<!>
<tr align=right><td><b><b>-1.0</b><!>-1<!>-1<!> 0.0<!>1.0<!>-1<!>-1<!>-1<!>
<tr align=right><td><b>-1.2</b><!>-1<!>-1<!>-0.2<!>1.2<!>-1<!>-1<!>-2<!>
<tr align=right><td><b>-1.5</b><!>-2<!>-1<!>-0.5<!>1.5<!>-1<!>-1<!>-2<!>
<tr align=right><td><b>-1.7</b><!>-2<!>-1<!>-0.7<!>1.7<!>-1<!>-1<!>-2<!>
<!ETBL>
>>
<<
120.1.1.8
Len
--
<!DEF>
function <!TW>Len (sText : string) : real;
<!TXT>
Liefert die Lnge des Strings <!PW>sText in Zeichen.

<!DEF>
function <!TW>Len (vVector : string|Vector|StringVector) : real;
<!TXT>
Liefert die Anzahl der Elemente, fr die in <!PW>vVector (Vector oder StringVector) Platz reserviert wurde.

Beispiele:
<!CODE>
  sString := 'Hello';
  rCount := Len( vNumbers ); // rCount = 5
  vNumbers := [1,2,3];
  rCount := Len( vNumbers ); // rCount = 3
  svStrings := ['Hello','World'];
  rCount := Len( vNumbers ); // rCount = 2
<!TXT>
>>
<<
120.1.1.10
Pos
--
<!DEF>
function <!TW>Pos (sSub, sText : string[; rFrom : real]) : real;
<!TXT>
Sucht den String <!PW>sSub im String <!PW>sText und liefert die Stelle des ersten Auftretens oder 0, wenn nicht gefunden. Ist <!PW>rFrom angegeben, so wird erst ab dem <!PW>rFrom-ten Zeichen gesucht.
>>
<<
120.1.1.11
Ord
--
<!DEF>
function <!TW>Ord (sText : string) : real;
<!TXT>
Liefert den Zeichencode des ersten Zeichens von <!PW>sText. Wenn <!PW>sText keine Zeichen enthlt, dann wird 0 geliefert.
>>
<<
120.1.1.12
Val
--
<!DEF>
function <!TW>Val (sWert : string; rDefault : real) : real;
<!TXT>
Wandelt den Text im String <!PW>sWert in einen Zahlenwert um. Wenn dies nicht funktioniert, wird der Wert <!PW>rDefault geliefert.
>>
<<
120.1.1.13
HexVal
--
<!DEF>
function <!TW>HexVal (sWert : string; rDefault : real) : real;
<!TXT>
Wandelt den Text im String <!PW>sWert in einen Zahlenwert um. <!PW>sWert wird dabei als Hex-Zahl betrachtet. Wenn dies nicht funktioniert, wird der Wert <!PW>rDefault geliefert.
>>
<<
120.1.1.14
LastPos
--
<!DEF>
function <!TW>LastPos (sSub, sText : string) : real;
<!TXT>
Sucht den String <!PW>sSub im String <!PW>sText und liefert die Stelle des letzten Auftretens oder 0, wenn nicht gefunden.
>>

<<
120.1.2
Interne String-Funktionen|String
>>
<<
120.1.2.1 
Chr
--
<!DEF>
function <!TW>Chr (rCode : real) : string;
<!TXT>
Liefert einen String, der das Zeichen enthlt, das dem Zeichencode in <!PW>rCode entspricht.
>>
<<
120.1.2.2
Str
!120.1.2.3 - HexStr
--
<!DEF>
function <!TW>Str (rWert : real [; rStellen : real [; rNako : real [; sFill : string [; bWhere : bool]]]]) : string;
<!TXT>
Wandelt den Zahlwert <!PW>rWert in einen String um, welcher der dezimalen Notation von <!PW>rWert entspricht. <!PW>rStellen gibt die Mindestanzahl der Zeichen im Ergebnis an, <!PW>rNako gibt an, wieviel Nachkommastellen das Ergebnis haben soll. Sind <!PW>rStellen bzw. <!PW>rNako nicht angegeben, so wird die jeweils bentigte Anzahl Stellen verwendet. Wenn <!PW>sFill angegeben ist, so werden evtl. fhrende Leerzeichen durch den ersten Buchstaben von <!PW>sFill ersetzt. <!PW>bWhere gibt an ob die Fllzeichen nach(-005) oder vor (XX-5) einem eventuellen '-' Zeichen verwendet werden. Standarmig ist der wert auf false eingestellt.
>>
<<
120.1.2.3
HexStr
!120.1.2.2 - Str
--
<!DEF>
function <!TW>HexStr (rWert : real [; rStellen : real [; sFill : string]]) : string;
<!TXT>
Wandelt den Zahlwert <!PW>rWert in einen String um, welcher der hexadezimalen Notation von <!PW>rWert entspricht. <!PW>rStellen gibt die Mindestanzahl der Zeichen im Ergebnis an. Wenn <!PW>sFill angegeben ist, so werden evtl. fhrende Leerzeichen durch den ersten Buchstaben von <!PW>sFill ersetzt.
>>
<<
120.1.2.4
Copy
!120.1.2.5 - Left
!120.1.2.6 - Right
--
<!DEF>
function <!TW>Copy (vVector : string|Vector|StringVector , rStart : real [, rAnzahl : real]) : string|Vector|StringVector;

<!TXT>
Liefert aus <!PW>sText nAnzahl Zeichen ab der Position <!PW>rStart.
Wird der Parameter Anzahl weggelassen, so werden alle Elemente bis Ende des Vectors kopiert.

>>
<<
120.1.2.5
Left
!120.1.2.4 - Copy
!120.1.2.6 - Right
--
<!DEF>
function <!TW>Left (sText : string; rAnzahl : real) : string;
<!TXT>
Liefert die ersten <!PW>rAnzahl Zeichen aus <!PW>sText.
>>
<<
120.1.2.6
Right
!120.1.2.4 - Copy
!120.1.2.5 - Left
--
<!DEF>
function <!TW>Right (sText : string; rAnzahl : real) : string;
<!TXT>
Liefert die letzten <!PW>rAnzahl Zeichen aus <!PW>sText.
>>
<<
120.1.2.7
Insert
!120.1.2.8 - Delete
--
<!DEF>
function <!TW>Insert (sIns, sText : string; rIndex : real) : string;
<!TXT>
Fgt den String <!PW>sIns an der Position <!PW>rIndex in den String <!PW>sText ein.
>>
<<
120.1.2.8
Delete
!120.1.2.7 - Insert
--
<!DEF>
function <!TW>Delete (sText : string; rStart, rAnzahl : real) : string;
<!TXT>
Entfernt aus <!PW>sText ab der Position <!PW>rStart <!PW>rAnzahl Zeichen.
>>
<<
120.1.2.9
RemoveChars
--
<!DEF>
function <!TW>RemoveChars (sText, sUnWanted : string) : string;
<!TXT>
Entfernt aus <!PW>sText alle Zeichen, die auch im String <!PW>sUnwanted vorkommen.
>>
<<
120.1.2.10
Message
--
<!DEF>
function <!TW>Message (rMsgNr : real [; sDefault : string]) : string;
<!TXT>
Ldt den Text der Nachricht mit der Nummer <!PW>rMsgNr (0..9999999) aus dem aktuellen USERMSG.INI-File. Aktuell ist jeweils die USERMSG.INI, die zur gewhlten Sprache gehrt.
Ist keine Nachricht fr die Nummer <!PW>rMsgNr vorhanden, so wird <!PW>sDefault zurckgegeben. Ist auch <!PW>sDefault nicht angegeben, so wird '&gt;&gt;Message xxx missing.&lt;&lt; zurckgegeben, wobei xxx durch <!PW>rMsgNr ersetzt ist.
Die Nachrichten mssen in der Sektion  [TEXTE] stehen. 
Beispiel fr ein USERMSG.INI-File:
<!CODE>
[TEXTE]
0000000=Nachricht Nummer 0
0000001=Dies ist die Nachricht Nummer 1
0000002=Diese Nachricht hat die Nummer 2
0000003=Und das ist die 3!
<!TXT>
>>
<<
120.1.2.11
RemoveOtherChars
--
<!DEF>
function <!TW>RemoveOtherChars (sText, sWanted : string) : string;
<!TXT>
Entfernt aus <!PW>sText alle Zeichen, die nicht im String <!PW>sWanted enthalten sind.
>>

<<
120.1.2.12
UpperCase
--
<!DEF>
function <!TW>UpperCase (sText : string) : string;
<!TXT>
Wandelt alle Kleinbuchstaben von <!PW>sText in Grobuchstaben um. Funktioniert nur mit den Buchstaben von A-Z, nicht mit Umlauten oder . Alle anderen Zeichen bleiben so, wie sie sind.
>>

<<
120.1.2.13
LowerCase
--
<!DEF>
function <!TW>LowerCase (sText : string) : string;
<!TXT>
Wandelt alle Grobuchstaben von <!PW>sText in Kleinbuchstaben um. Funktioniert nur mit den Buchstaben von A-Z, nicht mit Umlauten oder . Alle anderen Zeichen bleiben so, wie sie sind.
>>

<<
120.1.2.14
CutFirstToken
--
<!DEF>
function <!TW>CutFirstToken (var sText : string; sSeparatorChar : string) : string;
<!TXT>
Sucht im <!PW>sText nach dem ersten Auftreten des Zeichens <!PW>sSeparatorChar. Der Teil vor dem Trennzeichen wird als Ergebnis zurckgeliefert (FirstToken). Dieser Teil sowie das Trennzeichen werden aus <!PW>sText entfernt (Cut). Wird der <!PW>sSeparatorChar nicht gefunden, so wird <!PW>sText komplett als erstes Token betrachtet.

Vom <!PW>sSeparatorChar wird nur das erste Zeichen beachtet. Ist <!PW>sSeparatorChar leer (''), so wird <!PW>sText komplett als erstes Token betrachtet.

Ein String mit Trennzeichen kann mit CutFirstToken in seine Bestandteile zerlegt werden.

Beispiele:
<!CODE>
var
  sText, sResult : string;

  sText:='1,23,456789';
  sResult:=CutFirstToken (sText, ',');
  // --> sResult='1', sText='23,456789';
  sResult:=CutFirstToken (sText, ',');
  // --> sResult='23', sText='456789';
  sResult:=CutFirstToken (sText, ',');
  // --> sResult='456789', sText='';
  sResult:=CutFirstToken (sText, ',');
  // --> sResult='', sText='';

  sText:='1,23,456789';
  sResult:=CutFirstToken (sText, 'x');
  // --> sResult='1,23,456789', sText='';

  sText:='1,23,456789';
  sResult:=CutFirstToken (sText, '');
  // --> sResult='1,23,456789', sText='';
<!TXT>
>>
<<
120.1.2.15
Trim
--
<!DEF>
function <!TW>Trim (sUnTrimmed : string) : string;
<!TXT>
Entfernt entfernt alle am Anfang und Ende des mit <!PW>sUntrimmed angegebenen Strings vorhandenen Leer- und Steuerzeichen.
>>
<<
120.1.2.16
TrimLeft
--
<!DEF>
function <!TW>TrimLeft (sUnTrimmed : string) : string;
<!TXT>
Entfernt entfernt alle am Anfang des mit <!PW>sUntrimmed angegebenen Strings vorhandenen Leer- und Steuerzeichen.
>>
<<
120.1.2.17
TrimRight
--
<!DEF>
function <!TW>TrimRight (sUnTrimmed : string) : string;
<!TXT>
Entfernt entfernt alle am Ende des mit <!PW>sUntrimmed angegebenen Strings vorhandenen Leer- und Steuerzeichen.
>>
<<
120.1.2.18
Pad
--
<!DEF>
function <!TW>Pad (sData : string; rLen : real [; sFill : string [; rFlags : real]]) : string;
<!TXT>
Fllt den String <!PW>sData auf die Lnge <!PW>rLen auf.

Aufgefllt wird mit dem String <!PW>sFill.

<!PW>rFlags ist ein Bitmuster, das festlegt, wie gefllt wird, und ob ein evtl. zu langer String abgeschnitten wird.

<!STBL>
<tr bgcolor=f0f0f0 align=center><td><b>Bit</b><!><b>Wert</b><!><b>Wirkung</b><!>
<tr><td align=center rowspan=2>0</td><td align=center rowspan=2>1<!>0 = Es wird rechts aufgefllt / abgeschnitten<!>
<!>1 = Es wird links aufgefllt / abgeschnitten<!>
<tr><td align=center rowspan=2>1</td><td align=center rowspan=2>2<!>0 = Es wird nicht abgeschnitten<!>
<!>2 = Ein zu langer String wird auf nLen abgeschnitten<!>
<!ETBL>

Standardmig wird rechts mit Leerzeichen aufgefllt und der String nicht abgeschnitten, wenn er lnger als <!PW>rLen Zeichen ist. (Default fr <!PW>sFill = ' ', fr <!PW>rFlags = 0).

Beispiele:
<!CODE>
Pad ('', 10);                   -> '          ' (10 Leerzeichen)
Pad ('', 10, '*');              -> '**********'
Pad ('Hallo', 10);              -> 'Hallo     '
Pad ('Hallo', 10, '*');         -> 'Hallo*****'
Pad ('Hallo', 10, '', 1);       -> '     Hallo'
Pad ('Hallo', 10, '*', 1);      -> '*****Hallo'
Pad ('Hallo', 10, 'Welt');      -> 'HalloWeltW'
Pad ('Hallo', 10, 'Welt', 1);   -> 'WeltWHallo'
Pad ('Hallo', 3);               -> 'Hallo'
Pad ('Hallo', 3, '', 2);        -> 'Hal'
Pad ('Hallo', 3, '', 3);        -> 'llo'
<!TXT>
>>

<<
120.1.2.19
nThToken
--
<!DEF>
function <!TW>nThToken (rIdx : real; sText, sSeparatorChar : string) : string;
<!TXT>
Liefert das <!PW>rIdx-te Token aus dem String <!PW>sText. 

Die Token sind durch das Zeichen <!PW>sSeparatorChar getrennt. Von <!PW>sSeparatorChar wird nur das erste Zeichen beachtet.

Wenn <!PW>sSeparatorChar ein Leerstring ist, wird einfach das <!PW>rIdx-te Zeichen aus <!PW>sText geliefert.

Die Token werden von 1 ab gezhlt.

Wenn weniger Token im String vorhanden sind, wird ein Leerstring zurckgegeben.

Der String in <!PW>sText wird durch diese Operation (im Gegensatz zu <!RW>CutFirstToken) nicht gendert.

Beispiele:
<!CODE>
  nThToken (1, '1;23;456789', ';');   --> '1'
  nThToken (1, '1;23;456789', ';x');  --> '1'      das 'x' wird nicht beachtet
  nThToken (3, '1;23;456789', ';');   --> '456789'
  nThToken (5, '1;23;456789', ';');   --> ''
  nThToken (3, '1;23;456789', '');    --> '2'      das dritte Zeichen!
<!TXT>
>>

<<
120.1.3
Interne Vector-Funktionen|Vector
>>
<<
120.1.3.1
BVectToHex
--
<!DEF>
function <!TW>BVectToHex (vBVect : vector [; sFormat : string]) : string;
<!TXT>
Wandelt den Vektor <!PW>vBVect in einen String um, in dem die einzelnen Werte des Vektors stehen. <!PW>vBVect darf nur die Werte 0-255 (Byte-Bereich) und -1 als Don't-Care Wert enthalten. Mit <!PW>sFormat kann die Umwandlung gesteuert werden.
<!PW>sFormat besteht aus vier, durch |' getrennten Teilen, der erste gibt die Zeichen an, die vor jedes einzelne Byte gesetzt werden, der zweite gibt die Zeichen an, die zwischen die Bytes gesetzt werden, der dritte Teil wird fr Don't-Care Werte eingesetzt, der vierte fr Werte auerhalb des Byte-Bereiches. 

Default fr <!PW>sFormat ist '| |?|!'. Damit ergeben sich Strings wie z.B. : '12 3A B3 ? C2'.
>>
<<
120.1.3.2
HexToBVect
--
<!DEF>
function <!TW>HexToBVect (sHex  : string [; sDontCareChar : string]) : vector;
<!TXT>
Wandelt den String <!PW>sHex in einen Vektor. Alle Zeichen in <!PW>sHex, die keine Hex-Ziffern sind, werden als Trennzeichen zwischen zwei Bytes betrachtet. Stehen eine ungerade Zahl von Hex-Ziffern zwischen den Trennzeichen, so wird die letzte Ziffer als einzelnes Byte betrachtet.

Wenn ein Zeichen dem <!PW>sDontCareChar entspricht (Default : '?'), so wird dieses Zeichen wie ein Wert behandelt und an dessen Stelle eine -1 eingetragen. Dies kann nur in Verbindung mit den Check Funktionen benutzt werden.
<!CODE>
HexToBVect('$12$123$5') ergibt : [18, 18, 3, 5]

HexToBVect('12123?5') ergibt : [18, 18, 3, -1, 5]

HexToBVect('12 12 3 * 5', '*') ergibt : [18, 18, 3, -1, 5]
>>

<<
120.1.3.3
BVectToString
--
<!DEF>
function <!TW>BVectToString (vBVect : vector) : string;
<!TXT>
Wandelt den Vektor <!PW>vBVect in einen String um, in dem die einzelnen Werte des Vektors stehen. <!PW>vBVect darf nur die Werte 0-255 (Byte-Bereich) enthalten. Jedes Element von <!PW>vBVect wird in ein Zeichen des Strings (mit dem ASCII-Code des Elements) umgewandelt. Der sich ergebende String hat genau so viele Zeichen wie <!PW>vBVect Elemente.
>>
<<
120.1.3.4
StringToBVect
--
<!DEF>
function <!TW>StringToBVect (sData : string) : vector;
<!TXT>
Wandelt den String <!PW>sData in einen Vektor. Jedes Zeichen in <!PW>sData wird mit seinem ASCII-Wert zu einem Element des Ergebnisses. Der sich ergebende Vector hat genau so viele Elemente wie der String Zeichen.
<!CODE>
StringToBVect('ABCD') ergibt : [65, 66, 67, 68]
>>

<<
120.1.3.5
Check
--
<!DEF>
function <!TW>Check (vFrame, vSoll : vector [; rMode : real [; rDontCareValue : real]]) : real;
<!TXT>
Vergleicht den Frame im Vektor vFrame mit dem Frame im Vektor vSoll.

<!PW>rMode legt das Verhalten bei unterschiedlicher Lnge fest
<!STBL>
<tr bgcolor=f0f0f0><td><b>rMode</b><!><b>Verhalten</b><!>
<!>0<!>Lnge muss identisch sein (default)<!>
<!>1<!>vFrame darf krzer als vSoll sein<!>
<!>2<!>vFrame darf lnger als vSoll sein, kein Test der 'berstehenden' Werte<!>
<!>3<!>vFrame darf lnger oder krzer sein, verglichen wird bis zum letzten gemeinsamen Wert<!>
<!ETBL>

Wird ein Wert fr <!PW>rDontCareValue angegeben, und entspricht ein Element von <!PW>vSoll diesem Wert, so kann das korrespondierende Element in <!PW>vFrame einen beliebigen Wert haben.

Rckgabe: 0 = alles ok, sonst die Position in <!PW>vFrame, die abweicht.
<!CODE>
Check ([1,2,3,4],  [1,2,3,4], 1)  ->  0  - alles gleich
Check ([1,2,99,4], [1,2,3,4])  ->  3
Check ([1,2,99,4], [1,2,3,4], 0)  ->  3
Check ([1,2,3],    [1,2,3,4], 1)  ->  0  - darf krzer sein!
Check ([1,2,3],    [1,2,3,4], 2)  ->  3
Check ([1,2,3,5],  [1,2,3,-1], 0, -1) ->  0  - -1 ist DontCare!
<!TXT>
>>

<<
120.2
Interne Prozeduren ohne IP-Objekt|interne Prozeduren
>>
<<
120.2.1
Exit
--
<!DEF>
procedure <!TW>Exit;
<!TXT>
Verlsst den Interpreterschritt so, als ob das Ende erreicht worden wre. Der Befehl wirkt sich wie ein Sprung direkt an das Ende des Steps aus. Auch wenn dieser Befehl innerhalb einer Prozedur aufgerufen wird, endet der Step sofort!
>>
<<
120.2.2
Dec
!120.2.3 - Inc
--
<!DEF>
procedure <!TW>Dec (var rWert : real [; rDec : real]);
<!TXT>
Verringert den Wert der Variablen <!PW>rWert um den Wert von <!PW>rDec. Ist <!PW>rDec nicht angegeben, so wird <!PW>rWert um 1 verringert. Dieser Befehl ist etwas schneller als die (im Ergebnis gleiche) Zuweisung:
<!CODE>
rWert := rWert - rDec;
>>
<<
120.2.3
Inc
!120.2.2  - Dec
--
<!DEF>
procedure <!TW>Inc (var rWert : real [; rInc : real]);
<!TXT>
Erhht den Wert der Variablen <!PW>rWert um den Wert von <!PW>rInc. Ist <!PW>rInc nicht angegeben, so wird <!PW>rWert um 1 erhht. Dieser Befehl ist etwas schneller als die (im Ergebnis gleiche) Zuweisung:
<!CODE>
rWert := rWert + rInc;
>>
<<
120.2.4
SetLen
--
<h4>Fr Vektoren:</h4>
<!DEF>
procedure <!TW>SetLen (var vVector : vector; rLen :real);
<!TXT>
Setzt die Lnge des Vektors <!PW>vVector auf <!PW>rLen Werte (0 &lt;= <!PW>rLen &lt; 65535). Neu belegte Elemente haben den Wert 0, der Wert abgeschnittener Elemente geht verloren.
Beispiel:
<!CODE>
vData:=[1,2,3,4];
SetLen (vData, 6);   // -> vData=[1,2,3,4,0,0]
SetLen (vData, 3);   // -> vData=[1,2,3]
<!TXT>

<!DEF>
procedure <!TW>SetLen (var vVector : vector; rLen, rValue : real);
<!TXT>
Wie zuvor, aber: Neu belegte Elemente haben den Wert <!PW>rValue, der Wert abgeschnittener Elemente geht verloren.
<!CODE>
vData:=[1,2,3,4];
SetLen (vData, 6, 9);   // -> vData=[1,2,3,4,9,9]
SetLen (vData, 3, 9);   // -> vData=[1,2,3]
<!TXT>

<h4>Fr StringVektoren:</h4>
<!DEF>
procedure <!TW>SetLen (var svVector : StringVector; rLen :real);
<!TXT>
Setzt die Lnge des StringVektors <!PW>svVector auf <!PW>rLen Werte (0 &lt;= <!PW>rLen &lt; 65535). Neu belegte Elemente haben den Wert '', der Wert abgeschnittener Elemente geht verloren.
Beispiel:
<!CODE>
svData:=['Hello','World','!'];
SetLen (svData, 5);   // -> vData=['Hello','World','!','','']
SetLen (svData, 2);   // -> vData=['Hello','World']
<!TXT>

<!DEF>
procedure <!TW>SetLen (var svVector : StringVector; rLen, sValue : string);
<!TXT>
Wie zuvor, aber: Neu belegte Elemente haben den Wert <!PW>sValue, der Wert abgeschnittener Elemente geht verloren.
<!CODE>
vData:=['Hello','World','!'];
SetLen (vData, 5, 'cPCI');   // -> vData=['Hello','World','!','cPCI','cPCI']
SetLen (vData, 2, 'cPCI');   // -> vData=['Hello','World']
<!TXT>

<h4>Fr Strings:</h4>
<!DEF>
procedure <!TW>SetLen (var sString : string; rLen : real);
<!TXT>
Setzt die Lnge des Strings <!PW>sString auf <!PW>rLen Zeichen (0 &lt;= <!PW>rLen). Neu belegte Zeichen werden mit Leerzeichen gefllt.
Beispiel:
<!CODE>
sData:='1234';
SetLen (sData, 6);   // -> sData='1234  ';
SetLen (sData, 3);   // -> sData='123';
<!TXT>

<!DEF>
procedure <!TW>SetLen (var sString : string; rLen : real; sValue : string);
<!TXT>
Setzt die Lnge des Strings <!PW>sString auf <!PW>rLen Zeichen (0 &lt;= <!PW>rLen). Muss dazu der String verlngert werden, so wird <!PW>sValue so oft angefgt, bis die Wunschlnge erreicht ist. Ist <!PW>sValue leer, so werden Leerzeichen angehngt.
Beispiel:
<!CODE>
sData:='1234';
SetLen (sData, 6, '*');     // -> sData='1234**';
SetLen (sData, 3);          // -> sData='123';
SetLen (sData, 10, 'ABC');  // -> sData='123ABCABCA';
<!TXT>
>>
<<
120.2.5
Return
--
<!DEF>
procedure <!TW>Return;
<!TXT>
Darf nur in Funktionen und Prozeduren eingesetzt werden und bewirkt den Rcksprung aus der Prozedur oder Funktion zum aufrufenden Block. Wirkt wie ein Sprung zum letzen <!RW>END; der Prozedur oder Funktion. Um eine hnliche Wirkung im Hauptblock (<!RW>STEP <!RW>END.) zu erzielen kann <a href="120.2.1">Exit</a>; benutzt werden.

<!DEF>
procedure <!TW>Return (.Wert : Real|String|Vector|StringVector);
<!TXT>
Darf nur in Funktionen eingesetzt werden und wirkt wie die Kombination aus:
<!CODE>
Result:=Wert;
Return;
<!TXT>
Der Datentyp von Wert muss mit dem Rckgabetyp bereinstimmen.
>>
