Momentum-Firmware/applications/external/brainfuck/worker.c

#include "worker.h"
#include <furi_hal_resources.h>
#include <furi.h>

bool killswitch = false;

int status = 0; //0: idle, 1: running, 2: failure

char* inst = 0;
int instCount = 0;
int instPtr = 0;
int runOpCount = 0;

char* wOutput = 0;
int wOutputPtr = 0;

char* wInput = 0;
int wInputPtr = 0;

uint8_t* bfStack = 0;
int stackPtr = 0;
int stackSize = BF_STACK_INITIAL_SIZE;
int stackSizeReal = 0;

BFApp* wrkrApp = 0;

void killThread() {
    killswitch = true;
}

bool validateInstPtr() {
    if(instPtr > instCount || instPtr < 0) {
        return false;
    }
    return true;
}

bool validateStackPtr() {
    if(stackPtr > stackSize || stackPtr < 0) {
        return false;
    }
    return true;
}

char* workerGetOutput() {
    return wOutput;
}

int getStackSize() {
    return stackSizeReal;
}

int getOpCount() {
    return runOpCount;
}

int getStatus() {
    return status;
}

void initWorker(BFApp* app) {
    wrkrApp = app;

    //rebuild output
    if(wOutput) {
        free(wOutput);
    }
    wOutput = (char*)malloc(BF_OUTPUT_SIZE);
    wOutputPtr = 0;

    //rebuild stack
    if(bfStack) {
        free(bfStack);
    }
    bfStack = (uint8_t*)malloc(BF_STACK_INITIAL_SIZE);
    memset(bfStack, 0x00, BF_STACK_INITIAL_SIZE);
    stackSize = BF_STACK_INITIAL_SIZE;
    stackSizeReal = 0;
    stackPtr = 0;

    //set instructions
    inst = wrkrApp->dataBuffer;
    instCount = wrkrApp->dataSize;
    instPtr = 0;
    runOpCount = 0;

    //set input
    wInput = wrkrApp->inputBuffer;
    wInputPtr = 0;

    //set status
    status = 0;
}

void rShift() {
    runOpCount++;
    stackPtr++;
    if(!validateStackPtr()) {
        status = 2;
        return;
    }

    while(stackPtr > stackSize) {
        stackSize += BF_STACK_STEP_SIZE;
        void* tmp = realloc(bfStack, stackSize);

        if(!tmp) {
            status = 2;
            return;
        }

        memset((tmp + stackSize) - BF_STACK_STEP_SIZE, 0x00, BF_STACK_STEP_SIZE);
        bfStack = (uint8_t*)tmp;
    };
    if(stackPtr > stackSizeReal) {
        stackSizeReal = stackPtr;
    }
}

void lShift() {
    runOpCount++;
    stackPtr--;
    if(!validateStackPtr()) {
        status = 2;
        return;
    }
}

void inc() {
    runOpCount++;
    if(!validateStackPtr()) {
        status = 2;
        return;
    }
    bfStack[stackPtr]++;
}

void dec() {
    runOpCount++;
    if(!validateStackPtr()) {
        status = 2;
        return;
    }
    bfStack[stackPtr]--;
}

void print() {
    runOpCount++;
    wOutput[wOutputPtr] = bfStack[stackPtr];
    wOutputPtr++;
    if(wOutputPtr > (BF_OUTPUT_SIZE - 1)) {
        wOutputPtr = 0;
    }
}

void input() {
    runOpCount++;

    bfStack[stackPtr] = (uint8_t)wInput[wInputPtr];
    if(wInput[wInputPtr] == 0x00 || wInputPtr >= 64) {
        wInputPtr = 0;
    } else {
        wInputPtr++;
    }
}

void loop() {
    runOpCount++;
    if(bfStack[stackPtr] == 0) {
        int loopCount = 1;
        while(loopCount > 0) {
            instPtr++;
            if(!validateInstPtr()) {
                status = 2;
                return;
            }
            if(inst[instPtr] == '[') {
                loopCount++;
            } else if(inst[instPtr] == ']') {
                loopCount--;
            }
        }
    }
}

void endLoop() {
    runOpCount++;
    if(bfStack[stackPtr] != 0) {
        int loopCount = 1;
        while(loopCount > 0) {
            instPtr--;
            if(!validateInstPtr()) {
                status = 2;
                return;
            }
            if(inst[instPtr] == ']') {
                loopCount++;
            } else if(inst[instPtr] == '[') {
                loopCount--;
            }
        }
    }
}

static const NotificationSequence led_on = {
    &message_blue_255,
    &message_do_not_reset,
    NULL,
};

static const NotificationSequence led_off = {
    &message_blue_0,
    NULL,
};

void input_kill(void* _ctx) {
    UNUSED(_ctx);
    killswitch = true;
}

void beginWorker() {
    status = 1;

    //redefined from furi_hal_resources.c
    const GpioPin gpio_button_back = {.port = GPIOC, .pin = LL_GPIO_PIN_13};

    while(inst[instPtr] != 0x00) {
        if(runOpCount % 500 == 0) {
            text_box_set_text(wrkrApp->text_box, workerGetOutput());
            notification_message(wrkrApp->notifications, &led_on);
        }

        //status 2 indicates failure
        if(status == 2) {
            status = 0;
            break;
        }

        //read back button directly to avoid weirdness in furi
        if(killswitch || !furi_hal_gpio_read(&gpio_button_back)) {
            status = 0;
            killswitch = false;
            break;
        }

        switch(inst[instPtr]) {
        case '>':
            rShift();
            break;
        case '<':
            lShift();
            break;

        case '+':
            inc();
            break;

        case '-':
            dec();
            break;

        case '.':
            print();
            break;

        case ',':
            input();
            break;

        case '[':
            loop();
            break;

        case ']':
            endLoop();
            break;

        default:
            break;
        }
        instPtr++;
        if(!validateInstPtr()) {
            status = 0;
            break;
        }
    }

    notification_message(wrkrApp->notifications, &led_off);
    text_box_set_text(wrkrApp->text_box, workerGetOutput());
    status = 0;
}