Renamed grammar and lexer functions

diff --git a/source/libparse/grammar.c b/source/libparse/grammar.c
index 4bfcc0bfed7543816a91754d9eb9c43546c7b12e..b18f6b8a49b036f4e70e3f86807de4958212ee36 100644 (file)
--- a/source/libparse/grammar.c
+++ b/source/libparse/grammar.c
@@ -6,20 +6,33 @@
 */
 #include <libparse.h>
 
-AST* grammar_toplevel(Parser* p)
+static void require(Parser* p);
+static void type_annotation(Parser* p);
+static void type_definition(Parser* p);
+static void type(Parser* p);
+static void tuple(Parser* p);
+static void function(Parser* p);
+static void definition(Parser* p);
+static void expression(Parser* p);
+static void literal(Parser* p);
+static void arglist(Parser* p);
+static void if_stmnt(Parser* p);
+static void fn_stmnt(Parser* p);
+
+AST* toplevel(Parser* p)
 {
     AST* p_tree = NULL;
     try {
         if (accept_str(p, T_ID, "require"))
-            grammar_require(p);
+            require(p);
         else if (accept_str(p, T_ID, "type"))
-            grammar_type_definition(p);
+            type_definition(p);
         else if (accept_str(p, T_ID, "ann"))
-            grammar_type_annotation(p);
+            type_annotation(p);
         else if (accept_str(p, T_ID, "def"))
-            grammar_definition(p);
+            definition(p);
         else
-            grammar_expression(p);
+            expression(p);
         p_tree = get_tree(p);
     } catch(ParseException) {
         /* Do nothing, the tree is bad */
@@ -27,7 +40,7 @@ AST* grammar_toplevel(Parser* p)
     return p_tree;
 }
 
-void grammar_require(Parser* p)
+static void require(Parser* p)
 {
     size_t mrk = mark(p);
     expect(p, T_STRING);
@@ -35,51 +48,51 @@ void grammar_require(Parser* p)
     reduce(p, mrk);
 }
 
-void grammar_type_annotation(Parser* p)
+static void type_annotation(Parser* p)
 {
     size_t mrk = mark(p);
     expect(p, T_ID);
-    grammar_type(p);
+    type(p);
     expect(p, T_END);
     reduce(p, mrk);
 }
 
-void grammar_type_definition(Parser* p)
+static void type_definition(Parser* p)
 {
     size_t mrk = mark(p);
     expect(p, T_ID);
     expect_str(p, T_ID, "is");
-    grammar_type(p);
+    type(p);
     expect(p, T_END);
     reduce(p, mrk);
 }
 
-void grammar_type(Parser* p) {
+static void type(Parser* p) {
     if (accept(p, T_LBRACE)) {
-        grammar_tuple(p);
+        tuple(p);
     } else {
         expect(p, T_ID);
         if (accept(p, T_LPAR)) {
-            grammar_function(p);
+            function(p);
         }
     }
 }
 
-void grammar_tuple(Parser* p) {
+static void tuple(Parser* p) {
     size_t mrk = mark(p);
     insert(p, T_ID, lexer_dup("tuple"));
     do {
-        grammar_type(p);
+        type(p);
     } while (accept(p, T_COMMA));
     expect(p, T_RBRACE);
     reduce(p, mrk);
 }
 
-void grammar_function(Parser* p) {
+static void function(Parser* p) {
     size_t mark1 = mark(p) - 1;
     size_t mark2 = mark(p);
     while (!accept(p, T_RPAR)) {
-        grammar_type(p);
+        type(p);
         if (T_RPAR != peek(p)->type)
             expect(p, T_COMMA);
     }
@@ -87,42 +100,42 @@ void grammar_function(Parser* p) {
     reduce(p, mark1);
 }
 
-void grammar_definition(Parser* p)
+static void definition(Parser* p)
 {
     size_t mrk = mark(p);
     expect(p,T_ID);
     if (peek(p)->type == T_LPAR) {
         insert(p, T_ID, lexer_dup("fn"));
-        grammar_fn_stmnt(p);
+        fn_stmnt(p);
     } else {
-        grammar_expression(p);
+        expression(p);
         expect(p,T_END);
     }
     reduce(p, mrk);
 }
 
-void grammar_expression(Parser* p)
+static void expression(Parser* p)
 {
     if (accept(p, T_LPAR)) {
         size_t mrk = mark(p);
-        grammar_expression(p);
+        expression(p);
         expect(p, T_RPAR);
         reduce(p, mrk);
     } else if (accept_str(p, T_ID, "if")) {
-        grammar_if_stmnt(p);
+        if_stmnt(p);
     } else if (accept_str(p, T_ID, "fn")) {
-        grammar_fn_stmnt(p);
+        fn_stmnt(p);
     } else if (peek(p)->type == T_ID) {
         expect(p, T_ID);
         if (peek(p)->type == T_LPAR) {
-            grammar_arglist(p);
+            arglist(p);
         }
     } else {
-        grammar_literal(p);
+        literal(p);
     }
 }
 
-void grammar_literal(Parser* p)
+static void literal(Parser* p)
 {
     switch (peek(p)->type) {
         case T_BOOL:
@@ -138,12 +151,12 @@ void grammar_literal(Parser* p)
     }
 }
 
-void grammar_arglist(Parser* p)
+static void arglist(Parser* p)
 {
     size_t mrk = mark(p);
     expect(p, T_LPAR);
     while(peek(p)->type != T_RPAR) {
-        grammar_expression(p);
+        expression(p);
         if(peek(p)->type != T_RPAR)
             expect(p, T_COMMA);
     }
@@ -151,19 +164,19 @@ void grammar_arglist(Parser* p)
     reduce(p, mrk);
 }
 
-void grammar_if_stmnt(Parser* p)
+static void if_stmnt(Parser* p)
 {
     size_t mrk = mark(p);
-    grammar_expression(p);
-    grammar_expression(p);
+    expression(p);
+    expression(p);
     if (accept_str(p, T_ID, "else")) {
-        grammar_expression(p);
+        expression(p);
     }
     expect(p,T_END);
     reduce(p, mrk);
 }
 
-void grammar_fn_stmnt(Parser* p)
+static void fn_stmnt(Parser* p)
 {
     size_t mark1 = mark(p);
     expect(p, T_LPAR);
@@ -176,7 +189,7 @@ void grammar_fn_stmnt(Parser* p)
     expect(p, T_RPAR);
     reduce(p, mark2);
     while(peek(p)->type != T_END) {
-        grammar_expression(p);
+        expression(p);
     }
     expect(p, T_END);
     reduce(p, mark1);

diff --git a/source/libparse/lexer.c b/source/libparse/lexer.c
index 3a9b6fd01a74fee7c582d0fc6f02d67598bd88b0..91499c582fc9828f7615fec5ea7ff9002d6270ee 100644 (file)
--- a/source/libparse/lexer.c
+++ b/source/libparse/lexer.c
@@ -35,7 +35,7 @@ static void lex_tok_free(void* p_obj) {
         mem_release(p_tok->value);
 }
 
-Token* lex_tok_new(TokenType type, void* val) {
+Token* token(TokenType type, void* val) {
     Token* p_tok = (Token*)mem_allocate(sizeof(Token), &lex_tok_free);
     p_tok->type  = type;
     p_tok->value = val;
@@ -59,8 +59,7 @@ Lexer* lexer_new(char* p_prompt, FILE* p_input) {
 
 Token* lexer_read(Lexer* p_lexer) {
     Token* p_tok = NULL;
-    size_t line;
-    size_t col;
+    size_t line, col;
     char* text = read(p_lexer, &line, &col);
     if (NULL != text) {
         p_tok = lexer_make_token(line, col, text);
@@ -76,12 +75,12 @@ void lexer_skipline(Lexer* p_lexer) {
 static Token* lexer_make_token(size_t line, size_t col, char* text) {
     Token* p_tok = NULL;
     if (0 == strcmp(text,"end")) {
-        p_tok = lex_tok_new(T_END, NULL);
+        p_tok = token(T_END, NULL);
     } else if (lexer_oneof("()[]{};,'", text[0])) {
         p_tok = lexer_punc(text);
     } else if ('"' == text[0]) {
         text[strlen(text)-1] = '\0';
-        p_tok = lex_tok_new(T_STRING, lexer_dup(&text[1]));
+        p_tok = token(T_STRING, lexer_dup(&text[1]));
     } else if (text[0] == '\\') {
         p_tok = lexer_char(text);
     } else if ((text[0] == '0') && lexer_oneof("bodh",text[1])) {
@@ -105,15 +104,15 @@ static Token* lexer_punc(char* text)
 {
     Token* p_tok = NULL;
     switch (text[0]) {
-        case '(':  p_tok = lex_tok_new(T_LPAR,   NULL); break;
-        case ')':  p_tok = lex_tok_new(T_RPAR,   NULL); break;
-        case '{':  p_tok = lex_tok_new(T_LBRACE, NULL); break;
-        case '}':  p_tok = lex_tok_new(T_RBRACE, NULL); break;
-        case '[':  p_tok = lex_tok_new(T_LBRACK, NULL); break;
-        case ']':  p_tok = lex_tok_new(T_RBRACK, NULL); break;
-        case ';':  p_tok = lex_tok_new(T_END,    NULL); break;
-        case ',':  p_tok = lex_tok_new(T_COMMA,  NULL); break;
-        case '\'': p_tok = lex_tok_new(T_SQUOTE, NULL); break;
+        case '(':  p_tok = token(T_LPAR,   NULL); break;
+        case ')':  p_tok = token(T_RPAR,   NULL); break;
+        case '{':  p_tok = token(T_LBRACE, NULL); break;
+        case '}':  p_tok = token(T_RBRACE, NULL); break;
+        case '[':  p_tok = token(T_LBRACK, NULL); break;
+        case ']':  p_tok = token(T_RBRACK, NULL); break;
+        case ';':  p_tok = token(T_END,    NULL); break;
+        case ',':  p_tok = token(T_COMMA,  NULL); break;
+        case '\'': p_tok = token(T_SQUOTE, NULL); break;
     }
     return p_tok;
 }
@@ -129,11 +128,11 @@ static Token* lexer_char(char* text)
         "\v\0vtab"
     };
     if (strlen(text) == 2) {
-        p_tok = lex_tok_new(T_CHAR, (void*)((intptr_t)text[1]));
+        p_tok = token(T_CHAR, (void*)((intptr_t)text[1]));
     } else {
         for(int i = 0; i < 5; i++) {
             if (0 == strcmp(&text[1], &(lookup_table[i][2]))) {
-                p_tok = lex_tok_new(T_CHAR, (void*)((intptr_t)lookup_table[i][0]));
+                p_tok = token(T_CHAR, (void*)((intptr_t)lookup_table[i][0]));
                 break;
             }
         }
@@ -168,7 +167,7 @@ static Token* lexer_integer(char* text, int base)
     errno = 0;
     *p_int = strtol(text, &end, base);
     assert(errno == 0);
-    return (end[0] == '\0') ? lex_tok_new(T_INT, p_int) : NULL;
+    return (end[0] == '\0') ? token(T_INT, p_int) : NULL;
 }
 
 static Token* lexer_float(char* text)
@@ -178,17 +177,17 @@ static Token* lexer_float(char* text)
     errno = 0;
     *p_dbl = strtod(text, &end);
     assert(errno == 0);
-    return (end[0] == '\0') ? lex_tok_new(T_FLOAT, p_dbl) : NULL;
+    return (end[0] == '\0') ? token(T_FLOAT, p_dbl) : NULL;
 }
 
 static Token* lexer_bool(char* text)
 {
-    return lex_tok_new(T_BOOL, (void*)((intptr_t)((0 == strcmp(text,"true")) ? true : false)));
+    return token(T_BOOL, (void*)((intptr_t)((0 == strcmp(text,"true")) ? true : false)));
 }
 
 static Token* lexer_var(char* text)
 {
-    return lex_tok_new(T_ID, lexer_dup(text));
+    return token(T_ID, lexer_dup(text));
 }
 
 static bool lexer_oneof(const char* class, char c) {
@@ -233,7 +232,7 @@ static int read_radix(char ch) {
 
 /*****************************************************************************/
 
-char* read(Lexer* ctx, size_t* line, size_t* column) {
+static char* read(Lexer* ctx, size_t* line, size_t* column) {
     char* p_tok = NULL;
     skip_ws(ctx);
     *line   = ctx->lineno;
@@ -246,8 +245,7 @@ char* read(Lexer* ctx, size_t* line, size_t* column) {
             p_tok = read_string(ctx);
         } else {
             size_t start = ctx->index;
-            while(!oneof(ctx," \t\r\n()[]{};,'\"") &&
-                  (current(ctx) != '\0')) {
+            while(!oneof(ctx," \t\r\n()[]{};,'\"") && (current(ctx) != '\0')) {
                 ctx->index++;
             }
             p_tok = dup(ctx, start, ctx->index - start);
@@ -296,12 +294,12 @@ static char* read_string(Lexer* ctx) {
     return tok;
 }
 
-bool eof(Lexer* ctx)
+static bool eof(Lexer* ctx)
 {
     return (eol(ctx) && feof(ctx->p_input));
 }
 
-bool eol(Lexer* ctx)
+static bool eol(Lexer* ctx)
 {
     bool ret = true;
     size_t index = ctx->index;
@@ -316,7 +314,7 @@ bool eol(Lexer* ctx)
     return ret;
 }
 
-void getline(Lexer* ctx) {
+static void getline(Lexer* ctx) {
     int c;
     size_t capacity = 8;
     size_t index    = 0;
@@ -383,4 +381,3 @@ static char* dup(Lexer* ctx, size_t start_idx, size_t len) {
     return p_str;
 }
 
-

diff --git a/source/libparse/libparse.h b/source/libparse/libparse.h
index 7355c004013756595f0b17ec6d17003151c7d24b..0f79ae8215ca325a088f455eedc009a794a9f0cd 100644 (file)
--- a/source/libparse/libparse.h
+++ b/source/libparse/libparse.h
@@ -60,7 +60,7 @@ typedef struct {
 
 // Lexer routines
 Lexer* lexer_new(char* p_prompt, FILE* p_input);
-Token* lex_tok_new(TokenType type, void* val);
+Token* token(TokenType type, void* val);
 Token* lexer_read(Lexer* p_lexer);
 void lexer_skipline(Lexer* p_lexer);
 char* lexer_dup(const char* p_old);
@@ -90,18 +90,6 @@ void* tree_get_child_val(AST* p_tree, size_t idx);
 bool tree_is_formtype(AST* p_tree, const char* val);
 
 // Grammar Routines
-AST* grammar_toplevel(Parser* p);
-void grammar_require(Parser* p);
-void grammar_type_annotation(Parser* p);
-void grammar_type_definition(Parser* p);
-void grammar_type(Parser* p);
-void grammar_tuple(Parser* p);
-void grammar_function(Parser* p);
-void grammar_definition(Parser* p);
-void grammar_expression(Parser* p);
-void grammar_literal(Parser* p);
-void grammar_arglist(Parser* p);
-void grammar_if_stmnt(Parser* p);
-void grammar_fn_stmnt(Parser* p);
+AST* toplevel(Parser* p);
 
 #endif /* LIBPARSE_H */

diff --git a/source/libparse/parser.c b/source/libparse/parser.c
index 674f2d7e8f33f1f251a85d0daec60abea0ec1c11..f51b4e571bba72039695e91d45ebdbbdb3b2bb8b 100644 (file)
--- a/source/libparse/parser.c
+++ b/source/libparse/parser.c
@@ -137,7 +137,7 @@ AST* get_tree(Parser* p_parser) {
 }
 
 void insert(Parser* p_parser, TokenType type, void* value) {
-    Token* p_tok = lex_tok_new(type, value);
+    Token* p_tok = token(type, value);
     AST*   p_tree = tree_new(ATOM, p_tok);
     vec_push_back(p_parser->p_tok_buf, p_tree);
 }

diff --git a/source/sclpl/main.c b/source/sclpl/main.c
index edfa7af69f456bdbab35e93efeb367ad48f7ca0d..a9a393f3d949c64105ab68eb5ac7fa823de01aa4 100644 (file)
--- a/source/sclpl/main.c
+++ b/source/sclpl/main.c
@@ -118,7 +118,7 @@ static int emit_csource(void) {
 static int exec_repl(void) {
     Parser* p_parser = parser_new(":> ", stdin);
     while(!parser_eof(p_parser)) {
-        AST* p_tree = grammar_toplevel(p_parser);
+        AST* p_tree = toplevel(p_parser);
         if (NULL != p_tree) {
             AST* p_ast = tree_convert(p_tree);
             pprint_tree(stdout, p_ast, 0);

diff --git a/source/sclpl/ops.c b/source/sclpl/ops.c
index 681a371878d84cd97bc15edc2ccf33bdcc68a00c..eb5bdc0201c1db0652482829756641c92612f705 100644 (file)
--- a/source/sclpl/ops.c
+++ b/source/sclpl/ops.c
@@ -17,7 +17,7 @@ vec_t* ops_parse_file(str_t* in) {
     Parser* p_parser = parser_new(NULL, input);
     vec_t* p_vec = vec_new(0);
     while(!parser_eof(p_parser)) {
-        AST* p_tree = grammar_toplevel(p_parser);
+        AST* p_tree = toplevel(p_parser);
         if (NULL != p_tree) {
             AST* p_ast = tree_convert(p_tree);
             mem_release(p_tree);