Subversion Repositories Kolibri OS

(*

    Copyright 2016 Anton Krotov

    This program is free software: you can redistribute it and/or modify

    it under the terms of the GNU Lesser General Public License as published by

    the Free Software Foundation, either version 3 of the License, or

    (at your option) any later version.

    This program is distributed in the hope that it will be useful,

    but WITHOUT ANY WARRANTY; without even the implied warranty of

    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    GNU Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public License

    along with this program.  If not, see .

*)

MODULE API;

IMPORT sys := SYSTEM;

TYPE

  TP* = ARRAY 2 OF INTEGER;

VAR

  Param*: INTEGER;

  sec*            : INTEGER;

  dsec*           : INTEGER;

  stdin*          : INTEGER;

  stdout*         : INTEGER;

  stderr*         : INTEGER;

  dlopen*         : PROCEDURE [cdecl] (filename, flag: INTEGER): INTEGER;

  dlsym*          : PROCEDURE [cdecl] (handle, symbol: INTEGER): INTEGER;

  _malloc*        : PROCEDURE [cdecl] (size: INTEGER): INTEGER;

  free*           : PROCEDURE [cdecl] (ptr: INTEGER);

  fopen*          : PROCEDURE [cdecl] (fname, fmode: INTEGER): INTEGER;

  fclose*, ftell* : PROCEDURE [cdecl] (file: INTEGER): INTEGER;

  fwrite*, fread* : PROCEDURE [cdecl] (buffer, bytes, blocks, file: INTEGER): INTEGER;

  fseek*          : PROCEDURE [cdecl] (file, offset, origin: INTEGER): INTEGER;

  exit*           : PROCEDURE [cdecl] (code: INTEGER);

  strncmp*        : PROCEDURE [cdecl] (str1, str2, n: INTEGER): INTEGER;

  strlen*         : PROCEDURE [cdecl] (str: INTEGER): INTEGER;

  clock_gettime*  : PROCEDURE [cdecl] (clock_id: INTEGER; VAR tp: TP): INTEGER;

PROCEDURE [stdcall] zeromem* (size, adr: INTEGER);

BEGIN

  sys.CODE("578B7D0C8B4D0833C09CFCF3AB9D5F")

END zeromem;

PROCEDURE Align(n, m: INTEGER): INTEGER;

  RETURN n + (m - n MOD m) MOD m

END Align;

PROCEDURE malloc* (Bytes: INTEGER): INTEGER;

VAR res: INTEGER;

BEGIN

  Bytes := Align(Bytes, 4);

  res := _malloc(Bytes);

  IF res # 0 THEN

    zeromem(ASR(Bytes, 2), res)

  END

  RETURN res

END malloc;

PROCEDURE Free* (hMem: INTEGER): INTEGER;

BEGIN

  free(hMem)

  RETURN 0

END Free;

PROCEDURE _NEW*(size: INTEGER): INTEGER;

  RETURN malloc(size)

END _NEW;

PROCEDURE _DISPOSE*(p: INTEGER): INTEGER;

  RETURN Free(p)

END _DISPOSE;

PROCEDURE ConOut(str, length: INTEGER);

BEGIN

  length := fwrite(str, length, 1, stdout)

END ConOut;

PROCEDURE DebugMsg* (lpText, lpCaption: INTEGER);

VAR eol: ARRAY 3 OF CHAR;

BEGIN

  eol[0] := 0DX;

  eol[1] := 0AX;

  eol[2] := 00X;

  ConOut(sys.ADR(eol), 2);

  ConOut(lpCaption, strlen(lpCaption));

  ConOut(sys.ADR(":"), 1);

  ConOut(sys.ADR(eol), 2);

  ConOut(lpText, strlen(lpText));

  ConOut(sys.ADR(eol), 2);

END DebugMsg;

PROCEDURE ExitProcess* (code: INTEGER);

BEGIN

  exit(code)

END ExitProcess;

PROCEDURE ExitThread* (code: INTEGER);

BEGIN

  exit(code)

END ExitThread;

PROCEDURE GetProc(name: ARRAY OF CHAR; hMOD, adr: INTEGER);

VAR H: INTEGER;

BEGIN

  H := dlsym(hMOD, sys.ADR(name[0]));

  ASSERT(H # 0);

  sys.PUT(adr, H);

END GetProc;

PROCEDURE init* (esp: INTEGER);

VAR lib, proc: INTEGER;

BEGIN

  Param := esp;

  sys.MOVE(Param + 12, sys.ADR(dlopen), 4);

  sys.MOVE(Param + 16, sys.ADR(dlsym),  4);

  sys.MOVE(Param + 20, sys.ADR(exit),   4);

  sys.MOVE(Param + 24, sys.ADR(stdin),  4);

  sys.MOVE(Param + 28, sys.ADR(stdout), 4);

  sys.MOVE(Param + 32, sys.ADR(stderr), 4);

  sys.MOVE(Param + 36, sys.ADR(_malloc), 4);

  sys.MOVE(Param + 40, sys.ADR(free),   4);

  sys.MOVE(Param + 44, sys.ADR(fopen),  4);

  sys.MOVE(Param + 48, sys.ADR(fclose), 4);

  sys.MOVE(Param + 52, sys.ADR(fwrite), 4);

  sys.MOVE(Param + 56, sys.ADR(fread),  4);

  sys.MOVE(Param + 60, sys.ADR(fseek),  4);

  sys.MOVE(Param + 64, sys.ADR(ftell),  4);

  lib := dlopen(sys.ADR("libc.so.6"), 1);

  ASSERT(lib # 0);

  GetProc("strncmp", lib, sys.ADR(strncmp));

  GetProc("strlen", lib, sys.ADR(strlen));

  lib := dlopen(sys.ADR("librt.so.1"), 1);

  ASSERT(lib # 0);

  GetProc("clock_gettime", lib, sys.ADR(clock_gettime));

END init;

END API.