слито

в этой ветку свякое уже добавлено, что хотелось бы использовать дальше
fix build && add auto run for tests
2025-06-03 14:22:34 +02:00 · 2025-05-29 13:46:26 +05:00 · 2025-05-18 15:05:26 +05:00 · 2025-05-08 23:48:52 +05:00 · 2025-05-02 13:43:03 +05:00 · 2025-05-02 13:13:56 +05:00
31 changed files with 1902 additions and 456 deletions
--- a/.gitmodules
+++ b/.gitmodules
@@ -1,3 +0,0 @@
-[submodule "lua"]
-	path = lua
-	url = https://git.kolibrios.org/lua/lua.git
--- a/.vscode/c_cpp_properties.json
+++ b/.vscode/c_cpp_properties.json
@@ -1,20 +1,42 @@
 {
    "configurations": [
        {
-            "name": "Release",
+            "name": "Windows Lua5.4",
            "includePath": [
-                "${workspaceFolder}/lua/src",
+                "C:/MinGW/msys/1.0/home/autobuild/tools/win32/include",
+                "C:/MinGW/msys/1.0/home/autobuild/tools/win32/include/lua5.4",
                "${workspaceFolder}/../kolibrios/contrib/sdk/sources/newlib/libc/include"
            ],
-            "defines": []
+            "defines": [
+                "SYSCALLS_VERSION_A",
+                "SYSCALLS_VERSION_B",
+                "SYSCALLS_VERSION_C"
+            ]
+        },
+        {
+            "name": "Windows Lua5.3",
+            "includePath": [
+                "C:/MinGW/msys/1.0/home/autobuild/tools/win32/include",
+                "C:/MinGW/msys/1.0/home/autobuild/tools/win32/include/lua5.3",
+                "${workspaceFolder}/../kolibrios/contrib/sdk/sources/newlib/libc/include"
+            ],
+            "defines": [
+                "SYSCALLS_VERSION_A",
+                "SYSCALLS_VERSION_B",
+                "SYSCALLS_VERSION_C"
+            ]
        },
        {
            "name": "Debug",
            "includePath": [
-                "${workspaceFolder}/lua/src",
+                "/home/autobuild/tools/win32/include",
+                "/home/autobuild/tools/win32/include/lua5.4",
                "${workspaceFolder}/../kolibrios/contrib/sdk/sources/newlib/libc/include"
            ],
            "defines": [
+                "SYSCALLS_VERSION_A",
+                "SYSCALLS_VERSION_B",
+                "SYSCALLS_VERSION_C",
                "NDEBUG"
            ]
        }
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -7,7 +7,11 @@
        "socket.h": "c",
        "graphic.h": "c",
        "syscalls.h": "c",
-        "registers.h": "c"
+        "registers.h": "c",
+        "version_type.h": "c",
+        "library_version.h": "c",
+        "scancodes.h": "c",
+        "ipc.h": "c"
    },
    "cSpell.words": [
        "syscalls",
@@ -28,6 +32,7 @@
        "luaL_checkudata",
        "luaL_optinteger",
        "luaL_pushfail",
+        "lua_pushlightuserdata",
        "lua_pushboolean",
        "lua_pushinteger",
        "lua_pushnumber",
--- a/.vscode/tasks.json
+++ b/.vscode/tasks.json
@@ -0,0 +1,30 @@
+{
+	"version": "2.0.0",
+	"tasks": [
+		{
+			"label": "Build",
+			"type": "process",
+			"command": "make",
+			"args": [
+				"syscalls.dll"
+			],
+			"group": {
+				"isDefault": true,
+				"kind": "build"
+			},
+			"problemMatcher": "$gcc"
+		},
+		{
+			"label": "Clean",
+			"type": "process",
+			"command": "make",
+			"args": [
+				"clean"
+			],
+			"group": {
+				"isDefault": false,
+				"kind": "build"
+			}
+		}
+	]
+}
--- a/40
+++ b/40
@@ -1,13 +1,18 @@
-LUA_V = 54
+
+LUA_V = 5.4
+SYSCALLS_VER_A = 2
+SYSCALLS_VER_B = 0
+SYSCALLS_VER_C = 0
+SYSCALLS_VER = $(SYSCALLS_VER_C).$(SYSCALLS_VER_B).$(SYSCALLS_VER_A)

 CC = kos32-gcc
 LD = kos32-ld
 STRIP = kos32-strip
 OBJCOPY = kos32-objcopy
 STD = -std=gnu11
-CFLAGS = $(SYSCFLAGS) -O2 -Wall -Wextra $(STD) $(MYCFLAGS)
+CFLAGS = $(SYSCFLAGS) -O2 -Wall -Wextra $(STD) $(MYCFLAGS) -DSYSCALLS_VERSION_A=$(SYSCALLS_VER_A) -DSYSCALLS_VERSION_B=$(SYSCALLS_VER_B) -DSYSCALLS_VERSION_C=$(SYSCALLS_VER_C)
 LDFLAGS = $(SYSLDFLAGS) $(MYLDFLAGS)
-LIBS = $(SYSLIBS) $(MYLIBS) $(TOOLCHAIN_PATH)/mingw32/lib/lua$(LUA_V).dll.a
+LIBS = $(SYSLIBS) $(MYLIBS) -llua$(LUA_V).dll

 ifeq ($(OS), Windows_NT)
 	TOOLCHAIN_PATH = C:/MinGW/msys/1.0/home/autobuild/tools/win32
@@ -21,9 +26,8 @@ KOLIBRIOS_REPO = $(abspath ../kolibrios)

 SDK_DIR = $(KOLIBRIOS_REPO)/contrib/sdk
 NewLib_DIR = $(SDK_DIR)/sources/newlib
-SYSCFLAGS = -fno-ident -fomit-frame-pointer -U__WIN32__ -U_Win32 -U_WIN32 -U__MINGW32__ -UWIN32 -I$(NewLib_DIR)/libc/include -I$(abspath .)/lua/src
-SYSLDFLAGS = --image-base 0 -Tapp-dynamic.lds
-SYSLIBS = -nostdlib -L $(SDK_DIR)/lib -L$(TOOLCHAIN_PATH)/lib -L$(TOOLCHAIN_PATH)/mingw32/lib -lgcc -lc.dll -ldll
+SYSCFLAGS = -fno-ident -fomit-frame-pointer -U__WIN32__ -U_Win32 -U_WIN32 -U__MINGW32__ -UWIN32 -I$(NewLib_DIR)/libc/include -I$(TOOLCHAIN_PATH)/include -I$(TOOLCHAIN_PATH)/include/lua$(LUA_V)
+SYSLIBS = -L $(SDK_DIR)/lib -lgcc -lc.dll -ldll
 MYCFLAGS =
 MYLDFLAGS =
 MYLIBS =
@@ -31,12 +35,14 @@ MYOBJS =


 Socket_O = src/sockets/socket.o src/sockets/socket_lua.o src/sockets/sockaddr.o
+IPC_O = src/IPC/ipc.o src/IPC/IPC_msg.o src/IPC/IPC_buffer.o
 Debug_O = src/debug/debug.o src/debug/registers.o
+Version_O = src/version/coreversion.o src/version/version_type.o

-ALL_O = src/syscalls.o src/ARP_entry.o src/systemColors.o src/graphic.o $(Socket_O) $(Debug_O)
+ALL_O = src/syscalls.o src/ARP_entry.o src/systemColors.o src/graphic.o $(Socket_O) $(Debug_O) $(Version_O) $(IPC_O) src/background/background.o

 syscalls.dll: $(ALL_O)
-	$(CC) -shared -T dll.lds --entry _DllStartup -o $@ $(ALL_O) $(LIBS)
+	$(LD) -shared -T dll.lds --entry _DllStartup $(LDFLAGS) -o $@ $(ALL_O) $(LIBS)

 clean:
 	rm -f $(ALL_O) syscalls.dll
@@ -45,7 +51,9 @@ clean:

 ## Sources

-src/syscalls.o:	src/syscalls.c	src/syscalls.h	src/systemColors.h	src/ARP_entry.h	src/scancodes.h	src/sockets/socket_lua.h	src/graphic.h
+IPC_H = src/IPC/IPC_msg.h	src/IPC/IPC_buffer.h	src/IPC/ipc.h
+
+src/syscalls.o:	src/syscalls.c	src/syscalls.h	src/systemColors.h	src/ARP_entry.h	src/scancodes.h	src/sockets/socket_lua.h	src/graphic.h	src/version/library_version.h	$(IPC_H)
 src/ARP_entry.o:	src/ARP_entry.c	src/ARP_entry.h	src/debug.h
 src/systemColors.o:	src/systemColors.c	src/systemColors.h	src/debug.h
 src/sockets/socket.o:	src/sockets/socket.c	src/sockets/socket.h
@@ -53,7 +61,13 @@ src/sockets/socket_lua.o:	src/sockets/socket_lua.c	src/sockets/socket_lua.h
 src/sockets/sockaddr.o:	src/sockets/sockaddr.c	src/sockets/sockaddr.h
 src/graphic.o:	src/graphic.c	src/graphic.h
 src/debug/debug.o:	src/debug/debug.c	src/debug/debug.h	src/debug/registers.h
-src/debug/registers.o:	src/debug/registers.c	src/debug/registers.h	src/syscalls.h
+src/IPC/ipc.o:	src/IPC/ipc.c	src/IPC/ipc.h	src/IPC/IPC_msg.h
+src/IPC/IPC_msg.o:	src/IPC/IPC_msg.c	src/IPC/IPC_msg.h
+src/IPC/IPC_buffer.o:	src/IPC/IPC_buffer.c	src/IPC/IPC_buffer.h	src/IPC/IPC_msg.h
+src/debug/registers.o:	src/debug/registers.c	src/debug/registers.h	src/syscalls.h	src/debug.h
+src/version/coreversion.o:	src/version/coreversion.c	src/version/coreversion.h
+src/version/version_type.o:	src/version/version_type.c	src/version/version_type.h	src/debug.h
+src/background/background.o:	src/background/background.c	src/background/background.h

 ## headers

@@ -62,3 +76,9 @@ src/sockets/socket_lua.h:	src/syscalls.h	src/sockets/socket.h
 src/sockets/sockaddr.h:	src/sockets/socket.h	src/syscalls.h
 src/debug/debug.h:	src/syscalls.h
 src/debug/registers.h:	src/syscalls.h
+src/IPC/IPC_msg.h:	src/syscalls.h
+src/IPC/IPC_buffer.h:	src/syscalls.h
+src/IPC/ipc.h:	src/syscalls.h 
+src/version/coreversion.h:	src/version/version_type.h
+src/version/version_type.h:	src/syscalls.h
+src/background/background.h:	src/syscalls.h
--- a/doc/manual.md
+++ b/doc/manual.md
@@ -1,13 +1,34 @@
 # Manual

+This is KolibriOS lua syscalls library. Usually you shouldn't use this library
+
+Better if you read before [KolibriOS syscalls wiki](http://wiki.kolibrios.org/wiki/)
+
+include this library:
 ```lua
 local syscalls = require("syscalls")
 ```

-
-
 ## Events

+### SetEventMask(newMask)
+
+### CheckEvent()
+
+check [event](#events-list)
+
+### WaitEvent()
+
+Endless wait [event](#events-list)
+
+### WaitEventTimeout(timeout)
+
+Wait timeout 1/100 sec
+
+return event or `nil`
+
+### Events list
+
 ```lua
 syscalls.Event.<EventName>
 ```
@@ -21,6 +42,62 @@ syscalls.Event.<EventName>
 + `IPC`
 + `Debug`

+## Window
+
+### CreateWindow(x, y, width, height, workColor, [style](#window-style), borderColor, titleColor)
+
+Define window
+
+`borderColor` and borderColor` only for FixSizes` and CanChangeSizes` (without skin styles) style.
+
+### StartRedraw()
+
+Start window redraw. Just call it before CreateWindow`
+
+### EndRedraw()
+
+End window redraw. Just call it after you done redraw window.
+
+### ChangeWindow(newX, newY, newWidth, newHeight)
+
+### FocusWindow(slot)
+
+### UnfocusWindow(slot)
+
+### SetWindowTitle(newTitle)
+
+### GetSkinHeight()
+
+return skin height.
+
+### SetSkin(path)
+
+return error code
+
+### GetSkinTitleArea()
+
+return table:
+```lua
+{
+	Left: number,
+	Right: number,
+	Top: number,
+	Bottom: number
+}
+```
+
+### Window Style
+
+```lua
+syscalls.windowStyle.<Value>
+```
+
+ `FixSizes`
+ `NoDraw` (you must draw window manually)
+ `CanChangeSizes`
+ `WithSkin` (usually use it)
+ `WithSkinFixSizes` (with skin, but window size fixed)
+
 ## Graphic

 ### Text encoding
@@ -57,25 +134,237 @@ syscalls.textSize.<value>
 + `56x112`
 + `64x128`

-### `DrawText(text, xPos, yPos, textColor, textScale, textLen, backgroundColor, encoding)`
+### DrawText(text, xPos, yPos, textColor, [textScale](#text-sizes), textLen, backgroundColor, [encoding](#text-encoding))

-### `DrawTextFixSize(text, xPos, yPos, textColor, textSize, textLen, backgroundColor, encoding)`
+### DrawTextFixSize(text, xPos, yPos, textColor, [textScale](#text-sizes), textLen, backgroundColor, [encoding](#text-encoding))

 Draw text.

 textSize, textLen, backgroundColor, encoding are optional.

-### `DrawLine(x1, y1, x2, y2)`
+### DrawLine(x1, y1, x2, y2)

-### `DrawRectangle(x, y, w, h color)`
+### DrawRectangle(x, y, width, height, color)

-### `ReadPoint(x, y)`
+### ReadPoint(x, y)

 return color

+## Buttons
+
+### DefineButton(x, y, width, height, id, color)
+
+### DeleteButton(id)
+
+### GetButton()
+
+return pressed button or `nil`
+
+### SetButtonStyle([style](#button-styles))
+
+Set buttons style
+
+### buttons
+
+button's ids that defined default by window with skin
+
+```lua
+syscalls.buttons.<Value>
+```
+
+ `close`
+ `minimization`
+
+### Button styles
+
+```lua
+syscalls.buttonStyle.<Value>
+```
+
+ `Flat`
+ `Volume`
+
+## Keyboard
+
+### GetKey()
+
+return:
+ `nil` if buffer empty
+ if hotkey return second number
+ if key pressed and key input mode is ascii return string(1 char), else return [scancode](#scancodes)
+
+example:
+
+```lua
+local key, hotkey = syscalls.GetKey()
+
+if key then
+	print("key pressed")
+end
+
+if hotkey then
+	print("hotkey pressed")
+end
+```
+
+### SetKeyInputMode(mode)
+
+by default is `ASCII`
+
+### GetKeyInputMode()
+
+return key input mode.
+
+isn't syscall
+
+### Scancodes
+
+```lua
+syscalls.scancode.<Value>
+```
+
+ `A`
+ `B`
+ `C`
+ `D`
+ `E`
+ `F`
+ `G`
+ `H`
+ `J`
+ `K`
+ `L`
+ `M`
+ `O`
+ `P`
+ `Q`
+ `S`
+ `T`
+ `U`
+ `W`
+ `X`
+ `Y`
+ `Z`
+ `1`
+ `2`
+ `3`
+ `4`
+ `5`
+ `6`
+ `7`
+ `8`
+ `9`
+ `F1`
+ `F2`
+ `F3`
+ `F4`
+ `F5`
+ `F6`
+ `F7`
+ `F8`
+ `F9`
+ `F10`
+ `F11`
+ `F12`
+ `LeftShift`
+ `RightShift`
+ `LeftAlt`
+ `RightAlt`
+ `Tab`
+
+## SystemColors
+
+### SystemColors type
+
+userdata 
+
+#### Fields
+
+```lua
+{
+	frameArea: number,
+	grabBar: number,
+	grabBarButton: number,
+	grabButtonText: number
+	grabText: number,
+	workArea: number,
+	workButton: number,
+	workButton: number,
+	workButtonText: number,
+	workGraph: number,
+	workText: number
+}
+```
+
+#### Constructor
+
+```lua
+syscalls.SystemColors.new(
+	frameArea,
+	grabBar,
+	grabBarButton,
+	grabButtonText,
+	grabText,
+	workArea,
+	workButton,
+	workButton,
+	workButtonText,
+	workGraph,
+	workText
+)
+```
+
+### GetSystemColors()
+
+return [SystemColors](#systemcolors-type)
+
+### SetSystemColors([SystemColors](#systemcolors-type))
+
+## Threads
+
+### ThreadInfo(pid)
+
+return table:
+
+```lua
+{
+	name: string,
+	pid: number,
+	cpu_usage: number,
+	memused: number,
+	winXPos: number,
+	winYPos: number,
+	winXSize: number,
+	winYPos: number,
+	slotState: number,
+	windowState: number,
+	slotNumWindowStack: number,
+	posInWindowStack: number,
+	keyInputMode: number
+}
+```
+
+### KillBySlot(slot)
+
+### Slot states
+
+```lua
+syscalls.slotState.<Value>
+```
+
+ `Running`
+ `Suspended`
+ `SuspendedWaitEvent`
+ `NormalTerm`
+ `ExceptTerm`
+ `WaitEvent`
+ `Free`
+
 ## Sockets

-### `OpenSocket(domain, type, protocol)`
+### OpenSocket([domain](#socket-types), [type](#address-families), [protocol](#ip-protocols))
+
+return socket

 ```lua
 local socket, err = syscalls.OpenSocket(
@@ -91,9 +380,9 @@ else
 end
 ```

-### `CloseSocket(socket)`
+### CloseSocket(socket)

-### `PairSocket()`
+### PairSocket()

 ```lua
 local first, second = PairSocket()
@@ -105,19 +394,19 @@ else
 end
 ```

-### `Bind(socket, address)`
+### Bind(socket, address)

-### `Listen(socket, backlog)`
+### Listen(socket, backlog)

-### `Connect(socket, address)`
+### Connect(socket, address)

-### `Accept(socket, , flags)`
+### Accept(socket, , flags)

-### `Receive(socket, , flags)`
+### Receive(socket, , flags)

-### `SetSocketOption(socket, opt)`
+### SetSocketOption(socket, [opt](#socket-options))

-### `GetSocketOption(socket, opt)`
+### GetSocketOption(socket, [opt](#socket-options))

 ### Socket types

@@ -170,4 +459,132 @@ syscalls.SO.<Value>
 + `BINDTODEVICE`
 + `NONBLOCK`

+## Debug

+### Registers type
+
+```lua
+{
+	eax: number
+	ebx: number,
+	esp: number,
+	esi: number,
+	edi: number,
+	eip: number,
+	eflags: number
+}
+```
+
+### DebugPutc(char)
+
+Put char to debug board
+
+### DebugPuts(text)
+
+Put string to debug board
+
+### GetRegisters(pid)
+
+The process must be loaded for debugging (as stated in the general description).
+
+return registers table
+
+### SetRegisters(pid, [registers](#registers-type))
+
+The process must be loaded for debugging (as stated in the general description).
+
+### Disconnect(pid)
+
+The process must be loaded for debugging (as stated in the general description).
+
+If the process was suspended, it resumes execution.
+
+### Stop(pid)
+
+The process must be loaded for debugging (as stated in the general description).
+
+### Continue(pid)
+
+The process must be loaded for debugging (as stated in the general description).
+
+### ReadFromMem(pid, bytes, pointer, buffer)
+
+The process must be loaded for debugging (as stated in the general description).
+
+return or `nil`
+
+### WriteToMem(pid, bytes, pointer, buffer)
+
+The process must be loaded for debugging (as stated in the general description).
+
+return or `nil`
+
+### Done(pid)
+
+### DefineBreakpoint(pid, index, condition, len)
+
+### UndefBreakpoint(pid, index, condition, len)
+
+## IPC
+
+### DefineIPCBuffer(size)
+
+Define buffer for IPC receive
+
+Return [buffer](#ipc_buffer) type
+
+### SendIPCMessage(pid, [message](#ipc_msg))
+
+Send message to process by pid
+
+return [Error code](#ipc-error-codes)
+
+### IPC Error codes
+
+```lua
+syscalls.IPCError.<Value>
+```
+
+ `Ok`
+ `BufferLocked`
+ `BufferNotDefined`
+ `BufferOverflow`
+ `PIDNotExist`
+
+### IPC_buffer
+
+```lua
+{
+	used: number,
+	lock: boolean,
+	Lock: (self: IPC_buffer) -> nil
+	Unlock: (self: IPC_buffer) -> nil
+	GetMessage: (self: IPC_buffer, i: number) -> IPC_msg
+	GetLastMessage: (self: IPC_buffer) -> IPC_msg
+}
+```
+
+#### Lock(self)
+
+Lock buffer
+
+#### Unlock(self)
+
+Unlock buffer
+
+#### GetMessage(self, i)
+
+return [message](#ipc_msg) that were send by number i
+
+#### GetLastMessage(self)
+
+return last sended [message](#ipc_msg)
+
+### IPC_msg
+
+```lua
+{
+	pid: number,
+	size: number
+}
+```
--- a/src/ARP_entry.c
+++ b/src/ARP_entry.c
@@ -33,7 +33,7 @@ int syscalls_indexARPEntry(lua_State* L)
 	else if (strcmp(index, "MAC") == 0)
 	{
 		char str[7];
-		memset(str, entry->MAC, 6);
+		memcpy(str, &entry->MAC, 6);
 		str[6] = '\n';
 		lua_pushstring(L, str);
 	}
@@ -79,7 +79,7 @@ int syscalls_newindexARPEntry(lua_State* L)
 	}
 	else
 	{
-		_ksys_debug_puts("err\n");
+		luaL_error(L, "wrong index: %s", index);
 	}

 	return 0;
--- a/src/ARP_entry.h
+++ b/src/ARP_entry.h
@@ -10,7 +10,7 @@
 struct ARP_entry
 {
 	uint32_t IP;
-	char MAC[6];
+	uint8_t MAC[6];
 	uint16_t Status;
 	uint16_t TTL;
 };
--- a/src/IPC/IPC_buffer.c
+++ b/src/IPC/IPC_buffer.c
@@ -0,0 +1,244 @@
+#include "IPC_buffer.h"
+#include "IPC_msg.h"
+#include <string.h>
+#include "../debug.h"
+#include <ctype.h>
+
+
+
+static int syscalls_indexIPC_buffer(lua_State* L)
+{
+	struct IPC_buffer* r = luaL_checkudata(L, 1, syscalls_IPC_buffer_metatable_name);
+	const char* index = luaL_checkstring(L, 2);
+
+	if (strcmp(index, "used") == 0)
+	{
+		lua_pushinteger(L, r->used);
+	}
+	else if (strcmp(index, "lock") == 0)
+	{
+		lua_pushboolean(L, r->lock);
+	}
+	else if (strcmp(index, "size") == 0)
+	{
+		lua_pushinteger(L, r->size);
+	}
+	else
+	{
+		lua_pushnil(L);
+	}
+
+	return 1;
+}
+
+static int syscalls_newindexIPC_buffer(lua_State* L)
+{
+	struct IPC_buffer* r = luaL_checkudata(L, 1, syscalls_IPC_buffer_metatable_name);
+	const char* index = luaL_checkstring(L, 2);
+	int val = luaL_checkinteger(L, 3);
+
+	if (strcmp(index, "used") == 0)
+	{
+		r->used = val;
+	}
+	else if (strcmp(index, "lock") == 0)
+	{
+		r->lock = val;
+	}
+	else
+	{
+		luaL_error(L, "wrong index: %s", index);
+	}
+
+	return 0;
+}
+
+static bool compare_ipc_buffer(ksys_ipc_buffer* a, ksys_ipc_buffer* b)
+{	// блять че за высер...
+	if (a == b)
+		return true;
+
+	if (a->used == b->used)
+	{
+		return memcmp(
+			a + (2 * sizeof(unsigned)),
+			b + (2 * sizeof(unsigned)),
+			a->used
+		);
+	}
+	else	// длина сообщений не совпадает, занчитт они зразу не могут быть равны
+	{
+		return false;
+	}
+}
+
+static int syscalls_eqIPC_buffer(lua_State* L)
+{
+	lua_pushboolean(
+		L,
+		compare_ipc_buffer(
+			luaL_checkudata(L, 1, syscalls_IPC_buffer_metatable_name),
+			luaL_checkudata(L, 2, syscalls_IPC_buffer_metatable_name)
+		)
+	);
+
+	return 1;
+}
+
+static int syscalls_IPC_buffer_lock(lua_State* L)
+{
+	struct IPC_buffer* buffer = luaL_checkudata(L, 1, syscalls_IPC_buffer_metatable_name);
+
+	buffer->lock = 1;
+
+	return 0;
+}
+
+static int syscalls_IPC_buffer_unlock(lua_State* L)
+{
+	struct IPC_buffer* buffer = luaL_checkudata(L, 1, syscalls_IPC_buffer_metatable_name);
+
+	buffer->lock = 0;
+
+	return 0;
+}
+
+/**
+ * @brief Получить сообщение под номером
+ * @param buffer
+ * @param i
+ * @return указатель на сообщение, если такого сообщения ещё нет, то возвращает 0
+ */
+static ksys_ipc_msg* IPC_buffer_get_message(ksys_ipc_buffer* buffer, int i)
+{
+	ksys_ipc_msg* j = (ksys_ipc_msg*)(buffer + 8);
+	unsigned diff = 0;
+
+	for (int k = 0; k < i; k++)
+	{
+		diff += j->datalen + 8; // прибавление длинны сообщения и заголовка 
+		j += diff;
+
+		if (diff >= buffer->used)
+			return 0;
+	}
+
+	return j;
+}
+
+static ksys_ipc_msg* IPC_buffer_get_last_message(ksys_ipc_buffer* buffer)
+{
+	ksys_ipc_msg* j = (ksys_ipc_msg*)(buffer + 8);
+	unsigned diff = 0;
+
+	while (diff < buffer->used)
+	{
+		j += diff;
+		diff += j->datalen + 8; // прибавление длинны сообщения и заголовка 
+	}
+
+	return j;
+}
+
+static int syscalls_IPC_buffer_get_message(lua_State* L)
+{
+	struct IPC_buffer* buffer = luaL_checkudata(L, 1, syscalls_IPC_buffer_metatable_name);
+	unsigned i = luaL_checkinteger(L, 2);
+
+	ksys_ipc_msg* msg = IPC_buffer_get_message(IPC_buffer_to_ksys_ipc_buffer(buffer), i);
+
+	if (msg != 0)
+	{
+		lua_pushlightuserdata(L, msg);
+		luaL_setmetatable(L, syscalls_IPC_msg_metatable_name);
+	}
+	else
+	{
+		lua_pushnil(L);
+	}
+
+	return 1;
+}
+
+static int syscalls_IPC_buffer_get_last_message(lua_State* L)
+{
+	struct IPC_buffer* buffer = luaL_checkudata(L, 1, syscalls_IPC_buffer_metatable_name);
+
+	ksys_ipc_msg* msg = IPC_buffer_get_last_message(IPC_buffer_to_ksys_ipc_buffer(buffer));
+
+	if ((unsigned)msg != (unsigned)buffer)
+	{
+		lua_pushlightuserdata(L, msg);
+		luaL_setmetatable(L, syscalls_IPC_msg_metatable_name);
+	}
+	else
+	{
+		lua_pushnil(L);
+	}
+
+	return 1;
+}
+
+static int syscalls_IPC_buffer_reset(lua_State* L)
+{
+	struct IPC_buffer* buffer = luaL_checkudata(L, 1, syscalls_IPC_buffer_metatable_name);
+
+	buffer->used = 0;
+	memset(&buffer->data, 0, buffer->size);
+
+	return 0;
+}
+
+static const luaL_Reg syscalls_IPC_buffer_m[] = {
+	{"__newindex", syscalls_newindexIPC_buffer},
+	{"__eq", syscalls_eqIPC_buffer},
+	{"__index", syscalls_indexIPC_buffer},
+	{NULL, NULL}
+};
+
+struct IPC_buffer* syscalls_pushIPC_buffer(lua_State* L, size_t size)
+{
+	DEBUG_LINE("push " syscalls_IPC_buffer_name " entry");
+
+	struct IPC_buffer* buffer = lua_newuserdata(L, sizeof(struct IPC_buffer) + size);
+
+	luaL_setmetatable(L, syscalls_IPC_buffer_metatable_name);
+
+	buffer->used = 0;
+	buffer->size = size;
+
+	return buffer;
+}
+
+static int syscalls_newIPC_buffer(lua_State* L)
+{
+	size_t size = luaL_checkinteger(L, 1);
+	struct IPC_buffer* buffer = syscalls_pushIPC_buffer(L, size);
+
+	return 1;
+}
+
+static const luaL_Reg syscalls_IPC_buffer_lib[] = {
+	{"new", syscalls_newIPC_buffer},
+	{"Lock", syscalls_IPC_buffer_lock},
+	{"Unlock", syscalls_IPC_buffer_unlock},
+	{"GetMessage", syscalls_IPC_buffer_get_message},
+	{"GetLastMessage", syscalls_IPC_buffer_get_last_message},
+	{"Reset", syscalls_IPC_buffer_reset},
+	{NULL, NULL}
+};
+
+void syscalls_register_IPC_buffer(lua_State* L)
+{
+	DEBUG_LINE("register " syscalls_IPC_buffer_name " entry");
+
+	luaL_newlib(L, syscalls_IPC_buffer_lib);
+
+	lua_setfield(L, -2, syscalls_IPC_buffer_name);
+
+
+	luaL_newmetatable(L, syscalls_IPC_buffer_metatable_name);
+	luaL_setfuncs(L, syscalls_IPC_buffer_m, 0);
+
+	lua_pop(L, 1);
+}
--- a/src/IPC/IPC_buffer.h
+++ b/src/IPC/IPC_buffer.h
@@ -0,0 +1,27 @@
+#ifndef __IPC_BUFFER_H__
+#define __IPC_BUFFER_H__
+
+#include "../syscalls.h"
+
+struct IPC_buffer
+{
+	size_t size;
+	ksys_ipc_buffer;
+};
+
+static inline ksys_ipc_buffer* IPC_buffer_to_ksys_ipc_buffer(struct IPC_buffer* buffer)
+{
+	return (ksys_ipc_buffer*)(buffer + (sizeof(struct IPC_buffer) - sizeof(ksys_ipc_buffer)));
+}
+
+#define syscalls_IPC_buffer_metatable_name "syscalls IPC_buffer metatable"
+#define syscalls_IPC_buffer_name "IPC_buffer"
+
+struct IPC_buffer* syscalls_pushIPC_buffer(lua_State* L, size_t dataLen);
+
+/**
+ * Register SystemColors lib
+ */
+void syscalls_register_IPC_buffer(lua_State* L);
+
+#endif // __IPC_BUFFER_H__
--- a/src/IPC/IPC_msg.c
+++ b/src/IPC/IPC_msg.c
@@ -0,0 +1,225 @@
+#include "IPC_msg.h"
+#include <string.h>
+#include "../debug.h"
+#include <sys/ksys.h>
+#include <stdlib.h>
+
+
+static int syscalls_indexIPC_msg(lua_State* L)
+{
+	ksys_ipc_msg* r = luaL_checkudata(L, 1, syscalls_IPC_msg_metatable_name);
+	const char* index = luaL_checkstring(L, 2);
+
+	if (strcmp(index, "size") == 0)
+	{
+		lua_pushinteger(L, r->datalen);
+	}
+	else if (strcmp(index, "pid") == 0)
+	{
+		lua_pushboolean(L, r->pid);
+	}
+	else
+	{
+		lua_pushnil(L);
+	}
+
+	return 1;
+}
+
+static int syscalls_newindexIPC_msg(lua_State* L)
+{
+	ksys_ipc_msg* r = luaL_checkudata(L, 1, syscalls_IPC_msg_metatable_name);
+	lua_Integer index_i = lua_isnumber(L, 2);
+	uint32_t val = luaL_checkinteger(L, 3);
+
+	if (!index_i)
+	{
+		const char* index = luaL_checkstring(L, 2);
+
+		if (strcmp(index, "size") == 0)
+		{
+			r->datalen = val;
+		}
+		else if (strcmp(index, "pid") == 0)
+		{
+			r->pid = val;
+		}
+		else
+		{
+			luaL_error(L, "wrong index: %s", index);
+		}
+	}
+	else
+	{
+		if (index_i < (unsigned)r->data)
+		{
+			((lua_Integer*)r + (2 * sizeof(unsigned)))[index_i] = val;
+		}
+		else
+		{
+			luaL_error(L, "out of range. size: %d index: %d", r->datalen, index_i);
+		}
+	}
+
+	return 0;
+}
+
+static bool compare_ipc_msg(ksys_ipc_msg* a, ksys_ipc_msg* b)
+{
+	if (a->datalen == b->datalen)
+	{
+		return memcmp(
+			a + (2 * sizeof(unsigned)),
+			b + (2 * sizeof(unsigned)),
+			a->datalen
+		);
+	}
+	else	// длина сообщений не совпадает, занчитт они зразу не могут быть равны
+	{
+		return false;
+	}
+}
+
+static int syscalls_eqIPC_msg(lua_State* L)
+{
+	lua_pushboolean(
+		L,
+		compare_ipc_msg(
+			luaL_checkudata(L, 1, syscalls_IPC_msg_metatable_name),
+			luaL_checkudata(L, 2, syscalls_IPC_msg_metatable_name)
+		)
+	);
+
+	return 1;
+}
+
+static int syscalls_IPC_msg_ReadByte(lua_State* L)
+{
+	lua_pushinteger(
+		L,
+		((uint8_t*)luaL_checkudata(L, 1, syscalls_IPC_msg_metatable_name) + (2 * sizeof(unsigned)))[luaL_checkinteger(L, 2)]
+	);
+
+	return 1;
+}
+
+static int syscalls_IPC_msg_ReadWord(lua_State* L)
+{
+	lua_pushinteger(
+		L,
+		((uint16_t*)luaL_checkudata(L, 1, syscalls_IPC_msg_metatable_name) + (2 * sizeof(unsigned)))[luaL_checkinteger(L, 2)]
+	);
+
+	return 1;
+}
+
+static int syscalls_IPC_msg_ReadDword(lua_State* L)
+{
+	lua_pushinteger(
+		L,
+		((uint32_t*)luaL_checkudata(L, 1, syscalls_IPC_msg_metatable_name) + (2 * sizeof(unsigned)))[luaL_checkinteger(L, 2)]
+	);
+
+	return 1;
+}
+
+static int syscalls_IPC_msg_ReadInteger(lua_State* L)
+{
+	lua_pushinteger(
+		L,
+		((lua_Integer*)luaL_checkudata(L, 1, syscalls_IPC_msg_metatable_name) + (2 * sizeof(unsigned)))[luaL_checkinteger(L, 2)]
+	);
+
+	return 1;
+}
+
+static int syscalls_IPC_msg_tostring(lua_State* L)
+{
+	ksys_ipc_msg* msg = luaL_checkudata(L, 1, syscalls_IPC_msg_metatable_name);
+
+	char* buff = malloc(msg->datalen + 24 + 1);
+
+	sprintf(buff, "pid: %d, len: %d, text: ", msg->pid, msg->datalen);
+
+	memcpy(buff + 24, &msg->data, msg->datalen);
+
+	buff[msg->datalen + 24] = '\0';
+
+	lua_pushstring(L, buff);
+
+	free(buff);
+
+	return 1;
+}
+
+static const luaL_Reg syscalls_IPC_msg_m[] = {
+	{"__newindex", syscalls_newindexIPC_msg},
+	{"__eq", syscalls_eqIPC_msg},
+	{"__tostring", syscalls_IPC_msg_tostring},
+	{"__index", syscalls_indexIPC_msg},
+	{NULL, NULL}
+};
+
+ksys_ipc_msg* syscalls_pushIPC_msg(lua_State* L, size_t dataLen)
+{
+	DEBUG_LINE("push IPC_msg entry");
+
+	ksys_ipc_msg* msg = lua_newuserdata(L, sizeof(ksys_ipc_msg) + dataLen);
+
+	luaL_setmetatable(L, syscalls_IPC_msg_metatable_name);
+
+	msg->datalen = dataLen;
+
+	return msg;
+}
+
+static int syscalls_newIPC_msg(lua_State* L)
+{
+	size_t dataLen = luaL_checkinteger(L, 1);
+	unsigned pid = luaL_checkinteger(L, 2);
+	ksys_ipc_msg* msg = syscalls_pushIPC_msg(L, dataLen);
+
+	msg->pid = pid;
+
+	return 1;
+}
+
+static int syscalls_fromStringIPC_msg(lua_State* L)
+{
+	const char* text = luaL_checkstring(L, 1);
+	unsigned pid = luaL_checkinteger(L, 2);
+	size_t len = strlen(text);
+
+	ksys_ipc_msg* r = syscalls_pushIPC_msg(L, len);
+	r->pid = pid;
+
+	memcpy(&r->data, text, len);
+
+	return 1;
+}
+
+
+static const luaL_Reg syscalls_IPC_msg_lib[] = {
+	{"new", syscalls_newIPC_msg},
+	{"fromString", syscalls_fromStringIPC_msg},
+	{"ReadByte", syscalls_IPC_msg_ReadByte},
+	{"ReadWord", syscalls_IPC_msg_ReadWord},
+	{"ReadDword", syscalls_IPC_msg_ReadDword},
+	{"ReadInteger", syscalls_IPC_msg_ReadInteger},
+	{NULL, NULL}
+};
+
+void syscalls_register_IPC_msg(lua_State* L)
+{
+	DEBUG_LINE("register IPC_msg entry");
+
+	luaL_newlib(L, syscalls_IPC_msg_lib);
+
+	lua_setfield(L, -2, syscalls_IPC_msg_name);
+
+
+	luaL_newmetatable(L, syscalls_IPC_msg_metatable_name);
+	luaL_setfuncs(L, syscalls_IPC_msg_m, 0);
+
+	lua_pop(L, 1);
+}
--- a/src/IPC/IPC_msg.h
+++ b/src/IPC/IPC_msg.h
@@ -0,0 +1,17 @@
+#ifndef _SYSCALLS_IPC_MSG_H_
+#define _SYSCALLS_IPC_MSG_H_
+
+#include "../syscalls.h"
+#include <sys/ksys.h>
+
+#define syscalls_IPC_msg_metatable_name "syscalls IPC_msg metatable"
+#define syscalls_IPC_msg_name "IPC_msg"
+
+ksys_ipc_msg* syscalls_pushIPC_msg(lua_State* L, size_t dataLen);
+
+/**
+ * Register SystemColors lib
+ */
+void syscalls_register_IPC_msg(lua_State* L);
+
+#endif // _SYSCALLS_IPC_MSG_H_
--- a/src/IPC/ipc.c
+++ b/src/IPC/ipc.c
@@ -0,0 +1,51 @@
+#include "ipc.h"
+#include "IPC_msg.h"
+#include "IPC_buffer.h"
+#include <sys/ksys.h>
+
+inline static void define_ipc(ksys_ipc_buffer* buffer, size_t bufLen)
+{
+	asm_inline(
+		"int $0x40"
+		::"a"(60), "b"(1), "c"(buffer), "d"(bufLen)
+	);
+}
+
+inline static enum SendIPCErrors send_ipc(int pid, void* msg, size_t len)
+{
+	enum SendIPCErrors ret;
+
+	asm_inline(
+		"int $0x40"
+		: "=a"(ret)
+		: "a"(60), "b"(2), "c"(pid), "d"(msg), "S"(len)
+	);
+
+	return ret;
+}
+
+int syscalls_DefineIPCBuffer(lua_State* L)
+{
+	uint32_t len = luaL_checkinteger(L, 1);
+	struct IPC_buffer* buffer = syscalls_pushIPC_buffer(L, len);
+
+	define_ipc(IPC_buffer_to_ksys_ipc_buffer(buffer), len);
+
+	return 1;
+}
+
+int syscalls_SendIPCMessage(lua_State* L)
+{
+	ksys_ipc_msg* msg = luaL_checkudata(L, 1, syscalls_IPC_msg_metatable_name);
+
+	lua_pushinteger(
+		L,
+		send_ipc(
+			msg->pid,
+			msg + 8,
+			msg->datalen
+		)
+	);
+
+	return 1;
+}
--- a/src/IPC/ipc.h
+++ b/src/IPC/ipc.h
@@ -0,0 +1,32 @@
+#ifndef __IPC_H__
+#define __IPC_H__
+
+#include "../syscalls.h"
+
+enum SendIPCErrors
+{
+	Ok = 0,
+	BufferNotDefined = 1,
+	BufferLocked = 2,
+	BufferOverflow = 3,
+	PIDNotExist = 4
+};
+
+int syscalls_DefineIPCBuffer(lua_State* L);
+int syscalls_SendIPCMessage(lua_State* L);
+
+
+inline void syscalls_push_IPC_errors(lua_State* L)
+{
+	lua_createtable(L, 0, 5);
+
+	LUA_PUSH_INTEGER_FIELD(L, Ok, "Ok");
+	LUA_PUSH_INTEGER_FIELD(L, BufferLocked, "BufferLocked");
+	LUA_PUSH_INTEGER_FIELD(L, BufferNotDefined, "BufferNotDefined");
+	LUA_PUSH_INTEGER_FIELD(L, BufferOverflow, "BufferOverflow");
+	LUA_PUSH_INTEGER_FIELD(L, PIDNotExist, "PIDNotExist");
+
+	lua_setfield(L, -2, "IPCError");
+}
+
+#endif // __IPC_H__
--- a/src/background/background.c
+++ b/src/background/background.c
@@ -0,0 +1,129 @@
+#include "background.h"
+
+static ksys_pos_t sizes;
+
+int syscalls_backgroundGetSize(lua_State* L)
+{
+	asm_inline(
+		"int $0x40"
+		:"=a"(sizes)
+		: "a"(39), "b"(1)
+	);
+
+	syscalls_push_pos_t(L, sizes);
+
+	return 1;
+}
+
+int syscalls_backgroundSetSize(lua_State* L)
+{
+	sizes = syscalls_check_pos_t(L, 1);
+
+	_ksys_bg_set_size(
+		sizes.x,
+		sizes.y
+	);
+
+	return 0;
+}
+
+int syscalls_backgroundPutPixel(lua_State* L)
+{
+	uint32_t x = luaL_checkinteger(L, 1);
+	uint32_t y = luaL_checkinteger(L, 2);
+
+	_ksys_bg_put_pixel(
+		x,
+		y,
+		sizes.x,
+		luaL_checkinteger(L, 3)
+	);
+
+	return 0;
+}
+
+ksys_color_t background_read_point(ksys_pos_t pos, uint16_t w)
+{
+	ksys_color_t color;
+
+	asm_inline(
+		"int $0x40"
+		:"=a"(color)
+		: "a"(39), "b"(2), "c"((pos.x + pos.y * w) * 3)
+	);
+
+	return color;
+}
+
+int syscalls_backgroundReadPoint(lua_State* L)
+{
+	lua_pushinteger(
+		L,
+		background_read_point(syscalls_check_pos_t(L, 1), sizes.x)
+	);
+
+	return 1;
+}
+
+int syscalls_backgroundRedraw(lua_State* L)
+{
+	_ksys_bg_redraw();
+
+	return 0;
+}
+
+int syscalls_backgroundSetDrawMode(lua_State* L)
+{
+	_ksys_bg_set_mode(luaL_checkinteger(L, 1));
+
+	return 0;
+}
+
+int syscalls_backgroundGetDrawMode(lua_State* L)
+{
+	enum KSYS_BG_MODES mode;
+
+	asm_inline(
+		"int $0x40"
+		:"=a"(mode)
+		: "a"(39), "b"(4)
+	);
+
+	lua_pushinteger(L, mode);
+
+	return 1;
+}
+
+int syscalls_backgroundOpenMap(lua_State* L)
+{
+	lua_pushinteger(
+		L,
+		_ksys_bg_get_map()
+	);
+
+	return 1;
+}
+
+int syscalls_backgroundCloseMap(lua_State* L)
+{
+	if (_ksys_bg_close_map(luaL_checkinteger(L, 1)) == 0)
+	{
+		lua_pushnil(L);
+	}
+	else
+	{
+		lua_pushboolean(L, true);
+	}
+
+	return 1;
+}
+
+int syscalls_backgroundRedrawArea(lua_State* L)
+{
+	_ksys_bg_redraw_bar(
+		syscalls_check_pos_t(L, 1),
+		syscalls_check_pos_t(L, 3)
+	);
+
+	return 0;
+}
--- a/src/background/background.h
+++ b/src/background/background.h
@@ -0,0 +1,33 @@
+#ifndef __BACKGROUND_H__
+#define __BACKGROUND_H__
+
+#include "../syscalls.h"
+
+int syscalls_backgroundSetSize(lua_State* L);
+
+int syscalls_backgroundPutPixel(lua_State* L);
+
+int syscalls_backgroundRedraw(lua_State* L);
+
+int syscalls_backgroundSetDrawMode(lua_State* L);
+
+int syscalls_backgroundGetDrawMode(lua_State* L);
+
+int syscalls_backgroundOpenMap(lua_State* L);
+
+int syscalls_backgroundCloseMap(lua_State* L);
+
+int syscalls_backgroundRedrawArea(lua_State* L);
+
+inline syscalls_push_BackgroundDrawMode(lua_State* L)
+{
+	lua_createtable(L, 0, 2);
+
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_BG_MODE_PAVE, "Pave");
+
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_BG_MODE_STRETCH, "Stretch");
+
+	lua_setfield(L, -2, "DrawMode");
+}
+
+#endif // __BACKGROUND_H__
--- a/src/debug/debug.c
+++ b/src/debug/debug.c
@@ -37,9 +37,8 @@ int syscalls_SetMessageArea(lua_State* L)

 int syscalls_GetRegisters(lua_State* L)
 {
-	struct registers* r = syscalls_pushRegisters(L);
-
 	uint32_t pid = luaL_checkinteger(L, 1);
+	struct registers* r = syscalls_pushRegisters(L);

 	asm_inline(
 		"int $0x40"
@@ -59,7 +58,7 @@ int syscalls_SetRegisters(lua_State* L)
 		:: "a"(69), "b"(2), "c"(pid), "d"(sizeof(struct registers)), "S"(r)
 	);

-	return 1;
+	return 0;
 }

 int syscalls_Disconnect(lua_State* L)
@@ -71,7 +70,7 @@ int syscalls_Disconnect(lua_State* L)
 		:: "a"(69), "b"(3), "c"(pid)
 	);

-	return 1;
+	return 0;
 }

 int syscalls_Stop(lua_State* L)
@@ -83,7 +82,7 @@ int syscalls_Stop(lua_State* L)
 		:: "a"(69), "b"(4), "c"(pid)
 	);

-	return 1;
+	return 0;
 }

 int syscalls_Continue(lua_State* L)
@@ -95,7 +94,7 @@ int syscalls_Continue(lua_State* L)
 		:: "a"(69), "b"(5), "c"(pid)
 	);

-	return 1;
+	return 0;
 }

 int syscalls_ReadFromMem(lua_State* L)
@@ -151,7 +150,7 @@ int syscalls_Done(lua_State* L)
 		:: "a"(69), "b"(8), "c"(pid)
 	);

-	return 1;
+	return 0;
 }

 int syscalls_DefineBreakpoint(lua_State* L)
--- a/src/debug/registers.c
+++ b/src/debug/registers.c
@@ -83,7 +83,7 @@ static int syscalls_newindexRegisters(lua_State* L)
 		luaL_error(L, "wrong index: %s", index);
 	}

-	return 1;
+	return 0;
 }

 static int syscalls_eqRegisters(lua_State* L)
--- a/src/debug/registers.h
+++ b/src/debug/registers.h
@@ -20,6 +20,6 @@ struct registers

 struct registers* syscalls_pushRegisters(lua_State* L);

-inline void syscalls_register_registers(lua_State* L);
+void syscalls_register_registers(lua_State* L);

 #endif // __REGISTERS_H__
--- a/src/graphic.h
+++ b/src/graphic.h
@@ -45,53 +45,37 @@ inline void syscalls_push_textSizes(lua_State* L)
 {
 	lua_newtable(L);

-	lua_pushinteger(L, TextScale_SIZE_6x9);
-	lua_setfield(L, -2, "6x9");
+	LUA_PUSH_INTEGER_FIELD(L, TextScale_SIZE_6x9, "6x9");

-	lua_pushinteger(L, TextScale_SIZE_8x16);
-	lua_setfield(L, -2, "8x16");
+	LUA_PUSH_INTEGER_FIELD(L, TextScale_SIZE_8x16, "8x16");

-	lua_pushinteger(L, TextScale_SIZE_12x18);
-	lua_setfield(L, -2, "12x18");
+	LUA_PUSH_INTEGER_FIELD(L, TextScale_SIZE_12x18, "12x18");

-	lua_pushinteger(L, TextScale_SIZE_16x32);
-	lua_setfield(L, -2, "16x32");
+	LUA_PUSH_INTEGER_FIELD(L, TextScale_SIZE_16x32, "16x32");

-	lua_pushinteger(L, TextScale_SIZE_18x27);
-	lua_setfield(L, -2, "18x27");
+	LUA_PUSH_INTEGER_FIELD(L, TextScale_SIZE_18x27, "18x27");

-	lua_pushinteger(L, TextScale_SIZE_24x36);
-	lua_setfield(L, -2, "24x36");
+	LUA_PUSH_INTEGER_FIELD(L, TextScale_SIZE_24x36, "24x36");

-	lua_pushinteger(L, TextScale_SIZE_24x48);
-	lua_setfield(L, -2, "24x48");
+	LUA_PUSH_INTEGER_FIELD(L, TextScale_SIZE_24x48, "24x48");

-	lua_pushinteger(L, TextScale_SIZE_30x45);
-	lua_setfield(L, -2, "30x45");
+	LUA_PUSH_INTEGER_FIELD(L, TextScale_SIZE_30x45, "30x45");

-	lua_pushinteger(L, TextScale_SIZE_32x64);
-	lua_setfield(L, -2, "32x64");
+	LUA_PUSH_INTEGER_FIELD(L, TextScale_SIZE_32x64, "32x64");

-	lua_pushinteger(L, TextScale_SIZE_36x54);
-	lua_setfield(L, -2, "36x54");
+	LUA_PUSH_INTEGER_FIELD(L, TextScale_SIZE_36x54, "36x54");

-	lua_pushinteger(L, TextScale_SIZE_40x80);
-	lua_setfield(L, -2, "40x80");
+	LUA_PUSH_INTEGER_FIELD(L, TextScale_SIZE_40x80, "40x80");

-	lua_pushinteger(L, TextScale_SIZE_42x63);
-	lua_setfield(L, -2, "42x63");
+	LUA_PUSH_INTEGER_FIELD(L, TextScale_SIZE_42x63, "42x63");

-	lua_pushinteger(L, TextScale_SIZE_48x72);
-	lua_setfield(L, -2, "48x72");
+	LUA_PUSH_INTEGER_FIELD(L, TextScale_SIZE_48x72, "48x72");

-	lua_pushinteger(L, TextScale_SIZE_48x96);
-	lua_setfield(L, -2, "48x96");
+	LUA_PUSH_INTEGER_FIELD(L, TextScale_SIZE_48x96, "48x96");

-	lua_pushinteger(L, TextScale_SIZE_56x112);
-	lua_setfield(L, -2, "56x112");
+	LUA_PUSH_INTEGER_FIELD(L, TextScale_SIZE_56x112, "56x112");

-	lua_pushinteger(L, TextScale_SIZE_64x128);
-	lua_setfield(L, -2, "64x128");
+	LUA_PUSH_INTEGER_FIELD(L, TextScale_SIZE_64x128, "64x128");

 	lua_setfield(L, -2, "textSize");
 }
@@ -100,21 +84,17 @@ inline void syscalls_push_Encoding(lua_State* L)
 {
 	lua_newtable(L);

-	lua_pushinteger(L, cp866);
-	lua_setfield(L, -2, "cp866");
+	LUA_PUSH_INTEGER_FIELD(L, cp866, "cp866");

-	lua_pushinteger(L, cp866_8x16);
-	lua_setfield(L, -2, "cp866_8x16");
+	LUA_PUSH_INTEGER_FIELD(L, cp866_8x16, "cp866_8x16");

-	lua_pushinteger(L, utf8);
-	lua_setfield(L, -2, "utf8");
+	LUA_PUSH_INTEGER_FIELD(L, utf8, "utf8");

-	lua_pushinteger(L, utf16);
-	lua_setfield(L, -2, "utf16");
+	LUA_PUSH_INTEGER_FIELD(L, utf16, "utf16");

 	lua_setfield(L, -2, "Encoding");
 }

 #define syscalls_push_graphic(L) syscalls_push_textSizes(L); syscalls_push_Encoding(L);

-#endif // __GRAPHIC_H__
+#endif // __GRAPHIC_H_
--- a/src/scancodes.h
+++ b/src/scancodes.h
@@ -8,270 +8,183 @@

 static inline void syscalls_register_scancodes(lua_State* L)
 {
-    lua_newtable(L);
+	lua_newtable(L);

-    lua_pushinteger(L, KSYS_SCANCODE_0);
-    lua_setfield(L, -2, "0");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SCANCODE_0, "0");

-    lua_pushinteger(L, KSYS_SCANCODE_1);
-    lua_setfield(L, -2, "1");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SCANCODE_1, "1");

-    lua_pushinteger(L, KSYS_SCANCODE_2);
-    lua_setfield(L, -2, "2");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SCANCODE_2, "2");

-    lua_pushinteger(L, KSYS_SCANCODE_3);
-    lua_setfield(L, -2, "3");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SCANCODE_3, "3");

-    lua_pushinteger(L, KSYS_SCANCODE_4);
-    lua_setfield(L, -2, "4");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SCANCODE_4, "5");

-    lua_pushinteger(L, KSYS_SCANCODE_5);
-    lua_setfield(L, -2, "6");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SCANCODE_5, "6");

-    lua_pushinteger(L, KSYS_SCANCODE_7);
-    lua_setfield(L, -2, "7");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SCANCODE_7, "7");

-    lua_pushinteger(L, KSYS_SCANCODE_8);
-    lua_setfield(L, -2, "8");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SCANCODE_8, "8");

-    lua_pushinteger(L, KSYS_SCANCODE_9);
-    lua_setfield(L, -2, "9");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SCANCODE_9, "9");

-    lua_pushinteger(L, KSYS_SCANCODE_A);
-    lua_setfield(L, -2, "A");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SCANCODE_A, "A");

-    lua_pushinteger(L, KSYS_SCANCODE_B);
-    lua_setfield(L, -2, "B");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SCANCODE_B, "B");

-    lua_pushinteger(L, KSYS_SCANCODE_C);
-    lua_setfield(L, -2, "C");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SCANCODE_C, "C");

-    lua_pushinteger(L, KSYS_SCANCODE_D);
-    lua_setfield(L, -2, "D");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SCANCODE_D, "D");

-    lua_pushinteger(L, KSYS_SCANCODE_E);
-    lua_setfield(L, -2, "E");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SCANCODE_E, "E");

-    lua_pushinteger(L, KSYS_SCANCODE_F);
-    lua_setfield(L, -2, "F");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SCANCODE_F, "F");

-    lua_pushinteger(L, KSYS_SCANCODE_G);
-    lua_setfield(L, -2, "G");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SCANCODE_G, "G");

-    lua_pushinteger(L, KSYS_SCANCODE_H);
-    lua_setfield(L, -2, "H");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SCANCODE_H, "H");

-    lua_pushinteger(L, KSYS_SCANCODE_J);
-    lua_setfield(L, -2, "J");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SCANCODE_J, "J");

-    lua_pushinteger(L, KSYS_SCANCODE_K);
-    lua_setfield(L, -2, "K");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SCANCODE_K, "K");

-    lua_pushinteger(L, KSYS_SCANCODE_L);
-    lua_setfield(L, -2, "L");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SCANCODE_L, "L");

-    lua_pushinteger(L, KSYS_SCANCODE_M);
-    lua_setfield(L, -2, "M");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SCANCODE_M, "M");

-    lua_pushinteger(L, KSYS_SCANCODE_N);
-    lua_setfield(L, -2, "N");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SCANCODE_N, "N");

-    lua_pushinteger(L, KSYS_SCANCODE_O);
-    lua_setfield(L, -2, "O");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SCANCODE_O, "O");

-    lua_pushinteger(L, KSYS_SCANCODE_P);
-    lua_setfield(L, -2, "P");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SCANCODE_P, "P");

-    lua_pushinteger(L, KSYS_SCANCODE_Q);
-    lua_setfield(L, -2, "Q");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SCANCODE_Q, "Q");

-    lua_pushinteger(L, KSYS_SCANCODE_R);
-    lua_setfield(L, -2, "R");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SCANCODE_R, "R");

-    lua_pushinteger(L, KSYS_SCANCODE_S);
-    lua_setfield(L, -2, "S");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SCANCODE_S, "S");

-    lua_pushinteger(L, KSYS_SCANCODE_T);
-    lua_setfield(L, -2, "T");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SCANCODE_T, "T");

-    lua_pushinteger(L, KSYS_SCANCODE_U);
-    lua_setfield(L, -2, "U");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SCANCODE_U, "U");

-    lua_pushinteger(L, KSYS_SCANCODE_V);
-    lua_setfield(L, -2, "V");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SCANCODE_V, "V");

-    lua_pushinteger(L, KSYS_SCANCODE_W);
-    lua_setfield(L, -2, "W");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SCANCODE_W, "W");

-    lua_pushinteger(L, KSYS_SCANCODE_X);
-    lua_setfield(L, -2, "X");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SCANCODE_X, "X");

-    lua_pushinteger(L, KSYS_SCANCODE_Y);
-    lua_setfield(L, -2, "Y");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SCANCODE_Y, "Y");

-    lua_pushinteger(L, KSYS_SCANCODE_Z);
-    lua_setfield(L, -2, "Z");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SCANCODE_Z, "Z");

-    lua_pushinteger(L, KSYS_SCANCODE_F1);
-    lua_setfield(L, -2, "F1");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SCANCODE_F1, "F1");

-    lua_pushinteger(L, KSYS_SCANCODE_F2);
-    lua_setfield(L, -2, "F2");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SCANCODE_F2, "F2");

-    lua_pushinteger(L, KSYS_SCANCODE_F3);
-    lua_setfield(L, -2, "F3");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SCANCODE_F3, "F3");

-    lua_pushinteger(L, KSYS_SCANCODE_F4);
-    lua_setfield(L, -2, "F4");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SCANCODE_F4, "F4");

-    lua_pushinteger(L, KSYS_SCANCODE_F5);
-    lua_setfield(L, -2, "F5");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SCANCODE_F5, "F5");

-    lua_pushinteger(L, KSYS_SCANCODE_F6);
-    lua_setfield(L, -2, "F6");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SCANCODE_F6, "F6");

-    lua_pushinteger(L, KSYS_SCANCODE_F7);
-    lua_setfield(L, -2, "F7");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SCANCODE_F7, "F7");

-    lua_pushinteger(L, KSYS_SCANCODE_F8);
-    lua_setfield(L, -2, "F8");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SCANCODE_F8, "F8");

-    lua_pushinteger(L, KSYS_SCANCODE_F9);
-    lua_setfield(L, -2, "F9");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SCANCODE_F9, "F9");

-    lua_pushinteger(L, KSYS_SCANCODE_F10);
-    lua_setfield(L, -2, "F10");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SCANCODE_F10, "F10");

-    lua_pushinteger(L, KSYS_SCANCODE_F11);
-    lua_setfield(L, -2, "F11");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SCANCODE_F11, "F11");

-    lua_pushinteger(L, KSYS_SCANCODE_F12);
-    lua_setfield(L, -2, "F12");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SCANCODE_F12, "F12");

-    lua_pushinteger(L, KSYS_SCANCODE_LSHIFT);
-    lua_setfield(L, -2, "LeftShift");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SCANCODE_LSHIFT, "LeftShift");

-    lua_pushinteger(L, KSYS_SCANCODE_RSHIFT);
-    lua_setfield(L, -2, "RightShift");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SCANCODE_RSHIFT, "RightShift");

-    lua_pushinteger(L, KSYS_SCANCODE_BACKSLASH);
-    lua_setfield(L, -2, "Backslash");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SCANCODE_BACKSLASH, "Backslash");

-    lua_pushinteger(L, KSYS_SCANCODE_COMMA);
-    lua_setfield(L, -2, "Comma");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SCANCODE_COMMA, "Comma");

-    lua_pushinteger(L, KSYS_SCANCODE_SLASH);
-    lua_setfield(L, -2, "Slash");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SCANCODE_SLASH, "Slash");

-    lua_pushinteger(L, KSYS_SCANCODE_LALT);
-    lua_setfield(L, -2, "LeftAlt");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SCANCODE_LALT, "LeftAlt");

-    lua_pushinteger(L, KSYS_SCANCODE_EXT_RALT);
-    lua_setfield(L, -2, "RightAlt");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SCANCODE_EXT_RALT, "RightAlt");

-    lua_pushinteger(L, KSYS_SCANCODE_LCTRL);
-    lua_setfield(L, -2, "LeftCtrl");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SCANCODE_LCTRL, "LeftCtrl");

-    lua_pushinteger(L, KSYS_SCANCODE_EXT_RCTRL);
-    lua_setfield(L, -2, "RightCtrl");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SCANCODE_EXT_RCTRL, "RightCtrl");

-    lua_pushinteger(L, KSYS_SCANCODE_CAPSLOCK);
-    lua_setfield(L, -2, "CapsLock");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SCANCODE_CAPSLOCK, "CapsLock");

-    lua_pushinteger(L, KSYS_SCANCODE_NUMLOCK);
-    lua_setfield(L, -2, "NumLock");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SCANCODE_NUMLOCK, "NumLock");

-    lua_pushinteger(L, KSYS_SCANCODE_POINT);
-    lua_setfield(L, -2, "Point");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SCANCODE_POINT, "Point");

-    lua_pushinteger(L, KSYS_SCANCODE_ENTER);
-    lua_setfield(L, -2, "Enter");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SCANCODE_ENTER, "Enter");

-    lua_pushinteger(L, KSYS_SCANCODE_ESC);
-    lua_setfield(L, -2, "Esc");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SCANCODE_ESC, "Esc");

-    lua_pushinteger(L, KSYS_SCANCODE_TAB);
-    lua_setfield(L, -2, "Tab");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SCANCODE_TAB, "Tab");

-    lua_pushinteger(L, KSYS_SCANCODE_EXT_HOME);
-    lua_setfield(L, -2, "Home");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SCANCODE_EXT_HOME, "Home");

-    lua_pushinteger(L, KSYS_SCANCODE_EXT_PGUP);
-    lua_setfield(L, -2, "PageUp");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SCANCODE_EXT_PGUP, "PageUp");

-    lua_pushinteger(L, KSYS_SCANCODE_EXT_PGDOWN);
-    lua_setfield(L, -2, "PageDown");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SCANCODE_EXT_PGDOWN, "PageDown");

-    lua_pushinteger(L, KSYS_SCANCODE_EXT_END);
-    lua_setfield(L, -2, "End");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SCANCODE_EXT_END, "End");

-    lua_pushinteger(L, KSYS_SCANCODE_EXT_UP);
-    lua_setfield(L, -2, "Up");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SCANCODE_EXT_UP, "Up");

-    lua_pushinteger(L, KSYS_SCANCODE_EXT_DOWN);
-    lua_setfield(L, -2, "Down");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SCANCODE_EXT_DOWN, "Down");

-    lua_pushinteger(L, KSYS_SCANCODE_EXT_LEFT);
-    lua_setfield(L, -2, "Left");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SCANCODE_EXT_LEFT, "Left");

-    lua_pushinteger(L, KSYS_SCANCODE_EXT_RIGHT);
-    lua_setfield(L, -2, "Right");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SCANCODE_EXT_RIGHT, "Right");

-    lua_pushinteger(L, KSYS_SCANCODE_EXT_DELETE);
-    lua_setfield(L, -2, "Delete");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SCANCODE_EXT_DELETE, "Delete");

-    lua_pushinteger(L, KSYS_SCANCODE_EXT_INSERT);
-    lua_setfield(L, -2, "Insert");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SCANCODE_EXT_INSERT, "Insert");

-    lua_pushinteger(L, KSYS_SCANCODE_MINUS);
-    lua_setfield(L, -2, "Minus");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SCANCODE_MINUS, "Minus");

-    lua_pushinteger(L, KSYS_SCANCODE_EXT_NUMPAD_ENTER);
-    lua_setfield(L, -2, "NumpadEnter");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SCANCODE_EXT_NUMPAD_ENTER, "NumpadEnter");

-    lua_pushinteger(L, KSYS_SCANCODE_EXT_NUMPAD_DIV);
-    lua_setfield(L, -2, "NumpadDiv");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SCANCODE_EXT_NUMPAD_DIV, "NumpadDiv");

-    lua_pushinteger(L, KSYS_SCANCODE_NUMPAD_MULT);
-    lua_setfield(L, -2, "NumpadMult");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SCANCODE_NUMPAD_MULT, "NumpadMult");

-    lua_pushinteger(L, KSYS_SCANCODE_NUMPAD_MINUS);
-    lua_setfield(L, -2, "NumpadMinus");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SCANCODE_NUMPAD_MINUS, "NumpadMinus");

-    lua_pushinteger(L, KSYS_SCANCODE_NUMPAD_PLUS);
-    lua_setfield(L, -2, "NumpadPlus");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SCANCODE_NUMPAD_PLUS, "NumpadPlus");

-    lua_pushinteger(L, KSYS_SCANCODE_NUMPAD_0);
-    lua_setfield(L, -2, "Numpad_0");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SCANCODE_NUMPAD_0, "Numpad_0");

-    lua_pushinteger(L, KSYS_SCANCODE_NUMPAD_1);
-    lua_setfield(L, -2, "Numpad_1");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SCANCODE_NUMPAD_1, "Numpad_1");

-    lua_pushinteger(L, KSYS_SCANCODE_NUMPAD_2);
-    lua_setfield(L, -2, "Numpad_2");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SCANCODE_NUMPAD_2, "Numpad_2");

-    lua_pushinteger(L, KSYS_SCANCODE_NUMPAD_3);
-    lua_setfield(L, -2, "Numpad_3");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SCANCODE_NUMPAD_3, "Numpad_3");

-    lua_pushinteger(L, KSYS_SCANCODE_NUMPAD_4);
-    lua_setfield(L, -2, "Numpad_4");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SCANCODE_NUMPAD_4, "Numpad_4");

-    lua_pushinteger(L, KSYS_SCANCODE_NUMPAD_5);
-    lua_setfield(L, -2, "Numpad_5");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SCANCODE_NUMPAD_5, "Numpad_5");

-    lua_pushinteger(L, KSYS_SCANCODE_NUMPAD_6);
-    lua_setfield(L, -2, "Numpad_6");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SCANCODE_NUMPAD_6, "Numpad_6");

-    lua_pushinteger(L, KSYS_SCANCODE_NUMPAD_7);
-    lua_setfield(L, -2, "Numpad_7");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SCANCODE_NUMPAD_7, "Numpad_7");

-    lua_pushinteger(L, KSYS_SCANCODE_NUMPAD_8);
-    lua_setfield(L, -2, "Numpad_8");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SCANCODE_NUMPAD_8, "Numpad_8");

-    lua_pushinteger(L, KSYS_SCANCODE_NUMPAD_9);
-    lua_setfield(L, -2, "Numpad_9");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SCANCODE_NUMPAD_9, "Numpad_9");

-    lua_setfield(L, -2, "scancode");
+	lua_setfield(L, -2, "scancode");
 }

 #endif // _SYSCALLS_ENUM_SCANCODES_
--- a/src/syscalls.c
+++ b/src/syscalls.c
@@ -9,13 +9,18 @@

 #include "syscalls.h"
 #include "scancodes.h"
-#include "ARP_entry.h"

+#include "ARP_entry.h"
 #include "systemColors.h"
 #include "sockets/socket_lua.h"
 #include "debug/debug.h"
 #include "graphic.h"
-
+#include "IPC/ipc.h"
+#include "IPC/IPC_msg.h"
+#include "IPC/IPC_buffer.h"
+#include "version/coreversion.h"
+#include "version/library_version.h"
+#include "background/background.h"

 /*
 	Режим ввода с клавиатуры
@@ -95,6 +100,7 @@ static int syscalls_endRedraw(lua_State* L)
 static int syscalls_SetSkin(lua_State* L)
 {
 	unsigned ret;
+
 	asm_inline(
 		"int $0x40"
 		: "=a"(ret)
@@ -105,7 +111,7 @@ static int syscalls_SetSkin(lua_State* L)
 	return 1;
 }

-static int syscalls_GetSkinTilteArea(lua_State* L)
+static int syscalls_GetSkinTitleArea(lua_State* L)
 {
 	ksys_pos_t leftRight, topBottom;

@@ -139,34 +145,39 @@ static int syscalls_SetWorkArea(lua_State* L)
 	uint32_t bottom = luaL_checkinteger(L, 4);

 	asm_inline(
-		"int $0x40" ::"a"(48), "b"(6), "c"(left * 65536 + right), "d"(top * 65536 + bottom));
+		"int $0x40" ::
+		"a"(48),
+		"b"(6),
+		"c"((left << 16) | right),
+		"d"((top << 16) | bottom)
+	);

 	return 0;
 }

 static int syscalls_GetWorkArea(lua_State* L)
 {
-	ksys_pos_t leftlright;
-	ksys_pos_t toplbottom;
+	ksys_pos_t leftAndRight;
+	ksys_pos_t topAndBottom;

 	asm_inline(
 		"int $0x40"
-		:"=a"(leftlright), "=b"(toplbottom)
+		:"=a"(leftAndRight), "=b"(topAndBottom)
 		: "a"(48), "b"(5)
 	);

 	lua_createtable(L, 0, 4);

-	lua_pushinteger(L, leftlright.x);
+	lua_pushinteger(L, leftAndRight.x);
 	lua_setfield(L, -2, "Left");

-	lua_pushinteger(L, leftlright.y);
+	lua_pushinteger(L, leftAndRight.y);
 	lua_setfield(L, -2, "Right");

-	lua_pushinteger(L, toplbottom.x);
+	lua_pushinteger(L, topAndBottom.x);
 	lua_setfield(L, -2, "Top");

-	lua_pushinteger(L, toplbottom.y);
+	lua_pushinteger(L, topAndBottom.y);
 	lua_setfield(L, -2, "Bottom");

 	return 1;
@@ -195,6 +206,7 @@ static int syscalls_deleteButton(lua_State* L)
 static int syscalls_SetButtonsStyle(lua_State* L)
 {
 	uint32_t style = luaL_checkinteger(L, 1);
+
 	asm_inline(
 		"int $0x40" ::"a"(48), "b"(1), "c"(style));

@@ -228,7 +240,7 @@ static int syscalls_WindowMsg(lua_State* L)

 	asm_inline(
 		"int $0x40"
-		:"=a"(ret)
+		: "=a"(ret)
 		: "a"(72), "b"(1), "c"(event), "d"(code)
 	);

@@ -241,55 +253,54 @@ static int syscalls_threadInfo(lua_State* L)
 {
 	ksys_thread_t t;

-	_ksys_thread_info(&t, luaL_checkinteger(L, 1));
+	_ksys_thread_info(&t, luaL_optinteger(L, 1, -1));

 	lua_createtable(L, 0, 13);

 	lua_pushstring(L, t.name);
-	lua_setfield(L, -2, "name");
+	lua_setfield(L, -2, "Name");

 	lua_pushinteger(L, t.cpu_usage);
-	lua_setfield(L, -2, "cpu_usage");
+	lua_setfield(L, -2, "CpuUsage");

 	lua_pushinteger(L, t.memused);
-	lua_setfield(L, -2, "memused");
+	lua_setfield(L, -2, "MemUsed");

 	lua_pushinteger(L, t.pid);
-	lua_setfield(L, -2, "pid");
+	lua_setfield(L, -2, "PID");

 	lua_pushinteger(L, t.key_input_mode);
-	lua_setfield(L, -2, "keyInputMode");
+	lua_setfield(L, -2, "KeyInputMode");

 	lua_pushinteger(L, t.pos_in_window_stack);
-	lua_setfield(L, -2, "posInWindowStack");
+	lua_setfield(L, -2, "PosInWindowStack");

 	lua_pushinteger(L, t.slot_num_window_stack);
-	lua_setfield(L, -2, "slotNumWindowStack");
+	lua_setfield(L, -2, "SlotNumWindowStack");

 	lua_pushinteger(L, t.slot_state);
-	lua_setfield(L, -2, "slotState");
+	lua_setfield(L, -2, "SlotState");

 	lua_pushinteger(L, t.window_state);
-	lua_setfield(L, -2, "windowState");
+	lua_setfield(L, -2, "WindowState");

 	lua_pushinteger(L, t.winx_size);
-	lua_setfield(L, -2, "winXSize");
+	lua_setfield(L, -2, "WinXSize");

 	lua_pushinteger(L, t.winy_size);
-	lua_setfield(L, -2, "winYSize");
+	lua_setfield(L, -2, "WinYSize");

 	lua_pushinteger(L, t.winx_start);
-	lua_setfield(L, -2, "winXPos");
+	lua_setfield(L, -2, "WinXPos");

 	lua_pushinteger(L, t.winy_start);
-	lua_setfield(L, -2, "winYPos");
+	lua_setfield(L, -2, "WinYPos");

 	return 1;
 }

 static int syscalls_KillBySlot(lua_State* L)
 {
-
 	_ksys_kill_by_slot(
 		luaL_checkinteger(L, 1));

@@ -319,7 +330,10 @@ static int syscalls_checkEvent(lua_State* L)

 static int syscalls_waitEventTimeout(lua_State* L)
 {
-	lua_pushinteger(L, _ksys_wait_event_timeout(luaL_checkinteger(L, 1)));
+	lua_pushinteger(
+		L,
+		_ksys_wait_event_timeout(luaL_checkinteger(L, 1))
+	);

 	return 1;
 }
@@ -398,37 +412,6 @@ static int syscalls_getButton(lua_State* L)
 }


-/*
-	Backgound
-*/
-
-static int syscalls_backgroundSetSize(lua_State* L)
-{
-	_ksys_bg_set_size(
-		luaL_checkinteger(L, 1),
-		luaL_checkinteger(L, 2));
-
-	return 0;
-}
-
-static int syscalls_backgroundPutPixel(lua_State* L)
-{
-	_ksys_bg_put_pixel(
-		luaL_checkinteger(L, 1),
-		luaL_checkinteger(L, 2),
-		luaL_checkinteger(L, 3),
-		luaL_checkinteger(L, 4));
-
-	return 0;
-}
-
-static int syscalls_backgroundRedraw(lua_State* L)
-{
-	_ksys_bg_redraw();
-
-	return 0;
-}
-
 static int syscalls_getCPUClock(lua_State* L)
 {
 	lua_pushinteger(L, _ksys_get_cpu_clock());
@@ -496,7 +479,7 @@ static int syscalls_getKey(lua_State* L)
 		{
 			char s[2];
 			s[0] = a.code;
-			s[1] = '\n';
+			s[1] = '\0';
 			lua_pushstring(L, s);
 		}
 		else
@@ -688,7 +671,7 @@ static int syscalls_getMouseEvents(lua_State* L)
 	createMouseState(state, L);

 	lua_pushboolean(L, state & (1 << 8));
-	lua_setfield(L, -2, "getMouseEvents");
+	lua_setfield(L, -2, "LeftButtonPressed");

 	lua_pushboolean(L, state & (1 << 9));
 	lua_setfield(L, -2, "RightButtonPressed");
@@ -756,13 +739,13 @@ static int syscalls_GetMouseSettings(lua_State* L)
 	lua_createtable(L, 0, 3);

 	lua_pushinteger(L, getMouseSettings(KSYS_MOUSE_GET_SPEED));
-	lua_setfield(L, -2, "speed");
+	lua_setfield(L, -2, "Speed");

 	lua_pushinteger(L, getMouseSettings(KSYS_MOUSE_GET_SENS));
-	lua_setfield(L, -2, "sensitivity");
+	lua_setfield(L, -2, "Sensitivity");

 	lua_pushinteger(L, getMouseSettings(KSYS_MOUSE_GET_DOUBLE_CLICK_DELAY));
-	lua_setfield(L, -2, "doubleClickDelay");
+	lua_setfield(L, -2, "DoubleClickDelay");

 	return 1;
 }
@@ -825,7 +808,7 @@ static int syscalls_SetMouseSettings(lua_State* L)
 	luaL_checktype(L, 1, LUA_TTABLE);

 	lua_getfield(L, 1, "Speed");
-	lua_getfield(L, 1, "Sens");
+	lua_getfield(L, 1, "Sensitivity");
 	lua_getfield(L, 1, "DoubleClickDelay");

 	_ksys_set_mouse_settings(KSYS_MOUSE_GET_SPEED, luaL_checkinteger(L, -3));
@@ -985,10 +968,7 @@ static int syscalls_GetTXByteCount(lua_State* L)
 		: "=a"(num), "=b"(NUM)
 		: "a"(74), "b"(8 | device << 8));

-	if (num == -1)
-		lua_pushnil(L);
-	else
-		lua_pushinteger(L, (uint64_t)(num | NUM << 31));
+	syscalls_ReturnIntegerValueOrNil(num, num | NUM << 31, L);

 	return 1;
 }
@@ -1004,10 +984,7 @@ static int syscalls_GetRXByteCount(lua_State* L)
 		: "=a"(num), "=b"(NUM)
 		: "a"(74), "b"(9 | device << 8));

-	if (num == -1)
-		lua_pushnil(L);
-	else
-		lua_pushinteger(L, (uint64_t)(num | NUM << 31));
+	syscalls_ReturnIntegerValueOrNil(num, num | NUM << 31, L);

 	return 1;
 }
@@ -1023,10 +1000,7 @@ static int syscalls_GetTXErrorPacketCount(lua_State* L)
 		: "=a"(num), "=b"(NUM)
 		: "a"(74), "b"(11 | device << 8));

-	if (num == -1)
-		lua_pushnil(L);
-	else
-		lua_pushinteger(L, (uint64_t)(num | NUM << 31));
+	syscalls_ReturnIntegerValueOrNil(num, num | NUM << 31, L);

 	return 1;
 }
@@ -1042,10 +1016,7 @@ static int syscalls_GetTXDropPacketCount(lua_State* L)
 		: "=a"(num), "=b"(NUM)
 		: "a"(74), "b"(12 | device << 8));

-	if (num == -1)
-		lua_pushnil(L);
-	else
-		lua_pushinteger(L, (uint64_t)(num | NUM << 31));
+	syscalls_ReturnIntegerValueOrNil(num, num | NUM << 31, L);

 	return 1;
 }
@@ -1061,10 +1032,7 @@ static int syscalls_GetTXMissPacketCount(lua_State* L)
 		: "=a"(num), "=b"(NUM)
 		: "a"(74), "b"(13 | device << 8));

-	if (num == -1)
-		lua_pushnil(L);
-	else
-		lua_pushinteger(L, (uint64_t)(num | NUM << 31));
+	syscalls_ReturnIntegerValueOrNil(num, num | NUM << 31, L);

 	return 1;
 }
@@ -1080,10 +1048,7 @@ static int syscalls_GetRXErrorPacketCount(lua_State* L)
 		: "=a"(num), "=b"(NUM)
 		: "a"(74), "b"(14 | device << 8));

-	if (num == -1)
-		lua_pushnil(L);
-	else
-		lua_pushinteger(L, (uint64_t)(num | NUM << 31));
+	syscalls_ReturnIntegerValueOrNil(num, num | NUM << 31, L);

 	return 1;
 }
@@ -1124,10 +1089,10 @@ enum ConnectionStatus
 {
 	NoConnect = 0,
 	Unknown = 1,
-	Mb10 = 4,         // 10Mb
-	Mb100 = 5,        // 100Mb
-	Gb = 6,           // 1Gb
-	FullDuplex = 0b10 //
+	Mb10 = 4,       	// 10Mb
+	Mb100 = 5,      	// 100Mb
+	Gb = 6,         	// 1Gb
+	FullDuplex = 0b10	//
 };

 static int syscalls_GetConnectionStatus(lua_State* L)
@@ -1144,6 +1109,7 @@ static int syscalls_GetConnectionStatus(lua_State* L)
 		lua_pushnil(L);
 	else
 		lua_pushinteger(L, num & 0x101);
+
 	lua_pushinteger(L, (num & FullDuplex) != 0);

 	return 2;
@@ -1173,7 +1139,7 @@ typedef enum SYSCALLS_PROTOCOLS
 	ARP = 5
 } SYSCALLS_PROTOCOLS;

-inline int syscalls_ReadPacketSend(lua_State* L, SYSCALLS_PROTOCOLS protocol)
+static inline int syscalls_ReadPacketSend(lua_State* L, SYSCALLS_PROTOCOLS protocol)
 {
 	uint32_t eax;
 	uint8_t device = luaL_checkinteger(L, 1);
@@ -1188,7 +1154,7 @@ inline int syscalls_ReadPacketSend(lua_State* L, SYSCALLS_PROTOCOLS protocol)
 	return 1;
 }

-inline int syscalls_ReadPacketReceive(lua_State* L, SYSCALLS_PROTOCOLS protocol)
+static inline int syscalls_ReadPacketReceive(lua_State* L, SYSCALLS_PROTOCOLS protocol)
 {
 	uint32_t eax;
 	uint8_t device = luaL_checkinteger(L, 1);
@@ -1420,7 +1386,7 @@ static int syscalls_ReadARPEntry(lua_State* L)
 	if (eax == -1)
 		lua_pushnil(L);
 	else
-		memcpy(syscalls_pushARPEntry(L), &buffer, sizeof(struct ARP_entry));
+		memcpy(syscalls_pushARPEntry(L), &buffer, sizeof(struct ARP_entry));	// не самый лучший вариант реализации, но если если запушить в луа это раньше то как потом запушить nil? хз может потому будут идеи более адекватной реализации

 	return 1;
 }
@@ -1502,7 +1468,7 @@ static const luaL_Reg syscallsLib[] = {
 	{"SetWindowTitle", syscalls_setWindowTitle},
 	{"GetSkinHeight", syscalls_getSkinHeight},
 	{"SetSkin", syscalls_SetSkin},
-	{"GetSkinTitleArea", syscalls_GetSkinTilteArea},
+	{"GetSkinTitleArea", syscalls_GetSkinTitleArea},
 	/* Buttons funcs*/
 	{"DefineButton", syscalls_defineButton},
 	{"DeleteButton", syscalls_deleteButton},
@@ -1514,11 +1480,16 @@ static const luaL_Reg syscallsLib[] = {
 	{"CheckEvent", syscalls_checkEvent},
 	{"WaitEventTimeout", syscalls_waitEventTimeout},
 	/* Background funcs */
-	{"BackgroundSetSize", syscalls_backgroundSetSize},
-	{"BackgroundPutPixel", syscalls_backgroundPutPixel},
-	{"BackgroundRedraw", syscalls_backgroundRedraw},
+	{ "BackgroundSetSize", syscalls_backgroundSetSize },
+	{ "BackgroundPutPixel", syscalls_backgroundPutPixel },
+	{ "BackgroundRedraw", syscalls_backgroundRedraw },
+	{ "BackgroundSetDrawMode", syscalls_backgroundSetDrawMode },
+	{ "BackgroundGetDrawMode", syscalls_backgroundGetDrawMode },
+	{ "BackgroundOpenMap", syscalls_backgroundOpenMap },
+	{ "BackgroundCloseMap", syscalls_backgroundCloseMap },
+	{ "BackgroundRedrawArea", syscalls_backgroundRedrawArea },
 	/* system funcs */
-	{"GetRamSize", syscalls_getRamSize},
+	{ "GetRamSize", syscalls_getRamSize },
 	{"GetFreeRam", syscalls_getFreeRam},
 	{"GetCPUClock", syscalls_getCPUClock},
 	{"ShutdownPowerOff", syscalls_shutdownPowerOff},
@@ -1539,8 +1510,8 @@ static const luaL_Reg syscallsLib[] = {
 	/* keyboard funcs */
 	{"SetKeyInputMode", syscalls_setKeyInputMode},
 	{"GetKeyInputMode", syscalls_getKeyInputMode},
-	{"getKey", syscalls_getKey},
-	{"getControlKeyState", syscalls_getControlKeyState},
+	{"GetKey", syscalls_getKey},
+	{"GetControlKeyState", syscalls_getControlKeyState},
 	{"SetHotkey", syscalls_SetHotkey},
 	{"DeleteHotkey", syscalls_DeleteHotkey},
 	{"LockNormalInput", syscalls_LockNormalInput},
@@ -1636,6 +1607,9 @@ static const luaL_Reg syscallsLib[] = {
 	{ "Done", syscalls_Done },
 	{ "DefineBreakpoint", syscalls_DefineBreakpoint },
 	{ "UndefBreakpoint", syscalls_UndefBreakpoint },
+	/* IPC */
+	{ "DefineIPCBuffer", syscalls_DefineIPCBuffer },
+	{ "SendIPCMessage", syscalls_SendIPCMessage },
 	{ NULL, NULL }
 };

@@ -1643,35 +1617,25 @@ static inline void syscalls_push_events(lua_State* L)
 {
 	lua_newtable(L);

-	lua_pushinteger(L, KSYS_EVENT_NONE);
-	lua_setfield(L, -2, "None");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_EVENT_NONE, "None");

-	lua_pushinteger(L, KSYS_EVENT_REDRAW);
-	lua_setfield(L, -2, "Redraw");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_EVENT_REDRAW, "Redraw");

-	lua_pushinteger(L, KSYS_EVENT_KEY);
-	lua_setfield(L, -2, "Key");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_EVENT_KEY, "Key");

-	lua_pushinteger(L, KSYS_EVENT_BUTTON);
-	lua_setfield(L, -2, "Button");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_EVENT_BUTTON, "Button");

-	lua_pushinteger(L, KSYS_EVENT_DESKTOP);
-	lua_setfield(L, -2, "Desktop");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_EVENT_DESKTOP, "Desktop");

-	lua_pushinteger(L, KSYS_EVENT_MOUSE);
-	lua_setfield(L, -2, "Mouse");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_EVENT_MOUSE, "Mouse");

-	lua_pushinteger(L, KSYS_EVENT_IPC);
-	lua_setfield(L, -2, "IPC");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_EVENT_IPC, "IPC");

-	lua_pushinteger(L, KSYS_EVENT_NETWORK);
-	lua_setfield(L, -2, "Network");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_EVENT_NETWORK, "Network");

-	lua_pushinteger(L, KSYS_EVENT_DEBUG);
-	lua_setfield(L, -2, "Debug");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_EVENT_DEBUG, "Debug");

-	lua_pushinteger(L, KSYS_EVENT_IRQBEGIN);
-	lua_setfield(L, -2, "IRQBegin");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_EVENT_IRQBEGIN, "IRQBegin");

 	lua_setfield(L, -2, "Event");
 }
@@ -1680,20 +1644,15 @@ static inline void syscalls_push_buttonCodes(lua_State* L)
 {
 	lua_newtable(L);

-	lua_pushinteger(L, KSYS_MOUSE_LBUTTON_PRESSED);
-	lua_setfield(L, -2, "LeftButton");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_MOUSE_LBUTTON_PRESSED, "LeftButton");

-	lua_pushinteger(L, KSYS_MOUSE_RBUTTON_PRESSED);
-	lua_setfield(L, -2, "RightButton");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_MOUSE_RBUTTON_PRESSED, "RightButton");

-	lua_pushinteger(L, KSYS_MOUSE_MBUTTON_PRESSED);
-	lua_setfield(L, -2, "MiddleButton");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_MOUSE_MBUTTON_PRESSED, "MiddleButton");

-	lua_pushinteger(L, KSYS_MOUSE_4BUTTON_PRESSED);
-	lua_setfield(L, -2, "Button4");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_MOUSE_4BUTTON_PRESSED, "Button4");

-	lua_pushinteger(L, KSYS_MOUSE_5BUTTON_PRESSED);
-	lua_setfield(L, -2, "Button5");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_MOUSE_5BUTTON_PRESSED, "Button5");

 	lua_setfield(L, -2, "mouseButtons");
 }
@@ -1702,26 +1661,19 @@ static inline void syscalls_push_slotStates(lua_State* L)
 {
 	lua_newtable(L);

-	lua_pushinteger(L, KSYS_SLOT_STATE_RUNNING);
-	lua_setfield(L, -2, "Running");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SLOT_STATE_RUNNING, "Running");

-	lua_pushinteger(L, KSYS_SLOT_STATE_SUSPENDED);
-	lua_setfield(L, -2, "Suspended");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SLOT_STATE_SUSPENDED, "Suspended");

-	lua_pushinteger(L, KSYS_SLOT_STATE_SUSPENDED_WAIT_EVENT);
-	lua_setfield(L, -2, "SuspendedWaitEvent");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SLOT_STATE_SUSPENDED_WAIT_EVENT, "SuspendedWaitEvent");

-	lua_pushinteger(L, KSYS_SLOT_STATE_NORMAL_TERM);
-	lua_setfield(L, -2, "NormalTerm");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SLOT_STATE_NORMAL_TERM, "NormalTerm");

-	lua_pushinteger(L, KSYS_SLOT_STATE_EXCEPT_TERM);
-	lua_setfield(L, -2, "ExceptTerm");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SLOT_STATE_EXCEPT_TERM, "ExceptTerm");

-	lua_pushinteger(L, KSYS_SLOT_STATE_EXCEPT_TERM);
-	lua_setfield(L, -2, "WaitEvent");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SLOT_STATE_EXCEPT_TERM, "WaitEvent");

-	lua_pushinteger(L, KSYS_SLOT_STATE_WAIT_EVENT);
-	lua_setfield(L, -2, "Free");
+	LUA_PUSH_INTEGER_FIELD(L, KSYS_SLOT_STATE_WAIT_EVENT, "Free");

 	lua_setfield(L, -2, "slotState");
 }
@@ -1730,21 +1682,15 @@ static inline void syscalls_push_hotkey_states(lua_State* L)
 {
 	lua_newtable(L);

-	lua_pushinteger(L, 0);
-	lua_setfield(L, -2, "hotkeyNoOne");
+	LUA_PUSH_INTEGER_FIELD(L, 0, "NoOne");

-	lua_pushinteger(L, 1);
-	lua_setfield(L, -2, "hotkeyOnlyOne");
+	LUA_PUSH_INTEGER_FIELD(L, 1, "OnlyOne");

-	lua_pushinteger(L, 2);
-	lua_setfield(L, -2, "hotkeyBoth");
+	LUA_PUSH_INTEGER_FIELD(L, 2, "Both");

-	lua_pushinteger(L, 4);
-	lua_setfield(L, -2, "hotkeyLeftOnly");
-
-	lua_pushinteger(L, 5);
-	lua_setfield(L, -2, "hotkeyRightOnly");
+	LUA_PUSH_INTEGER_FIELD(L, 4, "LeftOnly");

+	LUA_PUSH_INTEGER_FIELD(L, 5, "RightOnly");

 	lua_setfield(L, -2, "hotkeyStates");
 }
@@ -1753,12 +1699,9 @@ static inline void syscalls_push_buttonsStyle(lua_State* L)
 {
 	lua_newtable(L);

-	lua_pushinteger(L, 0);
-	lua_setfield(L, -2, "ButtonStyleFlat");
-
-	lua_pushinteger(L, 1);
-	lua_setfield(L, -2, "ButtonStyleVolume");
+	LUA_PUSH_INTEGER_FIELD(L, 0, "Flat");

+	LUA_PUSH_INTEGER_FIELD(L, 1, "Volume");

 	lua_setfield(L, -2, "buttonStyle");
 }
@@ -1767,20 +1710,15 @@ static inline void syscalls_push_windowStyles(lua_State* L)
 {
 	lua_newtable(L);

-	lua_pushinteger(L, 0);
-	lua_setfield(L, -2, "FixSizes");
+	LUA_PUSH_INTEGER_FIELD(L, 0, "FixSizes");

-	lua_pushinteger(L, 1);
-	lua_setfield(L, -2, "NoDraw");
+	LUA_PUSH_INTEGER_FIELD(L, 1, "NoDraw");

-	lua_pushinteger(L, 2);
-	lua_setfield(L, -2, "CanChangeSizes");
+	LUA_PUSH_INTEGER_FIELD(L, 2, "CanChangeSizes");

-	lua_pushinteger(L, 3);
-	lua_setfield(L, -2, "WithSkin");
+	LUA_PUSH_INTEGER_FIELD(L, 3, "WithSkin");

-	lua_pushinteger(L, 4);
-	lua_setfield(L, -2, "WithSkinFixSizes");
+	LUA_PUSH_INTEGER_FIELD(L, 4, "WithSkinFixSizes");

 	lua_setfield(L, -2, "windowStyle");
 }
@@ -1789,11 +1727,9 @@ static inline void syscalls_push_buttons(lua_State* L)
 {
 	lua_newtable(L);

-	lua_pushinteger(L, 0xffff);
-	lua_setfield(L, -2, "minimization");
+	LUA_PUSH_INTEGER_FIELD(L, 0xffff, "minimization");

-	lua_pushinteger(L, 1);
-	lua_setfield(L, -2, "close");
+	LUA_PUSH_INTEGER_FIELD(L, 1, "close");

 	lua_setfield(L, -2, "buttons");
 }
@@ -1802,20 +1738,15 @@ static inline void syscalls_push_connectionStatus(lua_State* L)
 {
 	lua_newtable(L);

-	lua_pushinteger(L, NoConnect);
-	lua_setfield(L, -2, "no");
+	LUA_PUSH_INTEGER_FIELD(L, NoConnect, "No");

-	lua_pushinteger(L, Unknown);
-	lua_setfield(L, -2, "unknown");
+	LUA_PUSH_INTEGER_FIELD(L, Unknown, "Unknown");

-	lua_pushinteger(L, Mb10);
-	lua_setfield(L, -2, "10Mb");
+	LUA_PUSH_INTEGER_FIELD(L, Mb10, "10Mb");

-	lua_pushinteger(L, Mb100);
-	lua_setfield(L, -2, "100Mb");
+	LUA_PUSH_INTEGER_FIELD(L, Mb100, "100Mb");

-	lua_pushinteger(L, Gb);
-	lua_setfield(L, -2, "1Gb");
+	LUA_PUSH_INTEGER_FIELD(L, Gb, "1GB");

 	lua_setfield(L, -2, "connectionStatus");
 }
@@ -1826,19 +1757,34 @@ LUALIB_API int luaopen_syscalls(lua_State* L)
 {
 	luaL_newlib(L, syscallsLib);

+	syscalls_push_library_version(L);
+
 	syscalls_push_events(L);
 	syscalls_push_slotStates(L);
+
 	syscalls_register_scancodes(L);
 	syscalls_push_hotkey_states(L);
+
 	syscalls_push_buttonsStyle(L);
 	syscalls_push_windowStyles(L);
+
 	syscalls_push_buttons(L);
+
+	// net
 	syscalls_push_connectionStatus(L);
+	syscalls_register_ARPEntry(L);
+
 	syscalls_push_graphic(L);

-	syscalls_register_ARPEntry(L);
+	// Register IPC
+	syscalls_register_IPC_msg(L);
+	syscalls_register_IPC_buffer(L);
+	syscalls_push_IPC_errors(L);
+
 	syscalls_register_SystemColors(L);

+	syscalls_register_Version(L);
+
 	_ksys_set_event_mask(7); // set default event mask

 	return 1;
--- a/src/syscalls.h
+++ b/src/syscalls.h
@@ -4,8 +4,9 @@
 #include <lua.h>
 #include <lualib.h>
 #include <lauxlib.h>
+#include <sys/ksys.h>

-inline void syscalls_ReturnIntegerOrNil(LUA_INTEGER value, lua_State* L)
+static inline void syscalls_ReturnIntegerOrNil(LUA_INTEGER value, lua_State* L)
 {
 	if (value == -1)
 	{
@@ -17,7 +18,7 @@ inline void syscalls_ReturnIntegerOrNil(LUA_INTEGER value, lua_State* L)
 	}
 }

-inline void syscalls_ReturnIntegerValueOrNil(LUA_INTEGER cond, LUA_INTEGER value, lua_State* L)
+static inline void syscalls_ReturnIntegerValueOrNil(LUA_INTEGER cond, LUA_INTEGER value, lua_State* L)
 {
 	if (cond == -1)
 	{
@@ -29,7 +30,7 @@ inline void syscalls_ReturnIntegerValueOrNil(LUA_INTEGER cond, LUA_INTEGER value
 	}
 }

-inline void syscalls_ReturnTrueOrNil(LUA_INTEGER value, lua_State* L)
+static inline void syscalls_ReturnTrueOrNil(LUA_INTEGER value, lua_State* L)
 {
 	if (value == -1)
 	{
@@ -41,7 +42,7 @@ inline void syscalls_ReturnTrueOrNil(LUA_INTEGER value, lua_State* L)
 	}
 }

-inline void syscalls_ReturnStringOrNil(LUA_INTEGER cond, const char* value, lua_State* L)
+static inline void syscalls_ReturnStringOrNil(LUA_INTEGER cond, const char* value, lua_State* L)
 {
 	if (cond == -1)
 	{
@@ -53,4 +54,27 @@ inline void syscalls_ReturnStringOrNil(LUA_INTEGER cond, const char* value, lua_
 	}
 }

+#define LUA_PUSH_INTEGER_FIELD(L, val, name) lua_pushinteger(L, val); lua_setfield(L, -2, name);
+#define LUA_PUSH_STRING_FIELD(L, val, name) lua_pushstring(L, val); lua_setfield(L, -2, name);
+#define LUA_PUSH_NUMBER_FIELD(L, val, name) lua_pushnumber(L, val); lua_setfield(L, -2, name);
+
+static inline ksys_pos_t syscalls_check_pos_t(lua_State* L, int index)
+{
+	ksys_pos_t pos;
+
+	pos.x = luaL_checkinteger(L, index);
+	pos.y = luaL_checkinteger(L, index + 1);
+
+	return pos;
+}
+
+static inline void syscalls_push_pos_t(lua_State* L, ksys_pos_t pos)
+{
+	lua_createtable(L, 0, 2);
+
+	LUA_PUSH_INTEGER_FIELD(L, pos.x, "x");
+
+	LUA_PUSH_INTEGER_FIELD(L, pos.y, "y");
+}
+
 #endif // __SYSCALLS_H__
--- a/src/version/coreversion.c
+++ b/src/version/coreversion.c
@@ -0,0 +1,13 @@
+#include "coreversion.h"
+
+int syscalls_GetCoreVersion(lua_State* L)
+{
+	struct core_version* ver = syscalls_pushVersion(L);
+
+	asm_inline(
+		"int $0x40"
+		::"a"(18), "b"(13), "c"(ver)
+	);
+
+	return 1;
+}
--- a/src/version/coreversion.h
+++ b/src/version/coreversion.h
@@ -0,0 +1,8 @@
+#ifndef __CORE_VERSION_H__
+#define __CORE_VERSION_H__
+
+#include "version_type.h"
+
+int syscalls_GetCoreVersion(lua_State *L);
+
+#endif // __CORE_VERSION_H__
--- a/src/version/library_version.h
+++ b/src/version/library_version.h
@@ -0,0 +1,17 @@
+#ifndef __LIBRARY_VERSION_H__
+#define __LIBRARY_VERSION_H__
+
+#include "../syscalls.h"
+
+inline void syscalls_push_library_version(lua_State* L)
+{
+	lua_createtable(L, 0, 3);
+
+	LUA_PUSH_INTEGER_FIELD(L, SYSCALLS_VERSION_A, "a");
+	LUA_PUSH_INTEGER_FIELD(L, SYSCALLS_VERSION_B, "b");
+	LUA_PUSH_INTEGER_FIELD(L, SYSCALLS_VERSION_C, "c");
+
+	lua_setfield(L, -2, "version");
+}
+
+#endif // __LIBRARY_VERSION_H__
--- a/src/version/version_type.c
+++ b/src/version/version_type.c
@@ -0,0 +1,202 @@
+#include "version_type.h"
+#include <string.h>
+#include "../debug.h"
+
+static int syscalls_indexVersion(lua_State* L)
+{
+	struct core_version* r = luaL_checkudata(L, 1, syscalls_Version_metatable_name);
+	const char* index = luaL_checkstring(L, 2);
+
+	if (strcmp(index, "a") == 0)
+	{
+		lua_pushinteger(L, r->a);
+	}
+	else if (strcmp(index, "b") == 0)
+	{
+		lua_pushinteger(L, r->b);
+	}
+	else if (strcmp(index, "c") == 0)
+	{
+		lua_pushinteger(L, r->c);
+	}
+	else if (strcmp(index, "d") == 0)
+	{
+		lua_pushinteger(L, r->d);
+	}
+	else if (strcmp(index, "rev") == 0)
+	{
+		lua_pushinteger(L, r->revision);
+	}
+	else
+	{
+		lua_pushnil(L);
+	}
+
+	return 1;
+}
+
+static int syscalls_newindexVersion(lua_State* L)
+{
+	struct core_version* r = luaL_checkudata(L, 1, syscalls_Version_metatable_name);
+	const char* index = luaL_checkstring(L, 2);
+	uint32_t val = luaL_checkinteger(L, 3);
+
+	if (strcmp(index, "a") == 0)
+	{
+		r->a = val;
+	}
+	else if (strcmp(index, "b") == 0)
+	{
+		r->b = val;
+	}
+	else if (strcmp(index, "c") == 0)
+	{
+		r->c = val;
+	}
+	else if (strcmp(index, "d") == 0)
+	{
+		r->d = val;
+	}
+	else if (strcmp(index, "rev") == 0)
+	{
+		r->revision = val;
+	}
+	else
+	{
+		luaL_error(L, "wrong index: %s", index);
+	}
+
+	return 0;
+}
+
+static int syscalls_eqVersion(lua_State* L)
+{
+	lua_pushboolean(
+		L,
+		memcmp(
+			luaL_checkudata(L, 1, syscalls_Version_metatable_name),
+			luaL_checkudata(L, 2, syscalls_Version_metatable_name),
+			sizeof(struct core_version)
+		)
+	);
+
+	return 1;
+}
+
+static int syscalls_ltVersion(lua_State* L)
+{
+	struct core_version* a = luaL_checkudata(L, 1, syscalls_Version_metatable_name);
+	struct core_version* b = luaL_checkudata(L, 2, syscalls_Version_metatable_name);
+
+	bool r;
+
+	if (a->a < b->a)
+		r = true;
+	else if (a->b < b->b)
+		r = true;
+	else if (a->c < b->c)
+		r = true;
+	else if (a->d < b->d)
+		r = true;
+	else if (a->revision < b->revision)
+		r = true;
+	else
+		r = false;
+
+	lua_pushboolean(L, r);
+
+	return 1;
+}
+
+static int syscalls_leVersion(lua_State* L)
+{
+	struct core_version* a = luaL_checkudata(L, 1, syscalls_Version_metatable_name);
+	struct core_version* b = luaL_checkudata(L, 2, syscalls_Version_metatable_name);
+
+	bool r;
+
+	if (a->a <= b->a)
+		r = true;
+	else if (a->b <= b->b)
+		r = true;
+	else if (a->c <= b->c)
+		r = true;
+	else if (a->d <= b->d)
+		r = true;
+	else if (a->revision <= b->revision)
+		r = true;
+	else
+		r = false;
+
+	lua_pushboolean(L, r);
+	return 1;
+}
+
+static int syscalls_tostringVersion(lua_State* L)
+{
+	// AAA.BBB.CCC.DDD.RRRRRRRRRRRRR
+	// +1 на конце на всякий случай
+	char buff[4 + 4 + 4 + 4 + 13 + 1];
+	struct core_version* a = luaL_checkudata(L, 1, syscalls_Version_metatable_name);
+
+	sprintf(buff, "%d.%d.%d.%d.%d", a->a, a->b, a->c, a->d, a->revision);
+
+	lua_pushstring(L, buff);
+
+	return 1;
+}
+
+static const luaL_Reg syscalls_Version_m[] = {
+	{"__index", syscalls_indexVersion},
+	{"__newindex", syscalls_newindexVersion},
+	{"__eq", syscalls_eqVersion},
+	{"__lt", syscalls_ltVersion},
+	{"__le", syscalls_ltVersion},
+	{"__tostring", syscalls_tostringVersion},
+	{NULL, NULL}
+};
+
+struct core_version* syscalls_pushVersion(lua_State* L)
+{
+	DEBUG_LINE("push Version entry");
+
+	struct core_version* entry = lua_newuserdata(L, sizeof(struct core_version));
+
+	luaL_setmetatable(L, syscalls_Version_metatable_name);
+
+	return entry;
+}
+
+static int syscalls_newVersion(lua_State* L)
+{
+	struct core_version* r = syscalls_pushVersion(L);
+	memset(r, 0, sizeof(struct core_version));
+
+	r->a = luaL_checkinteger(L, 1);
+	r->b = luaL_checkinteger(L, 2);
+	r->c = luaL_checkinteger(L, 3);
+	r->d = luaL_checkinteger(L, 4);
+	r->revision = luaL_checkinteger(L, 5);
+
+	return 1;
+}
+
+static const luaL_Reg syscalls_Version_lib[] = {
+	{"new", syscalls_newVersion},
+	{NULL, NULL}
+};
+
+void syscalls_register_Version(lua_State* L)
+{
+	DEBUG_LINE("register Version entry");
+
+	luaL_newlib(L, syscalls_Version_lib);
+
+	lua_setfield(L, -2, syscalls_Version_name);
+
+
+	luaL_newmetatable(L, syscalls_Version_metatable_name);
+	luaL_setfuncs(L, syscalls_Version_m, 0);
+
+	lua_pop(L, 1);
+}
--- a/src/version/version_type.h
+++ b/src/version/version_type.h
@@ -0,0 +1,28 @@
+#ifndef __VERSION_TYPE_H__
+#define __VERSION_TYPE_H__
+
+#include <sys/ksys.h>
+#include "../syscalls.h"
+
+// sub library name
+#define syscalls_Version_name "CoreVersion"
+#define syscalls_Version_metatable_name "Version table"
+#define syscalls_Version_metatable_name "Version metatable"
+
+struct core_version
+{
+	uint8_t a;
+	uint8_t b;
+	uint8_t c;
+	uint8_t d;
+	uint8_t zero;
+	uint32_t revision;
+
+	uint32_t unused;
+};
+
+struct core_version* syscalls_pushVersion(lua_State* L);
+
+void syscalls_register_Version(lua_State* L);
+
+#endif // __VERSION_TYPE_H__
--- a/tests/ipc_get.lua
+++ b/tests/ipc_get.lua
@@ -0,0 +1,35 @@
+--[[
+	Этот скрипт принимает данные от ipc_send и выводит в консоль
+]]
+
+local syscalls = require("syscalls")
+
+-- Enable IPC event only
+syscalls.SetEventMask(1 << (syscalls.Event.IPC - 1))
+
+-- write pid to /tmp0/1/lua_test_ipc_pid
+
+local pid = syscalls.ThreadInfo().PID
+
+local f = io.open("/tmp0/1/lua_test_ipc_pid", "w")
+
+if f then
+	f:write(pid);
+
+	f:close()
+end
+
+------------
+
+local buffer = syscalls.DefineIPCBuffer(4096)
+syscalls.IPC_buffer.Unlock(buffer)
+
+
+while true do
+	print("buffer:", buffer.used .. '/' .. buffer.size, "Locked:" .. tostring(buffer.lock))
+	if syscalls.WaitEvent() == syscalls.Event.IPC then
+		syscalls.IPC_buffer.Lock(buffer)
+		print("message:", syscalls.IPC_buffer.GetLastMessage(buffer))
+		syscalls.IPC_buffer.Unlock(buffer)
+	end
+end
--- a/tests/ipc_send.lua
+++ b/tests/ipc_send.lua
@@ -0,0 +1,21 @@
+--[[
+	скрипт который отправляет данные по IPC
+]]
+
+local syscalls = require("syscalls")
+
+local f = io.open("/tmp0/1/lua_test_ipc_pid", "r")
+
+local pid
+
+if f then
+	pid = tonumber(f:read("l"))
+	f:close()
+end
+
+if pid then
+	while true do
+		local msg = syscalls.IPC_msg.fromString("Test aboba", pid)
+		print("Send:", msg, "State:", syscalls.SendIPCMessage(msg))
+	end
+end
--- a/tests/run_tests.sh
+++ b/tests/run_tests.sh
@@ -0,0 +1,11 @@
+#SHS
+
+# Graphic
+../lua helloWorld.lua
+
+../lua SystemColors.lua
+
+# IPC tests
+../lua ipc_get.lua
+../lua ipc_send.lua
+
Author	SHA1	Message	Date
Егор	0622e8b455	слито в этой ветку свякое уже добавлено, что хотелось бы использовать дальше	2025-06-03 14:22:34 +02:00
Egor00f	6ff2ed0386	fix build && add auto run for tests	2025-05-29 13:46:26 +05:00
Egor00f	5e441a984f	некотрые фиксы ipc (но всеравное всрато работаетЖ не работает)	2025-05-18 15:05:26 +05:00
Egor00f	521d00fdb8	create buffer class && some warnings fixes && update manual && create vscode tasks	2025-05-08 23:48:52 +05:00
Egor00f	79a79c5409	Merge branch 'main' into add-ipc	2025-05-02 13:43:03 +05:00
Egor00f	105f80a8f6	delete lua && add background funcs	2025-05-02 13:13:56 +05:00
Egor00f	1c77f25017	use ld instead gcc	2025-04-27 14:58:40 +05:00
Egor00f	a4042c34d4	Merge branch 'update-lua'	2025-04-27 12:03:33 +05:00
Egor00f	37ae2a28a9	add core version and library version	2025-04-26 19:57:15 +02:00
Egor00f	e6cc79ee8b	make build for different lua versions	2025-04-26 22:43:31 +05:00
Egor00f	5319af9056	delete lua	2025-04-26 22:42:45 +05:00
Egor00f	63359cb028	update lua	2025-04-26 21:44:24 +05:00
Егор	68e8b3417e	fix GetKey function зачем то добавлялся к символу перевод на новую строку, хотя должен быть это 0. Наверное опечатка. теперь исправил	2025-04-25 20:37:15 +02:00
Egor00f	9b6f4a4404	add IPC errors && fix build errors	2025-04-18 16:11:11 +05:00
Egor00f	563259355d	сделал нормальные имена полей таблиц, возвращаемых некоторыми функциями(и получаемых в аргументах) && create and use macro LUA_PUSH_INTEGER_FILED for push enums	2025-04-18 12:44:18 +02:00
Egor00f	8c155bbe09	update manual.md	2025-04-18 12:44:18 +02:00
Егор	ac932b3a43	update manual	2025-04-18 12:44:18 +02:00
Егор	e75ef3eb9e	Update manual Add more funcs	2025-04-18 12:44:18 +02:00
Egor00f	180d3f795b	add IPC to build && fix errors	2025-04-18 15:31:41 +05:00
Egor00f	f81b5c1b23	create IPC folder && create IPC_msg class	2025-04-18 15:13:25 +05:00
Егор	907322a122	create ipc.c	2025-04-17 06:51:38 +02:00
Egor00f	008485e004	сделал нормальные имена полей таблиц, возвращаемых некоторыми функциями(и получаемых в аргументах) && create and use macro LUA_PUSH_INTEGER_FILED for push enums	2025-04-16 20:23:27 +05:00
Egor00f	14ef5e42a8	update manual.md	2025-04-16 15:49:54 +05:00
Егор	9ca0d8d658	update manual	2025-04-16 08:59:49 +02:00
Егор	186fbe426e	Update manual Add more funcs	2025-04-16 08:41:11 +02:00