home *** CD-ROM | disk | FTP | other *** search
/ Amiga MA Magazine 1998 #6 / amigamamagazinepolishissue1998.iso / coders / jËzyki_programowania / oberon / system / strings.mod (.txt) < prev    next >
Oberon Text  |  1977-12-31  |  5KB  |  142 lines
  1. Syntax10.Scn.Fnt
  2. FoldElems
  3. Syntax10i.Scn.Fnt
  4. Documentation
  5. StampElems
  6. Alloc
  7. 11 Dec 95
  8. Syntax10b.Scn.Fnt
  9. Syntax8i.Scn.Fnt
  10. (*-------------------------------------------------------------
  11. Strings provides a set of operations on strings (i.e., on string constants and character
  12. arrays, both of which contain the character 0X as a terminator). All positions in
  13. strings start at 0.
  14. Strings.Length(s)
  15.     returns the number of characters in s up to and excluding the first 0X.
  16. Strings.Insert(src, pos, dst)
  17.     inserts the string src into the string dst at position pos (0 <= pos <= Length(dst)).
  18.     If pos = Length(dst), src is appended to dst. If the size of dst is not large enough
  19.     to hold the result of the operation, the result is truncated so that dst is always
  20.     terminated with a 0X.
  21. Strings.Append(s, dst)
  22.     has the same effect as Insert(s, Length(s), dst).
  23. Strings.Delete(s, pos, n)
  24.     deletes n characters from s starting at position pos (0 <= pos < Length(s)).
  25.     If n > Length(s) - pos, the new length of s is pos.
  26. Strings.Replace(src, pos, dst)
  27.     has the same effect as Delete(dst, pos, Length(src)) followed by an Insert(src, pos, dst).
  28. Strings.Extract(src, pos, n, dst)
  29.     extracts a substring dst with n characters from position pos (0 <= pos < Length(src)) in src.
  30.     If n > Length(src) - pos, dst is only the part of src from pos to Length(src) - 1. If the size of
  31.     dst is not large enough to hold the result of the operation, the result is truncated so that
  32.     dst is always terminated with a 0X.
  33. Strings.Pos(pat, s, pos)
  34.     returns the position of the first occurrence of pat in s after position pos (inclusive).
  35.     If pat is not found, -1 is returned.
  36. Strings.Cap(s)
  37.     replaces each lower case letter in s by its upper case equivalent.
  38. -------------------------------------------------------------*)
  39. MODULE Strings;    (*HM 94-06-22 / 
  40. PROCEDURE Length* (s: ARRAY OF CHAR): INTEGER;
  41.     VAR i: INTEGER;
  42. BEGIN
  43.     i := 0; WHILE (i < LEN(s)) & (s[i] # 0X) DO INC(i) END ;
  44.     RETURN i
  45. END Length;
  46. PROCEDURE Append* (extra: ARRAY OF CHAR; VAR dest: ARRAY OF CHAR);
  47.     VAR n1, n2, i: INTEGER;
  48. BEGIN
  49.     n1 := Length(dest); n2 := Length(extra); i := 0;
  50.     WHILE (i < n2) & (i + n1 < LEN(dest)) DO dest[i + n1] := extra[i]; INC(i) END ;
  51.     IF i + n1 < LEN(dest) THEN dest[i + n1] := 0X END
  52. END Append;
  53. PROCEDURE Insert* (source: ARRAY OF CHAR; pos: INTEGER; VAR dest: ARRAY OF CHAR);
  54.     VAR n1, n2, i: INTEGER;
  55. BEGIN
  56.     n1 := Length(dest); n2 := Length(source);
  57.     IF pos < 0 THEN pos := 0 END ;
  58.     IF pos > n1 THEN Append(dest, source); RETURN END ;
  59.     IF pos + n2 < LEN(dest) THEN  (*make room for source*)
  60.         i := n1; (*move also 0X if it is there*)
  61.         WHILE i >= pos DO
  62.             IF i + n2 < LEN(dest) THEN dest[i + n2] := dest[i] END ;
  63.             DEC(i)
  64.         END
  65.     END ;
  66.     i := 0; WHILE i < n2 DO dest[pos + i] := source[i]; INC(i) END
  67. END Insert;
  68. PROCEDURE Delete* (VAR s: ARRAY OF CHAR; pos, n: INTEGER);
  69.     VAR len, i: INTEGER;
  70. BEGIN
  71.     len:=Length(s);
  72.     IF pos < 0 THEN pos:=0 ELSIF pos >= len THEN RETURN END ;
  73.     IF pos + n < len THEN
  74.         i:=pos + n; WHILE i < len DO s[i - n]:=s[i]; INC(i) END ;
  75.         IF i - n < LEN(s) THEN s[i - n]:=0X END
  76.     ELSE s[pos]:=0X
  77. END Delete;
  78. PROCEDURE Replace* (source: ARRAY OF CHAR; pos: INTEGER; VAR dest: ARRAY OF CHAR);
  79. BEGIN
  80.     Delete(dest, pos, pos + Length(source));
  81.     Insert(source, pos, dest)
  82. END Replace;
  83. PROCEDURE Extract* (source: ARRAY OF CHAR; pos, n: INTEGER; VAR dest: ARRAY OF CHAR);
  84.     VAR len, destLen, i: INTEGER;
  85. BEGIN
  86.     len := Length(source); destLen := SHORT(LEN(dest)) - 1;
  87.     IF pos < 0 THEN pos := 0 END ;
  88.     IF pos >= len THEN dest[0] := 0X; RETURN END ;
  89.     i := 0;
  90.     WHILE (pos + i <= LEN(source)) & (source[pos + i] # 0X) & (i < n) DO
  91.         IF i < destLen THEN dest[i] := source[pos + i] END ;
  92.         INC(i)
  93.     END ;
  94.     dest[i] := 0X
  95. END Extract;
  96. PROCEDURE Pos* (pattern, s: ARRAY OF CHAR; pos: INTEGER): INTEGER;
  97.     VAR n1, n2, i, j: INTEGER;
  98. BEGIN
  99.     n1 := Length(s); n2 := Length(pattern);
  100.     IF n2 = 0 THEN RETURN 0 END ;
  101.     i := pos;
  102.     WHILE i <= n1 - n2 DO
  103.         IF s[i] = pattern[0] THEN
  104.             j := 1; WHILE (j < n2) & (s[i + j] = pattern[j]) DO INC(j) END ;
  105.             IF j = n2 THEN RETURN i END
  106.         END ;
  107.         INC(i)
  108.     END ;
  109.     RETURN -1
  110. END Pos;
  111. PROCEDURE Cap* (VAR s: ARRAY OF CHAR);
  112.     VAR i: INTEGER;
  113. BEGIN
  114.     i := 0;
  115.     WHILE s[i] # 0X DO
  116.         IF ("a" <= s[i]) & (s[i] <= "z") THEN s[i] := CAP(s[i]) END ;
  117.         INC(i)
  118. END Cap;
  119. PROCEDURE Match* (string, pattern: ARRAY OF CHAR): BOOLEAN;
  120.     PROCEDURE M (VAR name, mask: ARRAY OF CHAR; n, m: INTEGER): BOOLEAN;
  121.     BEGIN
  122.         WHILE (n >= 0) & (m >= 0) & (mask[m] # "*") DO
  123.             IF name[n] # mask[m] THEN RETURN FALSE END ;
  124.             DEC(n); DEC(m)
  125.         END ;
  126.         (* ----- name empty | mask empty | mask ends with "*" *)
  127.         IF m < 0 THEN RETURN n < 0 END ;
  128.         (* ----- name empty | mask ends with "*" *)
  129.         WHILE (m >= 0) & (mask[m] = "*") DO DEC(m) END ;
  130.         IF m < 0 THEN RETURN TRUE END ;
  131.         (* ----- name empty | mask still to be matched *)
  132.         WHILE n >= 0 DO
  133.             IF M(name, mask, n, m) THEN RETURN TRUE END ;
  134.             DEC(n)
  135.         END ;
  136.         RETURN FALSE
  137.     END M;
  138. BEGIN
  139.     RETURN M(string, pattern, Length(string)-1, Length(pattern)-1)
  140. END Match;
  141. END Strings.
  142.