Efthimis/First
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
fe1bcfb471
First/gui.c

660 lines
18 KiB
C
Raw Blame History

/* gui.c
This file is part of the "First" CPU simulator project.
Copyright (c) 2024 Efthymios Kritikos
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include <ncurses.h>
#include <string.h>
#include "simdata.h"
#include "assembly.h"
#include <stdlib.h>
#include "cpu.h"
#define GENERAL_STACK_MAX_WIDTH 16
#define GENERAL_DISAS_WIDTH 41
int terminal_width;
int terminal_height;
WINDOW *tabs;
WINDOW *general_memdump;
WINDOW *general_stack;
WINDOW *general_disas;
WINDOW *general_registers;
WINDOW *general_terminal_output;
int monochrome;
int get_terminal_size(){
int new_height,new_width;
getmaxyx(stdscr,new_height,new_width);
int changed=(new_width!=terminal_width)||(new_height!=terminal_height);
terminal_width=new_width;
terminal_height=new_height;
return changed;
}
int gui_ncurses_refresh(){
if(refresh()==ERR)
return 1;
if(wrefresh(tabs)==ERR)
return 1;
if(wrefresh(general_memdump)==ERR)
return 1;
if(wrefresh(general_stack)==ERR)
return 1;
if(wrefresh(general_disas)==ERR)
return 1;
if(wrefresh(general_registers)==ERR)
return 1;
if(wrefresh(general_terminal_output)==ERR)
return 1;
return 0;
}
char *tab_name[]={"Overview","Memory","Internal"};
unsigned int CURRENT_TAB=0;
enum GUI_CPU_STATE_t CPU_STATE=GUI_CPU_SINGLE_STEPPING;
void update_tabs(){
wattron(tabs,A_BOLD);
wattron(tabs,COLOR_PAIR(2));
for(int i=0;i<terminal_width;i++)
mvwprintw(tabs,0,i," ");
int x=2;
for(unsigned int i=0;i<sizeof(tab_name)/sizeof(tab_name[0]);i++){
if(i==CURRENT_TAB)
wattron(tabs,COLOR_PAIR(4));
else
wattron(tabs,COLOR_PAIR(5));
mvwprintw(tabs,0,x," %1d",i);
x+=2;
if(i==CURRENT_TAB)
wattron(tabs,COLOR_PAIR(3));
else{
wattron(tabs,COLOR_PAIR(2));
wattroff(tabs,A_BOLD);
}
mvwprintw(tabs,0,x," %s ",tab_name[i]);
wattron(tabs,A_BOLD);
x+=strlen(tab_name[i])+2+3;
}
switch(CPU_STATE){
case GUI_CPU_RUNNING:
wattron(tabs,COLOR_PAIR(6));
mvwprintw(tabs,0,terminal_width-13,"[ RUNNING ");
break;
case GUI_CPU_SINGLE_STEPPING:
wattron(tabs,COLOR_PAIR(7));
mvwprintw(tabs,0,terminal_width-21,"[ SINGLE-STEPPING ");
break;
case GUI_CPU_STOPPED:
wattron(tabs,COLOR_PAIR(8));
mvwprintw(tabs,0,terminal_width-13,"[ STOPPED ");
break;
}
mvwprintw(tabs,0,terminal_width-3,"]");
}
int start_gui(){
if(!initscr())
return 1;
monochrome=( has_colors() == FALSE );
init_color(8, 700, 700, 700);
init_color(COLOR_WHITE, 100, 1000, 1000);
if(!monochrome){
start_color();
init_pair(1, COLOR_RED, COLOR_BLACK);
//tab colors
init_pair(2, COLOR_BLACK, 8);
init_pair(3, 8, COLOR_BLACK);
init_pair(4, COLOR_WHITE, COLOR_BLACK);
init_pair(5, COLOR_WHITE, 8);
init_pair(6, COLOR_BLACK,COLOR_GREEN);
init_pair(7, COLOR_BLACK,COLOR_YELLOW);
init_pair(8, COLOR_BLACK,COLOR_RED);
//cpu instruction pipline location colors
init_pair(9, COLOR_MAGENTA,COLOR_BLACK); //fetch
init_pair(10, COLOR_YELLOW,COLOR_BLACK); //decode
init_pair(11, COLOR_GREEN,COLOR_BLACK); //exec
init_pair(12, COLOR_BLACK,COLOR_MAGENTA); //fetch
init_pair(13, COLOR_BLACK,COLOR_YELLOW); //decode
init_pair(14, COLOR_BLACK,COLOR_GREEN); //exec
}
noecho();
curs_set(0);
get_terminal_size();
mvprintw((terminal_height-3)/2+3,terminal_width/2-15,"Initialising the simulator...");
tabs = newwin(1,terminal_width,0,0);
update_tabs();
int len;
int y1_divider,y2_divider;
int border=4;
if( (terminal_height-2*border-1)*0.2 < 8 )
y1_divider=terminal_height-border-8;
else if ( ( terminal_height - 2*border )*0.2 < 15 )
y1_divider=terminal_height-border-11;
else
y1_divider=(terminal_height-border*2)*0.8;
y2_divider=(3*(terminal_height-2*border-1)/4);
int x=border;
int middle;
general_memdump=newwin(y1_divider,terminal_width/2,x,border);
x+=terminal_width/2;
x++;
x+=3;
middle=x;
len=(terminal_width/6)>GENERAL_DISAS_WIDTH?GENERAL_DISAS_WIDTH:(terminal_width/6);
general_disas=newwin(y2_divider,len,4,x);
x+=len;
x+=3;
len=(terminal_width/6)>GENERAL_STACK_MAX_WIDTH?GENERAL_STACK_MAX_WIDTH:(terminal_width/6);
general_stack=newwin(y2_divider,len,4,x);
x+=len;
general_registers=newwin(terminal_height-y1_divider-border-1,terminal_width/2,y1_divider+border+1,border);
x+=terminal_width/2;
x++;
general_terminal_output=newwin(terminal_height-y2_divider-border-1,terminal_width/2-3*border,y2_divider+border+1,middle);
scrollok(general_terminal_output,TRUE);
x+=terminal_width/2;
x++;
if(gui_ncurses_refresh())
return 1;
return 0;
}
int gui_error(char *str){
WINDOW *error_win = newwin(3,40,terminal_height/2-1,terminal_width/2-20);
box(error_win, 0 , 0);
if(!monochrome)
wattron(error_win,COLOR_PAIR(1));
mvwprintw(error_win,1,1,"%s",str);
if(wrefresh(error_win)==ERR)
return 1;
getch();
delwin(error_win);
return 0;
if(!monochrome)
wattroff(error_win,COLOR_PAIR(1));
}
//// WARNING!! THIS ASSUMES THAT ADDRESS IS CORRECTLY ALIGNED WITH THE INSTRUCTION START/END!!
int select_instruction_color(struct simdata_t *simdata, WINDOW* window,uint32_t ADDRESS, int applyremove){
if(simdata->cpu_gui_hints){
struct instr_list_t* pointer;
pointer=simdata->cpu_gui_hints->fetching_list;
while(pointer!=NULL){
if(pointer->address==ADDRESS){
if(applyremove)
wattron(window,COLOR_PAIR(9));
else
wattroff(window,COLOR_PAIR(9));
return 0;
}
pointer=pointer->next;
}
pointer=simdata->cpu_gui_hints->decoding_list;
while(pointer!=NULL){
if(pointer->address==ADDRESS){
if(applyremove)
wattron(window,COLOR_PAIR(10));
else
wattroff(window,COLOR_PAIR(10));
return 0;
}
pointer=pointer->next;
}
pointer=simdata->cpu_gui_hints->executing_list;
while(pointer!=NULL){
if(pointer->address==ADDRESS){
if(applyremove)
wattron(window,COLOR_PAIR(11));
else
wattroff(window,COLOR_PAIR(11));
return 0;
}
pointer=pointer->next;
}
}
return 1;
}
int update_general_disas(struct simdata_t *simdata){
werase(general_disas);
int width,height;
getmaxyx(general_disas,height,width);
box(general_disas, 0 , 0);
mvwprintw(general_disas,0,width/2-7,"[ DISASSEMBLY ]");
if(simdata->registers==NULL||simdata->RAM==NULL){
mvwprintw(general_disas,1,1,"Data not initialised");
return 0;
}
int offset_arrow;
int have_legend=(width>29);
int usable_height=height-2-have_legend;
if(width<41)
offset_arrow=2;
else
offset_arrow=3;
if(width<18){
mvwprintw(general_disas,1,1,"too small window");
}else{
uint32_t ADDRESS=(simdata->registers->PC-(usable_height/2-2)*4)&0x00FFFFFF;
for (int i=2;i<usable_height;i++){
int overall_offset=offset_arrow-2;
mvwaddch(general_disas,i,11+overall_offset,ACS_VLINE);
if(ADDRESS==simdata->registers->PC)
wattron(general_disas,A_BOLD);
mvwprintw(general_disas,i,4+overall_offset,"%06X",ADDRESS);
char* disas=disassemble(*(uint32_t*)(simdata->RAM+ADDRESS));
int space_left=width-14-2+(overall_offset?0:1);
if(space_left<25)
disas[space_left+1]=0;
select_instruction_color(simdata,general_disas,ADDRESS,1);
mvwprintw(general_disas,i,13+overall_offset,"%s",disas);
select_instruction_color(simdata,general_disas,ADDRESS,0);
if(ADDRESS==simdata->registers->PC)
wattroff(general_disas,A_BOLD);
ADDRESS=(ADDRESS+4)&0xFFFFFF;
free(disas);
}
mvwaddch(general_disas,usable_height/2,offset_arrow,ACS_RARROW);
mvwaddch(general_disas,usable_height/2,offset_arrow-1,ACS_ULCORNER);
mvwaddch(general_disas,usable_height/2+1,offset_arrow-1,ACS_VLINE);
mvwaddch(general_disas,usable_height/2+2,offset_arrow-1,ACS_VLINE);
mvwaddch(general_disas,usable_height/2+3,offset_arrow-1,ACS_VLINE);
mvwaddch(general_disas,usable_height/2+4,offset_arrow-1,ACS_VLINE);
mvwaddch(general_disas,usable_height/2+5,offset_arrow-1,ACS_VLINE);
mvwaddch(general_disas,usable_height/2+6,offset_arrow-1,'P');
if(offset_arrow==2)
mvwaddch(general_disas,usable_height/2+7,offset_arrow-1,'C');
else
mvwaddch(general_disas,usable_height/2+6,offset_arrow,'C');
if(have_legend){
wattron(general_disas,COLOR_PAIR(12));
mvwprintw(general_disas,height-2,2," ");
wattroff(general_disas,COLOR_PAIR(12));
mvwprintw(general_disas,height-2,4,"=Fetch");
wattron(general_disas,COLOR_PAIR(13));
mvwprintw(general_disas,height-2,11," ");
wattroff(general_disas,COLOR_PAIR(13));
mvwprintw(general_disas,height-2,13,"=Decode");
wattron(general_disas,COLOR_PAIR(14));
mvwprintw(general_disas,height-2,21," ");
wattroff(general_disas,COLOR_PAIR(14));
mvwprintw(general_disas,height-2,23,"=Exec");
}
}
return 0;
}
int update_general_stack(struct simdata_t *simdata){
int width,height;
getmaxyx(general_stack,height,width);
box(general_stack, 0 , 0);
mvwprintw(general_stack,0,width/2-4,"[ STACK ]");
if(simdata->registers==NULL||simdata->RAM==NULL){
mvwprintw(general_stack,1,1,"Data not initialised");
return 0;
}
if(width<13){
mvwprintw(general_stack,1,1,"too small window");
}else{
// Calculate config based on window size
int offset_data,offset_arrow;
if(width<14){
offset_data=3;
offset_arrow=2;
}else{
offset_data=5;
offset_arrow=3;
}
// draw data
uint32_t ADDRESS=(simdata->registers->SP-(height/2-2)*4)&0x00FFFFFF;
for(int i=0;i<height-4;i++){
if(ADDRESS==simdata->registers->SP)
wattron(general_stack,A_BOLD);
mvwprintw(general_stack,i+2,offset_data,"%08X",*(uint32_t*)(simdata->RAM+ADDRESS));
if(ADDRESS==simdata->registers->SP)
wattroff(general_stack,A_BOLD);
ADDRESS=(ADDRESS+4)&0xFFFFFF;
}
// draw graphics
mvwaddch(general_stack,height/4-2,offset_arrow-1,ACS_UARROW);
mvwaddch(general_stack,height/4-1,offset_arrow-1,ACS_VLINE);
mvwaddch(general_stack,height/4 ,offset_arrow-1,ACS_VLINE);
mvwaddch(general_stack,height/4+1,offset_arrow-1,ACS_VLINE);
if(offset_arrow!=2)
mvwprintw(general_stack,height/4+2,1,"(+)");
else
mvwprintw(general_stack,height/4+2,offset_arrow-1,"+");
mvwaddch(general_stack,height/2,offset_arrow,ACS_RARROW);
mvwaddch(general_stack,height/2,offset_arrow-1,ACS_ULCORNER);
mvwaddch(general_stack,height/2+1,offset_arrow-1,ACS_VLINE);
mvwaddch(general_stack,height/2+2,offset_arrow-1,ACS_VLINE);
mvwaddch(general_stack,height/2+3,offset_arrow-1,ACS_VLINE);
mvwaddch(general_stack,height/2+4,offset_arrow-1,'S');
if(offset_arrow==2)
mvwaddch(general_stack,height/2+5,offset_arrow-1,'P');
else
mvwaddch(general_stack,height/2+4,offset_arrow,'P');
}
return 0;
}
int update_general_memdump(struct simdata_t *simdata){
int width,height;
getmaxyx(general_memdump,height,width);
box(general_memdump, 0 , 0);
mvwprintw(general_memdump,0,terminal_width/4-6,"[ MEMDUMP ]");
if(simdata->registers==NULL||simdata->RAM==NULL){
mvwprintw(general_memdump,1,1,"Data not initialised");
return 0;
}
if(width<16){
mvwprintw(general_memdump,1,1,"too small window");
}else{
int n=(width-12)/4; // bytes in each line
int usable_height=height-3-(width-12)%2;
uint32_t ADDRESS=(simdata->registers->PC-n*usable_height/2)&0x00FFFFFF;
uint32_t color_addr;
int have_color;
for(int h=0;h<usable_height;h++){
wmove(general_memdump,h+2,2+(width-12)%2);
wattroff(general_memdump,A_BOLD);
wprintw(general_memdump,"%06x ",ADDRESS);
uint32_t temp_address=ADDRESS;
for (int i=0;i<n;i++){
if(ADDRESS>=simdata->registers->PC&&ADDRESS<=simdata->registers->PC+3)
wattron(general_memdump,A_BOLD);
else
wattroff(general_memdump,A_BOLD);
if(select_instruction_color(simdata,general_memdump,ADDRESS,1)==0){
have_color=5;
color_addr=ADDRESS;
}else if(have_color)
select_instruction_color(simdata,general_memdump,color_addr,1);
if(have_color){
have_color--;
if(!have_color)
select_instruction_color(simdata,general_memdump,color_addr,0);
}
wprintw(general_memdump,"%02x ",simdata->RAM[ADDRESS]);
ADDRESS=(ADDRESS+1)&0xFFFFFF;
}
if(have_color)
select_instruction_color(simdata,general_memdump,color_addr,0);
ADDRESS=temp_address;
for (int i=0;i<n;i++){
if(ADDRESS>=simdata->registers->PC&&ADDRESS<=simdata->registers->PC+3)
wattron(general_memdump,A_BOLD);
else
wattroff(general_memdump,A_BOLD);
wprintw(general_memdump,"%c",(simdata->RAM[ADDRESS]>=0x20&&simdata->RAM[ADDRESS]<0x7F)?simdata->RAM[ADDRESS]:'.');
ADDRESS=(ADDRESS+1)&0xFFFFFF;
}
}
}
return 0;
}
int update_general_registers(struct simdata_t *simdata){
int width,height;
werase(general_registers);
getmaxyx(general_registers,height,width);
box(general_registers, 0 , 0);
mvwprintw(general_registers,0,terminal_width/4-7,"[ REGISTERS ]");
if(simdata->registers==NULL){
mvwprintw(general_registers,1,1,"Data not initialised");
return 0;
}
if(simdata->registers==NULL)
mvwprintw(general_registers,1,1,"Registers data structure not initialised");
else{
int per_line=width/35;
if(per_line==0)
mvwprintw(general_registers,1,1,"too small window");
else{
int center_x_offset=((width-2)-35*per_line)/2;
int lines_used=(8/(int)per_line<8/(float)per_line)?8/per_line+1:8/per_line;
int lines_for_special_registers;
lines_for_special_registers=( width < 22+27+8 )?2:1;
int center_y_offset=((height-2)-(lines_used+lines_for_special_registers+1))/2;
if((lines_used+lines_for_special_registers+1)>(height-2)||width<37)
mvwprintw(general_registers,1,1,"too small window");
else{
int n=0,y=0;
while(y!=lines_used){
for(int i=0;i<per_line;i++){
if(n<8){
float float_equiv=*(float*)(simdata->registers->GPR+n);
if(float_equiv<9999999999&&float_equiv>-9999999999)
mvwprintw(general_registers,1+y+center_y_offset,1+i*35+center_x_offset,"R%d: %08X (%08f) ",n,simdata->registers->GPR[n],float_equiv);
else
mvwprintw(general_registers,1+y+center_y_offset,1+i*35+center_x_offset,"R%d: %08X (%cinf) ",n,simdata->registers->GPR[n],(float_equiv>0)?'+':'-');
n++;
}
}
y++;
}
for(int i=0;i<35*per_line;i++)
mvwaddch(general_registers,1+center_y_offset+lines_used,center_x_offset+i,ACS_HLINE);
int spec_reg_1_offset, spec_reg_2_offset;
if(lines_for_special_registers==2){
spec_reg_1_offset=((width-2)/2)-(23/2);
spec_reg_2_offset=((width-2)/2)-(27/2);
}else{
spec_reg_1_offset=((width-2)/2)-(22+27+8)/2;
spec_reg_2_offset=spec_reg_1_offset+22+8;
}
wattron(general_registers,A_BOLD);
mvwprintw(general_registers,1+center_y_offset+lines_used+1,spec_reg_1_offset," PC");
wattroff(general_registers,A_BOLD);
wprintw(general_registers,": %06X ",simdata->registers->PC);
wattron(general_registers,A_BOLD);
wprintw(general_registers,"SP");
wattroff(general_registers,A_BOLD);
wprintw(general_registers,": %06X ",simdata->registers->SP);
wattron(general_registers,A_BOLD);
mvwprintw(general_registers,center_y_offset+lines_used+1+lines_for_special_registers,spec_reg_2_offset," ZERO");
wattroff(general_registers,A_BOLD);
wprintw(general_registers,": %c ",(simdata->registers->FLAGS&1)?'1':'0');
wattron(general_registers,A_BOLD);
wprintw(general_registers,"CARRY");
wattroff(general_registers,A_BOLD);
wprintw(general_registers,": %c ",(simdata->registers->FLAGS&2)?'1':'0');
wattron(general_registers,A_BOLD);
wprintw(general_registers,"SIGN");
wattroff(general_registers,A_BOLD);
wprintw(general_registers,": %c ",(simdata->registers->FLAGS&4)?'1':'0');
}
}
}
return 0;
}
int term_curs_x,term_curs_y;
int update_general_terminal_output(struct simdata_t *simdata){
int width,height;
werase(general_terminal_output);
getmaxyx(general_terminal_output,height,width);
box(general_terminal_output, 0 , 0);
mvwprintw(general_terminal_output,0,width/2-7,"[ TERM OUTPUT ]");
term_curs_x=0;
term_curs_y=0;
for(uint64_t i=0;i < simdata->terminal_output_size;i++){
char c=simdata->terminal_output[i];
if(c>=' '&&c<='~'){
mvwprintw(general_terminal_output,term_curs_y+1,term_curs_x+1,"%c",c);
term_curs_x++;
if(term_curs_x>=width-2){
term_curs_x=0;
term_curs_y++;
}
if(term_curs_y>=height-2){
wscrl(general_terminal_output,1);
term_curs_y--;
for(int i=0;i<width;i++){
mvwprintw(general_terminal_output,term_curs_y+1,i," ");
}
box(general_terminal_output, 0 , 0);
mvwprintw(general_terminal_output,0,width/2-7,"[ TERM OUTPUT ]");
}
}else{
switch(c){
case 0x0a:
term_curs_x=0;
term_curs_y++;
if(term_curs_y>=height-2){
wscrl(general_terminal_output,1);
term_curs_y--;
for(int i=0;i<width;i++){
mvwprintw(general_terminal_output,term_curs_y+1,i," ");
}
box(general_terminal_output, 0 , 0);
mvwprintw(general_terminal_output,0,width/2-7,"[ TERM OUTPUT ]");
}
break;
default:
werase(general_terminal_output);
box(general_terminal_output, 0 , 0);
mvwprintw(general_terminal_output,0,width/2-7,"[ TERM OUTPUT ]");
mvwprintw(general_terminal_output,1,1,"Invalid output");
return 0;
}
}
}
mvwchgat(general_terminal_output,term_curs_y+1,term_curs_x+1, 1, A_REVERSE, 0, NULL);
return 0;
}
int clear_back_window=1;
int update_gui(struct simdata_t *simdata){
if(simdata->cpu_state==CPU_HALTED)
CPU_STATE=GUI_CPU_STOPPED;
if(clear_back_window){
clear();
clear_back_window=0;
}
update_tabs();
if(update_general_memdump(simdata))
return 1;
if(update_general_stack(simdata))
return 1;
if(update_general_disas(simdata))
return 1;
if(update_general_registers(simdata))
return 1;
if(update_general_terminal_output(simdata))
return 1;
if(gui_ncurses_refresh())
return 1;
return 0;
}
int gui_continue_request(struct simdata_t *simdata){
int inch;
int release=0;
while(release==0){
if(((inch=getch())==ERR)){
if(CPU_STATE==GUI_CPU_SINGLE_STEPPING)
return 1;
else
release=1;
}
switch(inch){
case 'r':
if(simdata->cpu_state!=CPU_HALTED){
if(CPU_STATE==GUI_CPU_RUNNING){
CPU_STATE=GUI_CPU_SINGLE_STEPPING;
nodelay(stdscr, FALSE);
}else{
CPU_STATE=GUI_CPU_RUNNING;
nodelay(stdscr, TRUE);
}
}
break;
case 'q':
return 2;
case '\n':
release=1;
break;
default:
}
}
return 0;
}
int end_gui(){
if(endwin()==ERR)
return 1;
return 0;
}
Reference in New Issue View Git Blame Copy Permalink