integrated lincds and fixed memory leaks

diff --git a/source/sclpl/lexer.c b/source/sclpl/lexer.c
index 8f9488cea0613a6c11a176ed6ec546286c707e11..20142b5bb0309f44223dd1ddaf6a7adb823a3a75 100644 (file)
--- a/source/sclpl/lexer.c
+++ b/source/sclpl/lexer.c
@@ -5,89 +5,44 @@
   $HeadURL$
   */
 #include "lexer.h"
+#include "mem.h"
 #include <string.h>
 #include <stdlib.h>
 #include <errno.h>
 
-bool lexer_oneof(const char* class, char c) {
-    bool ret = false;
-    size_t sz = strlen(class);
-    for (size_t idx = 0; idx < sz; idx++) {
-        if (c == class[idx]) {
-            ret = true;
-            break;
-        }
-    }
-    return ret;
-}
-
-bool is_float(char* text) {
-    while (text[0] != '\0')
-        if (text[0] == '.')
-            return true;
-        else
-            text++;
-    return false;
-}
-
-char* lexer_dup(const char* p_old) {
-    size_t length = strlen(p_old);
-    char* p_str = (char*)malloc(length+1);
-    memcpy(p_str, p_old, length);
-    p_str[length] = '\0';
-    return p_str;
-}
-
-lex_tok_t* lex_tok_new(lex_tok_type_t type, void* val) {
-    lex_tok_t* p_tok = (lex_tok_t*)malloc(sizeof(lex_tok_t));
+static lex_tok_t* lexer_make_token(char* text);
+static lex_tok_t* lexer_punc(char* text);
+static lex_tok_t* lexer_char(char* text);
+static lex_tok_t* lexer_radix_int(char* text);
+static lex_tok_t* lexer_number(char* text);
+static lex_tok_t* lexer_integer(char* text, int base);
+static lex_tok_t* lexer_float(char* text);
+static lex_tok_t* lexer_bool(char* text);
+static lex_tok_t* lexer_var(char* text);
+static char* lexer_tok_type_str(lex_tok_t* p_tok);
+static bool lexer_oneof(const char* class, char c);
+static bool is_float(char* text);
+static char* lexer_dup(const char* p_old);
+static int read_radix(char ch);
+
+static void lex_tok_free(void* p_obj) {
+    lex_tok_t* p_tok = (lex_tok_t*)p_obj;
+    mem_release(p_tok->value);
+}
+
+static lex_tok_t* lex_tok_new(lex_tok_type_t type, void* val) {
+    lex_tok_t* p_tok = (lex_tok_t*)mem_allocate(sizeof(lex_tok_t), &lex_tok_free);
     p_tok->type  = type;
     p_tok->value = val;
     return p_tok;
 }
 
-static int read_radix(char ch) {
-    switch(ch) {
-        case 'b': return 2;
-        case 'o': return 8;
-        case 'd': return 10;
-        case 'h': return 16;
-        default:  return 10;
-    }
-}
-
-lex_tok_t* lexer_make_token(char* text);
-lex_tok_t* lexer_punc(char* text);
-lex_tok_t* lexer_char(char* text);
-lex_tok_t* lexer_radix_int(char* text);
-lex_tok_t* lexer_number(char* text);
-lex_tok_t* lexer_integer(char* text, int base);
-lex_tok_t* lexer_float(char* text);
-lex_tok_t* lexer_bool(char* text);
-lex_tok_t* lexer_var(char* text);
-
-char* lexer_tok_type_str(lex_tok_t* p_tok) {
-    switch(p_tok->type) {
-        case T_END:      return "T_END";
-        case T_STRING:   return "T_STRING";
-        case T_CHAR:     return "T_CHAR";
-        case T_INT:      return "T_INT";
-        case T_FLOAT:    return "T_FLOAT";
-        case T_BOOL:     return "T_BOOL";
-        case T_LBRACE:   return "T_LBRACE";
-        case T_RBRACE:   return "T_RBRACE";
-        case T_LBRACK:   return "T_LBRACK";
-        case T_RBRACK:   return "T_RBRACK";
-        case T_LPAR:     return "T_LPAR";
-        case T_RPAR:     return "T_RPAR";
-        case T_COMMA:    return "T_COMMA";
-        case T_VAR:      return "T_VAR";
-        case T_END_FILE: return "T_END_FILE";
-        default:         return NULL;
-    }
+static void lexer_free(void* p_obj) {
+    mem_release(((lexer_t*)p_obj)->scanner);
 }
 
 lexer_t* lexer_new(char* p_prompt, FILE* p_input) {
-    lexer_t* p_lexer = (lexer_t*)malloc(sizeof(lexer_t));
+    lexer_t* p_lexer = (lexer_t*)mem_allocate(sizeof(lexer_t), &lexer_free);
     p_lexer->scanner = scanner_new(p_prompt, p_input);
     return p_lexer;
 }
@@ -104,7 +59,7 @@ lex_tok_t* lexer_read(lexer_t* p_lexer) {
     return p_tok;
 }
 
-lex_tok_t* lexer_make_token(char* text) {
+static lex_tok_t* lexer_make_token(char* text) {
     lex_tok_t* p_tok = NULL;
     if ((0 == strcmp(text,"end") || (text[0] == ';'))) {
         p_tok = lex_tok_new(T_END, NULL);
@@ -124,7 +79,7 @@ lex_tok_t* lexer_make_token(char* text) {
     return p_tok;
 }
 
-lex_tok_t* lexer_punc(char* text)
+static lex_tok_t* lexer_punc(char* text)
 {
     lex_tok_t* p_tok = NULL;
     switch (text[0]) {
@@ -140,7 +95,7 @@ lex_tok_t* lexer_punc(char* text)
     return p_tok;
 }
 
-lex_tok_t* lexer_char(char* text)
+static lex_tok_t* lexer_char(char* text)
 {
     lex_tok_t* p_tok = NULL;
     static const char* lookup_table[5] = {
@@ -163,12 +118,12 @@ lex_tok_t* lexer_char(char* text)
     return p_tok;
 }
 
-lex_tok_t* lexer_radix_int(char* text)
+static lex_tok_t* lexer_radix_int(char* text)
 {
     return lexer_integer(text, read_radix(text[1]));
 }
 
-lex_tok_t* lexer_number(char* text)
+static lex_tok_t* lexer_number(char* text)
 {
     lex_tok_t* p_tok = NULL;
     if (is_float(text))
@@ -178,7 +133,7 @@ lex_tok_t* lexer_number(char* text)
     return (NULL == p_tok) ? lexer_var(text) : p_tok;
 }
 
-lex_tok_t* lexer_integer(char* text, int base)
+static lex_tok_t* lexer_integer(char* text, int base)
 {
     char* end;
     long* p_int = (long*)malloc(sizeof(long));
@@ -188,7 +143,7 @@ lex_tok_t* lexer_integer(char* text, int base)
     return (end[0] == '\0') ? lex_tok_new(T_INT, p_int) : NULL;
 }
 
-lex_tok_t* lexer_float(char* text)
+static lex_tok_t* lexer_float(char* text)
 {
     char* end;
     double* p_dbl = (double*)malloc(sizeof(double));
@@ -198,13 +153,72 @@ lex_tok_t* lexer_float(char* text)
     return (end[0] == '\0') ? lex_tok_new(T_FLOAT, p_dbl) : NULL;
 }
 
-lex_tok_t* lexer_bool(char* text)
+static lex_tok_t* lexer_bool(char* text)
 {
     return lex_tok_new(T_BOOL, (void*)((intptr_t)((0 == strcmp(text,"true")) ? true : false)));
 }
 
-lex_tok_t* lexer_var(char* text)
+static lex_tok_t* lexer_var(char* text)
 {
     return lex_tok_new(T_VAR, lexer_dup(text));
 }
 
+static char* lexer_tok_type_str(lex_tok_t* p_tok) {
+    switch(p_tok->type) {
+        case T_END:      return "T_END";
+        case T_STRING:   return "T_STRING";
+        case T_CHAR:     return "T_CHAR";
+        case T_INT:      return "T_INT";
+        case T_FLOAT:    return "T_FLOAT";
+        case T_BOOL:     return "T_BOOL";
+        case T_LBRACE:   return "T_LBRACE";
+        case T_RBRACE:   return "T_RBRACE";
+        case T_LBRACK:   return "T_LBRACK";
+        case T_RBRACK:   return "T_RBRACK";
+        case T_LPAR:     return "T_LPAR";
+        case T_RPAR:     return "T_RPAR";
+        case T_COMMA:    return "T_COMMA";
+        case T_VAR:      return "T_VAR";
+        case T_END_FILE: return "T_END_FILE";
+        default:         return NULL;
+    }
+}
+
+static bool lexer_oneof(const char* class, char c) {
+    bool ret = false;
+    size_t sz = strlen(class);
+    for (size_t idx = 0; idx < sz; idx++) {
+        if (c == class[idx]) {
+            ret = true;
+            break;
+        }
+    }
+    return ret;
+}
+
+static bool is_float(char* text) {
+    while (text[0] != '\0')
+        if (text[0] == '.')
+            return true;
+        else
+            text++;
+    return false;
+}
+
+static char* lexer_dup(const char* p_old) {
+    size_t length = strlen(p_old);
+    char* p_str = (char*)malloc(length+1);
+    memcpy(p_str, p_old, length);
+    p_str[length] = '\0';
+    return p_str;
+}
+
+static int read_radix(char ch) {
+    switch(ch) {
+        case 'b': return 2;
+        case 'o': return 8;
+        case 'd': return 10;
+        case 'h': return 16;
+        default:  return 10;
+    }
+}

diff --git a/source/sclpl/main.c b/source/sclpl/main.c
index b354ac5f305781725b6e327ed0bf965c5b12d045..8a053611abfc7b2f7f1fc54e202441a5101ab28e 100644 (file)
--- a/source/sclpl/main.c
+++ b/source/sclpl/main.c
@@ -6,9 +6,9 @@
 /* Command Line Options
  *****************************************************************************/
 OptionConfig_T Options_Config[] = {
-    { SHORT, (char*)"L",   (char*)"scan", 0, (char*)"Output the results of lexical analysis and quit"},
-    { SHORT, (char*)"P",   (char*)"scan", 0, (char*)"Output the results of parsing quit"},
-    { END,   (char*)NULL,  (char*)NULL,     0, (char*)NULL }
+    { SHORT, (char*)"L",  (char*)"scan",  0, (char*)"Output the results of lexical analysis and quit"},
+    { SHORT, (char*)"P",  (char*)"parse", 0, (char*)"Output the results of parsing quit"},
+    { END,   (char*)NULL, (char*)NULL,    0, (char*)NULL }
 };
 
 /* SCLPL Parser
@@ -29,6 +29,7 @@ int main(int argc, char **argv) {
         grammar_toplevel(p_parser);
         puts("OK.");
     }
+    mem_release(p_parser);
 
     (void)results;
     return 0;

diff --git a/source/sclpl/parser.c b/source/sclpl/parser.c
index 356cd68de1c5d4dda13e93d2233a289c5eca0dbf..b5b523c25d76716ed4b8abf41480d49dd144c2b4 100644 (file)
--- a/source/sclpl/parser.c
+++ b/source/sclpl/parser.c
@@ -9,9 +9,15 @@
 
 lex_tok_t tok_eof = { T_END_FILE, NULL, 0, 0, NULL };
 
+static void parser_free(void* p_obj) {
+    parser_t* p_parser = (parser_t*)p_obj;
+    mem_release(p_parser->p_lexer);
+    mem_release(p_parser->p_tok_buf);
+}
+
 parser_t* parser_new(char* p_prompt, FILE* input)
 {
-    parser_t* p_parser = (parser_t*)malloc(sizeof(parser_t));
+    parser_t* p_parser = (parser_t*)mem_allocate(sizeof(parser_t), &parser_free);
     p_parser->p_lexer = lexer_new(p_prompt, input);
     p_parser->p_tok = NULL;
     p_parser->p_tok_buf = vec_new(0);

diff --git a/source/sclpl/scanner.c b/source/sclpl/scanner.c
index e6fafb40301f0fd3e1e30371865429772863c3a1..4813dc749c0d9230053af9b7184a2a0896a8123c 100644 (file)
--- a/source/sclpl/scanner.c
+++ b/source/sclpl/scanner.c
@@ -1,10 +1,5 @@
 #include "scanner.h"
-#include <stdint.h>
-#include <stdbool.h>
-#include <stddef.h>
-#include <stdlib.h>
-#include <string.h>
-#include <stdio.h>
+#include "mem.h"
 
 static void scanner_getline(scanner_t* p_scanner);
 static void scanner_skip_ws(scanner_t* p_scanner);
@@ -12,8 +7,14 @@ static char scanner_current(scanner_t* p_scanner);
 static bool scanner_oneof(scanner_t* p_scanner, const char* p_set);
 static char* scanner_dup(scanner_t* p_scanner, size_t start_idx, size_t len);
 
+void scanner_free(void* p_obj) {
+    scanner_t* p_scanner = (scanner_t*)p_obj;
+    if (p_scanner->p_line)
+        free(p_scanner->p_line);
+}
+
 scanner_t* scanner_new(char* p_prompt, FILE* p_file) {
-    scanner_t* p_scanner = (scanner_t*)malloc(sizeof(scanner_t));
+    scanner_t* p_scanner = (scanner_t*)mem_allocate(sizeof(scanner_t), &scanner_free);
     p_scanner->p_line   = NULL;
     p_scanner->index    = 0;
     p_scanner->p_input  = p_file;