Subversion Repositories Kolibri OS

Rev

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

  1. (*
  2.     Copyright 2021 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. BEGIN
  36.     WHILE n > 0 DO
  37.         SYSTEM.GET(s1, c1);
  38.         SYSTEM.GET(s2, c2);
  39.         INC(s1, 2);
  40.         INC(s2, 2);
  41.         IF c1 = c2 THEN
  42.             DEC(n)
  43.         ELSE
  44.             n := 0
  45.         END
  46.     END
  47.     RETURN c1 = c2
  48. END streq;
  49.  
  50.  
  51. PROCEDURE append* (VAR s1: ARRAY OF WCHAR; s2: ARRAY OF WCHAR);
  52. VAR
  53.     n1, n2, i, j: INTEGER;
  54. BEGIN
  55.     n1 := LENGTH(s1);
  56.     n2 := LENGTH(s2);
  57.  
  58.     ASSERT(n1 + n2 < LEN(s1));
  59.  
  60.     i := 0;
  61.     j := n1;
  62.     WHILE i < n2 DO
  63.         s1[j] := s2[i];
  64.         INC(i);
  65.         INC(j)
  66.     END;
  67.  
  68.     s1[j] := 0X
  69. END append;
  70.  
  71.  
  72. PROCEDURE append8* (VAR s1: ARRAY OF CHAR; s2: ARRAY OF CHAR);
  73. VAR
  74.     n1, n2, i, j: INTEGER;
  75. BEGIN
  76.     n1 := LENGTH(s1);
  77.     n2 := LENGTH(s2);
  78.  
  79.     ASSERT(n1 + n2 < LEN(s1));
  80.  
  81.     i := 0;
  82.     j := n1;
  83.     WHILE i < n2 DO
  84.         s1[j] := s2[i];
  85.         INC(i);
  86.         INC(j)
  87.     END;
  88.  
  89.     s1[j] := 0X
  90. END append8;
  91.  
  92.  
  93. PROCEDURE reverse* (VAR s: ARRAY OF WCHAR);
  94. VAR
  95.     ch: WCHAR;
  96.     i, j: INTEGER;
  97. BEGIN
  98.     i := 0;
  99.     j := LENGTH(s) - 1;
  100.     WHILE i < j DO
  101.         ch := s[i];
  102.         s[i] := s[j];
  103.         s[j] := ch;
  104.         INC(i);
  105.         DEC(j)
  106.     END
  107. END reverse;
  108.  
  109.  
  110. PROCEDURE reverse8* (VAR s: ARRAY OF CHAR);
  111. VAR
  112.     ch: CHAR;
  113.     i, j: INTEGER;
  114. BEGIN
  115.     i := 0;
  116.     j := LENGTH(s) - 1;
  117.     WHILE i < j DO
  118.         ch := s[i];
  119.         s[i] := s[j];
  120.         s[j] := ch;
  121.         INC(i);
  122.         DEC(j)
  123.     END
  124. END reverse8;
  125.  
  126.  
  127. PROCEDURE int2str* (val: INTEGER; VAR s: ARRAY OF WCHAR);
  128. VAR
  129.     i: INTEGER;
  130. BEGIN
  131.     i := 0;
  132.     REPEAT
  133.         s[i] := WCHR(ORD("0") + val MOD 10);
  134.         INC(i);
  135.         val := val DIV 10
  136.     UNTIL val = 0;
  137.     s[i] := 0X;
  138.     reverse(s)
  139. END int2str;
  140.  
  141.  
  142. PROCEDURE isDigit* (ch: WCHAR): BOOLEAN;
  143.     RETURN ("0" <= ch) & (ch <= "9")
  144. END isDigit;
  145.  
  146.  
  147. PROCEDURE isHex* (ch: WCHAR): BOOLEAN;
  148.     RETURN ("0" <= ch) & (ch <= "9") OR ("A" <= ch) & (ch <= "F")
  149. END isHex;
  150.  
  151.  
  152. PROCEDURE isLetter* (ch: WCHAR): BOOLEAN;
  153.     RETURN ("a" <= ch) & (ch <= "z") OR ("A" <= ch) & (ch <= "Z")
  154. END isLetter;
  155.  
  156.  
  157. PROCEDURE cap* (VAR ch: WCHAR): BOOLEAN;
  158. VAR
  159.     res: BOOLEAN;
  160. BEGIN
  161.     IF ("a" <= ch) & (ch <= "z") THEN
  162.         ch := WCHR(ORD(ch) - (ORD("z") - ORD("Z")));
  163.         res := TRUE
  164.     ELSIF (430H <= ORD(ch)) & (ORD(ch) <= 44FH) THEN
  165.         ch := WCHR(ORD(ch) - 20H);
  166.         res := TRUE
  167.     ELSIF (450H <= ORD(ch)) & (ORD(ch) <= 45FH) THEN
  168.         ch := WCHR(ORD(ch) - 50H);
  169.         res := TRUE
  170.     ELSIF ch = 491X THEN
  171.         ch := 490X;
  172.         res := TRUE
  173.     ELSE
  174.         res := FALSE
  175.     END
  176.     RETURN res
  177. END cap;
  178.  
  179.  
  180. PROCEDURE cap8 (VAR ch: CHAR): BOOLEAN;
  181. VAR
  182.     res: BOOLEAN;
  183. BEGIN
  184.     IF ("a" <= ch) & (ch <= "z") THEN
  185.         ch := CHR(ORD(ch) - (ORD("z") - ORD("Z")));
  186.         res := TRUE
  187.     ELSE
  188.         res := FALSE
  189.     END
  190.     RETURN res
  191. END cap8;
  192.  
  193.  
  194. PROCEDURE upcase* (VAR s: ARRAY OF CHAR);
  195. VAR
  196.     i: INTEGER;
  197. BEGIN
  198.     i := LENGTH(s) - 1;
  199.     WHILE i >= 0 DO
  200.         IF cap8(s[i]) THEN
  201.         END;
  202.         DEC(i)
  203.     END;
  204. END upcase;
  205.  
  206.  
  207. PROCEDURE upcase16* (VAR s: ARRAY OF WCHAR);
  208. VAR
  209.     i: INTEGER;
  210. BEGIN
  211.     i := LENGTH(s) - 1;
  212.     WHILE i >= 0 DO
  213.         IF cap(s[i]) THEN
  214.         END;
  215.         DEC(i)
  216.     END
  217. END upcase16;
  218.  
  219.  
  220. PROCEDURE low* (VAR ch: WCHAR): BOOLEAN;
  221. VAR
  222.     res: BOOLEAN;
  223. BEGIN
  224.     IF ("A" <= ch) & (ch <= "Z") THEN
  225.         ch := WCHR(ORD(ch) + (ORD("z") - ORD("Z")));
  226.         res := TRUE
  227.     ELSIF (410H <= ORD(ch)) & (ORD(ch) <= 42FH) THEN
  228.         ch := WCHR(ORD(ch) + 20H);
  229.         res := TRUE
  230.     ELSIF (400H <= ORD(ch)) & (ORD(ch) <= 40FH) THEN
  231.         ch := WCHR(ORD(ch) + 50H);
  232.         res := TRUE
  233.     ELSIF ch = 490X THEN
  234.         ch := 491X;
  235.         res := TRUE
  236.     ELSE
  237.         res := FALSE
  238.     END
  239.     RETURN res
  240. END low;
  241.  
  242.  
  243. PROCEDURE str2int* (s: ARRAY OF WCHAR; VAR val: INTEGER): BOOLEAN;
  244. VAR
  245.     i, temp: INTEGER;
  246.     res, neg: BOOLEAN;
  247. BEGIN
  248.     temp := 0;
  249.     res := TRUE;
  250.     neg := FALSE;
  251.     i := 0;
  252.     WHILE (s[i] # 0X) & (s[i] = SPACE) DO
  253.         INC(i)
  254.     END;
  255.  
  256.     IF s[i] = "-" THEN
  257.         INC(i);
  258.         neg := TRUE
  259.     ELSIF s[i] = "+" THEN
  260.         INC(i)
  261.     END;
  262.  
  263.     IF isDigit(s[i]) THEN
  264.         REPEAT
  265.             temp := temp * 10;
  266.             temp := temp + (ORD(s[i]) - ORD("0"));
  267.             INC(i)
  268.         UNTIL ~isDigit(s[i]);
  269.         IF neg THEN
  270.             temp := -temp
  271.         END;
  272.         val := temp
  273.     ELSE
  274.         res := FALSE
  275.     END
  276.  
  277.     RETURN res
  278. END str2int;
  279.  
  280.  
  281. PROCEDURE getFileName* (path: ARRAY OF CHAR; VAR name: ARRAY OF CHAR; ch: CHAR);
  282. VAR
  283.     i, j: INTEGER;
  284. BEGIN
  285.     j := 0;
  286.     i := LENGTH(path) - 1;
  287.     WHILE (i >= 0) & (path[i] # ch) DO
  288.         name[j] := path[i];
  289.         DEC(i);
  290.         INC(j)
  291.     END;
  292.     name[j] := 0X;
  293.     reverse8(name)
  294. END getFileName;
  295.  
  296.  
  297. PROCEDURE getPath* (fname: ARRAY OF CHAR; VAR path: ARRAY OF CHAR);
  298. VAR
  299.     i, j: INTEGER;
  300. BEGIN
  301.     j := 0;
  302.     i := LENGTH(fname) - 1;
  303.     WHILE (i >= 0) & (fname[i] # SLASH) DO
  304.         DEC(i)
  305.     END;
  306.     path := fname;
  307.     path[i] := 0X
  308. END getPath;
  309.  
  310.  
  311. PROCEDURE lg10* (n: INTEGER): INTEGER;
  312. VAR
  313.     res: INTEGER;
  314. BEGIN
  315.     res := 0;
  316.     WHILE n >= 10 DO
  317.         n := n DIV 10;
  318.         INC(res)
  319.     END
  320.     RETURN res
  321. END lg10;
  322.  
  323.  
  324. PROCEDURE sgn* (x: INTEGER): INTEGER;
  325. BEGIN
  326.     IF x > 0 THEN
  327.         x := 1
  328.     ELSIF x < 0 THEN
  329.         x := -1
  330.     ELSE
  331.         x := 0
  332.     END
  333.     RETURN x
  334. END sgn;
  335.  
  336.  
  337. PROCEDURE ptr2str* (ptr: INTEGER; VAR s: ARRAY OF CHAR);
  338. VAR
  339.     i, n: INTEGER;
  340. BEGIN
  341.     i := -1;
  342.     n := LEN(s) - 1;
  343.     REPEAT
  344.         INC(i);
  345.         SYSTEM.GET(ptr, s[i]);
  346.         INC(ptr)
  347.     UNTIL (i = n) OR (s[i] = 0X);
  348.     s[i] := 0X
  349. END ptr2str;
  350.  
  351.  
  352. PROCEDURE between* (a, b, c: INTEGER): BOOLEAN;
  353.         RETURN (a <= b) & (b <= c)
  354. END between;
  355.  
  356.  
  357. END Utils.