BRNSystems/RISC-B
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 2 Wiki Activity

Something is almost working

Browse Source
This commit is contained in:
Bruno Rybársky
2025-02-08 23:23:21 +01:00
parent aaf3dfb40c
commit 45653b6372
15 changed files with 969 additions and 326 deletions
Download Patch File Download Diff File Expand all files Collapse all files

309
main.c
View File

@@ -4,6 +4,8 @@
#include "util/font.h"
#include "assembler/assembler.h"
#include "util/texteditor.h"
#include "util/hexdump.h"
#include "util/cpustatusui.h"
//Screen dimension constants
const int SCREEN_WIDTH = 1280;
@@ -17,19 +19,75 @@ SDL_Window *window = NULL;
//The surface contained by the window
SDL_Renderer *renderer = NULL;
BitmapFont smallFont;
#define biggerFont fonts[0]
#define smallFont fonts[1]
#define smallerFont fonts[2]
#define fontCount 3
BitmapFont fonts[fontCount];
CPU cpu;
TextEditor codeEditor;
SDL_Texture *cpuStatsTexture;
TextEditor *activeEditor;
SDL_Texture *cpuStateTexture;
#define codeEditor editors[0]
#define memoryViewer editors[1]
#define editorCount 2
#define activeEditor editors[activeEditorIndex]
int activeEditorIndex = 0;
TextEditor editors[editorCount];
unsigned long frames = 0;
bool cursor = true;
char *read_file_as_string(const char *filename) {
FILE *file = fopen(filename, "rb"); // Open file in binary mode
if (file == NULL) {
perror("Error opening file");
return NULL;
}
// Seek to the end of the file to determine size
fseek(file, 0, SEEK_END);
long filesize = ftell(file);
rewind(file); // Go back to the beginning
// Allocate memory for file content (+1 for null terminator)
char *buffer = malloc(filesize + 1);
if (buffer == NULL) {
perror("Memory allocation failed");
fclose(file);
return NULL;
}
// Read entire file into buffer
fread(buffer, 1, filesize, file);
buffer[filesize] = '\0'; // Null-terminate the string
fclose(file);
return buffer; // Caller must free the memory
}
void updateState() {
cpuStatsTexture = renderVals(&cpu, &smallFont, &smallerFont, renderer);
cpuStateTexture = renderState(&cpu, &biggerFont, renderer);
char *dump = hexdump_to_string(cpu.memory, sizeof(cpu.memory));
fill_editor_from_string(&memoryViewer, dump, renderer);
free(dump);
}
void compile(bool erase) {
generate_string(&codeEditor);
completePass(codeEditor.outputString, &cpu, erase);
updateState();
}
char programString[65535];
int init() {
//Initialize SDL
if (SDL_Init(SDL_INIT_EVERYTHING) < 0) {
printf("SDL could not initialize! SDL_Error: %s\n", SDL_GetError());
@@ -42,7 +100,6 @@ int init() {
return 1;
}
//Create window
window = SDL_CreateWindow("SDLko", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, SCREEN_WIDTH,
SCREEN_HEIGHT, SDL_WINDOW_SHOWN | SDL_WINDOW_RESIZABLE);
@@ -51,39 +108,62 @@ int init() {
return 1;
}
//Get window surface
renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);
renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_SOFTWARE);
if (renderer == NULL) {
printf("Renderer could not be created SDL_Error: %s\n", SDL_GetError());
return 1;
}
biggerFont = prepText(renderer, 16, "../PublicPixel.ttf", 255, 255, 255, 255);
smallFont = prepText(renderer, 12, "../PublicPixel.ttf", 255, 255, 255, 255);
init_editor(&codeEditor, &smallFont, 50, 50, renderer);
activeEditor = &codeEditor;
smallerFont = prepText(renderer, 8, "../PublicPixel.ttf", 255, 255, 255, 255);
init_editor(&codeEditor, &smallFont, 10, 80, renderer, 34, 1000, 48, false);
init_editor(&memoryViewer, &smallerFont, 550, 80, renderer, 80, MEM_SIZE / 16 + 2, 70, true);
SDL_RenderSetLogicalSize(renderer, SCREEN_WIDTH, SCREEN_HEIGHT);
SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, 0);
generate_string_display(&codeEditor, renderer);
SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, NULL);
for (int i = 0; i < editorCount; i++) {
generate_string_display(&codeEditor, renderer);
}
init_cpu(&cpu);
compile(true);
return 0;
}
SDL_Rect rect1;
SDL_Rect rect2;
int render() {
SDL_SetRenderDrawColor(renderer, 128, 0, 0, 255);
SDL_SetRenderDrawColor(renderer, 32, 32, 32, 255);
SDL_RenderClear(renderer);
SDL_SetRenderDrawColor(renderer, 0, 128, 0, 255);
rect1.x = (rect1.x + 1) % 400;
rect1.y = 10;
rect1.w = 50;
rect1.h = 10;
SDL_RenderFillRect(renderer, &rect1);
for (int i = 0; i < editorCount; i++) {
editor_render(&editors[i], renderer, activeEditorIndex == i, cursor);
}
editor_render(&codeEditor, renderer);
SDL_Rect rect2;
rect2.x = 9;
rect2.y = 0;
rect2.w = 0;
rect2.h = 0;
SDL_QueryTexture(cpuStatsTexture, NULL, NULL, &rect2.w, &rect2.h);
SDL_RenderCopy(renderer, cpuStatsTexture, NULL, &rect2);
rect2.x = 100;
rect2.y = 46;
rect2.w = 0;
rect2.h = 0;
SDL_QueryTexture(cpuStateTexture, NULL, NULL, &rect2.w, &rect2.h);
SDL_RenderCopy(renderer, cpuStateTexture, NULL, &rect2);
SDL_RenderPresent(renderer);
frames++;
if (!(frames % 60)) {
cursor = !cursor;
}
return 0;
}
@@ -158,11 +238,9 @@ SDL_Keycode ConvertKPToNonKP(SDL_Keycode keycode) {
case SDLK_KP_GREATER:
return SDLK_GREATER;
case SDLK_KP_AMPERSAND:
return SDLK_AMPERSAND;
case SDLK_KP_DBLAMPERSAND:
return SDLK_AMPERSAND; // No direct match, best alternative
case SDLK_KP_VERTICALBAR:
return SDLK_BACKSLASH; // Vertical bar alternative
case SDLK_KP_DBLVERTICALBAR:
return SDLK_BACKSLASH; // No direct match
case SDLK_KP_COLON:
@@ -175,12 +253,6 @@ SDL_Keycode ConvertKPToNonKP(SDL_Keycode keycode) {
return SDLK_AT;
case SDLK_KP_EXCLAM:
return SDLK_EXCLAIM;
case SDLK_KP_MEMSTORE:
return SDLK_UNKNOWN; // No direct match
case SDLK_KP_MEMRECALL:
return SDLK_UNKNOWN;
case SDLK_KP_MEMCLEAR:
return SDLK_UNKNOWN;
case SDLK_KP_MEMADD:
return SDLK_PLUS;
case SDLK_KP_MEMSUBTRACT:
@@ -189,18 +261,15 @@ SDL_Keycode ConvertKPToNonKP(SDL_Keycode keycode) {
return SDLK_ASTERISK;
case SDLK_KP_MEMDIVIDE:
return SDLK_SLASH;
case SDLK_KP_MEMSTORE:
case SDLK_KP_MEMRECALL:
case SDLK_KP_MEMCLEAR:
case SDLK_KP_PLUSMINUS:
return SDLK_UNKNOWN;
case SDLK_KP_CLEAR:
return SDLK_UNKNOWN;
case SDLK_KP_CLEARENTRY:
return SDLK_UNKNOWN;
case SDLK_KP_BINARY:
return SDLK_UNKNOWN;
case SDLK_KP_OCTAL:
return SDLK_UNKNOWN;
case SDLK_KP_DECIMAL:
return SDLK_UNKNOWN;
case SDLK_KP_HEXADECIMAL:
return SDLK_UNKNOWN;
default:
@@ -208,6 +277,7 @@ SDL_Keycode ConvertKPToNonKP(SDL_Keycode keycode) {
}
}
uint8_t cpuSpeedTemp = 0;
int processEvent(SDL_Event e) {
if (e.type == SDL_QUIT) { return 0; }
@@ -220,44 +290,144 @@ int processEvent(SDL_Event e) {
SDL_RenderSetViewport(renderer, &viewport);
} else if (e.type == SDL_KEYDOWN) {
int keySym = ConvertKPToNonKP(e.key.keysym.sym);
int keyMod = e.key.keysym.mod;
cursor = true;
switch (keySym) {
case SDLK_UP:
if (activeEditor) {
move_cursor_relative(activeEditor, -1, 0);
}
move_cursor_relative(&activeEditor, -1, 0, false, renderer);
break;
case SDLK_PAGEUP:
move_cursor_relative(&activeEditor, -activeEditor.max_lines_display, -1, true, renderer);
break;
case SDLK_DOWN:
if (activeEditor) {
move_cursor_relative(activeEditor, 1, 0);
}
move_cursor_relative(&activeEditor, 1, 0, false, renderer);
break;
case SDLK_PAGEDOWN:
move_cursor_relative(&activeEditor, activeEditor.max_lines_display, 0, true, renderer);
break;
case SDLK_LEFT:
if (activeEditor) {
move_cursor_relative(activeEditor, 0, -1);
move_cursor_relative(&activeEditor, 0, -1, false, renderer);
break;
case SDLK_HOME:
if (keyMod & KMOD_CTRL) {
move_cursor(&activeEditor, 0, 0, false, renderer);
break;
}
move_cursor(&activeEditor, activeEditor.cursor_line, 0, false, renderer);
break;
case SDLK_RIGHT:
if (activeEditor) {
move_cursor_relative(activeEditor, 0, 1);
move_cursor_relative(&activeEditor, 0, 1, false, renderer);
break;
case SDLK_END:
int lineLen = strlen(activeEditor.lines[activeEditor.cursor_line].text);
if (keyMod & KMOD_CTRL) {
move_cursor(&activeEditor, activeEditor.line_count, lineLen, false, renderer);
break;
}
move_cursor(&activeEditor, activeEditor.cursor_line, lineLen, false, renderer);
break;
case SDLK_F9:
cpu.mode ^= CPU_MODE_LOOP;
updateState();
return 1;
case SDLK_F8:
if (++cpuSpeedTemp == 3) {
cpuSpeedTemp = 0;
}
cpu.mode &= ~(CPU_MODE_SECOND | CPU_MODE_STEP);
cpu.mode |= cpuSpeedTemp << 4;
updateState();
return 1;
case SDLK_F5:
compile(!(keyMod & KMOD_CTRL));
case SDLK_F7:
if (cpu.mode & (CPU_MODE_HALTED | CPU_MODE_ERROR) || (keyMod & KMOD_SHIFT)) {
cpu.pc = 0;
}
cpu.mode &= ~(CPU_MODE_HALTED | CPU_MODE_PAUSED | CPU_MODE_ERROR);
updateState();
break;
case SDLK_ESCAPE:
cpu.mode |= CPU_MODE_PAUSED;
if (keyMod & (KMOD_CTRL | KMOD_SHIFT)) {
cpu.mode |= CPU_MODE_HALTED;
}
updateState();
break;
case SDLK_s:
if (keyMod & KMOD_CTRL) {
FILE *fptr;
char fname[20];
snprintf(fname, sizeof(fname), "riscb%lu.bsm", time(NULL));
fptr = fopen(fname, "w");
generate_string(&editors[0]);
fputs(editors[0].outputString, fptr);
fclose(fptr);
return 1;
}
break;
case SDLK_l:
if (keyMod & KMOD_CTRL) {
FILE *fptr;
char fname[20];
sscanf(editors[0].lines[0].text, "%s", fname);
toLowerCase(fname);
strcat(fname, ".bsm");
fptr = fopen(fname, "r");
char *prog = read_file_as_string(fname);
fill_editor_from_string(&editors[0], prog, renderer);
free(prog);
fputs(editors[0].outputString, fptr);
fclose(fptr);
return 1;
}
break;
case SDLK_BACKSPACE:
if (!activeEditor.readOnly) {
remove_character(&activeEditor, false, renderer);
}
break;
case SDLK_DELETE:
if (!activeEditor.readOnly) {
remove_character(&activeEditor, true, renderer);
}
break;
case SDLK_RETURN:
case SDLK_RETURN2:
if (activeEditor && !activeEditor->readOnly) {
insert_line_rel(activeEditor, renderer);
if (keyMod & KMOD_CTRL && activeEditorIndex == 0) {
compile(!(keyMod & KMOD_SHIFT));
break;
}
if (!activeEditor.readOnly) {
insert_line_rel(&activeEditor, renderer);
}
break;
case SDLK_TAB:
activeEditorIndex++;
if (activeEditorIndex >= editorCount) {
activeEditorIndex = 0;
}
activeEditor = editors[activeEditorIndex];
break;
default:
break;
}
if (activeEditor && !activeEditor->readOnly && activeEditor->cursor_pos < MAX_LINE_WIDTH) {
if (keySym >= 32 && keySym <= 126) {
if (keySym > 0x60 && keySym < 0x7b) {
keySym -= 0x20;
} else if (e.type == SDL_TEXTINPUT) {
for (int i = 0; e.text.text[i] != '\0'; i++) { // Iterate over the input string
char keySym = e.text.text[i];
if (!activeEditor.readOnly && activeEditor.cursor_pos <= activeEditor.max_line_width) {
if (keySym >= 32 && keySym <= 126) { // Printable ASCII range
if (keySym > 0x60 && keySym < 0x7b) { // Convert lowercase to uppercase
keySym -= 0x20;
}
if (activeEditor.cursor_pos < activeEditor.max_line_width) {
insert_character(&activeEditor, keySym, renderer);
}
}
insert_character(activeEditor, (keySym & 0xff), renderer);
} else if (keySym == SDLK_BACKSPACE || keySym == SDLK_DELETE) {
remove_character(activeEditor, renderer);
}
}
}
@@ -286,6 +456,22 @@ int main(__attribute__((unused)) int argc, __attribute__((unused)) char *args[])
return status;
}
if (!(cpu.mode & (CPU_MODE_HALTED | CPU_MODE_PAUSED | CPU_MODE_ERROR))) {
if (cpu.mode & CPU_MODE_SECOND) {
if (frames % 60) {
step(&cpu);
updateState();
}
} else {
step(&cpu);
updateState();
}
if (cpu.mode & CPU_MODE_STEP) {
cpu.mode |= CPU_MODE_PAUSED;
updateState();
}
}
end = SDL_GetTicks64();
const unsigned long timeNeeded = end - start;
if (timeNeeded < delayNeeded) {
@@ -295,12 +481,13 @@ int main(__attribute__((unused)) int argc, __attribute__((unused)) char *args[])
}
}
uint8_t *program;
int program_size;
for (uint8_t i = 0; i < editorCount; i++) {
destroy_editor(&editors[i]);
}
completePass(programString, &cpu, true);
step(&cpu);
for (uint8_t i = 0; i < fontCount; i++) {
destroyFont(&fonts[i]);
}
//Destroy window
SDL_DestroyWindow(window);