Subversion Repositories Kolibri OS

Rev

Rev 7667 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. (*
  2.     BSD 2-Clause License
  3.  
  4.     Copyright (c) 2018, Anton Krotov
  5.     All rights reserved.
  6. *)
  7.  
  8. MODULE STRINGS;
  9.  
  10. IMPORT UTILS;
  11.  
  12.  
  13. PROCEDURE append* (VAR s1: ARRAY OF CHAR; s2: ARRAY OF CHAR);
  14. VAR
  15.     n1, n2, i, j: INTEGER;
  16. BEGIN
  17.     n1 := LENGTH(s1);
  18.     n2 := LENGTH(s2);
  19.  
  20.     ASSERT(n1 + n2 < LEN(s1));
  21.  
  22.     i := 0;
  23.     j := n1;
  24.     WHILE i < n2 DO
  25.         s1[j] := s2[i];
  26.         INC(i);
  27.         INC(j)
  28.     END;
  29.  
  30.     s1[j] := 0X
  31.  
  32. END append;
  33.  
  34.  
  35. PROCEDURE reverse* (VAR s: ARRAY OF CHAR);
  36. VAR
  37.     i, j: INTEGER;
  38.     a, b: CHAR;
  39.  
  40. BEGIN
  41.  
  42.     i := 0;
  43.     j := LENGTH(s) - 1;
  44.  
  45.     WHILE i < j DO
  46.         a := s[i];
  47.         b := s[j];
  48.         s[i] := b;
  49.         s[j] := a;
  50.         INC(i);
  51.         DEC(j)
  52.     END
  53. END reverse;
  54.  
  55.  
  56. PROCEDURE IntToStr* (x: INTEGER; VAR str: ARRAY OF CHAR);
  57. VAR
  58.     i, a: INTEGER;
  59.     minus: BOOLEAN;
  60.  
  61. BEGIN
  62.     IF x = UTILS.minint THEN
  63.         IF UTILS.bit_depth = 32 THEN
  64.             COPY("-2147483648", str)
  65.         ELSIF UTILS.bit_depth = 64 THEN
  66.             COPY("-9223372036854775808", str)
  67.         END
  68.  
  69.     ELSE
  70.  
  71.         minus := x < 0;
  72.         IF minus THEN
  73.             x := -x
  74.         END;
  75.         i := 0;
  76.         a := 0;
  77.         REPEAT
  78.             str[i] := CHR(x MOD 10 + ORD("0"));
  79.             x := x DIV 10;
  80.             INC(i)
  81.         UNTIL x = 0;
  82.  
  83.         IF minus THEN
  84.             str[i] := "-";
  85.             INC(i)
  86.         END;
  87.  
  88.         str[i] := 0X;
  89.         reverse(str)
  90.  
  91.     END
  92. END IntToStr;
  93.  
  94.  
  95. PROCEDURE copy* (src: ARRAY OF CHAR; VAR dst: ARRAY OF CHAR; spos, dpos, count: INTEGER);
  96. BEGIN
  97.     WHILE count > 0 DO
  98.         dst[dpos] := src[spos];
  99.         INC(spos);
  100.         INC(dpos);
  101.         DEC(count)
  102.     END
  103. END copy;
  104.  
  105.  
  106. PROCEDURE search* (s: ARRAY OF CHAR; VAR pos: INTEGER; c: CHAR; forward: BOOLEAN);
  107. VAR
  108.     length: INTEGER;
  109.  
  110. BEGIN
  111.     length := LENGTH(s);
  112.  
  113.     IF (0 <= pos) & (pos < length) THEN
  114.         IF forward THEN
  115.             WHILE (pos < length) & (s[pos] # c) DO
  116.                 INC(pos)
  117.             END;
  118.             IF pos = length THEN
  119.                 pos := -1
  120.             END
  121.         ELSE
  122.             WHILE (pos >= 0) & (s[pos] # c) DO
  123.                 DEC(pos)
  124.             END
  125.         END
  126.     ELSE
  127.         pos := -1
  128.     END
  129. END search;
  130.  
  131.  
  132. PROCEDURE letter* (c: CHAR): BOOLEAN;
  133.     RETURN ("a" <= c) & (c <= "z") OR ("A" <= c) & (c <= "Z") OR (c = "_")
  134. END letter;
  135.  
  136.  
  137. PROCEDURE digit* (c: CHAR): BOOLEAN;
  138.     RETURN ("0" <= c) & (c <= "9")
  139. END digit;
  140.  
  141.  
  142. PROCEDURE hexdigit* (c: CHAR): BOOLEAN;
  143.     RETURN ("0" <= c) & (c <= "9") OR ("A" <= c) & (c <= "F")
  144. END hexdigit;
  145.  
  146.  
  147. PROCEDURE space* (c: CHAR): BOOLEAN;
  148.     RETURN (0X < c) & (c <= 20X)
  149. END space;
  150.  
  151.  
  152. PROCEDURE StrToInt* (str: ARRAY OF CHAR; VAR x: INTEGER): BOOLEAN;
  153. VAR
  154.     i, k: INTEGER;
  155.     res: BOOLEAN;
  156.  
  157. BEGIN
  158.     res := TRUE;
  159.     i := 0;
  160.     x := 0;
  161.     k := LENGTH(str);
  162.     WHILE i < k DO
  163.         IF digit(str[i]) THEN
  164.             x := x * 10 + ORD(str[i]) - ORD("0")
  165.         ELSE
  166.             i := k;
  167.             res := FALSE
  168.         END;
  169.         INC(i)
  170.     END
  171.  
  172.     RETURN res
  173. END StrToInt;
  174.  
  175.  
  176. PROCEDURE CheckVer (str: ARRAY OF CHAR): BOOLEAN;
  177. VAR
  178.     i, k: INTEGER;
  179.     res: BOOLEAN;
  180.  
  181. BEGIN
  182.     k := LENGTH(str);
  183.     res := k < LEN(str);
  184.  
  185.     IF res & digit(str[0]) THEN
  186.         i := 0;
  187.         WHILE (i < k) & digit(str[i]) DO
  188.             INC(i)
  189.         END;
  190.         IF (i < k) & (str[i] = ".") THEN
  191.             INC(i);
  192.             IF i < k THEN
  193.                 WHILE (i < k) & digit(str[i]) DO
  194.                     INC(i)
  195.                 END
  196.             ELSE
  197.                 res := FALSE
  198.             END
  199.         ELSE
  200.             res := FALSE
  201.         END;
  202.  
  203.         res := res & (i = k)
  204.     ELSE
  205.         res := FALSE
  206.     END
  207.  
  208.     RETURN res
  209. END CheckVer;
  210.  
  211.  
  212. PROCEDURE StrToVer* (str: ARRAY OF CHAR; VAR major, minor: INTEGER): BOOLEAN;
  213. VAR
  214.     i: INTEGER;
  215.     res: BOOLEAN;
  216.  
  217. BEGIN
  218.     res := CheckVer(str);
  219.  
  220.     IF res THEN
  221.         i := 0;
  222.         minor := 0;
  223.         major := 0;
  224.         WHILE digit(str[i]) DO
  225.             major := major * 10 + ORD(str[i]) - ORD("0");
  226.             INC(i)
  227.         END;
  228.         INC(i);
  229.         WHILE digit(str[i]) DO
  230.             minor := minor * 10 + ORD(str[i]) - ORD("0");
  231.             INC(i)
  232.         END
  233.     END
  234.  
  235.     RETURN res
  236. END StrToVer;
  237.  
  238.  
  239. PROCEDURE Utf8To16* (src: ARRAY OF CHAR; VAR dst: ARRAY OF WCHAR): INTEGER;
  240. VAR
  241.     i, j, u, srclen, dstlen: INTEGER;
  242.     c: CHAR;
  243.  
  244. BEGIN
  245.     srclen := LEN(src);
  246.     dstlen := LEN(dst);
  247.     i := 0;
  248.     j := 0;
  249.     WHILE (i < srclen) & (j < dstlen) & (src[i] # 0X) DO
  250.         c := src[i];
  251.         CASE c OF
  252.         |00X..7FX:
  253.             u := ORD(c)
  254.  
  255.         |0C1X..0DFX:
  256.             u := LSL(ORD(c) - 0C0H, 6);
  257.             IF i + 1 < srclen THEN
  258.                 u := u + ROR(LSL(ORD(src[i + 1]), 26), 26);
  259.                 INC(i)
  260.             END
  261.  
  262.         |0E1X..0EFX:
  263.             u := LSL(ORD(c) - 0E0H, 12);
  264.             IF i + 1 < srclen THEN
  265.                 u := u + ROR(LSL(ORD(src[i + 1]), 26), 20);
  266.                 INC(i)
  267.             END;
  268.             IF i + 1 < srclen THEN
  269.                 u := u + ROR(LSL(ORD(src[i + 1]), 26), 26);
  270.                 INC(i)
  271.             END
  272. (*
  273.         |0F1X..0F7X:
  274.         |0F9X..0FBX:
  275.         |0FDX:
  276.         *)
  277.         ELSE
  278.         END;
  279.         INC(i);
  280.         dst[j] := WCHR(u);
  281.         INC(j)
  282.     END;
  283.     IF j < dstlen THEN
  284.         dst[j] := WCHR(0)
  285.     END
  286.  
  287.     RETURN j
  288. END Utf8To16;
  289.  
  290.  
  291. END STRINGS.