Subversion Repositories Kolibri OS

Rev

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

  1. (*
  2.     Copyright 2016 Anton Krotov
  3.  
  4.     This program is free software: you can redistribute it and/or modify
  5.     it under the terms of the GNU Lesser General Public License as published by
  6.     the Free Software Foundation, either version 3 of the License, or
  7.     (at your option) any later version.
  8.  
  9.     This program is distributed in the hope that it will be useful,
  10.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12.     GNU Lesser General Public License for more details.
  13.  
  14.     You should have received a copy of the GNU Lesser General Public License
  15.     along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16. *)
  17.  
  18. MODULE API;
  19.  
  20. IMPORT sys := SYSTEM;
  21.  
  22. TYPE
  23.  
  24.   TP* = ARRAY 2 OF INTEGER;
  25.  
  26. VAR
  27.  
  28.   Param*: INTEGER;
  29.  
  30.   sec*            : INTEGER;
  31.   dsec*           : INTEGER;
  32.   stdin*          : INTEGER;
  33.   stdout*         : INTEGER;
  34.   stderr*         : INTEGER;
  35.   dlopen*         : PROCEDURE [cdecl] (filename, flag: INTEGER): INTEGER;
  36.   dlsym*          : PROCEDURE [cdecl] (handle, symbol: INTEGER): INTEGER;
  37.   _malloc*        : PROCEDURE [cdecl] (size: INTEGER): INTEGER;
  38.   free*           : PROCEDURE [cdecl] (ptr: INTEGER);
  39.   fopen*          : PROCEDURE [cdecl] (fname, fmode: INTEGER): INTEGER;
  40.   fclose*, ftell* : PROCEDURE [cdecl] (file: INTEGER): INTEGER;
  41.   fwrite*, fread* : PROCEDURE [cdecl] (buffer, bytes, blocks, file: INTEGER): INTEGER;
  42.   fseek*          : PROCEDURE [cdecl] (file, offset, origin: INTEGER): INTEGER;
  43.   exit*           : PROCEDURE [cdecl] (code: INTEGER);
  44.   strncmp*        : PROCEDURE [cdecl] (str1, str2, n: INTEGER): INTEGER;
  45.   strlen*         : PROCEDURE [cdecl] (str: INTEGER): INTEGER;
  46.   clock_gettime*  : PROCEDURE [cdecl] (clock_id: INTEGER; VAR tp: TP): INTEGER;
  47.  
  48. PROCEDURE [stdcall] zeromem* (size, adr: INTEGER);
  49. BEGIN
  50.   sys.CODE("578B7D0C8B4D0833C09CFCF3AB9D5F")
  51. END zeromem;
  52.  
  53. PROCEDURE Align(n, m: INTEGER): INTEGER;
  54.   RETURN n + (m - n MOD m) MOD m
  55. END Align;
  56.  
  57. PROCEDURE malloc* (Bytes: INTEGER): INTEGER;
  58. VAR res: INTEGER;
  59. BEGIN
  60.   Bytes := Align(Bytes, 4);
  61.   res := _malloc(Bytes);
  62.   IF res # 0 THEN
  63.     zeromem(ASR(Bytes, 2), res)
  64.   END
  65.   RETURN res
  66. END malloc;
  67.  
  68. PROCEDURE Free* (hMem: INTEGER): INTEGER;
  69. BEGIN
  70.   free(hMem)
  71.   RETURN 0
  72. END Free;
  73.  
  74. PROCEDURE _NEW*(size: INTEGER): INTEGER;
  75.   RETURN malloc(size)
  76. END _NEW;
  77.  
  78. PROCEDURE _DISPOSE*(p: INTEGER): INTEGER;
  79.   RETURN Free(p)
  80. END _DISPOSE;
  81.  
  82. PROCEDURE ConOut(str, length: INTEGER);
  83. BEGIN
  84.   length := fwrite(str, length, 1, stdout)
  85. END ConOut;
  86.  
  87. PROCEDURE DebugMsg* (lpText, lpCaption: INTEGER);
  88. VAR eol: ARRAY 3 OF CHAR;
  89. BEGIN
  90.   eol[0] := 0DX;
  91.   eol[1] := 0AX;
  92.   eol[2] := 00X;
  93.   ConOut(sys.ADR(eol), 2);
  94.   ConOut(lpCaption, strlen(lpCaption));
  95.   ConOut(sys.ADR(":"), 1);
  96.   ConOut(sys.ADR(eol), 2);
  97.   ConOut(lpText, strlen(lpText));
  98.   ConOut(sys.ADR(eol), 2);
  99. END DebugMsg;
  100.  
  101. PROCEDURE ExitProcess* (code: INTEGER);
  102. BEGIN
  103.   exit(code)
  104. END ExitProcess;
  105.  
  106. PROCEDURE GetProc(name: ARRAY OF CHAR; hMOD, adr: INTEGER);
  107. VAR H: INTEGER;
  108. BEGIN
  109.   H := dlsym(hMOD, sys.ADR(name[0]));
  110.   ASSERT(H # 0);
  111.   sys.PUT(adr, H);
  112. END GetProc;
  113.  
  114. PROCEDURE init* (esp: INTEGER);
  115. VAR lib, proc: INTEGER;
  116. BEGIN
  117.   Param := esp;
  118.   sys.MOVE(Param + 12, sys.ADR(dlopen), 4);
  119.   sys.MOVE(Param + 16, sys.ADR(dlsym),  4);
  120.   sys.MOVE(Param + 20, sys.ADR(exit),   4);
  121.   sys.MOVE(Param + 24, sys.ADR(stdin),  4);
  122.   sys.MOVE(Param + 28, sys.ADR(stdout), 4);
  123.   sys.MOVE(Param + 32, sys.ADR(stderr), 4);
  124.   sys.MOVE(Param + 36, sys.ADR(_malloc), 4);
  125.   sys.MOVE(Param + 40, sys.ADR(free),   4);
  126.   sys.MOVE(Param + 44, sys.ADR(fopen),  4);
  127.   sys.MOVE(Param + 48, sys.ADR(fclose), 4);
  128.   sys.MOVE(Param + 52, sys.ADR(fwrite), 4);
  129.   sys.MOVE(Param + 56, sys.ADR(fread),  4);
  130.   sys.MOVE(Param + 60, sys.ADR(fseek),  4);
  131.   sys.MOVE(Param + 64, sys.ADR(ftell),  4);
  132.  
  133.   lib := dlopen(sys.ADR("libc.so.6"), 1);
  134.   ASSERT(lib # 0);
  135.   GetProc("strncmp", lib, sys.ADR(strncmp));
  136.   GetProc("strlen", lib, sys.ADR(strlen));
  137.  
  138.   lib := dlopen(sys.ADR("librt.so.1"), 1);
  139.   ASSERT(lib # 0);
  140.   GetProc("clock_gettime", lib, sys.ADR(clock_gettime));
  141. END init;
  142.  
  143. END API.