Subversion Repositories Kolibri OS

Rev

Rev 7107 | Go to most recent revision | Show entire file | Regard whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 7107 Rev 7597
Line 1... Line 1...
1 
(*
 1 
(*
2 
    Copyright 2016 Anton Krotov
 2 
    BSD 2-Clause License
Line 3... Line -...
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
 3 
 
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
 4 
    Copyright (c) 2019, Anton Krotov
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 .
 5 
    All rights reserved.
Line 16... Line 6...
16 
*)
 6 
*)
Line 17... Line 7...
17 
 
 7 
 
- 
 
 8 
MODULE API;
- 
 
 9 
 
- 
 
 10 
IMPORT SYSTEM;
- 
 
 11 
 
- 
 
 12 
 
- 
 
 13 
CONST
Line 18... Line 14...
18 
MODULE API;
 14 
 
Line 19... Line 15...
19 
 
 15 
    BASE_ADR = 08048000H;
Line -... Line 16...
- 
 
 16 
 
20 
IMPORT sys := SYSTEM;
 17 
 
Line -... Line 18...
- 
 
 18 
TYPE
21 
 
 19 
 
Line 22... Line 20...
22 
TYPE
 20 
    TP* = ARRAY 2 OF INTEGER;
- 
 
 21 
 
23 
 
 22 
 
24 
  TP* = ARRAY 2 OF INTEGER;
 23 
VAR
- 
 
 24 
 
25 
 
 25 
    eol*:  ARRAY 2 OF CHAR;
- 
 
 26 
    base*, MainParam*: INTEGER;
26 
VAR
 27 
 
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 
 
 - 
 
Line 48... Line 28...
48 
PROCEDURE [stdcall] zeromem* (size, adr: INTEGER);
 28 
    libc*, librt*: INTEGER;
- 
 
 29 
 
- 
 
 30 
    dlopen*        : PROCEDURE [linux] (filename, flag: INTEGER): INTEGER;
- 
 
 31 
    dlsym*         : PROCEDURE [linux] (handle, symbol: INTEGER): INTEGER;
- 
 
 32 
 
- 
 
 33 
    stdout*,
- 
 
 34 
    stdin*,
- 
 
 35 
    stderr*        : INTEGER;
- 
 
 36 
 
- 
 
 37 
    malloc*        : PROCEDURE [linux] (size: INTEGER): INTEGER;
- 
 
 38 
    free*          : PROCEDURE [linux] (ptr: INTEGER);
- 
 
 39 
    _exit*         : PROCEDURE [linux] (code: INTEGER);
- 
 
 40 
    puts*          : PROCEDURE [linux] (pStr: INTEGER);
- 
 
 41 
    fwrite*,
- 
 
 42 
    fread*         : PROCEDURE [linux] (buffer, bytes, blocks, file: INTEGER): INTEGER;
49 
BEGIN
 43 
    fopen*         : PROCEDURE [linux] (fname, fmode: INTEGER): INTEGER;
- 
 
 44 
    fclose*        : PROCEDURE [linux] (file: INTEGER): INTEGER;
50 
  sys.CODE("578B7D0C8B4D0833C09CFCF3AB9D5F")
 45 
 
51 
END zeromem;
 - 
 
52 
 
 - 
 
53 
PROCEDURE Align(n, m: INTEGER): INTEGER;
 - 
 
54 
  RETURN n + (m - n MOD m) MOD m
 46 
    clock_gettime* : PROCEDURE [linux] (clock_id: INTEGER; VAR tp: TP): INTEGER;
55 
END Align;
 - 
 
56 
 
 - 
 
57 
PROCEDURE malloc* (Bytes: INTEGER): INTEGER;
 47 
    time*          : PROCEDURE [linux] (ptr: INTEGER): INTEGER;
Line -... Line 48...
- 
 
 48 
 
58 
VAR res: INTEGER;
 49 
 
59 
BEGIN
 50 
PROCEDURE putc* (c: CHAR);
60 
  Bytes := Align(Bytes, 4);
 51 
VAR
61 
  res := _malloc(Bytes);
 52 
    res: INTEGER;
62 
  IF res # 0 THEN
 53 
 
- 
 
 54 
BEGIN
Line 63... Line 55...
63 
    zeromem(ASR(Bytes, 2), res)
 55 
    res := fwrite(SYSTEM.ADR(c), 1, 1, stdout)
- 
 
 56 
END putc;
- 
 
 57 
 
- 
 
 58 
 
- 
 
 59 
PROCEDURE DebugMsg* (lpText, lpCaption: INTEGER);
64 
  END
 60 
BEGIN
- 
 
 61 
    puts(lpCaption);
- 
 
 62 
    puts(lpText)
- 
 
 63 
END DebugMsg;
- 
 
 64 
 
- 
 
 65 
 
- 
 
 66 
PROCEDURE _NEW* (size: INTEGER): INTEGER;
- 
 
 67 
VAR
- 
 
 68 
    res, ptr, words: INTEGER;
- 
 
 69 
 
- 
 
 70 
BEGIN
- 
 
 71 
    res := malloc(size);
65 
  RETURN res
 72 
    IF res # 0 THEN
Line -... Line 73...
- 
 
 73 
        ptr := res;
66 
END malloc;
 74 
        words := size DIV SYSTEM.SIZE(INTEGER);
- 
 
 75 
        WHILE words > 0 DO
67 
 
 76 
            SYSTEM.PUT(ptr, 0);
- 
 
 77 
            INC(ptr, SYSTEM.SIZE(INTEGER));
68 
PROCEDURE Free* (hMem: INTEGER): INTEGER;
 78 
            DEC(words)
Line 69... Line -...
69 
BEGIN
 - 
 
70 
  free(hMem)
 - 
 
71 
  RETURN 0
 - 
 
72 
END Free;
 - 
 
Line 73... Line 79...
73 
 
 79 
        END
- 
 
 80 
    END
74 
PROCEDURE _NEW*(size: INTEGER): INTEGER;
 81 
 
75 
  RETURN malloc(size)
 82 
    RETURN res
- 
 
 83 
END _NEW;
- 
 
 84 
 
- 
 
 85 
 
- 
 
 86 
PROCEDURE _DISPOSE* (p: INTEGER): INTEGER;
- 
 
 87 
BEGIN
- 
 
 88 
    free(p)
- 
 
 89 
    RETURN 0
- 
 
 90 
END _DISPOSE;
- 
 
 91 
 
- 
 
 92 
 
76 
END _NEW;
 93 
PROCEDURE GetProcAdr (lib: INTEGER; name: ARRAY OF CHAR; VarAdr: INTEGER);
77 
 
 94 
VAR
78 
PROCEDURE _DISPOSE*(p: INTEGER): INTEGER;
 95 
    sym: INTEGER;
- 
 
 96 
BEGIN
79 
  RETURN Free(p)
 97 
    sym := dlsym(lib, SYSTEM.ADR(name[0]));
- 
 
 98 
    ASSERT(sym # 0);
- 
 
 99 
    SYSTEM.PUT(VarAdr, sym)
- 
 
 100 
END GetProcAdr;
- 
 
 101 
 
80 
END _DISPOSE;
 102 
 
- 
 
 103 
PROCEDURE init* (sp, code: INTEGER);
- 
 
 104 
BEGIN
- 
 
 105 
    SYSTEM.GET(code - 1000H - SYSTEM.SIZE(INTEGER) * 2, dlopen);
- 
 
 106 
    SYSTEM.GET(code - 1000H - SYSTEM.SIZE(INTEGER),     dlsym);
81 
 
 107 
    MainParam := sp;
- 
 
 108 
    base := BASE_ADR;
- 
 
 109 
    eol := 0AX;
- 
 
 110 
 
82 
PROCEDURE ConOut(str, length: INTEGER);
 111 
    libc := dlopen(SYSTEM.SADR("libc.so.6"), 1);
83 
BEGIN
 112 
    GetProcAdr(libc, "malloc", SYSTEM.ADR(malloc));
- 
 
 113 
    GetProcAdr(libc, "free", SYSTEM.ADR(free));
84 
  length := fwrite(str, length, 1, stdout)
 114 
    GetProcAdr(libc, "exit", SYSTEM.ADR(_exit));
- 
 
 115 
    GetProcAdr(libc, "stdout", SYSTEM.ADR(stdout));
85 
END ConOut;
 116 
    GetProcAdr(libc, "stdin", SYSTEM.ADR(stdin));
- 
 
 117 
    GetProcAdr(libc, "stderr", SYSTEM.ADR(stderr));
Line 86... Line 118...
86 
 
 118 
    SYSTEM.GET(stdout - SYSTEM.SIZE(INTEGER), stdout);
87 
PROCEDURE DebugMsg* (lpText, lpCaption: INTEGER);
 119 
    SYSTEM.GET(stdin  - SYSTEM.SIZE(INTEGER), stdin);
88 
VAR eol: ARRAY 3 OF CHAR;
 120 
    SYSTEM.GET(stderr - SYSTEM.SIZE(INTEGER), stderr);
89 
BEGIN
 121 
    GetProcAdr(libc, "puts", SYSTEM.ADR(puts));
- 
 
 122 
    GetProcAdr(libc, "fwrite", SYSTEM.ADR(fwrite));
Line 90... Line 123...
90 
  eol[0] := 0DX;
 123 
    GetProcAdr(libc, "fread", SYSTEM.ADR(fread));
91 
  eol[1] := 0AX;
 124 
    GetProcAdr(libc, "fopen", SYSTEM.ADR(fopen));
92 
  eol[2] := 00X;
 125 
    GetProcAdr(libc, "fclose", SYSTEM.ADR(fclose));
93 
  ConOut(sys.ADR(eol), 2);
 126 
    GetProcAdr(libc, "time", SYSTEM.ADR(time));
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 ExitThread* (code: INTEGER);
 - 
 
107 
BEGIN
 - 
 
108 
  exit(code)
 - 
 
109 
END ExitThread;
 - 
 
110 
 
 - 
 
111 
PROCEDURE GetProc(name: ARRAY OF CHAR; hMOD, adr: INTEGER);
 - 
 
112 
VAR H: INTEGER;
 - 
 
113 
BEGIN
 - 
 
114 
  H := dlsym(hMOD, sys.ADR(name[0]));
 - 
 
115 
  ASSERT(H # 0);
 - 
 
116 
  sys.PUT(adr, H);
 - 
 
117 
END GetProc;
 - 
 
118 
 
 - 
 
119 
PROCEDURE init* (esp: INTEGER);
 - 
 
120 
VAR lib, proc: INTEGER;
 - 
 
121 
BEGIN
 - 
 
122 
  Param := esp;
 - 
 
123 
  sys.MOVE(Param + 12, sys.ADR(dlopen), 4);
 - 
 
124 
  sys.MOVE(Param + 16, sys.ADR(dlsym),  4);
 - 
 
125 
  sys.MOVE(Param + 20, sys.ADR(exit),   4);
 - 
 
126 
  sys.MOVE(Param + 24, sys.ADR(stdin),  4);
 127 
 
127 
  sys.MOVE(Param + 28, sys.ADR(stdout), 4);
 - 
 
128 
  sys.MOVE(Param + 32, sys.ADR(stderr), 4);
 - 
 
129 
  sys.MOVE(Param + 36, sys.ADR(_malloc), 4);
 - 
 
130 
  sys.MOVE(Param + 40, sys.ADR(free),   4);
 - 
 
Line 131... Line 128...
131 
  sys.MOVE(Param + 44, sys.ADR(fopen),  4);
 128 
    librt := dlopen(SYSTEM.SADR("librt.so.1"), 1);
132 
  sys.MOVE(Param + 48, sys.ADR(fclose), 4);
 129 
    GetProcAdr(librt, "clock_gettime", SYSTEM.ADR(clock_gettime))