STRX.C2

Das Modul strx.c2 beinhaltet mehrere nützliche Funktionen zum Bearbeiten
von Stringvariablen.
Ab V2.4 benötigt strx.c2 für die meisten Funktionen den ASM-Treiber sys0002.hex,
welcher mit einem Download-Tool in Segment3 geladen werden.
sys0002.hex wird außerdem von den aktuellen Versionen von hwcom.c2, swcom.c2 und
mem.c2 benötigt.

Die Datei strx.c2 in das Verzeichnis .\CControl2\UserLib der IDE
kopieren und ggf. in der Datei modules.txt die Zeile strx.c2 einfügen.

Mit der Funktion getchar() wird ein einzelnes Zeichen von der
angegebenen Position des übergebenen Strings als Bytewert
zurückgegeben.

`s[]`	Stringvariable
`position`	Zeichenposition 0 bis 29

Mit comp() werden zwei Strings miteinander verglichen, ob diese
identisch sind. Es wird True(-1) zurückgegeben, wenn die Strings identisch sind,
andernfalls False(0).

inline function compsel(byte s1[], byte s2[], byte s2len, byte s1pos) returns int

Mit compsel() werden zwei Teilstrings miteinander verglichen, ob diese
identisch sind. Es wird True(-1) zurückgegeben, wenn die Strings identisch sind,
andernfalls False(0).
Mit s2len wird die Anzahl der zu vergleichenden Zeichen bestimmt, und mit
s1pos die Startposition von s1, ab der verglichen werden soll.
compsel() kann auch zum Vergleich von Bytearrays verwendet werden.

`s1[]`	Zu vergleichender QuellString
`s2[]`	der zu suchende String
`s2len`	Anzahl der Zeichen in String2 bzw. Anzahl zu vergleichender Zeichen (0-29)
`s1pos`	Startposition in String1, ab der verglichen werden soll (0-29)

inline function InStr(byte start, byte s1[], byte s2[], byte s1len, byte s2len) returns int

Mit der Funktion InStr() kann nach der Position einer Zeichenfolge in einem String
gesucht werden. Es wird dabei die Startposition des ersten Vorkommens der zu
suchenden Zeichenfolge zurückgegeben. Ist s2 in s1 nicht vorhanden, so wird -1 zurückgegeben.
Diese Funktion funktioniert wie die vergleichbare Funktion InStr() in Visual Basic.
InStr() kann auch mit Bytearrays verwendet werden.

`start`	Startposition in s1, ab der gesucht werden soll (0-29)
`s1[]`	Zu durchsuchender String
`s2[]`	Zu suchende Zeichenfolge
`s1len`	Anzahl zu durchsuchender Zeichen in s1 (0-29)
`s2len`	Anzahl der Zeichen in s2 bzw. Anzahl zu suchender Zeichen von s2 (0-29)

inline function Ucase(byte s[], byte start, byte len)
inline function Lcase(byte s[], byte start, byte len)

Mit diesen Funktion werden die Zeichen des übergebenen Strings
in Großbuchstaben (Ucase()) bzw. in Kleinbuchstaben(Lcase()) umgewandelt.
Es kann dabei die Startposition und die Anzahl der Zeichen übergeben werden,
wenn nur ein Teil der Zeichen des angegebenen Strings gewandelt werden soll.
Sollen generell alle Zeichen gewandelt werden, so kann für start der Wert 0 und
für len der Wert 30 übergeben werden.
Es werden hierbei nur alle Buchstaben berücksichtigt (incl. Umlaute).
Sonderzeichen und Zahlen bleiben unverändert.
Diese Funktionen können auch mit Bytearrays verwendet werden.

`s[]`	Zu wandelnder String
`start`	Startposition, ab der gewandelt werden soll (0-29)
`len`	Anzahl zu wandelnder Zeichen (1-30)

Die Funktion left() gibt die Anzahl len Zeichen ab dem ersten(linken) Zeichen
von s1 in s2 zurück.
Die Funktion ist mit derVB-Funktion Left() vergleichbar.

`s1[]`	Quellstring
`s2[]`	Zielstring
`len`	Anzahl der zurückzugebenden Zeichen (1-30)

Die Funktion right() gibt die Anzahl len Zeichen von der rechten Seite(dem Ende)
von s1 in s2 zurück.
Die Funktion ist mit derVB-Funktion Right() vergleichbar.

`s1[]`	Quellstring
`s2[]`	Zielstring
`len`	Anzahl der zurückzugebenden Zeichen (1-30)

Beispiel:
a="Das ist ein Test";
strx.right(a,b,4); //Hier wird in b "Test" zurückgegeben

Teilstring kopieren: mid() Nach oben

Die Funktion mid() gibt die Anzahl len Zeichen ab der Position start von s1 in s2 zurück.

`s1[]`	Quellstring
`s2[]`	Zielstring
`start`	Startposition (0-29)
`len`	Anzahl der zurückzugebenden Zeichen (1-30)

Beispiel:
a="Das ist ein Test";
strx.mid(a,b,8,3); //Hier wird in b "ein" zurückgegeben

Die Funktion paste() fügt len Zeichen von s1 in s2 ab Position start in s2 ein.
Vorhandene Zeichen an der Startposition werden dabei entsprechend der Länge
des einzufügenden Strings überschrieben.

`s1[]`	Quellstring
`s2[]`	Zielstring
`start`	Startposition in s2 (0-29)
`len`	Anzahl der einzufügenden Zeichen von s1(1-30)

Beispiel:
a="e C-Control II";
b="Das ist ein Test";
strx.paste(a,b,11,14);//Hier wird aus "Das ist ein Test" der String
// "Das ist eine C-Control II"

Zeichenfolge einfügen: insert() Nach oben

Die Funktion paste() fügt len Zeichen von s1 in s2 ab Position start in s2 ein.

`source[]`	Quellstring
`dest[]`	Zielstring
`start`	Startposition in s2 (0-29)
`len`	Anzahl der einzufügenden Zeichen von s1(1-30)

Beispiel:
a="schneller ";
b="Das ist ein Test";
strx.insert(a,b,8,10);//Hier wird aus "Das ist ein Test" der String
// "Das ist ein schneller Test"

Zeichenfolge ausschneiden: cut() Nach oben

Die Funktion cut() schneidet ab Position start aus s1 len Zeichen aus und
speichert diese in s2.

`s1[]`	Quellstring
`s2[]`	Zielstring
`start`	Startposition in s2 (0-29)
`len`	Anzahl der einzufügenden Zeichen von s1 (1-30)

Beispiel:
a="Das ist ein guter Controller";
strx.cut(a,b,12,6); //Hier wird aus "Das ist ein guter Controller"
//der String "Das ist ein Controller"
//In b wird "guter " zurückgegeben

Die Funktion split() zerteilt den String s1 anhand des Trennzeichens searchfor
in merere Strings und speichert diese im String-Array s2. Es darauf geachtet werden,
daß das Ziel-String-Array groß genug definiert wird !
Es wird die Anzahl der Strings, in die der Quellstring unterteilt wurde, zurückgegeben.

`s1[]`	Quellstring
`s2[]`	Zielstring-Array
`searchfor`	ASCII-Code des Trennzeichens

Beispiel:
string a,b[6];
a="Das ist ein guter Controller";
strx.cut(a,b,' '); //Hier wird der String "Das ist ein guter Controller"
                   //in 5 Strings zerlegt. Jedes Wort steht nun
                   //in einem eigenem String des Arrays b[]

String in Zahl umwandeln: getNum()   Nach oben

Mit Hilfe der Funktion getNum() können Zeichenfolgen, die eine Zahl darstellen,
als solche umgewandelt werden. Der Zahlenbereich kann bis Long-Integer und
sowohl im positiven als auch im negativen Bereich sein.
Im übergebenen String dürfen sich nur Ziffern und das Zeichen "-"(als erstes Zeichen) befinden.
Befindet sich ein anderes Zeichen im String, so wird 0x8000 für "keine Zahl" zurückgegeben.
Das Ergebnis kann in Byte-, Integer-und Long-Variablen gespeichert werden.

Mit Hilfe der Funktion getHex() können Zeichenfolgen, die eine Hexadezimale Zahl darstellen,
in eine Zahl umgewandelt werden. Der Zahlenbereich kann bis Long-Integer sein.
Im übergebenen String dürfen sich nur Hexadezimale Ziffern ohne Prefix befinden.
Befindet sich ein anderes Zeichen im String, so wird 0x8000 für "keine Zahl" zurückgegeben.
Das Ergebnis kann in Byte-, Integer-und Long-Variablen gespeichert werden.

Beispiel:
string a;int zahl;
a="2F4A";
zahl=strx.getHex(a); //Hier wird der String "2F4A" als Zahl eingelesen
                     //und mit dem Wert 12104 (=0x2F4A) in die Integervariable
                     //zahl gespeichert

Zeichen ersetzen: replace()   Nach oben

Die Funktion replace() ersetzt im String s alle Zeichen mit
dem ASCII-Code FindChar mit dem Zeichen NewChar.

`s`	Zu bearbeitender String
`FindChar`	Zu ersetzendes Zeichen
`NewChar`	Neues Zeichen

inline function replacelen(byte start, string s, byte slen, byte FindChar, byte NewChar) returns int

Die Funktion replacelen() ersetzt im String s ab Position start len Zeichen
alle Zeichen mit dem ASCII-Code FindChar mit dem Zeichen NewChar.
Anders als bei ReplaceChar() wird mit len nicht die Endpositon, sondern die Anzahl
der Zeichen ab start angegeben.

`start`	Startposition in s (0-29)
`s[]`	Zu bearbeitender String
`slen`	Anzahl zu bearbeitender Zeichen ab start (1-30)
`FindChar`	Zu ersetzendes Zeichen
`NewChar`	Neues Zeichen

function ReplaceChar(byte start, byte s[], byte slen, byte FindChar, byte NewChar) returns int

Die Funktion ReplaceChar() ersetzt im String s ab Position start bis Position slen
alle Zeichen mit dem ASCII-Code FindChar mit dem Zeichen NewChar.
Diese Funktion ist aus Kompatibilitätsgründen noch vorhanden.
Für neue Projekte sollten die Funktionen replace() und replacelen() verwendet werden,
da diese durch Assembler-Routinen um einiges schneller sind.

`start`	Startposition in s (0-29)
`s[]`	Zu bearbeitender String
`slen`	Endposition der zu bearbeitenden Zeichen (1-30)
`FindChar`	Zu ersetzendes Zeichen
`NewChar`	Neues Zeichen