Subversion Repositories Kolibri OS

Rev

Rev 8097 | Rev 9177 | 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-2021, Anton Krotov
  5.     All rights reserved.
  6. *)
  7.  
  8. MODULE UTILS;
  9.  
  10. IMPORT HOST;
  11.  
  12.  
  13. CONST
  14.  
  15.     slash* = HOST.slash;
  16.     eol* = HOST.eol;
  17.  
  18.     bit_depth* = HOST.bit_depth;
  19.     maxint* = HOST.maxint;
  20.     minint* = HOST.minint;
  21.  
  22.     min32* = -2147483647-1;
  23.     max32* =  2147483647;
  24.  
  25.     vMajor* = 1;
  26.     vMinor* = 52;
  27.     Date* = "07-may-2021";
  28.  
  29.     FILE_EXT* = ".ob07";
  30.     RTL_NAME* = "RTL";
  31.  
  32.     MAX_GLOBAL_SIZE* = 1600000000;
  33.  
  34.  
  35. VAR
  36.  
  37.     time*: INTEGER;
  38.  
  39.     maxreal*: REAL;
  40.  
  41.     target*:
  42.  
  43.       RECORD
  44.  
  45.           bit_depth*,
  46.           maxInt*,
  47.           minInt*,
  48.           maxSet*,
  49.           maxHex*:    INTEGER;
  50.  
  51.           maxReal*:   REAL
  52.  
  53.       END;
  54.  
  55.     bit_diff*: INTEGER;
  56.  
  57.  
  58. PROCEDURE FileRead* (F: INTEGER; VAR Buffer: ARRAY OF CHAR; bytes: INTEGER): INTEGER;
  59.     RETURN HOST.FileRead(F, Buffer, bytes)
  60. END FileRead;
  61.  
  62.  
  63. PROCEDURE FileWrite* (F: INTEGER; Buffer: ARRAY OF BYTE; bytes: INTEGER): INTEGER;
  64.     RETURN HOST.FileWrite(F, Buffer, bytes)
  65. END FileWrite;
  66.  
  67.  
  68. PROCEDURE FileCreate* (FName: ARRAY OF CHAR): INTEGER;
  69.     RETURN HOST.FileCreate(FName)
  70. END FileCreate;
  71.  
  72.  
  73. PROCEDURE FileClose* (F: INTEGER);
  74. BEGIN
  75.     HOST.FileClose(F)
  76. END FileClose;
  77.  
  78.  
  79. PROCEDURE FileOpen* (FName: ARRAY OF CHAR): INTEGER;
  80.     RETURN HOST.FileOpen(FName)
  81. END FileOpen;
  82.  
  83.  
  84. PROCEDURE chmod* (FName: ARRAY OF CHAR);
  85. BEGIN
  86.     HOST.chmod(FName)
  87. END chmod;
  88.  
  89.  
  90. PROCEDURE GetArg* (i: INTEGER; VAR str: ARRAY OF CHAR);
  91. BEGIN
  92.     HOST.GetArg(i, str)
  93. END GetArg;
  94.  
  95.  
  96. PROCEDURE Exit* (code: INTEGER);
  97. BEGIN
  98.     HOST.ExitProcess(code)
  99. END Exit;
  100.  
  101.  
  102. PROCEDURE GetTickCount* (): INTEGER;
  103.     RETURN HOST.GetTickCount()
  104. END GetTickCount;
  105.  
  106.  
  107. PROCEDURE OutChar* (c: CHAR);
  108. BEGIN
  109.     HOST.OutChar(c)
  110. END OutChar;
  111.  
  112.  
  113. PROCEDURE splitf* (x: REAL; VAR a, b: INTEGER): INTEGER;
  114.     RETURN HOST.splitf(x, a, b)
  115. END splitf;
  116.  
  117.  
  118. PROCEDURE d2s* (x: REAL): INTEGER;
  119.     RETURN HOST.d2s(x)
  120. END d2s;
  121.  
  122.  
  123. PROCEDURE isRelative* (path: ARRAY OF CHAR): BOOLEAN;
  124.     RETURN HOST.isRelative(path)
  125. END isRelative;
  126.  
  127.  
  128. PROCEDURE GetCurrentDirectory* (VAR path: ARRAY OF CHAR);
  129. BEGIN
  130.     HOST.GetCurrentDirectory(path)
  131. END GetCurrentDirectory;
  132.  
  133.  
  134. PROCEDURE UnixTime* (): INTEGER;
  135.     RETURN HOST.UnixTime()
  136. END UnixTime;
  137.  
  138.  
  139. PROCEDURE SetBitDepth* (BitDepth: INTEGER; Double: BOOLEAN);
  140. BEGIN
  141.     ASSERT((BitDepth = 16) OR (BitDepth = 32) OR (BitDepth = 64));
  142.     bit_diff := bit_depth - BitDepth;
  143.     ASSERT(bit_diff >= 0);
  144.  
  145.     target.bit_depth := BitDepth;
  146.     target.maxSet    := BitDepth - 1;
  147.     target.maxHex    := BitDepth DIV 4;
  148.     target.minInt    := ASR(minint, bit_diff);
  149.     target.maxInt    := ASR(maxint, bit_diff);
  150.  
  151.     IF Double THEN
  152.         target.maxReal := maxreal
  153.     ELSE
  154.         target.maxReal := 1.9;
  155.         PACK(target.maxReal, 127)
  156.     END
  157. END SetBitDepth;
  158.  
  159.  
  160. PROCEDURE Byte* (n: INTEGER; idx: INTEGER): BYTE;
  161.     RETURN ASR(n, 8 * idx) MOD 256
  162. END Byte;
  163.  
  164.  
  165. PROCEDURE Align* (VAR bytes: INTEGER; align: INTEGER): BOOLEAN;
  166. BEGIN
  167.     INC(bytes, (-bytes) MOD align)
  168.     RETURN bytes >= 0
  169. END Align;
  170.  
  171.  
  172. PROCEDURE Long* (value: INTEGER): INTEGER;
  173.     RETURN ASR(LSL(value, bit_diff), bit_diff)
  174. END Long;
  175.  
  176.  
  177. PROCEDURE Short* (value: INTEGER): INTEGER;
  178.     RETURN LSR(LSL(value, bit_diff), bit_diff)
  179. END Short;
  180.  
  181.  
  182. PROCEDURE Log2* (x: INTEGER): INTEGER;
  183. VAR
  184.     n: INTEGER;
  185.  
  186. BEGIN
  187.     n := 0;
  188.     WHILE ~ODD(x) DO
  189.         x := x DIV 2;
  190.         INC(n)
  191.     END;
  192.  
  193.     IF x # 1 THEN
  194.         n := -1
  195.     END
  196.  
  197.     RETURN n
  198. END Log2;
  199.  
  200.  
  201. PROCEDURE hexdgt* (n: BYTE): BYTE;
  202. BEGIN
  203.     IF n < 10 THEN
  204.         INC(n, ORD("0"))
  205.     ELSE
  206.         INC(n, ORD("A") - 10)
  207.     END
  208.  
  209.     RETURN n
  210. END hexdgt;
  211.  
  212.  
  213. BEGIN
  214.     time := HOST.GetTickCount();
  215.     maxreal := HOST.maxreal
  216. END UTILS.