From 990900ae9a2a191ae4a176cb0a85d523d101a4df Mon Sep 17 00:00:00 2001 From: Victor Fernandes Date: Wed, 12 Apr 2017 21:35:37 -0400 Subject: [PATCH] trying to fix memory --- scanner.c | 2 +- stable.c | 431 ++++++++++++++++++++++++++++-------------------------- 2 files changed, 221 insertions(+), 212 deletions(-) diff --git a/scanner.c b/scanner.c index 9607bd7..0209a1f 100755 --- a/scanner.c +++ b/scanner.c @@ -267,7 +267,7 @@ Token malar_next_token(Buffer * sc_buf) b_retract_to_mark(sc_buf); - lex_buf = b_create(1, 1, 'a'); + lex_buf = b_create(20, 8, 'a'); /* Copy the scanned lexeme into lexical buffer */ for (; lexstart < lexend; ++lexstart) { diff --git a/stable.c b/stable.c index 872329a..561e5ac 100644 --- a/stable.c +++ b/stable.c @@ -9,13 +9,13 @@ */ #include "stable.h" -#define PLSBD_SZ 256 +#define PLSBD_SZ 40 #define PLSBD_INC 8 #define DEBUG -/*#undef DEBUG*/ + /*#undef DEBUG*/ -/* Forward function declarations */ + /* Forward function declarations */ static void st_setsize(void); static void st_incoffset(void); extern STD sym_table; @@ -24,30 +24,30 @@ extern STD sym_table; * Author: Victor Fernandes, 040772243 * Version: 0.0.1 * Called functions: malloc, b_create, free - * Parameters: - int - size of the symbol table - * Return value: - STD - The symbol table + * Parameters: + int - size of the symbol table + * Return value: + STD - The symbol table * Algorithm: */ -STD st_create(int st_size){ - STD new_stable; +STD st_create(int st_size) { + STD new_stable; - new_stable.plsBD = NULL; + new_stable.plsBD = NULL; new_stable.pstvr = (STVR*)malloc((size_t)st_size * sizeof(STVR)); - if (st_size <= 0 || (new_stable.pstvr == NULL)) { - new_stable.st_size = 0; - } + if (st_size <= 0 || (new_stable.pstvr == NULL)) { + new_stable.st_size = 0; + } new_stable.plsBD = b_create(PLSBD_SZ, PLSBD_INC, 'a'); - if (new_stable.plsBD == NULL) { - free(new_stable.plsBD); - new_stable.st_size = 0; - } + if (new_stable.plsBD == NULL) { + free(new_stable.plsBD); + new_stable.st_size = 0; + } - new_stable.st_size = st_size; - new_stable.st_offset = 0; + new_stable.st_size = st_size; + new_stable.st_offset = 0; - return new_stable; + return new_stable; } /* Install a new entry in the symbol table @@ -55,101 +55,110 @@ STD st_create(int st_size){ * Version: 0.0.1 * Called functions: st_lookup, b_setmark, b_size, b_addc, b_rflag, st_incoffset * Parameters: - STD - The symbol table - char - The lexeme to be stored - char - the type of the lexeme - int - the line in the source file where the lexeme was found + STD - The symbol table + char - The lexeme to be stored + char - the type of the lexeme + int - the line in the source file where the lexeme was found * Return value: - int - the element offset of where the symbol table is pointing to - -1 if an internal error occurs + int - the element offset of where the symbol table is pointing to + -1 if an internal error occurs * Algorithm: */ -int st_install(STD s_table, char *lexeme, char type, int line){ - unsigned int offset, i, j, lex_len; - short bd_offset, flag; +int st_install(STD s_table, char *lexeme, char type, int line) { + int offset = -1, i, j, lex_len, bd_offset, lex_offset = 0, flag = 0; - /* Cannot add new entry, table full */ - if (s_table.st_offset >= s_table.st_size) - return -1; - - /* Look for an existing entry in the symbol table */ - offset = st_lookup(s_table, lexeme); - if (offset > -1) - return offset; + /* Cannot add new entry, table full */ + if (s_table.st_offset >= s_table.st_size) + return -1; - /* Add lexeme to the symbol table's lexeme buffer */ - lex_len = strlen(lexeme); - for (i = 0; i <= lex_len; ++i){ - if (!b_addc(s_table.plsBD, lexeme[i])) - return -1; - if (b_rflag(s_table.plsBD) == SET_R_FLAG){ /* COPY NEW ADDRESSES TO PLEX ENTRIES */ - flag = 1; - } - } - if (flag == 1){ - bd_offset = 0; - for (j = 0; j <= s_table.st_offset; ++j){ - s_table.pstvr[j].plex = b_setmark(s_table.plsBD, bd_offset + s_table.pstvr[j].i_value.str_offset); - if (j < s_table.st_offset) - bd_offset += s_table.pstvr[j+1].i_value.str_offset + 1; /*Add one because the offset doesn't include '\0' */ - } - } - + /* Look for an existing entry in the symbol table */ + if (s_table.st_offset > 0) + offset = st_lookup(s_table, lexeme); - /* Set proper pointer values on symbol table */ - s_table.pstvr[s_table.st_offset].plex = b_setmark(s_table.plsBD, b_size(s_table.plsBD)); - s_table.pstvr[s_table.st_offset].o_line = line; + if (offset > -1) + return offset; + + /* Add lexeme to the symbol table's lexeme buffer */ + lex_len = strlen(lexeme); + for (i = 0; i <= lex_len; ++i) { + if (!b_addc(s_table.plsBD, lexeme[i])) + return -1; + if (b_rflag(s_table.plsBD) == SET_R_FLAG) { /* COPY NEW ADDRESSES TO PLEX ENTRIES */ + flag = 1; + } + } + if (flag == 1) { + bd_offset = 0; + for (j = 0; j <= s_table.st_offset; ++j) { + s_table.pstvr[j].plex = b_setmark(s_table.plsBD, (short)(bd_offset + s_table.pstvr[j].i_value.str_offset)); + if (j < s_table.st_offset) + bd_offset += s_table.pstvr[j + 1].i_value.str_offset + 1; /*Add one because the offset doesn't include '\0' */ + } + } - /* Set the default mask before setting the rest of the masks */ - s_table.pstvr[s_table.st_offset].status_field = DFT_MASK; + /* Set proper pointer values on symbol table */ + /* Get buffer offset location of the lexeme stored */ + lex_offset = b_size(s_table.plsBD) - (strlen(lexeme) + 1); - switch (type){ - case 'I': /* Integer type */ - s_table.pstvr[s_table.st_offset].status_field |= INT_MASK; - s_table.pstvr[s_table.st_offset].i_value.int_val = 0; - break; - case 'F': /* Floating point type */ - s_table.pstvr[s_table.st_offset].status_field |= FLT_MASK; - s_table.pstvr[s_table.st_offset].i_value.fpl_val = 0.0f; - break; - case 'S': /* String type */ - s_table.pstvr[s_table.st_offset].status_field |= STR_MASK; - s_table.pstvr[s_table.st_offset].i_value.str_offset = -1; - break; - default: - return -1; /* Not supposed to fall into here */ - } + s_table.pstvr[s_table.st_offset].plex = b_setmark(s_table.plsBD, (short) lex_offset); + s_table.pstvr[s_table.st_offset].o_line = line; + s_table.pstvr[s_table.st_offset].i_value.str_offset = lex_offset; + /* Set the default mask before setting the rest of the masks */ + s_table.pstvr[s_table.st_offset].status_field = DFT_MASK; - /* Increment the symbol table offset */ - st_incoffset(); - return s_table.st_offset; + switch (type) { + case 'I': /* Integer type */ + s_table.pstvr[s_table.st_offset].status_field |= INT_MASK; + s_table.pstvr[s_table.st_offset].i_value.int_val = 0; + + break; + case 'F': /* Floating point type */ + s_table.pstvr[s_table.st_offset].status_field |= FLT_MASK; + s_table.pstvr[s_table.st_offset].i_value.fpl_val = 0.0f; + break; + case 'S': /* String type */ + s_table.pstvr[s_table.st_offset].status_field |= STR_MASK; + s_table.pstvr[s_table.st_offset].i_value.int_val = -1; + s_table.pstvr[s_table.st_offset].i_value.fpl_val = -1.0f; + break; + default: + return -1; /* Not supposed to fall into here */ + } + + /* Increment the symbol table offset */ + st_incoffset(); + return s_table.st_offset; } -/* Look up the lexeme string in the symbol table's buffer +/* Look up the lexeme string in the symbol table's buffer * Author: Victor Fernandes * Version: 0.1 * Called functions: b_setmark, strcmp, strlen * Parameters: - STD - The symbol table - char - The lexeme to be searched + STD - The symbol table + char - The lexeme to be searched * Return value: - int - the element offset index in the symbol table - -1 if no element was found + int - the element offset index in the symbol table + -1 if no element was found */ -int st_lookup(STD s_table, char *lexeme){ - int i; /* idx: index location for symbol table, i: increment counter*/ - - for (i = s_table.st_offset; i >= 0; --i) { - if (strcmp(lexeme, s_table.pstvr[i].plex) == 0) - return i; - } +int st_lookup(STD s_table, char *lexeme) { + int i; /* idx: index location for symbol table, i: increment counter*/ #ifdef DEBUG - printf("found nothing\n"); + printf("Looking up %s...", lexeme); #endif - return -1; /* Found nothing */ + for (i = s_table.st_offset - 1; i >= 0; --i) { + if (strcmp(lexeme, s_table.pstvr[i].plex) == 0) { + printf("YES\n"); + return i; + } + } +#ifdef DEBUG + printf("NO\n"); +#endif + return -1; /* Found nothing */ } /* Change the data type indicator of the variable entry located in vid_offset. @@ -157,40 +166,40 @@ int st_lookup(STD s_table, char *lexeme){ * Version: 0.1 * Called functions: N/A * Parameters: - STD - The symbol table - int - the offset location of the VID - char - the new type of the VID + STD - The symbol table + int - the offset location of the VID + char - the new type of the VID * Return value: - 1 if change successful, -1 if no change was made or internal error + 1 if change successful, -1 if no change was made or internal error */ int st_change_type(STD s_table, int vid_offset, char v_type) { - /* Do nothing if update flag has already been set */ - if ((s_table.pstvr[vid_offset].status_field & U_MASK)) return -1; + /* Do nothing if update flag has already been set */ + if ((s_table.pstvr[vid_offset].status_field & U_MASK)) return -1; - /* Reset to new type with default mask and update flag - Note: Can separate the statements to set the update flag at the - end, but this resets AND updates at once - */ - /*sym_table.pstvr[vid_offset].status_field = sym_table.pstvr[vid_offset].status_field & DFT_U_MASK;*/ - s_table.pstvr[vid_offset].status_field &= DFT_U_MASK; + /* Reset to new type with default mask and update flag + Note: Can separate the statements to set the update flag at the + end, but this resets AND updates at once + */ + /*sym_table.pstvr[vid_offset].status_field = sym_table.pstvr[vid_offset].status_field & DFT_U_MASK;*/ + s_table.pstvr[vid_offset].status_field &= DFT_U_MASK; - /*TODO: Ask if re-setting flags and "bailing out" is spec breaking, and - if flags should only be set if v_type is valid */ + /*TODO: Ask if re-setting flags and "bailing out" is spec breaking, and + if flags should only be set if v_type is valid */ - switch (v_type){ - case 'I': /* Integer type */ - s_table.pstvr[s_table.st_offset].status_field |= INT_MASK; - break; - case 'F': /* Floating point type */ - s_table.pstvr[s_table.st_offset].status_field |= FLT_MASK; - break; - case 'S': /* String type, do nothing as it cannot be changed */ - break; - default: - return -1; /* Not supposed to fall into here */ - } - return 1; + switch (v_type) { + case 'I': /* Integer type */ + s_table.pstvr[s_table.st_offset].status_field |= INT_MASK; + break; + case 'F': /* Floating point type */ + s_table.pstvr[s_table.st_offset].status_field |= FLT_MASK; + break; + case 'S': /* String type, do nothing as it cannot be changed */ + break; + default: + return -1; /* Not supposed to fall into here */ + } + return 1; } @@ -199,14 +208,14 @@ int st_change_type(STD s_table, int vid_offset, char v_type) { * Version: 0.0.1 * Called functions: N/A * Parameters: - STD - The symbol table - int - the offset location of the VID - Value - the new value of the VID + STD - The symbol table + int - the offset location of the VID + Value - the new value of the VID * Return value: the offset location of the VID */ -int st_change_value(STD s_table, int vid_offset, Value value){ - s_table.pstvr[vid_offset].i_value = value; - return vid_offset; +int st_change_value(STD s_table, int vid_offset, Value value) { + s_table.pstvr[vid_offset].i_value = value; + return vid_offset; } /* Get the type of the variable specified by vid_offset @@ -214,25 +223,25 @@ int st_change_value(STD s_table, int vid_offset, Value value){ * Version: 0.0.1 * Called functions: N/A * Parameters: - STD - The symbol table - int - the offset of the VID in the table + STD - The symbol table + int - the offset of the VID in the table * Return value: - char - the type of the VID ('I','F', or 'S') - -1 if there is an invalid value set + char - the type of the VID ('I','F', or 'S') + -1 if there is an invalid value set */ -char st_get_type(STD s_table, int vid_offset){ - unsigned short mask; - mask = s_table.pstvr[vid_offset].status_field & CHK_MASK; - switch (mask){ - case INT_MASK: - return 'I'; - case FLT_MASK: - return 'F'; - case STR_MASK: - return 'S'; - default: - return -1; /* Not supposed to fall into here */ - } +char st_get_type(STD s_table, int vid_offset) { + unsigned short mask; + mask = s_table.pstvr[vid_offset].status_field & CHK_MASK; + switch (mask) { + case INT_MASK: + return 'I'; + case FLT_MASK: + return 'F'; + case STR_MASK: + return 'S'; + default: + return -1; /* Not supposed to fall into here */ + } } /* Return the i_value of the variable specified by vid_offset @@ -240,14 +249,14 @@ char st_get_type(STD s_table, int vid_offset){ * Version: 0.0.1 * Called functions: * Parameters: - STD - The symbol table - int - the offset of the VID in the table - * Return value: - Value - the value of the VID - Incorrect parameters will cause undefined behaviour + STD - The symbol table + int - the offset of the VID in the table + * Return value: + Value - the value of the VID + Incorrect parameters will cause undefined behaviour */ -Value st_get_value(STD s_table, int vid_offset){ - return s_table.pstvr[vid_offset].i_value; +Value st_get_value(STD s_table, int vid_offset) { + return s_table.pstvr[vid_offset].i_value; } /* Free memory used by the symbol table @@ -255,14 +264,14 @@ Value st_get_value(STD s_table, int vid_offset){ * Version: 0.0.1 * Called functions: free, b_free * Parameters: - STD - The symbol table + STD - The symbol table */ -void st_destroy(STD s_table){ - if (s_table.pstvr != NULL){ - free(s_table.pstvr); - s_table.pstvr = NULL; - } - b_free(s_table.plsBD); +void st_destroy(STD s_table) { + if (s_table.pstvr != NULL) { + free(s_table.pstvr); + s_table.pstvr = NULL; + } + b_free(s_table.plsBD); } /* Print the contents of the symbol table to standard output @@ -270,70 +279,70 @@ void st_destroy(STD s_table){ * Version: 0.0.1 * Called functions: printf * Parameters: - STD - The symbol table + STD - The symbol table * Return value: - int - the number of items printed to stdout + int - the number of items printed to stdout */ -int st_print(STD s_table){ - int i; - - if (s_table.st_size <=0) return -1; - - printf("Symbol Table\n____________\nLine Number\tVariable Identifier\n"); - for(i = 0; i < s_table.st_offset; ++i) - printf("%2d\t\t%s\n", s_table.pstvr[i].o_line, s_table.pstvr[i].plex); - - return i; - } +int st_print(STD s_table) { + int i; -/* Store the symbol table to a file named $stable.ste. + if (s_table.st_size <= 0) return -1; + + printf("Symbol Table\n____________\nLine Number\tVariable Identifier\n"); + for (i = 0; i < s_table.st_offset - 1 ; ++i) + printf("%2d\t\t%s\n", s_table.pstvr[i].o_line, s_table.pstvr[i].plex); + + return i; +} + +/* Store the symbol table to a file named $stable.ste. It overwrites any existing file named $stable.ste. * Author: Victor Fernandes, 040772243 * Version: 0.0.1 * Called functions: fopen, fprintf, st_get_type, fclose, printf * Parameters: - STD - The symbol table + STD - The symbol table * Return value: - int - the number of items stored - -1 if the file stream cannot be opened + int - the number of items stored + -1 if the file stream cannot be opened */ -int st_store(STD s_table){ - FILE *out; /* The target file*/ - int i; +int st_store(STD s_table) { + FILE *out; /* The target file*/ + int i; /* Windows does not like fopen, and fopen_s is Windows-only. This will ensure the * use of the proper function call if PLATYPUS is being built on a non-windows system. - * Best approach is to add _CRT_SECURE_NO_WARNINGS to the preprocessor definitions, but - * this works, too. + * Best approach is to add _CRT_SECURE_NO_WARNINGS to the preprocessor definitions, but + * this works, too. */ #ifdef _WIN32 - if (fopen_s(&out, ST_FILE_NAME, "w+") != 0 || out == NULL) + if (fopen_s(&out, ST_FILE_NAME, "w+") != 0 || out == NULL) #else - if ((out = fopen(ST_FILE_NAME, "w+")) == NULL) + if ((out = fopen(ST_FILE_NAME, "w+")) == NULL) #endif return -1; /* Can't open file, stop. */ - fprintf(out, "%d", s_table.st_size); + fprintf(out, "%d", s_table.st_size); - for(i = 0; i < s_table.st_size; ++i){ - fprintf(out, " %4X %d %s %d", - s_table.pstvr[i].status_field, /* Status flag */ - (int)strlen(s_table.pstvr[i].plex), /* Length of lexeme */ - s_table.pstvr[i].plex, /* The lexeme itself */ - s_table.pstvr[i].o_line); /* Line number */ + for (i = 0; i < s_table.st_size; ++i) { + fprintf(out, " %4X %d %s %d", + s_table.pstvr[i].status_field, /* Status flag */ + (int)strlen(s_table.pstvr[i].plex), /* Length of lexeme */ + s_table.pstvr[i].plex, /* The lexeme itself */ + s_table.pstvr[i].o_line); /* Line number */ - /* Initial value */ - char type = st_get_type(s_table, i); - switch (type){ - case 'I': - case 'F': - case 'S': - fprintf(out, " %c", type); - } - } - fclose(out); - printf("Symbol Table stored\n"); - return i; + /* Initial value */ + char type = st_get_type(s_table, i); + switch (type) { + case 'I': + case 'F': + case 'S': + fprintf(out, " %c", type); + } + } + fclose(out); + printf("Symbol Table stored\n"); + return i; } @@ -344,10 +353,10 @@ int st_store(STD s_table){ * Parameters: N/A * Return value: N/A */ -static void st_setsize(void){ - sym_table.st_size = 0; +static void st_setsize(void) { + sym_table.st_size = 0; } - + /* Internal function to increment st_offset by 1. * Author: Victor Fernandes, 040772243 * Version: 0.0.1 @@ -355,8 +364,8 @@ static void st_setsize(void){ * Parameters: N/A * Return value: N/A */ -static void st_incoffset(void){ - ++sym_table.st_offset; +static void st_incoffset(void) { + ++sym_table.st_offset; } @@ -364,13 +373,13 @@ static void st_incoffset(void){ * Author: Victor Fernandes, 040772243 * Version: 0.0.1 * Called functions: - * Parameters: + * Parameters: * Return value: * Algorithm: */ -int st_sort(STD s_table, char s_order){ - /* Compiler warning about unused parameter, - * this is fine for this "future" implementation - */ - return 0; /* SYKE! */ +int st_sort(STD s_table, char s_order) { + /* Compiler warning about unused parameter, + * this is fine for this "future" implementation + */ + return 0; /* SYKE! */ }