From 4f72b08cb7dd9fd409be7aeee30a00d231c9ed70 Mon Sep 17 00:00:00 2001 From: "Mike D. Lowis" Date: Fri, 2 Oct 2015 15:23:23 -0400 Subject: [PATCH] Renamed grammar and lexer functions --- source/libparse/grammar.c | 85 ++++++++++++++++++++++---------------- source/libparse/lexer.c | 51 +++++++++++------------ source/libparse/libparse.h | 16 +------ source/libparse/parser.c | 2 +- source/sclpl/main.c | 2 +- source/sclpl/ops.c | 2 +- 6 files changed, 78 insertions(+), 80 deletions(-) diff --git a/source/libparse/grammar.c b/source/libparse/grammar.c index 4bfcc0b..b18f6b8 100644 --- a/source/libparse/grammar.c +++ b/source/libparse/grammar.c @@ -6,20 +6,33 @@ */ #include -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 3a9b6fd..91499c5 100644 --- 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 7355c00..0f79ae8 100644 --- 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 674f2d7..f51b4e5 100644 --- 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 edfa7af..a9a393f 100644 --- 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 681a371..eb5bdc0 100644 --- 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); -- 2.52.0