nameless_interpreter.c

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <assert.h>

/*
Opcodes for the Nameless Language VM
*/
enum Opcode
{
    OP_MOVR = 0,    //(0000)   Move the pointer to the right
    OP_MOVL = 1,    //(0001)   Move the pointer to the left
    OP_INC = 2,     //(0010)   Increment the memory cell under the pointer
    OP_DEC = 3,     //(0011)   Decrement the memory cell under the pointer
    OP_POP = 4,     //(0100)   Output the character signified by the cell at the pointer
    OP_PUSH = 5,    //(0101)   Input a character and store it in the cell at the pointer
    OP_JEZ = 6,     //(0110)   Jump past the matching 0111 if the cell under the pointer is 0
    OP_JNZ = 7,     //(0111)   Jump back to the matching 0110 if the cell under the pointer is nonzero
    OP_ADD = 8,     //(1000)   Add the next command's base 10 equivalent to the current cell
    OP_SUB = 9,     //(1001)   Subtract the next command's base 10 equivalent to the current cell
    OP_NOP = 10,    //(1010)   No Operation
    OP_CLC = 11,    //(1011)   Reset the current cell's value to 0
    OP_CLPTR = 12   //(1100)   Reset the pointer to point at cell 0
};

typedef struct VM
{
    unsigned int tapeSize;      //tape size in elements
    unsigned int *program;      //program to run in VM
    unsigned int programLength; //total program length
    unsigned int SP;            //pointer to tape memory (stack pointer)
    unsigned int PC;            //pointer to program memory
    char *tape;                 //growable memory
} VirtualMachine;

unsigned int ConvertBinaryStringToUInt(const char *bstring);
size_t __cdecl strlen_ojeb(const char* text);
void PrecompileSource(const char *source, unsigned int **program, unsigned int *programLength);

VirtualMachine *VM_Initialize(unsigned int *source, unsigned int programLength, unsigned int tapesize);
void VM_Run(VirtualMachine *vm);

int main(void)
{
    /* hello world program [currently not working due to lack of the jump commands] */
    const char *hello = "   00100010001000100010001000100010\
                            0110\
                            00000010001000100010\
                            0110\
                            000000100010\
                            0000001000100010\
                            0000001000100010\
                            00000010\
                            00010001000100010011\
                            0111\
                            00000010\
                            00000010\
                            00000011\
                            000000000010\
                            011000010111\
                            00010011\
                            0111\
                            000000000100\
                            00000011001100110100\
                            0010001000100010001000100010010001000010001000100100\
                            000000000100\
                            000100110100\
                            00010100\
                            0010001000100100\
                            0011001100110011001100110100\
                            001100110011001100110011001100110100\
                            0000000000100100";

    /* reads 5 chars from the input, and outputs them and increments them before outputting [works] */
    const char *cat = "010100100000\
                            010100100000\
                            010100100000\
                            010100100000\
                            01010010\
                            1100\
                            01000000\
                            01000000\
                            01000000\
                            01000000\
                            01000000";

    /* reads and prints out one char [works] */
    const char *pushpop = "010100100100";

    unsigned int *compiledProgram = NULL;
    unsigned int programLength = 0;

    PrecompileSource(pushpop, &compiledProgram, &programLength);

    VirtualMachine *environment = NULL;
    environment = VM_Initialize(compiledProgram, programLength, 100);
    assert(environment != NULL);

    VM_Run(environment);

    getchar();
    getchar();


    return 0;
}

/*
@procedure(VM_Run)

This function is responsible for decoding the opcode and executing the operation over the Virtual Machine
@param(vm): The Virtual Machine environment over which the Nameless program runs
@param(opcode): The 4bit buffer containing one opcode
*/
void VM_Run(VirtualMachine *vm)
{
    int loopcnt = 0;
    while (vm->PC != vm->programLength)
    {

        int op = vm->program[vm->PC];
        switch (op)
        {
        case OP_MOVR: //(0000)   Move the pointer to the right
        {
            if (vm->SP == vm->tapeSize - 1)
            {
                vm->SP = 0;
            }
            else
            {
                vm->SP++;
            }
            break;
        }
        case OP_MOVL: //(0001)   Move the pointer to the left
        {
            if (vm->SP == 0)
            {
                vm->SP = vm->tapeSize - 1;
            }
            else
            {
                vm->SP--;
            }
            break;
        }
        case OP_INC: //(0010)   Increment the memory cell under the pointer
        {
            vm->tape[vm->SP]++;
            break;
        }
        case OP_DEC: //(0011)   Decrement the memory cell under the pointer
        {
            vm->tape[vm->SP]--;
            break;
        }
        case OP_POP: //(0100)   Output the character signified by the cell at the pointer
        {
            char c = vm->tape[vm->SP];
            printf("%c", c);
            break;
        }
        case OP_PUSH: //(0101)   Input a character and store it in the cell at the pointer
        {
            scanf(" %c", &vm->tape[vm->SP]);
            break;
        }
        case OP_JEZ: //(0110)   Jump past the matching 0111 if the cell under the pointer is 0
        {
            break;
        }
        case OP_JNZ: //(0111)   Jump back to the matching 0110 if the cell under the pointer is nonzero
        {
            break;
        }
        case OP_ADD: //(1000)   Add the next command's base 10 equivalent to the current cell
        {
            vm->tape[vm->SP] += vm->program[vm->PC + 1];
            break;
        }
        case OP_SUB: //(1001)   Subtract the next command's base 10 equivalent to the current cell
        {
            vm->tape[vm->SP] -= vm->program[vm->PC + 1];
            break;
        }
        case OP_NOP: //(1010)   No Operation
        {
            //No Operation
            break;
        }
        case OP_CLC: //(1011)   Reset the current cell's value to 0
        {
            vm->tape[vm->SP] = 0;
            break;
        }
        case OP_CLPTR: //(1100)   Reset the pointer to point at cell 0
        {
            vm->SP = 0;
            break;
        }
        }

        vm->PC++;
    }
}

/*
@function(VM_Initialize)

Initializes the Virtual Machine with a program and creates a tape with [tapesize] number of cells
@param(source): The Nameless Language program source
@param(tapesize): The size of the tape memory to be created
@return(vm): The pre-created and allocated virtual machine ready to use
*/
VirtualMachine *VM_Initialize(unsigned int *source, unsigned int programLength, unsigned int tapesize)
{
    VirtualMachine *vm = (VirtualMachine *)malloc(sizeof(VirtualMachine));

    vm->tape = (char *)calloc(tapesize, sizeof(char));
    vm->tapeSize = tapesize;
    vm->program = source;
    vm->programLength = programLength;
    vm->SP = 0;
    vm->PC = 0;

    return vm;
}

/*
@function(PrecompileSource)

"Precompiles" the source to base10 ordinal array (unsigned int []) and removes bad input and/or comments
@param(source): The Nameless Language program source
@param(program): The program to be precompiled
@param(programLength): The precompiled program length
*/
void PrecompileSource(const char *source, unsigned int **program, unsigned int *programLength)
{
    unsigned int compiled[10000];
    register unsigned int len = strlen_ojeb(source);
    register unsigned int srclen = 0;
    char op[5];
    op[4] = '\0';

    for (register int i = 0; i < len; i++)
    {
        if (source[i] == '0' || source[i] == '1')
        {
            register int cnt = srclen % 4;
            op[cnt] = source[i];
            srclen++;
            if (cnt == 3)
            {
                compiled[(*programLength)] = ConvertBinaryStringToUInt(op);
                (*programLength)++;
            }
        }
    }
    *program = compiled;
}

/*
@function(ConvertBinaryStringToUInt)

Converts the binary string into a decimal number
@param(bstring): The binary number as string
@return(total): The base10 value of the binary string
*/
unsigned int ConvertBinaryStringToUInt(const char *bstring)
{
    const char* start = &bstring[0];
    unsigned int total = 0;
    while (*start)
    {
        total <<= 1;
        if (*start++ == '1')
        {
            total ^= 1;
        }
    }
    return total;
}

/*
@function(strlen_ojeb)

This string length function is here only because it is a bit faster code than in the standard library, feel free to use your own
@param(text): The text which length we want to know
@return(): The string length
*/
size_t __cdecl strlen_ojeb(const char* text)
{
    const char *s;
    const uint32_t* pdwText;
    register uint32_t dwText;

    pdwText = (uint32_t*)text;
    while (1)
    {
        dwText = *pdwText;

        if ((dwText - 0x01010101UL) & ~dwText & 0x80808080UL)
        {
            s = (const char*)pdwText;
            while (*s)
            {
                s++;
            }
            return s - text;
        }
        pdwText++;
    }
}