kvisc/vm/in/misc.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) { INTO(); return 0; }
IMPL_START(pause) { usleep(5000); return 0; }
IMPL_START(udf) { _except(E_UDF, "UDF instruction"); }

//----------------------------------------------------------------------------//

IMPL_START(break)
{
#ifndef NDEBUG
    trace("\nExecuting BREAK INSTR\n");
    dumpregs();

    do_hlt();

    trace("Resuming execution\n");
#endif
    return 0;
}

IMPL_START(dump)
{
#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)
{
    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)
{
    struct timeval time;
    gettimeofday(&time, NULL);
    *r1 = (time.tv_sec * 1000) + (time.tv_usec / 1000);

    return 1;
}

//----------------------------------------------------------------------------//

IMPL_START(cls)
{
    R(RFX) = 0;
    for (int i = RAX; i <= R20; i++) R(i) = 0;

    return 0;
}

//----------------------------------------------------------------------------//

IMPL_START(bswap)
{
    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)
{
    SRCP(p2);

    ulong v = p2->val;

    *r1 = ((v & 0xFFFF000000000000) >> 48)
        | ((v & 0x0000FFFF00000000) >> 16)
        | ((v & 0x00000000FFFF0000) << 16)
        | ((v & 0x000000000000FFFF) << 48);

    return 1;
}

IMPL_START(dswap)
{
    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)
{
    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)
{
    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)
{
    *r1 = console_scankeybuf();

    return 1;
}

//----------------------------------------------------------------------------//