#include "language.h"
#include <dirent.h>

#define PC memory.sys_start[0]
#define SP memory.sys_start[1]
#define RSP memory.sys_start[2]
#define JUMP_OFF memory.sys_start[3]

int stack_frames[256];
int stack_frame_sizes[256];
int stack_frames_index = 0;
//this stores free regions as start, end, size
int heap_list[2048][3];
int heap_length = 1;

double total_time = 0.0;
int number_of_steps = 0;

struct Memory {
   short *memory;
   short *sys_start;
   short *rom_start;
   short *stack_start;
   short *return_stack_start;
   short *heap_start;
};

int find_available_heap(int size)
{
   for(int x = 0; x < 2048; x++)
   {
       if( heap_list[x][2] > size )
       {
           int found = heap_list[x][0];
           heap_list[x][0] = heap_list[x][0] + size;
           heap_list[x][2] = heap_list[x][2] - size;
           return found;
       }
   }
}

void free_heap(int start, int size)
{
   heap_list[++heap_length][0] = start;
   heap_list[heap_length][1] = start + size;
   heap_list[heap_length][2] = size;
   for(int x = 0; x < heap_length - 1; x++)
   {
       if((heap_list[x][0] == (heap_list[heap_length][1])))
       {
           heap_list[x][0] -= size;
           heap_list[x][2] += size;
           heap_length--;
       }
       else if(heap_list[x][1] == (heap_list[heap_length][0]))
       {
           heap_list[x][1] += size;
           heap_list[x][2] += size;
           heap_length--;
       }
   }
}

int POP_S(int amount, struct Memory* memory)
{
   int data = memory->stack_start[memory->sys_start[1]-1];
   memory->sys_start[1] -= amount;
   if(memory->sys_start[1] < 0) memory->sys_start[1] = 0;
   return data;
}

void Q_POP_S(int amount, struct Memory* memory)
{
   memory->sys_start[1] -= amount;
   if(memory->sys_start[1] < 0) memory->sys_start[1] = 0;
}

void out_char(int output_format, int output_value)
{
   if(output_format == 'I') printf("%i",output_value);
   if(output_format == 'C') printf("%c",output_value);
   if(output_format == 'X') printf("%x",output_value);
   if(output_format == 'B'){
       while (output_value){
           if (output_value & 1) printf("1");
           else printf("0");
           output_value >>= 1;
       }
   }
}

void main(int argc, char *argv[])
{
   struct Memory memory;

   memory.memory = malloc(256*256*sizeof(short));
   memory.sys_start = &memory.memory[0];
   memory.rom_start = &memory.memory[255];
   memory.stack_start = &memory.memory[256*5-1];
   memory.heap_start = &memory.memory[256*6-1];
   memory.return_stack_start = &memory.memory[256*6-1];
   heap_list[0][0] = 256*7-1;
   heap_list[0][1] = 256*256;
   heap_list[0][2] = 256*256 - 256*7-1;
   stack_frames[0] = RSP + 256*6-1;

   PC = 255;
   JUMP_OFF = 0;

   int requested_number_of_steps = 100000000;

   if( argc > 2) requested_number_of_steps = atoi(argv[2]);
   if( argc > 3) memory.sys_start[4] = (short) atoi(argv[3]);
   if( argc > 4) memory.sys_start[5] = (short) atoi(argv[4]);

   FILE *fp = fopen(argv[1], "r");
   if (fp == NULL) printf("ROM could not be loaded\n");

   fread(memory.rom_start, sizeof(short)*256*4, 1, fp);
   fclose(fp);

   int running = 1;
   while(running){
       int redraw = 0;
       short datum = memory.memory[PC];

       memcpy(memory.stack_start+SP, memory.memory+PC, sizeof(short));

       int address;
       int output_length, output_address, output_mode, output_format, output_value;
       int compare_mode;
       short  load_value;
       switch( datum ){
           case LIT: PC++;memory.stack_start[SP] = memory.memory[PC];SP++;break;
           case DUP: memory.stack_start[SP] = memory.stack_start[SP - 1];SP++; break;
           case POP: Q_POP_S(1, &memory); break;
           case FHA:
               output_length = POP_S(1, &memory);
               output_address = POP_S(1, &memory);
               free_heap(output_address, output_length);
               break;
           case NFH:
               output_length = POP_S(1, &memory);
               output_address = find_available_heap(output_length);
               memory.stack_start[SP] = output_address;
               SP++;
               break;
           case STA: address = POP_S(1, &memory);memory.memory[address] = POP_S(1, &memory); break;
           case LFA: address = POP_S(1, &memory);memory.stack_start[SP] = memory.memory[address];SP++;
break;
           case JMP: PC = POP_S(1, &memory) - 1 + JUMP_OFF; break;
           case JMR:
               memory.return_stack_start[++RSP] = PC;
               PC = POP_S(1, &memory) - 1 + JUMP_OFF;
               stack_frames_index++;
               stack_frame_sizes[stack_frames_index] = 1;
               stack_frames[stack_frames_index] = RSP + 256*6-1;
               break;
           case JCC:
               RSP -= stack_frame_sizes[stack_frames_index]-1;
               PC = memory.return_stack_start[RSP--];
               stack_frames_index--;
               break;
           case JEQ:
               if( memory.stack_start[SP-2] == memory.stack_start[SP-3]){
                   PC = POP_S(3, &memory) - 1 + JUMP_OFF;
               }
               else Q_POP_S(3, &memory);
               break;
           case JNE:
               if( memory.stack_start[SP-2] != memory.stack_start[SP-3]){
                   PC = POP_S(3, &memory) - 1 + JUMP_OFF;
               }
               else Q_POP_S(3, &memory);
               break;
           case JER:
               if( memory.stack_start[SP-2] == memory.stack_start[SP-3]){
                   memory.return_stack_start[++RSP] = PC;
                   PC = POP_S(3, &memory) - 1 + JUMP_OFF;
                   stack_frames_index++;
                   stack_frame_sizes[stack_frames_index] = 1;
                   stack_frames[stack_frames_index] = RSP + 256*6-1;
               }
               else Q_POP_S(3, &memory);
               break;
           case JNR:
               if( memory.stack_start[SP-2] != memory.stack_start[SP-3]){
                   memory.return_stack_start[++RSP] = PC;
                   PC = POP_S(3, &memory) - 1 + JUMP_OFF;
                   stack_frames_index++;
                   stack_frame_sizes[stack_frames_index] = 1;
                   stack_frames[stack_frames_index] = RSP + 256*6-1;
               }
               else Q_POP_S(3, &memory);
               break;
           case SWP: memory.stack_start[SP] = memory.stack_start[SP-2];memory.stack_start[SP-2] =
memory.stack_
start[SP-1];memory.stack_start[SP-1] = memory.stack_start[SP]; break;
           case OVR: memory.stack_start[SP] = memory.stack_start[SP-2];SP++; break;
           //case DIV: memory.stack_start[SP-2] = floor(memory.stack_start[SP-2] /
memory.stack_start[SP-1]);Q_
POP_S(1, &memory); break;
           case MUL: memory.stack_start[SP-2] = memory.stack_start[SP-2] *
memory.stack_start[SP-1];Q_POP_S(1,
&memory); break;
           case SUB: memory.stack_start[SP-2] = memory.stack_start[SP-2] -
memory.stack_start[SP-1];Q_POP_S(1,
&memory); break;
           case ADD: memory.stack_start[SP-2] = memory.stack_start[SP-2] +
memory.stack_start[SP-1];Q_POP_S(1,
&memory); break;
           case LSL: memory.stack_start[SP-1] = (memory.stack_start[SP-1] << 1) |
(memory.stack_start[SP-1] >>
(15)) & (0x7F >> (15)); break;
           case AND:
               memory.stack_start[SP-2] = memory.stack_start[SP-2] & memory.stack_start[SP-1];
               Q_POP_S(1, &memory);
               break;
           case LOR: memory.stack_start[SP-2] = memory.stack_start[SP-2] |
memory.stack_start[SP-1];Q_POP_S(1,
&memory); break;
           case CMP:
               compare_mode = memory.stack_start[SP-1];
               switch (compare_mode){
                   case 0: memory.stack_start[SP-3] = memory.stack_start[SP-3] <
memory.stack_start[SP-2];Q_POP
_S(2, &memory); break;
                   case 1: memory.stack_start[SP-3] = memory.stack_start[SP-3] >
memory.stack_start[SP-2];Q_POP
_S(2, &memory); break;
                   case 2: memory.stack_start[SP-3] = memory.stack_start[SP-3] <=
memory.stack_start[SP-2];Q_PO
P_S(2, &memory); break;
                   case 3: memory.stack_start[SP-3] = memory.stack_start[SP-3] >=
memory.stack_start[SP-2];Q_PO
P_S(2, &memory); break;
                   case 4: memory.stack_start[SP-3] = memory.stack_start[SP-3] ==
memory.stack_start[SP-2];Q_PO
P_S(2, &memory); break;
                   case 5: memory.stack_start[SP-3] = memory.stack_start[SP-3] !=
memory.stack_start[SP-2];Q_PO
P_S(2, &memory); break;
                   case 6: memory.stack_start[SP-2] = memory.stack_start[SP-2] > 0;Q_POP_S(1, &memory);
break;
                   case 7: memory.stack_start[SP-2] = memory.stack_start[SP-2] < 0;Q_POP_S(1, &memory);
break;
               }
               break;
           case OUT:
               output_format = POP_S(1, &memory);
               output_length = POP_S(1, &memory);
               output_mode = POP_S(1, &memory);
               if(output_mode == 0) output_address = POP_S(1, &memory);
               if(output_length == ((short)555)) output_length = 60000;
               for(int x=0; x < output_length; x++){
                   if(output_mode == 0){
                       output_value = memory.memory[output_address+x];
                       out_char(output_format,output_value);
                   }
                   else{
                       memory.memory[5000-x] = memory.stack_start[SP-1];
                       output_value = POP_S(1, &memory);
                   }
                   if((output_value == 0) && (output_length == 60000)){
                       output_length = x;
                       break;
                   }
               }
               if(output_mode == 1){
                   for(int x=1; x <= output_length; x++){
                       out_char(output_format, memory.memory[5000-output_length+x]);
                   }
               }
               break;
           case LFR:
               load_value = stack_frames[stack_frames_index]+POP_S(1, &memory);
               memory.stack_start[SP++] = load_value;
               break;
           case PRS:
               memory.return_stack_start[++RSP] = POP_S(1, &memory);
               stack_frame_sizes[stack_frames_index]++;
               break;
           case STV:
               output_length = POP_S(1, &memory);
               output_address = POP_S(1, &memory);
               for(int x=1; x < output_length; x++){
                   memory.memory[output_address+output_length-x-1] = POP_S(1, &memory);
               }
               memory.memory[output_address+output_length-1] = POP_S(1, &memory);
               break;
           case STZ:
               output_length = POP_S(1, &memory);
               output_address = POP_S(1, &memory);
               for(int x=0; x < output_length; x++){
                   memory.memory[output_address+x] = 0;
               }
               break;
           case RIN:
               output_length = POP_S(1, &memory);
               output_address = POP_S(1, &memory);
               char format[24];
               sprintf(format, " %%n%%%i[^\n]%%n", output_length);
               int n1, n2;
               char test[255];
               scanf(format, &n1, &test, &n2);
               memory.memory[16] = (short)n2-n1;
               for(int x=0; x < n2-n1; x++){
                   memory.memory[output_address+x] = (short)test[x];
               }
               break;
           case END: running = 0; break;
           default: break;
       }
       if( memory.sys_start[48] > 0 ){
           char path[255];
           short path_address = memory.sys_start[49];
           short path_len = memory.sys_start[50];
           short result_address = memory.sys_start[51];
           short request_options = memory.sys_start[52];
           if((request_options & ((short)-32768)) == ((short)-32768));//local path
           for(int p = 0; p < path_len; p++){
               printf("%c",memory.memory[path_address+p]);
               path[p] = memory.memory[path_address+p];
           }
           printf("\n");
           path[path_len] = '\0';

           short last_len = 0;
           if((request_options & ((short)2048)) == ((short)2048)){
               //list
               struct dirent *directory;
               DIR *dr = opendir(path);
               if (dr == NULL){
                   memory.sys_start[48] = 0;
                   printf("Could not open current directory\n");
                   break;
               }
               while ((directory = readdir(dr)) != NULL){

                   short p[255];
                   for(int i=0;i<strlen(directory->d_name);i++){
                       p[i] = directory->d_name[i];
                   }
                   p[strlen(directory->d_name)] = 10;
                   memcpy(&memory.memory[result_address + last_len], p, 2*strlen(directory->d_name)+1);
                   last_len += strlen(directory->d_name)+1;
               }
               memory.memory[result_address + last_len] = 3;
               memory.sys_start[53] = last_len;
               closedir(dr);
           }
           if((request_options & ((short)16384)) == ((short)16384)){
               //read
               FILE *file_fp = fopen(path, "r");
               if (file_fp == NULL) printf("ROM could not be loaded\n");
               fread(&memory.memory[result_address], sizeof(short)*256*4, 1, file_fp);
               memory.sys_start[53] = 256;
               fclose(file_fp);
           }
           if((request_options & ((short)8192)) == ((short)8192));//write
           if((request_options & ((short)4096)) == ((short)4096));//execute
           memory.sys_start[48] = 0;
       }

       PC++;
       number_of_steps++;

       if (number_of_steps >= requested_number_of_steps){
           int scanned = 0;
           while(scanned != 1){
               scanf("%d", &scanned);
               if(scanned == 2){
                   printf("SYS:\n");
                   for(int x = 0; x < 255*6; x++){
                       if(x%30==0) printf("\n");
                       printf(" %04x", memory.sys_start[x]);
                   }
                   printf("\n");
               }
           }
       }
   }
}

You are viewing proxied material from sdf.org. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.