first commit

Readme.md

@@ -0,0 +1,9 @@
+# strUtils
+
+I'm makinga Gnu-Modula-2 version of strUtils, originaly written in Oberon by Norayr Chilingarian on his github : https://github.com/norayr/strutils
+
+It's a work in progress, as I only begin to write in GNU Modula-2.
+
+I used to write a lot of programs in Modula-2, but it was more than 30 years ago, with TopSpeed Modula-2.
+
+I have a lot of things to catch up (Iso libs etc. )

strUtils.def

@@ -0,0 +1,143 @@
+DEFINITION MODULE strUtils;
+
+CONST 
+  whitespace = ' \t\n\r\v\f';
+  asciiLowercase = 'abcdefghijklmnopqrstuvwxyz';
+  asciiUppercase = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
+  asciiLetters = asciiLowercase + asciiUppercase;
+  digits = '0123456789';
+  hexdigits = digits + 'abcdef' + 'ABCDEF';
+  octdigits = '01234567';
+  punctuation = "!#$%&'()*+,-./:;<=>?@[\]^_`{|}~" + '#';
+  printable = digits + asciiLetters + punctuation + whitespace;
+  alphanum = asciiLetters + digits;
+
+(* pythonlike functions 
+isalnum()	Returns True if all characters in the string are alphanumeric
+isalpha()	Returns True if all characters in the string are in the alphabet
+isascii()	Returns True if all characters in the string are ascii characters
+isdigit()	Returns True if all characters in the string are digits
+isidentifier()	Returns True if the string is an identifier
+islower()	Returns True if all characters in the string are lower case
+isprintable()	Returns True if all characters in the string are printable
+isspace()	Returns True if all characters in the string are whitespaces
+istitle() 	Returns True if the string follows the rules of a title
+isupper()	Returns True if all characters in the string are upper case
+*)
+
+PROCEDURE isalnum(s : ARRAY OF CHAR) : BOOLEAN;	
+(* Returns True if all characters in the string are alphanumeric*)
+
+PROCEDURE isalpha(s : ARRAY OF CHAR) : BOOLEAN;	
+(* Returns True if all characters in the string are in the alphabet *)
+
+PROCEDURE isascii(s : ARRAY OF CHAR) : BOOLEAN;	
+(* Returns True if all characters in the string are ascii characters *)
+
+PROCEDURE isdigit(s : ARRAY OF CHAR) : BOOLEAN;	
+(* Returns True if all characters in the string are digits *)
+
+PROCEDURE isidentifier(s : ARRAY OF CHAR) : BOOLEAN;
+(* Returns True if the string is an identifier *)
+
+PROCEDURE islower(s : ARRAY OF CHAR) : BOOLEAN;	
+(* 	eturns True if all characters in the string are lower case *)
+
+PROCEDURE isprintable(s : ARRAY OF CHAR) : BOOLEAN;
+(* Returns True if all characters in the string are printable *)
+
+PROCEDURE isspace(s : ARRAY OF CHAR) : BOOLEAN;	
+(* Returns True if all characters in the string are whitespaces *)
+
+PROCEDURE istitle(s : ARRAY OF CHAR) : BOOLEAN;	
+(*  Returns True if the string follows the rules of a title *)
+
+PROCEDURE isupper(s : ARRAY OF CHAR) : BOOLEAN;	
+(* Returns True if all characters in the string are upper case *)
+
+(* end of python alike functions *)
+
+
+(* this function copied from ooc source and may be considered a duplicate. *)
+ PROCEDURE Compare (stringVal1, stringVal2: ARRAY OF CHAR): INTEGER ;
+(**Returns @oconst{less}, @oconst{equal}, or @oconst{greater}, according as
+   @oparam{stringVal1} is lexically less than, equal to, or greater than
+   @oparam{stringVal2}.  Note that Oberon-2 and Oberon-07 already contains predefined comparison operators on strings.  *)
+   
+PROCEDURE Copy(VAR Ns: ARRAY OF CHAR; S: ARRAY OF CHAR);
+
+(* this function copied from ooc source and may be considered a duplicate. *)
+PROCEDURE Assign (source: ARRAY OF CHAR; VAR destination: ARRAY OF CHAR);
+(**Copies @oparam{source} to @oparam{destination}.  Equivalent to the
+   predefined procedure @code{COPY}.  Unlike @code{COPY}, this procedure can be
+   assigned to a procedure variable.  *)
+
+
+PROCEDURE Pos (substr : CHAR ; s : ARRAY OF CHAR; n : CARDINAL ) : CARDINAL ;
+
+PROCEDURE RemoveLeftChars (VAR s : ARRAY OF CHAR; ch : CHAR);
+
+PROCEDURE RemoveRightChars (VAR s : ARRAY OF CHAR; ch : CHAR);
+
+PROCEDURE WordCount (source : ARRAY OF CHAR; separator : CHAR) : CARDINAL ;
+
+PROCEDURE NumberOfChar (s : ARRAY OF CHAR; ch : CHAR) : CARDINAL ;
+
+PROCEDURE Rpos ( s : ARRAY OF CHAR ; ch : CHAR) : CARDINAL ;
+
+PROCEDURE Lpos ( s : ARRAY OF CHAR ; ch : CHAR) : CARDINAL;
+
+PROCEDURE copyBytes(VAR src, dst: ARRAY OF CHAR; start, quantity: CARDINAL );
+(*
+PROCEDURE appendNumChars(VAR extra: pstring; extraNum: LONGINT; VAR destination: pstring; destinationNum: LONGINT);
+
+PROCEDURE string2pstring(s: ARRAY OF CHAR; VAR d : pstring);
+
+PROCEDURE string2pstrings(VAR text: ARRAY OF CHAR): pstrings;
+
+PROCEDURE ExtractWord (n : INTEGER; s : ARRAY OF CHAR; ch : CHAR) : pstring;
+
+PROCEDURE tokenize(s : ARRAY OF CHAR; ch : CHAR) : pstrings;
+
+*)
+(* copies all array, even after 0X, but puts 0X in the end *)
+PROCEDURE copyAll (src : ARRAY OF CHAR ; VAR dst : ARRAY OF CHAR);
+
+
+(** fills whole array with zeroes, useful when one needs to get several strings which contain characters < ' ' and not necessarily end with 0X *)
+PROCEDURE zeroStr(VAR str: ARRAY OF CHAR);
+
+PROCEDURE appendLFCR(VAR str: ARRAY OF CHAR);
+(*
+PROCEDURE findChar(ch: CHAR; VAR line: ARRAY OF CHAR; VAR b: BOOLEAN; VAR pos: INTEGER);
+
+(* cuts line, takes the part till the eol *)
+PROCEDURE cutLine(VAR src, dst: ARRAY OF CHAR);
+
+(* put 0X after eol in the string *)
+PROCEDURE terminateLine(VAR str: ARRAY OF CHAR);
+
+PROCEDURE getTillEOL(VAR src: ARRAY OF CHAR; spos: INTEGER; VAR dst: ARRAY OF CHAR); (* actually get till any character < ' ' *)
+
+(* get next word starting from spos till the ' ' *)
+PROCEDURE getNextWord(VAR src: ARRAY OF CHAR; spos: INTEGER; VAR dst: ARRAY OF CHAR);
+
+PROCEDURE getNextAlphaNumWord(VAR src: ARRAY OF CHAR; spos: INTEGER; VAR dst: ARRAY OF CHAR);
+
+PROCEDURE contains (VAR line : ARRAY OF CHAR; pattern: ARRAY OF CHAR): BOOLEAN;
+
+PROCEDURE contains1(VAR line: ARRAY OF CHAR; pat : ARRAY OF CHAR): BOOLEAN;
+
+(* IntToStr routine taken from
+https://github.com/romiras/Oberon-F-components/blob/master/Ott/Mod/IntStr.cp
+and modified to work on 64bit system by dcwbrown,
+in order to avoid using oocIntStr, which has many dependencies *)
+PROCEDURE Reverse0 (VAR str : ARRAY OF CHAR; start, end : INTEGER);
+(* Reverses order of characters in the interval [start..end]. *)
+
+
+PROCEDURE dumpChars(VAR s : ARRAY OF CHAR);
+
+PROCEDURE dumpAllChars(VAR s : ARRAY OF CHAR);
+*)
+END strUtils.

strUtils.mod

@@ -0,0 +1,773 @@
+IMPLEMENTATION MODULE strUtils;
+
+IMPORT InOut, Strings,MemUtils, SYSTEM ;
+
+CONST
+  CR = 0DH;
+  LF = 0AH;
+  
+CONST
+  less = -1;
+  equal = 0;
+  greater = 1;
+ 
+ PROCEDURE Compare (stringVal1, stringVal2: ARRAY OF CHAR): INTEGER ;
+
+  VAR
+    index : CARDINAL ;
+    L,L1,L2 : CARDINAL; (* length of the arrays *)
+    
+  BEGIN
+    L1 := Strings.Length(stringVal1);
+    L2 := Strings.Length(stringVal2);
+    index := 0;
+    (*checking the # lengths of the strings and setting L to the shortest one *)
+    IF L1<L2 THEN L := L1 ELSE L := L2 END;
+    (* incrementing index as long as the chararcters are equal *)
+    WHILE (index < L) & (stringVal1[index] = stringVal2[index]) DO
+      INC (index)
+    END;
+    (* testing the char just after the equal part *)
+    IF (stringVal1[index] < stringVal2[index]) THEN
+      RETURN less
+    ELSIF (stringVal1[index] > stringVal2[index]) THEN
+      RETURN greater
+    ELSE
+      RETURN equal
+    END
+  END Compare;
+
+PROCEDURE Copy(VAR Ns: ARRAY OF CHAR; S: ARRAY OF CHAR);
+
+(*
+MemCopy - copys a region of memory to the required destination.
+
+PROCEDURE MemCopy (from: ADDRESS; length: CARDINAL; to: ADDRESS) ;
+*)
+
+VAR
+  H,L : CARDINAL;
+  
+BEGIN
+  H := HIGH(Ns)+1;
+  L := Strings.Length(S);
+  IF L > H THEN
+    L := H 
+  END;
+  MemUtils.MemCopy(SYSTEM.ADR(S),L,SYSTEM.ADR(Ns));
+  IF L < H THEN 
+    Ns[L] := 0C;
+  END;
+END Copy;
+
+
+PROCEDURE Assign (source: ARRAY OF CHAR; VAR destination: ARRAY OF CHAR);
+
+  (* several cases : 
+    - the strings are equal length
+    - the destination is shorter
+    - the destination is longer
+  *)
+
+  VAR
+    index: CARDINAL ;
+    L1,L2 : CARDINAL;
+    
+  BEGIN
+    L1 := Strings.Length(source);
+    L2 := HIGH(destination);
+    index := 0;
+    IF L2 > L1 THEN (* destination longer than source : need to put a 0C ate the end *)
+      FOR index := 0 TO L1 DO
+        destination[index] := source[index];
+      END;
+      source[index+1] := 0C;
+    ELSIF L2 < L1 THEN (*we only copy what is possible *)
+      FOR index := 0 TO L2 DO
+        destination[index] := source[index];
+      END;
+    ELSE (* equal length *)
+      FOR index := 0 TO L1 DO
+        destination[index] := source[index];
+      END;
+    END;      
+  END Assign;
+
+
+PROCEDURE Pos (substr : CHAR ; s : ARRAY OF CHAR; n : CARDINAL ) : CARDINAL ;
+  (* find th first occurence of a CHAR in the String, search beginning at the n.th Character *) 
+  
+VAR
+  i : CARDINAL ;
+  l : CARDINAL;
+  
+BEGIN
+  l := Strings.Length(s);
+  FOR i := n + 1 TO l -1 DO
+    IF s[i] = substr THEN RETURN(i) END;
+  END;
+  RETURN MAX(CARDINAL);
+END Pos;
+
+(* python like functions *)
+
+PROCEDURE isalnum(s : ARRAY OF CHAR) : BOOLEAN;	
+(* Returns True if all characters in the string are alphanumeric*)
+
+VAR 
+  i      : CARDINAL;
+  l      : CARDINAL;
+  result : BOOLEAN;
+
+BEGIN
+  result := TRUE;
+  l := Strings.Length(s);
+  FOR i := 0 TO l -1 DO 
+    IF Pos(s[i], alphanum,0) = MAX(CARDINAL) THEN
+      result :=  FALSE;
+    END;  
+  END;  
+  RETURN result
+END isalnum;
+
+
+PROCEDURE isalpha(s : ARRAY OF CHAR) : BOOLEAN;	
+(* Returns True if all characters in the string are in the alphabet *)
+
+VAR 
+  i      : CARDINAL;
+  l      : CARDINAL;
+  result : BOOLEAN;
+
+BEGIN 
+  result := TRUE;
+  l := Strings.Length(s);
+  FOR i := 0 TO l -1 DO 
+    IF Pos(s[i], asciiLetters,0) = MAX(CARDINAL) THEN
+      result :=  FALSE;
+    END;  
+  END;  
+  RETURN result
+END isalpha;
+
+PROCEDURE isascii(s : ARRAY OF CHAR) : BOOLEAN;	
+(* Returns True if all characters in the string are ascii characters *)
+
+VAR 
+  i      : CARDINAL;
+  l      : CARDINAL;
+  result : BOOLEAN;
+
+BEGIN 
+  result := TRUE;
+  l := Strings.Length(s);
+  FOR i := 0 TO l -1 DO 
+    IF ORD(s[i]) > 127 THEN
+      result :=  FALSE;
+    END;  
+  END;  
+  RETURN result
+END isascii;
+
+PROCEDURE isdigit(s : ARRAY OF CHAR) : BOOLEAN;	
+(* Returns True if all characters in the string are digits *)
+
+VAR 
+  i,l    : CARDINAL;
+  value  : CARDINAL;
+  result : BOOLEAN;
+
+BEGIN 
+  result := TRUE;
+  l := Strings.Length(s);
+  FOR i := 0 TO l DO 
+    value := ORD(s[i]);
+    IF  (value < 48) OR (value > 58) THEN
+      result :=  FALSE;
+    END;  
+  END;  
+  RETURN result
+END isdigit;
+
+PROCEDURE isidentifier(s : ARRAY OF CHAR) : BOOLEAN;
+(* Returns True if the string is an identifier *)
+
+VAR 
+  i      : CARDINAL;
+  l      : CARDINAL;
+  result : BOOLEAN;
+
+BEGIN 
+  result := TRUE;
+  l := Strings.Length(s);
+  i := 1;
+  IF Pos(s[i], asciiLetters,0) = MAX(CARDINAL) THEN
+      result :=  FALSE;
+  ELSE 
+    FOR i := 1 TO l DO 
+      IF Pos(s[i], alphanum,0) = MAX(CARDINAL) THEN
+        result :=  FALSE;
+      END;  
+    END; 
+  END;  
+  RETURN result
+END isidentifier;
+
+PROCEDURE islower(s : ARRAY OF CHAR) : BOOLEAN;	
+(* 	eturns True if all characters in the string are lower case *)
+
+VAR 
+  i      : CARDINAL;
+  l      : CARDINAL;
+  result : BOOLEAN;
+
+BEGIN 
+  result := TRUE;
+  l := Strings.Length(s);
+  FOR i := 0 TO l DO 
+    IF Pos(s[i], asciiLowercase,0) = MAX(CARDINAL) THEN
+      result :=  FALSE;
+    END;  
+  END;  
+  RETURN result
+END islower;
+
+PROCEDURE isprintable(s : ARRAY OF CHAR) : BOOLEAN;
+(* Returns True if all characters in the string are printable *)
+
+VAR 
+  i      : CARDINAL;
+  l      : CARDINAL;
+  result : BOOLEAN;
+
+BEGIN 
+  result := TRUE;
+  l := Strings.Length(s);
+  FOR i := 0 TO l DO 
+    IF Pos(s[i], printable,0) = MAX(CARDINAL) THEN
+      result :=  FALSE;
+    END;  
+  END;  
+  RETURN result
+END isprintable;
+
+PROCEDURE isspace(s : ARRAY OF CHAR) : BOOLEAN;	
+(* Returns True if all characters in the string are whitespaces *)
+
+VAR 
+  i      : CARDINAL;
+  l      : CARDINAL;
+  result : BOOLEAN;
+
+BEGIN 
+  result := TRUE;
+  l := Strings.Length(s);
+  FOR i := 0 TO l DO 
+    IF Pos(s[i], whitespace,0) = MAX(CARDINAL) THEN
+      result :=  FALSE;
+    END;  
+  END;  
+  RETURN result
+END isspace;
+
+PROCEDURE istitle(s : ARRAY OF CHAR) : BOOLEAN;	
+(*  Returns True if the string follows the rules of a title *)
+(* Check if each word start with an upper case letter:*)
+
+VAR 
+  i      : CARDINAL;
+  l      : CARDINAL;
+  result : BOOLEAN;
+
+BEGIN 
+  result := TRUE;
+  (* we need to separate the string into words and test the first char of every word *)
+  l := Strings.Length(s) -1;
+  WHILE i <= l DO 
+    
+  END;
+  RETURN result
+END istitle;
+
+PROCEDURE isupper(s : ARRAY OF CHAR) : BOOLEAN;	
+(* Returns True if all characters in the string are upper case *)
+
+VAR 
+  i      : CARDINAL;
+  l      : CARDINAL;
+  result : BOOLEAN;
+
+BEGIN 
+  result := TRUE;
+  l := Strings.Length(s) -1 ;
+  FOR i := 0 TO l DO 
+    IF( ORD(s[i]) < 65 ) OR (ORD(s[i]) > 90 ) THEN
+      result :=  FALSE;
+    END;  
+  END;  
+  RETURN result
+END isupper;
+
+(* end of python like functions *)
+
+PROCEDURE RemoveLeftChars (VAR s : ARRAY OF CHAR; ch : CHAR);
+
+BEGIN
+  REPEAT
+    IF s[0] = ch THEN 
+      Strings.Delete (s, 0, 1) 
+    END;
+  UNTIL s[0] # ch;
+END RemoveLeftChars;
+
+PROCEDURE RemoveRightChars (VAR s : ARRAY OF CHAR; ch : CHAR);
+
+VAR 
+  l : INTEGER;
+  
+BEGIN
+  l := Strings.Length(s);
+  REPEAT 
+   IF s[l] = ch THEN 
+     Strings.Delete (s, l, 1) 
+   END;
+   DEC(l);
+  UNTIL s[l] # ch;
+END RemoveRightChars;
+
+
+PROCEDURE WordCount (source : ARRAY OF CHAR; separator : CHAR) : CARDINAL ;
+  (* count the number of words separated by the separator*)  
+VAR
+  k,l : CARDINAL ;
+  
+BEGIN
+  (* remove the separator from the beginning and from the end : ltrim and rtrim *)
+  RemoveLeftChars(source, separator);
+  RemoveRightChars (source, separator);
+  k := 0;
+  l := 0;
+  REPEAT
+    IF source[l] = separator THEN
+      INC(k);
+      REPEAT
+        INC(l);
+      UNTIL source[l] # separator;
+    END;
+    INC(l);
+  UNTIL l = Strings.Length(source);
+  INC(k);
+  RETURN(k);
+END WordCount;
+
+
+PROCEDURE NumberOfChar (s : ARRAY OF CHAR; ch : CHAR) : CARDINAL ;
+ (* counts the number of a given char ch in string s*)
+VAR
+  n, i : CARDINAL ;
+  
+BEGIN
+  n := 0;
+  FOR i := 0 TO Strings.Length(s) DO
+    IF s[i] = ch THEN INC(n) END;
+  END;
+  RETURN(n);
+END NumberOfChar;
+
+
+PROCEDURE Rpos ( s : ARRAY OF CHAR ; ch : CHAR) : CARDINAL ;
+  (* display the position OF e caracter ch IN a STRING s beginning FROM the right *)
+VAR
+  l : CARDINAL;
+  
+BEGIN
+  l := Strings.Length (s);
+  REPEAT 
+    DEC(l) 
+  UNTIL (s[l] = ch) OR (l = 0);
+  RETURN l;
+ END Rpos;
+
+
+PROCEDURE Lpos ( s : ARRAY OF CHAR ; ch : CHAR) : CARDINAL;
+  (* display the position OF e caracter ch IN a STRING s beginning FROM the left *)
+VAR
+  l : CARDINAL ;
+  ll : CARDINAL; (* length *)
+  
+BEGIN
+  l := 0;
+  ll := Strings.Length(s);
+  REPEAT 
+    INC(l) 
+  UNTIL (s[l] = ch) OR (l = ll);
+  RETURN l;
+ END Lpos;
+
+PROCEDURE copyBytes(VAR src, dst: ARRAY OF CHAR; start, quantity: CARDINAL);
+  (* copy quantity of char from source to destination, beginning at start *)
+VAR
+  i, j : CARDINAL;
+  L1 : CARDINAL; (*LENGTH OF the source *) 
+  L2 : CARDINAL; (* length of the destination*)
+  
+BEGIN
+  (* the lengths *)
+  L1 := Strings.Length(src);
+  L2 := Strings.Length(dst);
+  (* iteration ; 
+     initialisation de i au premier caractere à copier, 
+     et j au début de la chaine destination*)
+  i := start; j := 0;
+  IF i < (L2 - 1) THEN
+     REPEAT
+        dst[j] := src[i];
+       INC(i); 
+       INC(j);
+     UNTIL (i = L1) OR (j = L2) OR (j = quantity);
+     IF i < L2 THEN 
+       dst[i+1] := 0C;
+     END;  
+  END
+END copyBytes;
+(*
+PROCEDURE appendNumChars(VAR extra: pstring; extraNum: LONGINT; VAR destination: pstring; destinationNum: LONGINT);
+VAR
+  tmp: pstring;
+BEGIN
+  IF extra # NIL THEN
+    IF destination = NIL THEN
+      NEW(destination, extraNum);
+      copyBytes(extra^, destination^, 0, extraNum);
+    ELSE
+      NEW(tmp, extraNum + destinationNum);
+      copyBytes(destination^, tmp^, 0, destinationNum);
+      copyBytes(extra^, tmp^, destinationNum, extraNum);
+      NEW(destination, LEN(tmp^));
+      copyBytes(tmp^, destination^, 0, LEN(tmp^));
+    END;
+  END
+END appendNumChars;
+
+
+PROCEDURE string2pstring(s: ARRAY OF CHAR; VAR d : pstring);
+BEGIN
+  NEW(d, Strings.Length(s)+1);
+  Assign (s, d^);
+END string2pstring;
+
+PROCEDURE string2pstrings(VAR text: ARRAY OF CHAR): pstrings;
+VAR
+  i, j, lineNum, start, number: INTEGER;
+  pstrs: pstrings;
+  pstr:  pstring;
+BEGIN
+  i := 0;
+  j := 0;
+  REPEAT
+    IF text[i] = 0AH THEN INC(j) END;
+    INC(i);
+  UNTIL (i = LEN(text)) OR (text[i] = 0H); 
+  NEW(pstrs, j); 
+  lineNum := 0;     
+  number := 0;    
+  REPEAT           
+    WHILE (text[number] = 0AH) OR (text[number] = 0DH) DO INC(number) END;
+    start := number;
+
+    REPEAT
+      INC(number)
+    UNTIL (number = LEN(text) - 1) OR (text[number] = 0AH)
+         OR (text[number] = 0DH) OR (text[number] = 0H);
+
+    NEW(pstr, number - start + 1);
+    Strings.Extract(text, start, number - start, pstr^);
+    pstrs^[lineNum] := pstr;
+    INC(lineNum);
+  UNTIL (lineNum = j) OR (number = i);
+  RETURN pstrs
+END string2pstrings;
+
+PROCEDURE ExtractWord (n : INTEGER; s : ARRAY OF CHAR; ch : CHAR) : pstring;
+VAR
+  i, j, k, l : INTEGER;
+  str : string;
+  pstr : pstring;
+BEGIN
+  RemoveLeftChars (s, ch);
+  RemoveRightChars (s, ch);
+  IF n = WordCount (s, ch) THEN
+    l := Rpos (s, ch);
+    Strings.Extract (s, l+1, Strings.Length(s)-l-1, str);
+    string2pstring(str, pstr);
+    RETURN (pstr);
+  ELSIF n = 1 THEN
+    l := Lpos(s, ch);
+    Strings.Extract (s, 0, l, str);
+    string2pstring(str, pstr);
+    RETURN (pstr);
+  ELSE
+    j := 0;
+    k := 0;
+    l := 0;
+    i := 0;
+    REPEAT
+      IF s[i] = ch THEN
+        INC(j) ;
+        IF j = (n-1) THEN k := i  END;
+        IF j = n THEN l := i END;
+      END;
+      INC(i);
+    UNTIL i = Strings.Length(s);
+    Strings.Extract(s, k+1, l-k-1, str);
+    string2pstring(str, pstr);
+    RETURN (pstr)
+    END
+END ExtractWord;
+
+PROCEDURE tokenize(s : ARRAY OF CHAR; ch : CHAR) : pstrings;
+VAR
+  pstr  : pstring;
+  pstrs : pstrings;
+  l, n : INTEGER;
+BEGIN
+  n := WordCount(s, ch);
+  IF n # 0 THEN
+    NEW (pstrs, n)
+  ELSE
+    pstrs := NIL;
+    RETURN pstrs
+  END;
+  IF n = 1 THEN
+    RemoveRightChars (s, ch);
+    RemoveLeftChars (s, ch);
+    string2pstring(s, pstrs^[0]);
+  ELSE
+    l := 0;
+    REPEAT
+      pstr := ExtractWord ( l+1, s, ch);
+      pstrs^[l] := pstr;
+      INC(l);
+    UNTIL l = n;
+  END;
+  RETURN pstrs
+END tokenize;
+*)
+PROCEDURE copyAll (src : ARRAY OF CHAR ; VAR dst : ARRAY OF CHAR);
+ (* copies all array, even after 0X, but puts 0X in the end *)
+VAR 
+  i, k : CARDINAL ;
+  L1, L2 : CARDINAL;
+  
+BEGIN
+  L1 := HIGH(src);
+  L2 := HIGH(dst);
+  InOut.WriteCard(L1,5);
+  InOut.WriteCard(L2,5);
+  InOut.WriteLn;
+  (* 3 cases :
+       - the arrays are the same size
+       - the source is bigger than the destination
+       - the destination is bigger than the source
+   *)
+  IF L1 = L2 THEN
+    FOR i := 0 TO L1 DO
+      (* the null if present in the source is copied as it is in the destination *)
+       dst[i] := src[i];
+     END
+  ELSIF L1< L2 THEN
+    (* here we need to terminate the des with the 0C char *)
+    InOut.WriteString("source plus petite que destination");
+    InOut.WriteLn;
+    FOR i := 0 TO L1 DO
+      dst[i] := src[i]
+    END;
+    dst[i+1] := 0C;
+  ELSE
+    (* here we only copy what is possible in the destination : no need for a 0C terminal *)
+    InOut.WriteString("source plus grande que destination");
+    InOut.WriteLn; 
+    FOR i := 0 TO L2 DO
+      dst[i] := src[i]
+    END
+  END;
+
+  END copyAll;
+
+PROCEDURE zeroStr(VAR str: ARRAY OF CHAR);
+VAR
+  i, j : CARDINAL ;
+BEGIN
+  i := Strings.Length(str);
+  FOR j := 0 TO i-1 DO
+    str[j] := 0C;
+  END;
+(*  j := 0;
+  REPEAT
+    str[j] := 0H;
+    INC(j)
+  UNTIL j = i;*)
+END zeroStr;
+
+
+PROCEDURE appendLFCR(VAR str: ARRAY OF CHAR);
+  (* what happens if the array is too small ???? *)
+  
+VAR
+  l : INTEGER;
+BEGIN
+  l := Strings.Length(str);
+  IF l <= (l - 3) THEN 
+    str[l] := CHR(LF);
+    str[l+1] := CHR(CR);
+    str[l+2] := 0C;
+  END;  
+END appendLFCR;
+
+(*
+PROCEDURE findChar(ch: CHAR; VAR line: ARRAY OF CHAR; VAR b: BOOLEAN; VAR pos: INTEGER);
+VAR
+  i : INTEGER;
+BEGIN
+  i := -1; pos := -1;
+  b := FALSE;
+  REPEAT
+    INC(i);
+    IF line[i] = ch THEN b := TRUE; pos := i END;
+  UNTIL b OR (i = LEN(line) - 1);
+END findChar;
+
+PROCEDURE cutLine(VAR src, dst: ARRAY OF CHAR);
+VAR
+ found: BOOLEAN;
+ pos : INTEGER;
+ i : INTEGER;
+BEGIN
+  COPY("", dst);
+  findChar(LF, src, found, pos);
+  IF found THEN
+    i := 0;
+    REPEAT
+      dst[i] := src[i];
+      INC(i);
+    UNTIL (i = pos) OR (i = LEN(dst)-2);
+    dst[i] := src[i];
+    dst[i+1] := 0H
+  END;
+END cutLine;
+
+PROCEDURE terminateLine(VAR str: ARRAY OF CHAR);
+VAR
+ found: BOOLEAN;
+ pos : INTEGER;
+BEGIN
+  findChar(LF, str, found, pos);
+  IF found THEN
+    IF (pos + 1) < LEN(str) THEN
+      str[pos + 1] := 0H
+    END
+  END;
+END terminateLine;
+
+PROCEDURE getTillEOL(VAR src: ARRAY OF CHAR; spos: INTEGER; VAR dst: ARRAY OF CHAR); 
+
+VAR
+  i, j: INTEGER;
+  l, k: LONGINT;
+BEGIN
+  l := Strings.Length(src);
+  k := Strings.Length(dst);
+   zeroStr(dst);
+  i := 0;
+  j := spos+1;
+  REPEAT
+    dst[i] := src[i+j];
+    INC(i);
+  UNTIL (i+j >= l) OR (src[i+j] < ' ') OR (i+j >= LEN(src)) OR (j >= LEN(dst));
+END getTillEOL;
+
+PROCEDURE getNextWord(VAR src: ARRAY OF CHAR; spos: INTEGER; VAR dst: ARRAY OF CHAR);
+VAR
+  i, j: INTEGER;
+BEGIN
+  zeroStr(dst);
+  i := 0;
+  j := spos;
+  REPEAT
+    dst[i] := src[i+j];
+  INC(i);
+  UNTIL (i+j = Strings.Length(src)) OR (src[i+j] <= ' ');
+END getNextWord;
+
+PROCEDURE getNextAlphaNumWord(VAR src: ARRAY OF CHAR; spos: INTEGER; VAR dst: ARRAY OF CHAR);
+VAR
+  i, j: INTEGER;
+  notAN: BOOLEAN;
+  o: INTEGER;
+BEGIN
+  zeroStr(dst);
+  i := 0;
+  j := spos;
+  notAN := FALSE;
+  REPEAT
+    dst[i] := src[i+j];
+  INC(i);
+  o := ORD(src[i+j]);
+  IF ~ ( ((o >= 48) & (o <=57)) OR ((o >= 65) & (o <= 90)) OR ( (o >= 97) & (o <= 122)  ) ) THEN notAN := TRUE END;
+  UNTIL (i+j = Strings.Length(src))OR notAN OR (src[i+j] <= ' ');
+END getNextAlphaNumWord;
+
+PROCEDURE contains (VAR line : ARRAY OF CHAR; pattern: ARRAY OF CHAR): BOOLEAN;
+
+END contains;
+
+PROCEDURE contains1(VAR line: ARRAY OF CHAR; pat : ARRAY OF CHAR): BOOLEAN;
+VAR
+ found: BOOLEAN;
+ pos : INTEGER;
+BEGIN
+  Strings.FindNext(pat, line, 0, found, pos);
+  IF found THEN RETURN TRUE ELSE RETURN FALSE END
+END contains1;
+
+  
+PROCEDURE Reverse0 (VAR str : ARRAY OF CHAR; start, end : INTEGER);
+
+ VAR
+   h : CHAR;
+
+BEGIN
+  WHILE start < end DO
+    h := str[start]; 
+    str[start] := str[end]; 
+    str[end] := h;
+    INC(start); DEC(end)
+  END
+END Reverse0;
+
+PROCEDURE dumpChars(VAR s : ARRAY OF CHAR);
+VAR
+  i : INTEGER;
+  l : LONGINT;
+BEGIN
+  i := 0;
+  l := Strings.Length(s);
+  WHILE i < l DO
+    Out.Int(i, 0); Out.Char(" "); Out.Char(s[i]); Out.Ln; INC(i)
+  END
+END dumpChars;
+
+PROCEDURE dumpAllChars(VAR s : ARRAY OF CHAR);
+VAR
+  i : INTEGER;
+  l : LONGINT;
+BEGIN
+  i := 0;
+  l := LEN(s);
+  WHILE i < l-1 DO
+    Out.Int(i, 0); Out.Char(" "); Out.Char(s[i]); Out.Ln; INC(i)
+  END
+END dumpAllChars;
+*)
+
+END strUtils.

test1.mod

@@ -0,0 +1,38 @@
+MODULE test1;
+
+IMPORT strUtils, InOut;
+
+VAR 
+  chaine1, chaine2 : ARRAY[0..30]OF CHAR;
+  
+BEGIN
+  InOut.WriteString("test1");
+  InOut.WriteLn;
+  chaine1 := "toto";
+  chaine2 := "toto";
+  InOut.WriteInt(strUtils.Compare(chaine1,chaine2),5);
+  InOut.WriteLn;
+  
+  
+  InOut.WriteString("test2");
+  InOut.WriteLn;
+  chaine1 := "toto";
+  chaine2 := "tito";
+  InOut.WriteInt(strUtils.Compare(chaine1,chaine2),5);
+  InOut.WriteLn;
+    
+  InOut.WriteString("test3");
+  InOut.WriteLn;
+  chaine1 := "tito";
+  chaine2 := "toto";
+  InOut.WriteInt(strUtils.Compare(chaine1,chaine2),5);
+  InOut.WriteLn;
+  
+  InOut.WriteString("test4");
+  InOut.WriteLn;
+  chaine1 := "toto";
+  chaine2 := "totototo";
+  InOut.WriteInt(strUtils.Compare(chaine1,chaine2),5);
+  InOut.WriteLn;
+  
+END test1.  

test10.mod

@@ -0,0 +1,57 @@
+MODULE test10;
+
+IMPORT strUtils, InOut, Strings;
+
+VAR
+  chaine1 : ARRAY[0..10] OF CHAR;
+  chaine2 : ARRAY[0..10] OF CHAR;
+  chaine3 : ARRAY[0..6]  OF CHAR;
+  chaine4 : ARRAY[0..15] OF CHAR;
+
+BEGIN
+
+  InOut.WriteString("Test 1 : source et destination de taille égales ");
+  InOut.WriteLn;
+  
+  chaine1 := "et voila";
+  chaine2 := "";
+  InOut.WriteString(" test de la copie complète d'un array of CHAR dans une autre");
+  InOut.WriteLn;
+  strUtils.copyAll(chaine1, chaine2);
+  InOut.WriteString("Voilà la chaine 1 : ");
+  InOut.WriteString(chaine1);
+  InOut.WriteLn;
+  InOut.WriteString("Et voilà la chaine 2 : ");
+  InOut.WriteString(chaine2);
+  InOut.WriteCard(Strings.Length(chaine2),5);
+  InOut.WriteLn;
+  InOut.WriteLn;
+  
+  InOut.WriteString("Test 2 : taille source < taille destination ");
+  InOut.WriteLn;
+  chaine3 := "toto";
+  strUtils.copyAll(chaine3, chaine2);
+  InOut.WriteString("Voilà la chaine 3 : ");
+  InOut.WriteString(chaine3);
+  InOut.WriteLn;
+  InOut.WriteString("Et voilà la chaine 2 : ");
+  InOut.WriteString(chaine2);
+  InOut.WriteCard(Strings.Length(chaine2),5);
+  InOut.WriteLn;
+  InOut.WriteLn;
+  
+  InOut.WriteString("Test 3 : taille source > taille destination ");
+  InOut.WriteLn;
+  chaine4 := "Une chaine beauc";
+  InOut.WriteCard(Strings.Length(chaine4),5);
+  InOut.WriteLn;
+  strUtils.copyAll(chaine4, chaine2); 
+  InOut.WriteString("Voilà la chaine 4 : ");
+  InOut.WriteString(chaine4);
+  InOut.WriteLn;
+  InOut.WriteString("Et voilà la chaine 2 : ");
+  InOut.WriteString(chaine2);
+  InOut.WriteCard(Strings.Length(chaine2),5);
+  InOut.WriteLn;
+  InOut.WriteLn;
+END test10.

test11.mod

@@ -0,0 +1,25 @@
+MODULE test11;
+
+IMPORT strUtils, InOut, Strings, WholeStr;
+
+VAR
+  chaine : ARRAY[0..15] OF CHAR;
+  i, longueur : CARDINAL;
+
+BEGIN
+  chaine := "et voila en";
+  longueur := Strings.Length(chaine);
+  InOut.WriteCard(longueur,5);
+  InOut.WriteLn;
+  
+  strUtils.zeroStr(chaine);
+  InOut.WriteCard(Strings.Length(chaine),5);
+  InOut.WriteLn;
+  
+  FOR i := 0 TO longueur -1 DO
+   IF chaine[i] = 0C THEN
+     InOut.Write("0");
+   END;  
+  END;
+  InOut.WriteLn;
+END test11.

test12.mod

@@ -0,0 +1,344 @@
+MODULE test12;
+
+IMPORT strUtils, InOut, Strings;
+
+CONST
+  CR = 0DH;
+  LF = 0AH;
+
+VAR
+  chaine : ARRAY[0..15] OF CHAR;
+  taille, longueur : CARDINAL;
+  i : CARDINAL;
+
+PROCEDURE testassign;
+
+BEGIN 
+
+END testassign;
+
+PROCEDURE testpos;
+
+BEGIN 
+
+END testpos;
+
+PROCEDURE testappendLFCR;
+
+BEGIN 
+  (* test des valeurs *)
+  InOut.WriteHex(0DH,2);
+  InOut.WriteLn;
+  InOut.WriteHex(0AH,2);
+  InOut.WriteLn;
+  InOut.WriteHex(0CH,2);
+  InOut.WriteLn;
+  
+(* we have several cases here :
+    - the length of the string is <= length of the array -3
+        so, we have space to append the 3 endline characters
+    - the length of the array is not long enough :
+        so, we do nothing, but there are more solutions available    
+*)
+
+  InOut.WriteString("test1 : y'a de la place");
+  InOut.WriteLn;
+  chaine := "et voila";
+  longueur := Strings.Length(chaine);
+  taille := HIGH(chaine);
+  
+  InOut.WriteCard(longueur,5);
+  InOut.WriteLn;
+  InOut.WriteCard(taille,5);
+  InOut.WriteLn;
+  
+  strUtils.appendLFCR(chaine);
+  
+  FOR i := 0 TO longueur -1 DO
+   IF chaine[i] = 0C THEN
+     InOut.WriteString("0C");
+   ELSIF chaine[i]  = CHR(LF) THEN 
+     InOut.WriteString("LF");
+   ELSIF chaine[i]  = CHR(CR) THEN
+     InOut.WriteString("CR");
+   ELSE
+     InOut.Write(chaine[i]);
+   END;  
+  END;
+  InOut.WriteLn;
+  
+END testappendLFCR;
+
+PROCEDURE testisalnum;
+
+BEGIN 
+  InOut.WriteString("test IN ");
+  InOut.WriteLn;
+  InOut.WriteString("test isalnum");  
+  chaine := "estvoila";
+  InOut.WriteLn;
+   IF strUtils.isalnum(chaine) THEN
+     InOut.WriteString("tout est alphanum");
+   ELSE
+     InOut.WriteString("Y'a un caractère étranger");
+   END;
+   InOut.WriteLn;
+   chaine := "sdkjhqslkf#$";
+   IF strUtils.isalnum(chaine) THEN
+     InOut.WriteString("tout est alphanum");
+   ELSE
+     InOut.WriteString("Y'a un caractère étranger");
+   END;
+   InOut.WriteLn;
+END testisalnum;
+
+PROCEDURE testisalpha;
+
+BEGIN 
+  InOut.WriteString("test isalpha");  
+   chaine := "estvoila";
+   InOut.WriteLn;
+   IF strUtils.isalpha(chaine) THEN
+     InOut.WriteString("tout est alpha");
+   ELSE
+     InOut.WriteString("Y'a un caractère étranger");
+   END;
+   InOut.WriteLn;
+   chaine := "sdkjhqs1";
+   IF strUtils.isalpha(chaine) THEN
+     InOut.WriteString("tout est alpha");
+   ELSE
+     InOut.WriteString("Y'a un caractère étranger");
+   END;
+   InOut.WriteLn;
+END testisalpha;
+
+PROCEDURE testisascii;
+
+BEGIN 
+   InOut.WriteString("test isascii");  
+   chaine := "estvoila";
+   InOut.WriteLn;
+   IF strUtils.isalpha(chaine) THEN
+     InOut.WriteString("tout est ascii");
+   ELSE
+     InOut.WriteString("Y'a un caractère étranger");
+   END;
+   InOut.WriteLn;
+   chaine := "sdkjùhqs";
+   IF strUtils.isalpha(chaine) THEN
+     InOut.WriteString("tout est ascii");
+   ELSE
+     InOut.WriteString("Y'a un caractère étranger");
+   END;
+   InOut.WriteLn;
+END testisascii;
+
+PROCEDURE testisdigit;
+
+BEGIN 
+   InOut.WriteString("test isdigit");
+    chaine := "12345";
+   InOut.WriteLn;
+   IF strUtils.isdigit(chaine) THEN
+     InOut.WriteString("tout est digit");
+   ELSE
+     InOut.WriteString("Y'a un caractère étranger");
+   END;
+   InOut.WriteLn;
+   chaine := "123m45";
+   IF strUtils.isdigit(chaine) THEN
+     InOut.WriteString("tout est digit");
+   ELSE
+     InOut.WriteString("Y'a un caractère étranger");
+   END;
+   InOut.WriteLn;
+END testisdigit;
+
+
+PROCEDURE testisidentifier;
+
+BEGIN 
+  InOut.WriteString("test isidentifier");
+    chaine := "estvoila";
+   InOut.WriteLn;
+   IF strUtils.isalpha(chaine) THEN
+     InOut.WriteString("tout est alpha");
+   ELSE
+     InOut.WriteString("Y'a un caractère étranger");
+   END;
+   InOut.WriteLn;
+   chaine := "sdkjhqs1";
+   IF strUtils.isalpha(chaine) THEN
+     InOut.WriteString("tout est alpha");
+   ELSE
+     InOut.WriteString("Y'a un caractère étranger");
+   END;
+   InOut.WriteLn;
+END testisidentifier;
+
+
+PROCEDURE testislower;
+
+BEGIN 
+   InOut.WriteString("test islower");
+   chaine := "estvoila";
+   InOut.WriteLn;
+   IF strUtils.isalpha(chaine) THEN
+     InOut.WriteString("tout est alpha");
+   ELSE
+     InOut.WriteString("Y'a un caractère étranger");
+   END;
+   InOut.WriteLn;
+   chaine := "sdkjhqs1";
+   IF strUtils.isalpha(chaine) THEN
+     InOut.WriteString("tout est alpha");
+   ELSE
+     InOut.WriteString("Y'a un caractère étranger");
+   END;
+   InOut.WriteLn;
+END testislower;
+
+PROCEDURE testisprintable;
+
+BEGIN 
+    InOut.WriteString("test isprintable");
+   chaine := "estvoila";
+   InOut.WriteLn;
+   IF strUtils.isalpha(chaine) THEN
+     InOut.WriteString("tout est alpha");
+   ELSE
+     InOut.WriteString("Y'a un caractère étranger");
+   END;
+   InOut.WriteLn;
+   chaine := "sdkjhqs1";
+   IF strUtils.isalpha(chaine) THEN
+     InOut.WriteString("tout est alpha");
+   ELSE
+     InOut.WriteString("Y'a un caractère étranger");
+   END;
+   InOut.WriteLn;
+END testisprintable;
+
+PROCEDURE testisspace;
+
+BEGIN 
+  InOut.WriteString("test isspace");
+   chaine := "estvoila";
+   InOut.WriteLn;
+   IF strUtils.isalpha(chaine) THEN
+     InOut.WriteString("tout est alpha");
+   ELSE
+     InOut.WriteString("Y'a un caractère étranger");
+   END;
+   InOut.WriteLn;
+   chaine := "sdkjhqs1";
+   IF strUtils.isalpha(chaine) THEN
+     InOut.WriteString("tout est alpha");
+   ELSE
+     InOut.WriteString("Y'a un caractère étranger");
+   END;
+   InOut.WriteLn;
+END testisspace;
+
+PROCEDURE testistitle;
+
+BEGIN 
+   InOut.WriteString("test istitle");
+   chaine := "Estvoila";
+   InOut.WriteLn;
+   IF strUtils.istitle(chaine) THEN
+     InOut.WriteString("C'est un titre");
+   ELSE
+     InOut.WriteString("Ce n'est pas un titre");
+   END;
+   InOut.WriteLn;
+   chaine := "sdkjhqs1";
+   IF strUtils.istitle(chaine) THEN
+     InOut.WriteString("C'est un titre");
+   ELSE
+     InOut.WriteString("Ce n'est pas un titre");
+   END;
+   InOut.WriteLn;
+END testistitle;
+
+
+PROCEDURE testisupper;
+
+BEGIN 
+      
+   InOut.WriteString("test isupper");
+   chaine := "VOILAUNECHAINE";
+   InOut.WriteLn;
+   IF strUtils.isupper(chaine) THEN
+     InOut.WriteString("tout est upcase");
+   ELSE
+     InOut.WriteString("Y'a un caractère en basse casse");
+   END;
+   InOut.WriteLn;
+   chaine := "VOILA UNE CHAINE";
+   IF strUtils.isupper(chaine) THEN
+     InOut.WriteString("tout est upcase");
+   ELSE
+     InOut.WriteString("Y'a un caractère en basse casse");
+   END;
+   InOut.WriteLn;
+END  testisupper;
+
+
+PROCEDURE testcopy;
+  (*PROCEDURE Copy(VAR Ns: ARRAY OF CHAR; S: ARRAY OF CHAR);*)
+
+VAR 
+  src1 : ARRAY [0..9] OF CHAR;
+  src2 : ARRAY [0..12] OF CHAR;
+  src3 : ARRAY [0..5] OF CHAR;
+  dst  : ARRAY [0..9] OF CHAR;
+  
+BEGIN 
+ (* plusieurs cas :
+   - chaines égales
+   - src > destination
+   - src < destination  
+  *)
+  
+  InOut.WriteString(" chaines égales");
+  InOut.WriteLn;
+  src1 := "1234567890";
+  InOut.WriteString("chaine origine : ");
+  InOut.WriteString(src1);
+  InOut.WriteLn;
+  strUtils.Copy(dst,src1);
+  InOut.WriteString("chaine destination : ");
+  InOut.WriteString(dst);
+  InOut.WriteLn;
+  InOut.WriteLn;
+  InOut.WriteLn;
+  
+  InOut.WriteString(" source > destination");
+  InOut.WriteLn;
+  src2 := "1234567890abc";
+  strUtils.Copy(dst,src2);
+  InOut.WriteString(src2);
+  InOut.WriteLn;
+  InOut.WriteString(dst);
+  InOut.WriteLn;
+  InOut.WriteLn;
+  InOut.WriteLn; 
+  
+  InOut.WriteString(" source < destination");
+  InOut.WriteLn;
+  src3 := "123456";
+  strUtils.Copy(dst,src3);
+  InOut.WriteString(src3);
+  InOut.WriteLn;
+  InOut.WriteString(dst);
+  InOut.WriteLn;
+  
+END testcopy;
+
+BEGIN      
+  (*testcopy;*)(* works fine *)
+  (* testisupper;*)(* works fine *)
+  testistitle;
+END test12.

test2.mod

@@ -0,0 +1,12 @@
+MODULE test2;
+
+IMPORT strUtils, InOut;
+
+VAR 
+  chaine1 : ARRAY[0..255]OF CHAR;
+
+BEGIN
+  chaine1 := "ceci est une chaine de test de la fonction pos ";
+  InOut.WriteCard(strUtils.Pos("u", chaine1, 12),5);
+  InOut.WriteLn;
+END test2.

test3.mod

@@ -0,0 +1,19 @@
+MODULE test3;
+
+IMPORT strUtils, InOut;
+
+VAR 
+  chaine1 : ARRAY[0..30] OF CHAR;
+  chaine2 : ARRAY[0..30] OF CHAR;
+
+BEGIN
+  InOut.WriteString("test1 : ");
+  chaine1 := "aaa une chaine bbb";
+  strUtils.RemoveLeftChars (chaine1, "a");
+  InOut.WriteString(chaine1);
+  InOut.WriteLn;
+  InOut.WriteString("test2 : ");
+  strUtils.RemoveRightChars (chaine1, "b");
+  InOut.WriteString(chaine1);
+  InOut.WriteLn;
+END test3.

test4.mod

@@ -0,0 +1,24 @@
+MODULE test4;
+
+IMPORT strUtils, InOut;
+
+VAR
+  chaine1 : ARRAY[0..255] OF CHAR;
+  chaine2 : ARRAY[0..255] OF CHAR;
+  chaine3 : ARRAY[0..3] OF CHAR;
+  
+BEGIN 
+  chaine1 := "";
+  chaine2 := "";
+  chaine1 := "encore un essai";
+  strUtils.Assign(chaine1, chaine2);
+  InOut.WriteString(chaine1);
+  InOut.WriteLn;
+  InOut.WriteString(chaine2);
+  InOut.WriteLn; 
+  InOut.WriteString("Essai 2 avec destination plus courte que source");
+  InOut.WriteLn;
+  strUtils.Assign(chaine1, chaine3);
+  InOut.WriteString(chaine3);
+  InOut.WriteLn; 
+  END test4.

test5.mod

@@ -0,0 +1,13 @@
+MODULE test5;
+
+IMPORT InOut, strUtils;
+
+VAR
+  chaine : ARRAY[0..255] OF CHAR;
+  
+BEGIN
+  chaine := "et voilà une joile chaine";
+  InOut.WriteCard(strUtils.NumberOfChar(chaine, "i"),5);
+  InOut.WriteLn;
+END test5. 
+

test6.mod

@@ -0,0 +1,13 @@
+MODULE test6;
+
+IMPORT strUtils, InOut;
+
+VAR
+  chaine : ARRAY[0..255] OF CHAR;
+
+BEGIN
+  chaine := "  et voici une petite chaine avec des espaces devant et derrière   ";
+  InOut.WriteString ("test : compter les mots avec séparateur : ");
+  InOut.WriteCard(strUtils.WordCount(chaine, " "),5);
+  InOut.WriteLn;
+END test6.

test7.mod

@@ -0,0 +1,13 @@
+MODULE test7;
+
+IMPORT strUtils, InOut;
+
+VAR
+  chaine : ARRAY[0..255] OF CHAR;
+
+BEGIN
+  chaine := " et voilà encore une petite chaîne";
+  InOut.WriteString(" test de la position d'un caractère dans la chaine, commençant par la droite");
+  InOut.WriteCard(strUtils.Rpos(chaine,"c"),5);
+  InOut.WriteLn;
+END test7.

test8.mod

@@ -0,0 +1,13 @@
+MODULE test8;
+
+IMPORT strUtils, InOut;
+
+VAR
+  chaine : ARRAY[0..255] OF CHAR;
+
+BEGIN
+  chaine := " et voilà encore une petite chaîne";
+  InOut.WriteString(" test de la position d'un caractère dans la chaine, commençant par la gauche");
+  InOut.WriteCard(strUtils.Lpos(chaine,"o"),5);
+  InOut.WriteLn;
+END test8.

test9.mod

@@ -0,0 +1,21 @@
+MODULE test9;
+
+IMPORT strUtils, InOut, Strings;
+
+VAR
+  chaine1 : ARRAY[0..255] OF CHAR;
+  chaine2 : ARRAY[0..255] OF CHAR;
+  start, quantity : CARDINAL;
+
+BEGIN
+  chaine1 := "et voila encore une petite chaîne";
+  chaine2 := "";
+  start := 3;
+  quantity := 5;
+  InOut.WriteString(" test de la copie d'une partie de chaine dans une autre, commençant à start");
+  InOut.WriteLn;
+  strUtils.copyBytes(chaine1, chaine2, start, quantity);
+  InOut.WriteString(chaine2);
+  InOut.WriteCard(Strings.Length(chaine2),5);
+  InOut.WriteLn;
+END test9.