/* %%%%%%%%%%%%%%%%%%%% (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 #include #include #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= ((*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; } }