1
0
mirror of https://gitlab.os-k.eu/os-k-team/kvisc.git synced 2023-08-25 14:05:46 +02:00
kvisc/vm/in/misc.c
julianb0 fa7e365b98
up
2019-08-08 18:39:12 +02:00

192 lines
3.7 KiB
C

// The OS/K Team licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
#include <pc/console.h>
#include <in/instrs.h>
#include <sys/time.h>
#include <unistd.h>
#include <time.h>
//----------------------------------------------------------------------------//
IMPL_START(into, 0) { INTO(); return 0; }
IMPL_START(pause, 0) { usleep(5000); return 0; }
IMPL_START(udf, 0) { _except(E_UDF, "UDF instruction"); }
//----------------------------------------------------------------------------//
IMPL_START(break, 0)
{
#ifndef NDEBUG
trace("\nExecuting BREAK INSTR\n");
dumpregs();
do_hlt();
trace("Resuming execution\n");
#endif
return 0;
}
IMPL_START(dump, 0)
{
#ifndef NDEBUG
if (ctx->dumpsw)
trace("0x%lX:\t...\n", ctx->cur_pc);
else if (!ctx->dumpsw)
dump_instr(ctx->cur_in, p1, p2, p3, 0, 0);
ctx->dumpsw = !ctx->dumpsw;
#endif
return 0;
}
//----------------------------------------------------------------------------//
IMPL_START(ytime, 3)
{
time_t t = time(NULL);
struct tm *tm = localtime(&t);
*r1 = tm->tm_sec + tm->tm_min * 60
+ tm->tm_hour * 60 * 60
+ tm->tm_mday * 60 * 60 * 24;
*r2 = tm->tm_mon;
*r3 = tm->tm_year + 1900;
return 3;
}
IMPL_START(utime, 1)
{
struct timeval time;
gettimeofday(&time, NULL);
*r1 = (time.tv_sec * 1000) + (time.tv_usec / 1000);
return 1;
}
//----------------------------------------------------------------------------//
IMPL_START(cls, 0)
{
R(RFX) = 0;
for (int i = RAX; i <= R20; i++) R(i) = 0;
return 0;
}
//----------------------------------------------------------------------------//
IMPL_START(bswap, 2)
{
SRCP(p2);
ulong v = p2->val;
*r1 = ((v & 0xFF00000000000000) >> 56)
| ((v & 0x00FF000000000000) >> 40)
| ((v & 0x0000FF0000000000) >> 24)
| ((v & 0x000000FF00000000) >> 8)
| ((v & 0x00000000FF000000) << 8)
| ((v & 0x0000000000FF0000) << 24)
| ((v & 0x000000000000FF00) << 40)
| ((v & 0x00000000000000FF) << 56);
return 1;
}
IMPL_START(wswap, 2)
{
SRCP(p2);
ulong v = p2->val;
*r1 = ((v & 0xFFFF000000000000) >> 48)
| ((v & 0x0000FFFF00000000) >> 16)
| ((v & 0x00000000FFFF0000) << 16)
| ((v & 0x000000000000FFFF) << 48);
return 1;
}
IMPL_START(dswap, 2)
{
SRCP(p2);
*r1 = ((p2->val & 0xFFFFFFFF00000000) >> 32)
| ((p2->val & 0x00000000FFFFFFFF) << 32);
return 1;
}
//----------------------------------------------------------------------------//
#define PRN_MAGIC_MASK 0x8BF00000
#define PRN_CLEAR_MAGIC 0x8BF00001
#define PRN_FLUSH_MAGIC 0x8BF00002
IMPL_START(prn, 1)
{
SRCP(p1);
ulong v = p1->val;
// Magic value? :)
if (__builtin_expect((v & PRN_MAGIC_MASK) > 0, 0))
{
switch (v)
{
case PRN_CLEAR_MAGIC:
console_clear();
break;
case PRN_FLUSH_MAGIC:
console_flushkeybuf();
break;
default:
_except(E_ILL, "Bad PRN magic");
}
}
else if (v > 0)
console_putc((char)v);
return 0;
}
IMPL_START(prns, 1)
{
if (p1->type != A_REG)
_except(E_ILL, "PRNS given a non-REG operand");
uchar ch = readmemzx(R(p1->reg), 1);
COMPARE_SUB(ch, 0);
if ((R(RFX) & ZF) == 0)
{
console_putc(ch);
if (R(RFX) & DF)
R(p1->reg)--;
else
R(p1->reg)++;
}
return 0;
}
IMPL_START(scan, 1)
{
*r1 = console_scankeybuf();
return 1;
}
//----------------------------------------------------------------------------//