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