| /* %%%%%%%%%%%%%%%%%%%% (c) William Landi 1991 %%%%%%%%%%%%%%%%%%%%%%%%%%%% */ |
| /* Permission to use this code is granted as long as the copyright */ |
| /* notice remains in place. */ |
| /* =============================== memory.c ================================ */ |
| /* Contains all the routines that manage the main memory of the SIC/XE */ |
| /* machine. */ |
| |
| #include "boolean.h" |
| #include <stdlib.h> |
| #include <stdio.h> |
| #include <string.h> |
| #include "constants.h" |
| #include "convert.h" |
| #include "load.h" |
| |
| /* MEM_SPACE The type of a main memory in this program.*/ |
| typedef char *MEM_SPACE; |
| |
| /* ========================== Printing memory constants ==================== */ |
| /* BYTES_PER_GROUP How many bytes to print out at a time. */ |
| #define BYTES_PER_GROUP 4 |
| /* GROUPS_PER_LINE How many groups of bytes to put on one */ |
| /* line*/ |
| #define GROUPS_PER_LINE 4 |
| /* LINES_OF_GAP_TO_ELIPSE How many consequative lines of unchanged */ |
| /* bytes must present to elipse out the */ |
| /* lines from the output. */ |
| #define LINES_OF_GAP_TO_ELIPSE 3 |
| |
| /* ========== Keeping Track of which locations have been modified ========== */ |
| /* Keep a linked list of blocks of memory that have been modified. ONLY */ |
| /* locations that where actually loaded into are included in any block and */ |
| /* locations that where loaded are in some block. */ |
| |
| /* BUFFER_ELEMENT Type of one block. START of block and it's */ |
| /* length. Plus a pointer because a linked */ |
| /* list. */ |
| struct BUFFER_ELEMENT { |
| int START; /* Start of the block. */ |
| int LENGTH; /* Length of the block. */ |
| struct BUFFER_ELEMENT *NEXT; /* Next block in the linked list. */ |
| }; |
| |
| /* BUFFER A record with the first and last element of */ |
| /* a lined list. */ |
| /* LOCATIONS_USED A BUFFER that contains the modifed locations*/ |
| struct BUFFER { |
| struct BUFFER_ELEMENT *HEAD;/* First block of the linked list. */ |
| struct BUFFER_ELEMENT *END; /* Last block of the linked list. */ |
| } LOCATIONS_USED = {NULL,NULL}; |
| |
| /* ---------------------------- ADD_TO_BUFFER (local) ---------------------- */ |
| /* Adds a block to the END of the linked list of blocks. */ |
| void ADD_TO_BUFFER(int LOCATION,int LEN) |
| { |
| if (LOCATIONS_USED.HEAD == NULL) { |
| /* ------------ Add to an empty list. */ |
| LOCATIONS_USED.HEAD = (struct BUFFER_ELEMENT *) malloc(sizeof(struct BUFFER_ELEMENT)); |
| LOCATIONS_USED.END = LOCATIONS_USED.HEAD; |
| } else { |
| /* ------------ Add to a non-empty list. */ |
| (*LOCATIONS_USED.END).NEXT = |
| (struct BUFFER_ELEMENT *) malloc(sizeof(struct BUFFER_ELEMENT)); |
| LOCATIONS_USED.END = (*LOCATIONS_USED.END).NEXT; |
| } |
| (*LOCATIONS_USED.END).START = LOCATION; |
| (*LOCATIONS_USED.END).LENGTH = LEN; |
| (*LOCATIONS_USED.END).NEXT = NULL; |
| } |
| |
| /* ============================= Memory Routines =========================== */ |
| |
| /* --------------------------------- INT ---------------------------------- */ |
| /* Return the integer representation for a character. Had to be written */ |
| /* Because the character 255 (for example) who be treated as the integer -1, */ |
| /* but I needed it to be 255. */ |
| int INT(char CH) |
| { |
| int I; |
| I = CH; |
| |
| if (I<0) return (256+I); |
| return (I); |
| } |
| |
| /* ----------------------------- Create Memory ----------------------------- */ |
| /* Create a megabyte of memory and point MEMORY to it. It does not initialize*/ |
| /* the memory as this took about 5 minuites. Since the memory was */ |
| /* uninitized I needed another way to know when locations where modified, */ |
| /* thus the above lined list of blocks. */ |
| void CREATE_MEMORY(MEM_SPACE *MEMORY) |
| { |
| if ((*MEMORY) != NULL) |
| (void) printf("CREATE_MEMORY called illegally.\n"); |
| else (*MEMORY) = malloc((unsigned int) MEM_SIZE_1); |
| } |
| |
| /* -------------------------- DO_STORE (local) ----------------------------- */ |
| /* Place BYTES consequative bytes into MEMORY, starting at ADDRESS. */ |
| void DO_STORE(char *VALUE,int BYTES,int ADDRESS,MEM_SPACE MEMORY, |
| BOOLEAN *ERROR,BOOLEAN BUFFER_Q) |
| { |
| BOOLEAN LOCAL_ERROR = FALSE_1; /* Was an error detected during the store. */ |
| int TEMP; /* A loop counter variable. */ |
| int INT_VAL; /* Integer representation of one byte of the */ |
| /* block. */ |
| |
| /* ---------------------- Check if fits into memory */ |
| if ( (ADDRESS + BYTES <= MEM_SIZE_1) && (ADDRESS + BYTES >= 0) ) { |
| |
| /* ---------------------- Remember loaded into this block (if necessary) */ |
| if (BUFFER_Q) ADD_TO_BUFFER(ADDRESS,BYTES); |
| |
| /* ---------------------- Load each byte into memory */ |
| for (TEMP = 0; ((TEMP < BYTES) && !eoln(VALUE[TEMP]) && !LOCAL_ERROR); |
| TEMP++) { |
| STR_TO_NUM(&(VALUE[TEMP*HEX_CHAR_PER_BYTE_1]),HEX_CHAR_PER_BYTE_1, |
| 16,&INT_VAL,&LOCAL_ERROR); |
| MEMORY[ADDRESS+TEMP] = (char) INT_VAL; |
| } |
| |
| if (LOCAL_ERROR) { |
| (void) printf("ERROR: Illegal store VALUE = %s.\n", VALUE); |
| (*ERROR) = TRUE_1; |
| } |
| } else { |
| (void) printf("ERROR: Illegal store[1] ADDRESS = %d, BYTES = %d.\n", |
| ADDRESS,BYTES); |
| (*ERROR) = TRUE_1; |
| } |
| } |
| |
| /* ------------------------------ STORE_AT --------------------------------- */ |
| /* Place BYTES consequative bytes into MEMORY, starting at ADDRESS. */ |
| void STORE_AT(char *VALUE,int BYTES,int ADDRESS,MEM_SPACE MEMORY, |
| BOOLEAN *ERROR) |
| { |
| /* vvvvvv Remember loaded this block*/ |
| DO_STORE(VALUE,BYTES,ADDRESS,MEMORY,ERROR,TRUE_1); |
| } |
| |
| /* ---------------------------- ADD_INT_TO_LOC ----------------------------- */ |
| /* Add the integer NUM to what is store at LOCATION in MEMORY. */ |
| void ADD_INT_TO_LOC(int NUM,int LOCATION,int HALF_BYTES,MEM_SPACE MEMORY, |
| BOOLEAN *ERROR) |
| { |
| int INT_MEM_VAL = 0; /* Integer stored at the relavant location. */ |
| char CHAR_MEM_VAL[BITS_PER_WORD_1/BITS_PER_HALFBYTE_1+2]; |
| /* CHAR_MEM_VAL is the string representation of */ |
| /* the number stored at a location of size */ |
| /* HALF_BYTES. */ |
| |
| if ( ((int) HALF_BYTES/2)*2 != HALF_BYTES) |
| HALF_BYTES ++; /* If odd number of half_bytes include an extra */ |
| /* one so that have an even number always. */ |
| |
| /* ----------------- Check if store is legal (fits in memory) */ |
| if ( (LOCATION + HALF_BYTES/HEX_CHAR_PER_BYTE_1 <= MEM_SIZE_1) |
| && (LOCATION + HALF_BYTES/HEX_CHAR_PER_BYTE_1 >= 0)) { |
| int I; |
| |
| /* ------ Get what is stored there */ |
| for (I = 0; I < HALF_BYTES/HEX_CHAR_PER_BYTE_1; I ++) |
| INT_MEM_VAL = INT_MEM_VAL*256 + INT(MEMORY[LOCATION+I]); |
| |
| /* ------ Add the NUMber to what was there */ |
| INT_MEM_VAL += NUM; |
| |
| /* ------ Put the result back */ |
| NUM_TO_STR(INT_MEM_VAL,16,HALF_BYTES,CHAR_MEM_VAL); |
| DO_STORE(CHAR_MEM_VAL,HALF_BYTES/HEX_CHAR_PER_BYTE_1, LOCATION, |
| MEMORY, ERROR,FALSE_1); |
| } else { |
| (void) printf("ERROR: Illegal store[2] ADDRESS = %d, BYTES = %d.\n", |
| LOCATION,HALF_BYTES/HEX_CHAR_PER_BYTE_1); |
| (*ERROR) = TRUE_1; |
| } |
| } |
| |
| /* ============================ Outputting routines ======================== */ |
| |
| /* ------------------------ START_OF_LINE_ADDR (local) --------------------- */ |
| /* Returns smallest address that is output on the same line as ADDRESS. */ |
| int START_OF_LINE_ADDR(int ADDRESS) |
| { |
| return ( ((int) ADDRESS / (BYTES_PER_GROUP * GROUPS_PER_LINE)) * |
| BYTES_PER_GROUP * GROUPS_PER_LINE); |
| } |
| |
| /* ------------------------- END_OF_LINE_ADDR (local) ---------------------- */ |
| /* Returns largest address that is output on the same line as ADDRESS. */ |
| int END_OF_LINE_ADDR(int ADDRESS) |
| { |
| return (START_OF_LINE_ADDR(ADDRESS) + BYTES_PER_GROUP * GROUPS_PER_LINE - 1); |
| } |
| |
| /* --------------------------- LINES_OF_GAP (local) ------------------------ */ |
| /* Number of lines (of output) of bytes that seperate the two blocks. */ |
| int LINES_OF_GAP(struct BUFFER_ELEMENT *REC1,struct BUFFER_ELEMENT *REC2) |
| { |
| int REC1_END; /* Smallest address displayed on an output */ |
| /* line that contains last byte of REC1. */ |
| int REC2_START; /* Smallest address displayed on an output */ |
| /* line that contains first byte of REC2. */ |
| |
| if (REC1 == NULL) REC1_END = 0; |
| else REC1_END = START_OF_LINE_ADDR( (*REC1).START + (*REC1).LENGTH - 1); |
| |
| if (REC2 == NULL) REC2_START = START_OF_LINE_ADDR(MEM_SIZE_1 - 1); |
| else REC2_START = START_OF_LINE_ADDR( (*REC2).START); |
| |
| return ( (REC2_START - REC1_END) / (BYTES_PER_GROUP * GROUPS_PER_LINE) ); |
| } |
| |
| /* -------------------------- PRINT_ELIPSE (local) ------------------------- */ |
| /* Elipse out portion of the output, if the gap between this block of memory */ |
| /* and previous block is large enough. */ |
| void PRINT_ELIPSE(struct BUFFER_ELEMENT *PREV,struct BUFFER_ELEMENT *CURR, |
| int PREV_ADDR,FILE *OUTPUT) |
| { |
| int LOOP_COUNTER; |
| /* ---------- STR_ADDR String rep of addr. */ |
| char STR_ADDR[MEM_ADDR_SIZE_1/BITS_PER_HALFBYTE_1 + 1]; |
| |
| |
| /* -------------- Check if gap is large enough */ |
| if ( LINES_OF_GAP(PREV,CURR) >= LINES_OF_GAP_TO_ELIPSE ) { |
| |
| NUM_TO_STR(PREV_ADDR,16,MEM_ADDR_SIZE_1/BITS_PER_HALFBYTE_1, STR_ADDR); |
| (void) fprintf(OUTPUT, |
| " %s xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx\n", |
| STR_ADDR); |
| |
| for (LOOP_COUNTER = 1;LOOP_COUNTER <= 3; LOOP_COUNTER++) |
| (void) fprintf(OUTPUT, |
| " . . . . .\n"); |
| |
| if (CURR != NULL) |
| NUM_TO_STR(START_OF_LINE_ADDR( (*CURR).START)- |
| BYTES_PER_GROUP*GROUPS_PER_LINE, |
| 16,MEM_ADDR_SIZE_1/BITS_PER_HALFBYTE_1, STR_ADDR); |
| else |
| NUM_TO_STR(START_OF_LINE_ADDR( MEM_SIZE_1) - |
| BYTES_PER_GROUP*GROUPS_PER_LINE, |
| 16,MEM_ADDR_SIZE_1/BITS_PER_HALFBYTE_1, STR_ADDR); |
| |
| (void) fprintf(OUTPUT, |
| " %s xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx\n", |
| STR_ADDR); |
| } |
| } |
| |
| /* ----------------------------- PRINT_MEM --------------------------------- */ |
| /* Output the loaded areas of memory in a nice user readable way. */ |
| void PRINT_MEM(MEM_SPACE MEMORY,FILE *OUTPUT) |
| { |
| struct BUFFER_ELEMENT *STEP; /* Current block of memory outputing. */ |
| struct BUFFER_ELEMENT *PREVIOUS = NULL; /* Last block output */ |
| int PREVIOUS_ADDR = 0; /* Start address of the last output block */ |
| int ADDRESS; /* Next address of memory to output. */ |
| char STR_ADDR[MEM_ADDR_SIZE_1/BITS_PER_HALFBYTE_1 + 1];/* String version of*/ |
| /* address */ |
| |
| (void) fprintf(OUTPUT,"MEMORY\n"); |
| (void) fprintf(OUTPUT,"ADDRESS Contents\n"); |
| (void) fprintf(OUTPUT,"------- --------------------------------------\n"); |
| /* 12345 12345678 12345678 12345678 12345678 */ |
| /* 123456789012345678901234567890123456789012345678 */ |
| |
| if (LOCATIONS_USED.HEAD == NULL) |
| (void) fprintf(OUTPUT, |
| "=========> NOTHING LOADED INTO MEMORY <=========\n"); |
| else { |
| |
| /* --------------- STEP through the list of loaded blocks */ |
| for (STEP = LOCATIONS_USED.HEAD; STEP != NULL; STEP = (*STEP).NEXT) { |
| |
| PRINT_ELIPSE(PREVIOUS,STEP,PREVIOUS_ADDR,OUTPUT); |
| ADDRESS = START_OF_LINE_ADDR((*STEP).START); |
| |
| /* ------ repeat until consequtive blocks are output on seperate lines. */ |
| do { |
| BOOLEAN REST_EMPTY = FALSE_1; |
| int I,J; |
| char STR_BYTE[HEX_CHAR_PER_BYTE_1 + 1]; |
| |
| NUM_TO_STR(ADDRESS,16,MEM_ADDR_SIZE_1/BITS_PER_HALFBYTE_1,STR_ADDR); |
| (void) fprintf(OUTPUT," %s ",STR_ADDR); |
| |
| /* --------- OUTPUT 1 line */ |
| for (I=0;I<GROUPS_PER_LINE;I++) { |
| for (J=0;J<BYTES_PER_GROUP;J++) { |
| int LOC; |
| |
| LOC = ADDRESS+I*BYTES_PER_GROUP+J; |
| if (!REST_EMPTY && (LOC >= ((*STEP).START + (*STEP).LENGTH))) |
| { |
| if ( ((*STEP).NEXT == NULL) || |
| (LINES_OF_GAP(STEP,(*STEP).NEXT) > 0)) REST_EMPTY = TRUE_1; |
| else STEP = (*STEP).NEXT; |
| } |
| |
| if ( REST_EMPTY || (LOC < (*STEP).START)) |
| (void) fprintf(OUTPUT,"xx"); |
| else { |
| NUM_TO_STR(INT(MEMORY[LOC]),16,HEX_CHAR_PER_BYTE_1,STR_BYTE); |
| (void) fprintf(OUTPUT,"%s",STR_BYTE); |
| } |
| } |
| (void) fprintf(OUTPUT," "); |
| } |
| (void) fprintf(OUTPUT,"\n"); |
| |
| ADDRESS = END_OF_LINE_ADDR(ADDRESS) + 1; |
| } while (ADDRESS <= |
| END_OF_LINE_ADDR( (*STEP).START + (*STEP).LENGTH - 1) ); |
| PREVIOUS_ADDR = ADDRESS; |
| PREVIOUS = STEP; |
| } |
| PRINT_ELIPSE(PREVIOUS,STEP,PREVIOUS_ADDR,OUTPUT); |
| } |
| } |
| |
| /* ---------------------------- OUTPUT_MEM --------------------------------- */ |
| /* Prints out the loaded areas of memory in a machine friendly format. Very */ |
| /* to the text records of the object stream except relocated and modified. */ |
| void OUTPUT_MEM(MEM_SPACE MEMORY,FILE *OUTPUT) |
| { |
| struct BUFFER_ELEMENT *CURRENT; /* Current block outputing */ |
| int COUNT; /* Simple loop counter */ |
| char ADDRESS[MEM_ADDR_SIZE_1/BITS_PER_HALFBYTE_1 + 2];/* String version of */ |
| /* address */ |
| char STR_BYTE[HEX_CHAR_PER_BYTE_1 + 1]; /* String version of byte */ |
| |
| CURRENT = LOCATIONS_USED.HEAD; |
| while (CURRENT != NULL) { |
| NUM_TO_STR((*CURRENT).START,16,MEM_ADDR_SIZE_1/BITS_PER_HALFBYTE_1+1, |
| ADDRESS); |
| NUM_TO_STR((*CURRENT).LENGTH,16,HEX_CHAR_PER_BYTE_1,STR_BYTE); |
| (void) fprintf(OUTPUT,"T%s%s",ADDRESS,STR_BYTE); |
| |
| for (COUNT = (*CURRENT).START; |
| COUNT < ((*CURRENT).START + (*CURRENT).LENGTH); |
| COUNT ++) { |
| NUM_TO_STR(INT(MEMORY[COUNT]),16,HEX_CHAR_PER_BYTE_1,STR_BYTE); |
| (void) fprintf(OUTPUT,"%s",STR_BYTE); |
| } |
| (void) fprintf(OUTPUT,"\n"); |
| CURRENT = (*CURRENT).NEXT; |
| } |
| } |
