Subversion Repositories Kolibri OS

Rev

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

  1. (*
  2.     Copyright 2021-2023 Anton Krotov
  3.  
  4.     This file is part of CEdit.
  5.  
  6.     CEdit is free software: you can redistribute it and/or modify
  7.     it under the terms of the GNU General Public License as published by
  8.     the Free Software Foundation, either version 3 of the License, or
  9.     (at your option) any later version.
  10.  
  11.     CEdit is distributed in the hope that it will be useful,
  12.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.     GNU General Public License for more details.
  15.  
  16.     You should have received a copy of the GNU General Public License
  17.     along with CEdit. If not, see <http://www.gnu.org/licenses/>.
  18. *)
  19.  
  20. MODULE Utils;
  21.  
  22. IMPORT SYSTEM;
  23.  
  24. CONST
  25.  
  26.         SPACE* = 20X;
  27.         SLASH* = "/";
  28.  
  29.         OS* = "KOS";
  30.  
  31.  
  32. PROCEDURE streq* (s1, s2: INTEGER; n: INTEGER): BOOLEAN;
  33. VAR
  34.         c1, c2: WCHAR;
  35.         res: BOOLEAN;
  36. BEGIN
  37.         res := TRUE;
  38.         WHILE (n > 0) & res DO
  39.                 SYSTEM.GET(s1, c1);
  40.                 SYSTEM.GET(s2, c2);
  41.                 res := c1 = c2;
  42.                 INC(s1, SYSTEM.SIZE(WCHAR));
  43.                 INC(s2, SYSTEM.SIZE(WCHAR));
  44.                 DEC(n)
  45.         END
  46.         RETURN res
  47. END streq;
  48.  
  49.  
  50. PROCEDURE append* (VAR s1: ARRAY OF WCHAR; s2: ARRAY OF WCHAR);
  51. VAR
  52.     n, i, j: INTEGER;
  53. BEGIN
  54.     j := LENGTH(s1);
  55.     n := LENGTH(s2);
  56.  
  57.     ASSERT(j + n < LEN(s1));
  58.  
  59.     i := 0;
  60.     WHILE i < n DO
  61.         s1[j] := s2[i];
  62.         INC(i);
  63.         INC(j)
  64.     END;
  65.  
  66.     s1[j] := 0X
  67. END append;
  68.  
  69.  
  70. PROCEDURE append8* (VAR s1: ARRAY OF CHAR; s2: ARRAY OF CHAR);
  71. VAR
  72.     n, i, j: INTEGER;
  73. BEGIN
  74.     j := LENGTH(s1);
  75.     n := LENGTH(s2);
  76.  
  77.     ASSERT(j + n < LEN(s1));
  78.  
  79.     i := 0;
  80.     WHILE i < n DO
  81.         s1[j] := s2[i];
  82.         INC(i);
  83.         INC(j)
  84.     END;
  85.  
  86.     s1[j] := 0X
  87. END append8;
  88.  
  89.  
  90. PROCEDURE reverse* (VAR s: ARRAY OF WCHAR);
  91. VAR
  92.     ch: WCHAR;
  93.     i, j: INTEGER;
  94. BEGIN
  95.     i := 0;
  96.     j := LENGTH(s) - 1;
  97.     WHILE i < j DO
  98.         ch := s[i];
  99.         s[i] := s[j];
  100.         s[j] := ch;
  101.         INC(i);
  102.         DEC(j)
  103.     END
  104. END reverse;
  105.  
  106.  
  107. PROCEDURE reverse8* (VAR s: ARRAY OF CHAR);
  108. VAR
  109.     ch: CHAR;
  110.     i, j: INTEGER;
  111. BEGIN
  112.     i := 0;
  113.     j := LENGTH(s) - 1;
  114.     WHILE i < j DO
  115.         ch := s[i];
  116.         s[i] := s[j];
  117.         s[j] := ch;
  118.         INC(i);
  119.         DEC(j)
  120.     END
  121. END reverse8;
  122.  
  123.  
  124. PROCEDURE int2str* (val: INTEGER; VAR s: ARRAY OF WCHAR);
  125. VAR
  126.     i: INTEGER;
  127. BEGIN
  128.     i := 0;
  129.     REPEAT
  130.         s[i] := WCHR(ORD("0") + val MOD 10);
  131.         INC(i);
  132.         val := val DIV 10
  133.     UNTIL val = 0;
  134.     s[i] := 0X;
  135.     reverse(s)
  136. END int2str;
  137.  
  138.  
  139. PROCEDURE isDigit* (ch: WCHAR): BOOLEAN;
  140.         RETURN ("0" <= ch) & (ch <= "9")
  141. END isDigit;
  142.  
  143.  
  144. PROCEDURE isOct* (ch: WCHAR): BOOLEAN;
  145.         RETURN ("0" <= ch) & (ch <= "7")
  146. END isOct;
  147.  
  148.  
  149. PROCEDURE isHex* (ch: WCHAR): BOOLEAN;
  150.         RETURN ("0" <= ch) & (ch <= "9") OR ("A" <= ch) & (ch <= "F")
  151. END isHex;
  152.  
  153.  
  154. PROCEDURE isLetter* (ch: WCHAR): BOOLEAN;
  155.         RETURN ("a" <= ch) & (ch <= "z") OR ("A" <= ch) & (ch <= "Z") OR
  156.                 (* cyrillic *)
  157.                         (430X <= ch) & (ch <= 44FX) OR (410X <= ch) & (ch <= 42FX) OR
  158.                         (ch = 491X) OR (ch = 490X) OR (450X <= ch) & (ch <= 45FX) OR
  159.                         (400X <= ch) & (ch <= 40FX)
  160. END isLetter;
  161.  
  162.  
  163. PROCEDURE upper* (VAR ch: WCHAR): BOOLEAN;
  164. VAR
  165.     res: BOOLEAN;
  166. BEGIN
  167.     IF ("a" <= ch) & (ch <= "z") OR (430X <= ch) & (ch <= 44FX) THEN
  168.         ch := WCHR(ORD(ch) - 20H);
  169.         res := TRUE
  170.     ELSIF (450X <= ch) & (ch <= 45FX) THEN
  171.         ch := WCHR(ORD(ch) - 50H);
  172.         res := TRUE
  173.     ELSIF ch = 491X THEN
  174.         ch := 490X;
  175.         res := TRUE
  176.     ELSE
  177.         res := FALSE
  178.     END
  179.     RETURN res
  180. END upper;
  181.  
  182.  
  183. PROCEDURE lower* (VAR ch: WCHAR): BOOLEAN;
  184. VAR
  185.     res: BOOLEAN;
  186. BEGIN
  187.     IF ("A" <= ch) & (ch <= "Z") OR (410X <= ch) & (ch <= 42FX) THEN
  188.         ch := WCHR(ORD(ch) + 20H);
  189.         res := TRUE
  190.     ELSIF (400X <= ch) & (ch <= 40FX) THEN
  191.         ch := WCHR(ORD(ch) + 50H);
  192.         res := TRUE
  193.     ELSIF ch = 490X THEN
  194.         ch := 491X;
  195.         res := TRUE
  196.     ELSE
  197.         res := FALSE
  198.     END
  199.     RETURN res
  200. END lower;
  201.  
  202.  
  203. PROCEDURE lowcase* (VAR s: ARRAY OF WCHAR);
  204. VAR
  205.     i: INTEGER;
  206. BEGIN
  207.     i := LENGTH(s) - 1;
  208.     WHILE i >= 0 DO
  209.         IF lower(s[i]) THEN
  210.         END;
  211.         DEC(i)
  212.     END
  213. END lowcase;
  214.  
  215.  
  216. PROCEDURE lowcase8* (VAR s: ARRAY OF CHAR);
  217. VAR
  218.     i: INTEGER;
  219. BEGIN
  220.     i := LENGTH(s) - 1;
  221.     WHILE i >= 0 DO
  222.         IF ("A" <= s[i]) & (s[i] <= "Z") THEN
  223.                 s[i] := CHR(ORD(s[i]) + 20H)
  224.         END;
  225.         DEC(i)
  226.     END
  227. END lowcase8;
  228.  
  229.  
  230. PROCEDURE str2int* (s: ARRAY OF WCHAR; VAR val: INTEGER): BOOLEAN;
  231. VAR
  232.     i, temp: INTEGER;
  233.     res, neg: BOOLEAN;
  234. BEGIN
  235.     temp := 0;
  236.     res := TRUE;
  237.     neg := FALSE;
  238.     i := 0;
  239.     WHILE (s[i] # 0X) & (s[i] = SPACE) DO
  240.         INC(i)
  241.     END;
  242.  
  243.     IF s[i] = "-" THEN
  244.         INC(i);
  245.         neg := TRUE
  246.     ELSIF s[i] = "+" THEN
  247.         INC(i)
  248.     END;
  249.  
  250.     IF isDigit(s[i]) THEN
  251.         REPEAT
  252.             temp := temp*10 + ORD(s[i]) - ORD("0");
  253.             INC(i)
  254.         UNTIL ~isDigit(s[i]);
  255.         IF neg THEN
  256.             temp := -temp
  257.         END;
  258.         val := temp
  259.     ELSE
  260.         res := FALSE
  261.     END
  262.  
  263.     RETURN res
  264. END str2int;
  265.  
  266.  
  267. PROCEDURE getFileName* (path: ARRAY OF CHAR; VAR name: ARRAY OF CHAR; ch: CHAR);
  268. VAR
  269.     i, j: INTEGER;
  270. BEGIN
  271.     j := 0;
  272.     i := LENGTH(path) - 1;
  273.     WHILE (i >= 0) & (path[i] # ch) DO
  274.         name[j] := path[i];
  275.         DEC(i);
  276.         INC(j)
  277.     END;
  278.     name[j] := 0X;
  279.     reverse8(name)
  280. END getFileName;
  281.  
  282.  
  283. PROCEDURE getPath* (fname: ARRAY OF CHAR; VAR path: ARRAY OF CHAR);
  284. VAR
  285.     i, j: INTEGER;
  286. BEGIN
  287.     j := 0;
  288.     i := LENGTH(fname) - 1;
  289.     WHILE (i >= 0) & (fname[i] # SLASH) DO
  290.         DEC(i)
  291.     END;
  292.     path := fname;
  293.     path[i] := 0X
  294. END getPath;
  295.  
  296.  
  297. PROCEDURE lg10* (n: INTEGER): INTEGER;
  298. VAR
  299.     res: INTEGER;
  300. BEGIN
  301.     res := 0;
  302.     WHILE n >= 10 DO
  303.         n := n DIV 10;
  304.         INC(res)
  305.     END
  306.     RETURN res
  307. END lg10;
  308.  
  309.  
  310. PROCEDURE between* (a, b, c: INTEGER): BOOLEAN;
  311.         RETURN (a <= b) & (b <= c)
  312. END between;
  313.  
  314.  
  315. PROCEDURE inString* (c: WCHAR; s: ARRAY OF WCHAR): BOOLEAN;
  316. VAR
  317.         i, L: INTEGER;
  318. BEGIN
  319.         L := LENGTH(s);
  320.         i := 0;
  321.         WHILE (i < L) & (c # s[i]) DO
  322.                 INC(i)
  323.         END
  324.         RETURN i < L
  325. END inString;
  326.  
  327.  
  328. PROCEDURE isWordChar* (c: WCHAR): BOOLEAN;
  329.         RETURN isLetter(c) OR isDigit(c) OR (c = "_")
  330. END isWordChar;
  331.  
  332.  
  333. END Utils.