738 lines
18 KiB
C
738 lines
18 KiB
C
/*
|
||
* ntfiles.h
|
||
*
|
||
* Copyright 2026
|
||
*
|
||
* This program is free software; you can redistribute it and/or modify
|
||
* it under the terms of the GNU General Public License as published by
|
||
* the Free Software Foundation; either version 2 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 General Public License for more details.
|
||
*
|
||
* You should have received a copy of the GNU General Public License
|
||
* along with this program; if not, write to the Free Software
|
||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
|
||
* MA 02110-1301, USA.
|
||
*
|
||
*
|
||
*/
|
||
|
||
#if (!defined(__LIB_ntfiles_H))
|
||
#define __LIB_ntfiles_H
|
||
|
||
typedef unsigned char byte_t;
|
||
typedef unsigned short int word_t;
|
||
|
||
#if defined(__LP64__) || defined(_M_IA64)
|
||
typedef unsigned int dword_t;
|
||
typedef unsigned long int qword_t;
|
||
#else
|
||
typedef unsigned long int dword_t;
|
||
typedef unsigned long long int qword_t;
|
||
#endif
|
||
|
||
typedef signed char sbyte_t;
|
||
typedef signed short int sword_t;
|
||
|
||
#if defined(__LP64__) || defined(_M_IA64)
|
||
typedef signed int sdword_t;
|
||
typedef signed long int sqword_t;
|
||
#else
|
||
typedef signed long int sdword_t;
|
||
typedef signed long long int sqword_t;
|
||
#endif
|
||
|
||
#define stack __ntsys_stack
|
||
#define sp __ntsys_stack_pointer
|
||
#define buf __ntsys_buffer
|
||
#define cnt __ntsys_buffer_ptr
|
||
#define ip __ntsys_buffer_ptr
|
||
|
||
static void push(void) {
|
||
size_t size = buf[cnt];
|
||
sp -= size;
|
||
size_t t = 0;
|
||
while (t < size) {
|
||
stack[sp + t] = buf[++cnt];
|
||
t ++;
|
||
}
|
||
cnt ++;
|
||
}
|
||
|
||
static void pop(void) {
|
||
sp += buf[cnt++];
|
||
}
|
||
|
||
static void push_str(void) {
|
||
size_t size = 0;
|
||
while (buf[cnt] != 0) {
|
||
size ++;
|
||
cnt ++;
|
||
}
|
||
size ++;
|
||
cnt -= size;
|
||
sp -= size;
|
||
size_t t = 0;
|
||
while (t < size) {
|
||
stack[sp + t] = buf[++cnt];
|
||
t ++;
|
||
}
|
||
cnt ++;
|
||
}
|
||
|
||
__e_byte_t arg1_fGH6VSEzu7qNiGVE[8];
|
||
__e_byte_t arg2_fGH6VSEzu7qNiGVE[8];
|
||
|
||
#define arg1 arg1_fGH6VSEzu7qNiGVE
|
||
#define arg2 arg2_fGH6VSEzu7qNiGVE
|
||
|
||
static void pop_arg(size_t size, __e_byte_t* arg) {
|
||
int __i = 1;
|
||
if (!(*((char *)&__i) == 1)) {
|
||
/* BIG ENDIAN */
|
||
size_t i = 0;
|
||
while (i < size) {
|
||
arg[size - i - 1] = stack[sp + i];
|
||
i ++;
|
||
}
|
||
sp += size;
|
||
} else {
|
||
/* LITTLE ENDIAN */
|
||
size_t i = 0;
|
||
while (i < size) {
|
||
arg[i] = stack[sp + i];
|
||
i ++;
|
||
}
|
||
sp += size;
|
||
}
|
||
}
|
||
|
||
static void nt_not() {
|
||
size_t size = buf[cnt++];
|
||
pop_arg(size, arg1);
|
||
sp -= size;
|
||
size_t i = 0;
|
||
while (i < size) {
|
||
stack[sp + i] = ~arg1[i];
|
||
i ++;
|
||
}
|
||
}
|
||
|
||
static void operation(__e_byte_t op) {
|
||
size_t size = buf[cnt++];
|
||
pop_arg(size & 0x0F, arg1);
|
||
pop_arg(size & 0x0F, arg2);
|
||
switch (op) {
|
||
case 1:
|
||
switch (size) {
|
||
case 0x01:
|
||
*(byte_t*)arg1 = *(byte_t*)arg1 + *(byte_t*)arg2;
|
||
break;
|
||
case 0x02:
|
||
*(word_t*)arg1 = *(word_t*)arg1 + *(word_t*)arg2;
|
||
break;
|
||
case 0x04:
|
||
*(dword_t*)arg1 = *(dword_t*)arg1 + *(dword_t*)arg2;
|
||
break;
|
||
case 0x08:
|
||
*(qword_t*)arg1 = *(qword_t*)arg1 + *(qword_t*)arg2;
|
||
break;
|
||
case 0xF1:
|
||
*(sbyte_t*)arg1 = *(sbyte_t*)arg1 + *(sbyte_t*)arg2;
|
||
break;
|
||
case 0xF2:
|
||
*(sword_t*)arg1 = *(sword_t*)arg1 + *(sword_t*)arg2;
|
||
break;
|
||
case 0xF4:
|
||
*(sdword_t*)arg1 = *(sdword_t*)arg1 + *(sdword_t*)arg2;
|
||
break;
|
||
case 0xF8:
|
||
*(sqword_t*)arg1 = *(sqword_t*)arg1 + *(sqword_t*)arg2;
|
||
break;
|
||
}
|
||
break;
|
||
case 2:
|
||
switch (size) {
|
||
case 0x01:
|
||
*(byte_t*)arg1 = *(byte_t*)arg1 - *(byte_t*)arg2;
|
||
break;
|
||
case 0x02:
|
||
*(word_t*)arg1 = *(word_t*)arg1 - *(word_t*)arg2;
|
||
break;
|
||
case 0x04:
|
||
*(dword_t*)arg1 = *(dword_t*)arg1 - *(dword_t*)arg2;
|
||
break;
|
||
case 0x08:
|
||
*(qword_t*)arg1 = *(qword_t*)arg1 - *(qword_t*)arg2;
|
||
break;
|
||
case 0xF1:
|
||
*(sbyte_t*)arg1 = *(sbyte_t*)arg1 - *(sbyte_t*)arg2;
|
||
break;
|
||
case 0xF2:
|
||
*(sword_t*)arg1 = *(sword_t*)arg1 - *(sword_t*)arg2;
|
||
break;
|
||
case 0xF4:
|
||
*(sdword_t*)arg1 = *(sdword_t*)arg1 - *(sdword_t*)arg2;
|
||
break;
|
||
case 0xF8:
|
||
*(sqword_t*)arg1 = *(sqword_t*)arg1 - *(sqword_t*)arg2;
|
||
break;
|
||
}
|
||
break;
|
||
case 3:
|
||
switch (size) {
|
||
case 0x01:
|
||
*(byte_t*)arg1 = *(byte_t*)arg1 * (*(byte_t*)arg2);
|
||
break;
|
||
case 0x02:
|
||
*(word_t*)arg1 = *(word_t*)arg1 * (*(byte_t*)arg2);
|
||
break;
|
||
case 0x04:
|
||
*(dword_t*)arg1 = *(dword_t*)arg1 * (*(byte_t*)arg2);
|
||
break;
|
||
case 0x08:
|
||
*(qword_t*)arg1 = *(qword_t*)arg1 * (*(byte_t*)arg2);
|
||
break;
|
||
case 0xF1:
|
||
*(sbyte_t*)arg1 = *(sbyte_t*)arg1 * (*(byte_t*)arg2);
|
||
break;
|
||
case 0xF2:
|
||
*(sword_t*)arg1 = *(sword_t*)arg1 * (*(byte_t*)arg2);
|
||
break;
|
||
case 0xF4:
|
||
*(sdword_t*)arg1 = *(sdword_t*)arg1 * (*(byte_t*)arg2);
|
||
break;
|
||
case 0xF8:
|
||
*(sqword_t*)arg1 = *(sqword_t*)arg1 * (*(byte_t*)arg2);
|
||
break;
|
||
}
|
||
break;
|
||
case 4:
|
||
switch (size) {
|
||
case 0x01:
|
||
*(byte_t*)arg1 = *(byte_t*)arg1 / *(byte_t*)arg2;
|
||
break;
|
||
case 0x02:
|
||
*(word_t*)arg1 = *(word_t*)arg1 / *(word_t*)arg2;
|
||
break;
|
||
case 0x04:
|
||
*(dword_t*)arg1 = *(dword_t*)arg1 / *(dword_t*)arg2;
|
||
break;
|
||
case 0x08:
|
||
*(qword_t*)arg1 = *(qword_t*)arg1 / *(qword_t*)arg2;
|
||
break;
|
||
case 0xF1:
|
||
*(sbyte_t*)arg1 = *(sbyte_t*)arg1 / *(sbyte_t*)arg2;
|
||
break;
|
||
case 0xF2:
|
||
*(sword_t*)arg1 = *(sword_t*)arg1 / *(sword_t*)arg2;
|
||
break;
|
||
case 0xF4:
|
||
*(sdword_t*)arg1 = *(sdword_t*)arg1 / *(sdword_t*)arg2;
|
||
break;
|
||
case 0xF8:
|
||
*(sqword_t*)arg1 = *(sqword_t*)arg1 / *(sqword_t*)arg2;
|
||
break;
|
||
}
|
||
break;
|
||
}
|
||
sp -= size & 0x0F;
|
||
size_t i = 0;
|
||
while (i < (size & 0x0F)) {
|
||
stack[sp + i] = arg1[i];
|
||
i ++;
|
||
}
|
||
}
|
||
|
||
static void add(void) {
|
||
operation(1);
|
||
}
|
||
|
||
static void sub(void) {
|
||
operation(2);
|
||
}
|
||
|
||
static void mul(void) {
|
||
operation(3);
|
||
}
|
||
|
||
static void div_r(void) {
|
||
operation(4);
|
||
}
|
||
|
||
static void logic_operation(__e_byte_t n) {
|
||
size_t size = buf[cnt++];
|
||
pop_arg(size, arg1);
|
||
pop_arg(size, arg2);
|
||
switch (n) {
|
||
case 1:
|
||
switch (size) {
|
||
case 0x01:
|
||
*(byte_t*)arg1 = *(byte_t*)arg1 >> *(byte_t*)arg2;
|
||
case 0x02:
|
||
*(word_t*)arg1 = *(word_t*)arg1 >> *(word_t*)arg2;
|
||
case 0x04:
|
||
*(dword_t*)arg1 = *(dword_t*)arg1 >> *(dword_t*)arg2;
|
||
case 0x08:
|
||
*(qword_t*)arg1 = *(qword_t*)arg1 >> *(qword_t*)arg2;
|
||
}
|
||
break;
|
||
case 2:
|
||
switch (size) {
|
||
case 0x01:
|
||
*(byte_t*)arg1 = *(byte_t*)arg1 << *(byte_t*)arg2;
|
||
case 0x02:
|
||
*(word_t*)arg1 = *(word_t*)arg1 << *(word_t*)arg2;
|
||
case 0x04:
|
||
*(dword_t*)arg1 = *(dword_t*)arg1 << *(dword_t*)arg2;
|
||
case 0x08:
|
||
*(qword_t*)arg1 = *(qword_t*)arg1 << *(qword_t*)arg2;
|
||
}
|
||
break;
|
||
case 3:
|
||
switch (size) {
|
||
case 0x01:
|
||
*(byte_t*)arg1 = *(byte_t*)arg1 | *(byte_t*)arg2;
|
||
case 0x02:
|
||
*(word_t*)arg1 = *(word_t*)arg1 | *(word_t*)arg2;
|
||
case 0x04:
|
||
*(dword_t*)arg1 = *(dword_t*)arg1 | *(dword_t*)arg2;
|
||
case 0x08:
|
||
*(qword_t*)arg1 = *(qword_t*)arg1 | *(qword_t*)arg2;
|
||
}
|
||
break;
|
||
case 4:
|
||
switch (size) {
|
||
case 0x01:
|
||
*(byte_t*)arg1 = *(byte_t*)arg1 & *(byte_t*)arg2;
|
||
case 0x02:
|
||
*(word_t*)arg1 = *(word_t*)arg1 & *(word_t*)arg2;
|
||
case 0x04:
|
||
*(dword_t*)arg1 = *(dword_t*)arg1 & *(dword_t*)arg2;
|
||
case 0x08:
|
||
*(qword_t*)arg1 = *(qword_t*)arg1 & *(qword_t*)arg2;
|
||
}
|
||
break;
|
||
case 5:
|
||
switch (size) {
|
||
case 0x01:
|
||
*(byte_t*)arg1 = *(byte_t*)arg1 ^ *(byte_t*)arg2;
|
||
case 0x02:
|
||
*(word_t*)arg1 = *(word_t*)arg1 ^ *(word_t*)arg2;
|
||
case 0x04:
|
||
*(dword_t*)arg1 = *(dword_t*)arg1 ^ *(dword_t*)arg2;
|
||
case 0x08:
|
||
*(qword_t*)arg1 = *(qword_t*)arg1 ^ *(qword_t*)arg2;
|
||
}
|
||
break;
|
||
}
|
||
sp -= size;
|
||
size_t i = 0;
|
||
while (i < size) {
|
||
stack[sp + i] = arg1[i];
|
||
i ++;
|
||
}
|
||
}
|
||
|
||
static void nt_shr(void) {
|
||
logic_operation(1);
|
||
}
|
||
|
||
static void nt_shl(void) {
|
||
logic_operation(2);
|
||
}
|
||
|
||
static void nt_or(void) {
|
||
logic_operation(3);
|
||
}
|
||
|
||
static void nt_and(void) {
|
||
logic_operation(4);
|
||
}
|
||
|
||
static void nt_xor(void) {
|
||
logic_operation(5);
|
||
}
|
||
|
||
static void nt_goto(void) {
|
||
pop_arg(2, arg1);
|
||
cnt = *(word_t*)arg1;
|
||
}
|
||
|
||
static void bez_bnez(__e_byte_t mode) {
|
||
size_t size = buf[cnt++];
|
||
pop_arg(size & 0x0F, arg1);
|
||
__e_byte_t res = 0;
|
||
switch (size) {
|
||
case 0x01:
|
||
if (*(byte_t*)arg1 == 0) res = 1;
|
||
break;
|
||
case 0x02:
|
||
if (*(word_t*)arg1 == 0) res = 1;
|
||
break;
|
||
case 0x04:
|
||
if (*(dword_t*)arg1 == 0) res = 1;
|
||
break;
|
||
case 0x08:
|
||
if (*(qword_t*)arg1 == 0) res = 1;
|
||
break;
|
||
case 0xF1:
|
||
if (*(sbyte_t*)arg1 == 0) res = 1;
|
||
break;
|
||
case 0xF2:
|
||
if (*(sword_t*)arg1 == 0) res = 1;
|
||
break;
|
||
case 0xF4:
|
||
if (*(sdword_t*)arg1 == 0) res = 1;
|
||
break;
|
||
case 0xF8:
|
||
if (*(sqword_t*)arg1 == 0) res = 1;
|
||
break;
|
||
}
|
||
if (mode) res = !res;
|
||
pop_arg(2, arg2);
|
||
if (res) {
|
||
cnt = *(word_t*)arg2;
|
||
}
|
||
}
|
||
|
||
static void push_arg(size_t size, __e_byte_t* arg) {
|
||
sp -= size;
|
||
size_t i = 0;
|
||
while (i < size) {
|
||
stack[sp + i] = arg[i];
|
||
i ++;
|
||
}
|
||
}
|
||
|
||
static void n_up_down_eq(__e_byte_t mode) {
|
||
size_t size = buf[cnt++];
|
||
pop_arg(size & 0x0F, arg1);
|
||
pop_arg(size & 0x0F, arg2);
|
||
__e_byte_t res = 0;
|
||
switch (mode & 0x0F) {
|
||
case 0:
|
||
switch (size) {
|
||
case 0x01:
|
||
if (*(byte_t*)arg1 == *(byte_t*)arg2) res = 1;
|
||
break;
|
||
case 0x02:
|
||
if (*(word_t*)arg1 == *(word_t*)arg2) res = 1;
|
||
break;
|
||
case 0x04:
|
||
if (*(dword_t*)arg1 == *(dword_t*)arg2) res = 1;
|
||
break;
|
||
case 0x08:
|
||
if (*(qword_t*)arg1 == *(qword_t*)arg2) res = 1;
|
||
break;
|
||
case 0xF1:
|
||
if (*(qword_t*)arg1 == *(qword_t*)arg2) res = 1;
|
||
break;
|
||
case 0xF2:
|
||
if (*(sword_t*)arg1 == *(sword_t*)arg2) res = 1;
|
||
break;
|
||
case 0xF4:
|
||
if (*(sdword_t*)arg1 == *(sdword_t*)arg2) res = 1;
|
||
break;
|
||
case 0xF8:
|
||
if (*(sqword_t*)arg1 == *(sqword_t*)arg2) res = 1;
|
||
break;
|
||
}
|
||
break;
|
||
case 1:
|
||
switch (size) {
|
||
case 0x01:
|
||
if (*(byte_t*)arg1 > *(byte_t*)arg2) res = 1;
|
||
break;
|
||
case 0x02:
|
||
if (*(word_t*)arg1 > *(word_t*)arg2) res = 1;
|
||
break;
|
||
case 0x04:
|
||
if (*(dword_t*)arg1 > *(dword_t*)arg2) res = 1;
|
||
break;
|
||
case 0x08:
|
||
if (*(qword_t*)arg1 > *(qword_t*)arg2) res = 1;
|
||
break;
|
||
case 0xF1:
|
||
if (*(qword_t*)arg1 > *(qword_t*)arg2) res = 1;
|
||
break;
|
||
case 0xF2:
|
||
if (*(sword_t*)arg1 > *(sword_t*)arg2) res = 1;
|
||
break;
|
||
case 0xF4:
|
||
if (*(sdword_t*)arg1 > *(sdword_t*)arg2) res = 1;
|
||
break;
|
||
case 0xF8:
|
||
if (*(sqword_t*)arg1 > *(sqword_t*)arg2) res = 1;
|
||
break;
|
||
}
|
||
break;
|
||
case 2:
|
||
switch (size) {
|
||
case 0x01:
|
||
if (*(byte_t*)arg1 < *(byte_t*)arg2) res = 1;
|
||
break;
|
||
case 0x02:
|
||
if (*(word_t*)arg1 < *(word_t*)arg2) res = 1;
|
||
break;
|
||
case 0x04:
|
||
if (*(dword_t*)arg1 < *(dword_t*)arg2) res = 1;
|
||
break;
|
||
case 0x08:
|
||
if (*(qword_t*)arg1 < *(qword_t*)arg2) res = 1;
|
||
break;
|
||
case 0xF1:
|
||
if (*(qword_t*)arg1 < *(qword_t*)arg2) res = 1;
|
||
break;
|
||
case 0xF2:
|
||
if (*(sword_t*)arg1 < *(sword_t*)arg2) res = 1;
|
||
break;
|
||
case 0xF4:
|
||
if (*(sdword_t*)arg1 < *(sdword_t*)arg2) res = 1;
|
||
break;
|
||
case 0xF8:
|
||
if (*(sqword_t*)arg1 < *(sqword_t*)arg2) res = 1;
|
||
break;
|
||
}
|
||
break;
|
||
}
|
||
if ((mode & 0xF0) == 0xF0) res = !res;
|
||
pop_arg(2, arg2);
|
||
if (res) {
|
||
cnt = *(word_t*)arg2;
|
||
}
|
||
}
|
||
|
||
static void eq(void) {
|
||
n_up_down_eq(0x00);
|
||
}
|
||
|
||
static void neq(void) {
|
||
n_up_down_eq(0xF0);
|
||
}
|
||
|
||
static void up(void) {
|
||
n_up_down_eq(0x01);
|
||
}
|
||
|
||
static void down(void) {
|
||
n_up_down_eq(0x02);
|
||
}
|
||
|
||
static void upne(void) {
|
||
n_up_down_eq(0xF1);
|
||
}
|
||
|
||
static void downe(void) {
|
||
n_up_down_eq(0xF2);
|
||
}
|
||
|
||
static void bnez(void) {
|
||
bez_bnez(1);
|
||
}
|
||
|
||
static void bez(void) {
|
||
bez_bnez(0);
|
||
}
|
||
|
||
static void mwrt(void) {
|
||
size_t size = buf[cnt++];
|
||
pop_arg(2, arg1);
|
||
pop_arg(size, arg2);
|
||
word_t pos = *(word_t*)arg1;
|
||
size_t i = 0;
|
||
while (i < size) {
|
||
stack[i + pos] = arg2[i];
|
||
i ++;
|
||
}
|
||
}
|
||
|
||
static void mrd(void) {
|
||
size_t size = buf[cnt++];
|
||
pop_arg(2, arg1);
|
||
word_t pos = *(word_t*)arg1;
|
||
sp -= size;
|
||
size_t i = 0;
|
||
while (i < size) {
|
||
stack[sp + i] = stack[pos + i];
|
||
i ++;
|
||
}
|
||
}
|
||
|
||
static void get_sp(void) {
|
||
push_arg(2, (__e_byte_t*)&sp);
|
||
}
|
||
|
||
static void set_sp(void) {
|
||
pop_arg(2, arg1);
|
||
sp = *(word_t*)arg1;
|
||
}
|
||
|
||
static word_t get_pop_sp_word(void) {
|
||
pop_arg(2, arg1);
|
||
return *(word_t*)arg1;
|
||
}
|
||
|
||
static byte_t get_pop_sp_byte(void) {
|
||
pop_arg(1, arg1);
|
||
return *(byte_t*)arg1;
|
||
}
|
||
|
||
static void nt_fs_syscall(void) {
|
||
/* printf("\nStack point %d 0x%X\n", __ntsys_stack_pointer, __ntsys_stack_pointer); */
|
||
switch (get_pop_sp_byte()) {
|
||
case 0x00:
|
||
{
|
||
fputs((char*)stack + sp, stdout);
|
||
size_t len = strlen((char*)stack + sp);
|
||
sp += len + 1;
|
||
}
|
||
break;
|
||
case 0x01:
|
||
{
|
||
char ch = getchar();
|
||
push_arg(1, (__e_byte_t*)&ch);
|
||
}
|
||
break;
|
||
case 0x02:
|
||
{
|
||
fGH6VSEzu7qNiGVE_stat = get_pop_sp_word();
|
||
cnt = __ntsys_buffer_size;
|
||
}
|
||
break;
|
||
case 0x03:
|
||
{
|
||
if ((fGH6VSEzu7qNiGVE_stat = system((char*)stack + sp)) != EXIT_SUCCESS)
|
||
cnt = __ntsys_buffer_size - 1;
|
||
size_t len = strlen((char*)stack + sp);
|
||
sp += len + 1;
|
||
}
|
||
break;
|
||
case 0x04:
|
||
{
|
||
__e_byte_t ch = rand() % 255;
|
||
push_arg(1, (__e_byte_t*)&ch);
|
||
}
|
||
break;
|
||
case 0x05:
|
||
{
|
||
srand(get_pop_sp_word());
|
||
}
|
||
break;
|
||
}
|
||
/* printf("\nStack point %d 0x%X\n", __ntsys_stack_pointer, __ntsys_stack_pointer); */
|
||
}
|
||
|
||
static void stack_swap(void) {
|
||
size_t size = buf[cnt++];
|
||
pop_arg(1, arg1);
|
||
pop_arg(size, arg2);
|
||
sp -= size;
|
||
size_t i = 0;
|
||
while (i < ((size_t)(*(byte_t*)arg1) * size)) {
|
||
stack[sp + i] = stack[sp + (i) + size];
|
||
i ++;
|
||
}
|
||
i = 0;
|
||
byte_t r = ((*(byte_t*)arg1) - 1) * size;
|
||
while (i < size) {
|
||
stack[sp + r + i] = arg2[i];
|
||
i ++;
|
||
}
|
||
}
|
||
|
||
static void stack_copy(void) {
|
||
size_t size = buf[cnt++];
|
||
sp -= size;
|
||
size_t i = 0;
|
||
while (i < size) {
|
||
stack[sp + i] = stack[sp + (i) + size];
|
||
i ++;
|
||
}
|
||
}
|
||
|
||
word_t fGH6VSEzu7qNiGVE_sp_save = 0;
|
||
word_t fGH6VSEzu7qNiGVE_sp_std = 0;
|
||
__e_byte_t fGH6VSEzu7qNiGVE_flag = 0;
|
||
|
||
static void stack_spawn_set(void) {
|
||
pop_arg(2, arg1);
|
||
fGH6VSEzu7qNiGVE_sp_std = *(word_t*)arg1;
|
||
}
|
||
|
||
static void stack_spawn_mov(void) {
|
||
if (fGH6VSEzu7qNiGVE_flag == 0) {
|
||
fGH6VSEzu7qNiGVE_sp_save = sp;
|
||
sp = fGH6VSEzu7qNiGVE_sp_std;
|
||
} else {
|
||
sp = fGH6VSEzu7qNiGVE_sp_save;
|
||
}
|
||
fGH6VSEzu7qNiGVE_flag = !fGH6VSEzu7qNiGVE_flag;
|
||
}
|
||
|
||
#define NTSYS_CALL_BUFFER_LENGTH (32)
|
||
|
||
word_t fGH6VSEzu7qNiGVE_call_buf[NTSYS_CALL_BUFFER_LENGTH];
|
||
word_t fGH6VSEzu7qNiGVE_d_ptr = NTSYS_CALL_BUFFER_LENGTH - 1;
|
||
|
||
#define call_buf fGH6VSEzu7qNiGVE_call_buf
|
||
#define call_sp fGH6VSEzu7qNiGVE_d_ptr
|
||
|
||
static void f_call(void) {
|
||
call_sp -= 1;
|
||
call_buf[call_sp] = cnt;
|
||
nt_goto();
|
||
}
|
||
|
||
static void f_ret(void) {
|
||
if (call_sp < NTSYS_CALL_BUFFER_LENGTH) {
|
||
cnt = call_buf[call_sp];
|
||
call_sp += 1;
|
||
}
|
||
}
|
||
|
||
#undef call_buf
|
||
#undef call_sp
|
||
|
||
void (*fn_fGH6VSEzu7qNiGVE[])(void) = {
|
||
/* Операции со стеком (0 - 2) */
|
||
push, pop, push_str,
|
||
/* Арифметические операции (3 - 6) */
|
||
add, sub, mul, div_r,
|
||
/* Логические операции (7 - 12) */
|
||
nt_not, nt_shr, nt_shl, nt_or,
|
||
nt_and, nt_xor,
|
||
/* Переход (13) */
|
||
nt_goto,
|
||
/* Условия (14 - 21) */
|
||
bnez, bez,
|
||
up, down,
|
||
eq, neq,
|
||
upne, downe,
|
||
/* Работа с памятью (22 - 23) */
|
||
mwrt, mrd,
|
||
/* Адресация на стеке (24 - 25) */
|
||
get_sp, set_sp,
|
||
/* Системные вызовы (26) */
|
||
nt_fs_syscall,
|
||
/* Управление положение на стеке (27 - 30) */
|
||
stack_swap, stack_copy,
|
||
stack_spawn_set, stack_spawn_mov,
|
||
/* Функции (31 - 32) */
|
||
f_call, f_ret
|
||
};
|
||
|
||
#undef stack
|
||
#undef sp
|
||
#undef buf
|
||
#undef cnt
|
||
#undef ip
|
||
|
||
#undef arg1
|
||
#undef arg2
|
||
|
||
#endif /* __LIB_ntfiles_H */ |