Subversion Repositories Kolibri OS

Rev

Rev 7983 | Go to most recent revision | Blame | Last modification | View Log | Download | RSS feed

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