From 16d508cdd8c9ea60b78e21139ce2cccf60bb92e6 Mon Sep 17 00:00:00 2001 From: "Michael D. Lowis" Date: Wed, 23 May 2018 22:18:37 -0400 Subject: [PATCH] minor refactoring and added = token --- source/ast.c | 70 +++++++-------------------- source/lexer.l | 1 + source/parser.c | 124 +----------------------------------------------- source/sclpl.h | 6 +-- 4 files changed, 23 insertions(+), 178 deletions(-) diff --git a/source/ast.c b/source/ast.c index f105c50..7891139 100644 --- a/source/ast.c +++ b/source/ast.c @@ -1,136 +1,102 @@ #include -static AST* ast(ASTType type) -{ +static AST* ast(ASTType type) { AST* tree = emalloc(sizeof(AST)); memset(tree, 0, sizeof(AST)); tree->type = type; return tree; } -AST* String(Tok* val) -{ +AST* String(Tok* val) { AST* node = ast(AST_STRING); node->value.text = val->value.text; return node; } -char* string_value(AST* val) -{ - assert(val != NULL); +char* string_value(AST* val) { assert(val->type == AST_STRING); return val->value.text; } -AST* Symbol(Tok* val) -{ +AST* Symbol(Tok* val) { AST* node = ast(AST_SYMBOL); node->value.text = val->value.text; return node; } -char* symbol_value(AST* val) -{ - assert(val != NULL); +char* symbol_value(AST* val) { assert(val->type == AST_SYMBOL); return val->value.text; } -AST* Char(Tok* val) -{ +AST* Char(Tok* val) { AST* node = ast(AST_CHAR); node->value.character = val->value.character; return node; } -uint32_t char_value(AST* val) -{ - assert(val != NULL); +uint32_t char_value(AST* val) { assert(val->type == AST_CHAR); return val->value.character; } -AST* Integer(Tok* val) -{ +AST* Integer(Tok* val) { AST* node = ast(AST_INT); node->value.integer = val->value.integer; return node; } -intptr_t integer_value(AST* val) -{ - assert(val != NULL); +intptr_t integer_value(AST* val) { assert(val->type == AST_INT); return val->value.integer; } -intptr_t temp_value(AST* val) -{ - assert(val != NULL); - return val->value.integer; -} - -AST* Float(Tok* val) -{ +AST* Float(Tok* val) { AST* node = ast(AST_FLOAT); node->value.floating = val->value.floating; return node; } -double float_value(AST* val) -{ - assert(val != NULL); +double float_value(AST* val) { assert(val->type == AST_FLOAT); return val->value.floating; } -AST* Bool(Tok* val) -{ +AST* Bool(Tok* val) { AST* node = ast(AST_BOOL); node->value.boolean = val->value.boolean; return node; } -bool bool_value(AST* val) -{ - assert(val != NULL); +bool bool_value(AST* val) { assert(val->type == AST_BOOL); return val->value.boolean; } -AST* Ident(Tok* val) -{ +AST* Ident(Tok* val) { AST* node = ast(AST_IDENT); node->value.text = val->value.text; return node; } -char* ident_value(AST* val) -{ - assert(val != NULL); +char* ident_value(AST* val) { assert(val->type == AST_IDENT); return val->value.text; } -AST* Let(Tok* name, AST* value) -{ +AST* Let(Tok* name, AST* value) { AST* node = ast(AST_LET); node->value.let.name = name->value.text; node->value.let.value = value; return node; } -char* let_name(AST* let) -{ - assert(let != NULL); +char* let_name(AST* let) { assert(let->type == AST_LET); return let->value.let.name; } -AST* let_value(AST* let) -{ - assert(let != NULL); +AST* let_value(AST* let) { assert(let->type == AST_LET); return let->value.let.value; } - diff --git a/source/lexer.l b/source/lexer.l index 89931cb..9105367 100644 --- a/source/lexer.l +++ b/source/lexer.l @@ -48,6 +48,7 @@ NOSPACE [^ \t\r\n] "'" { return T_SQUOTE; } ":" { return T_COLON; } "&" { return T_AMP; } +"=" { return T_ASSIGN; } \\. { Value.character = yytext[1]; return T_CHAR; } \\space { Value.character = ' '; return T_CHAR; } diff --git a/source/parser.c b/source/parser.c index 3711410..8e47f1c 100644 --- a/source/parser.c +++ b/source/parser.c @@ -1,14 +1,10 @@ #include -/* Private Declarations - *****************************************************************************/ -// Grammar Routines static AST* const_definition(Parser* p); static AST* const_expression(Parser* p); static AST* definition(Parser* p); static AST* expression(Parser* p); static AST* identifier(Parser* p); - static AST* function(Parser* p); static void type_annotation(Parser* p); static AST* literal(Parser* p); @@ -81,6 +77,7 @@ static AST* const_definition(Parser* p) { // expr = function(p); // } else { type_annotation(p); + expect(p, T_ASSIGN); expr = const_expression(p); expect(p, T_END); // } @@ -153,122 +150,3 @@ static AST* identifier(Parser* p) { return NULL; } } - - - - - - - - - - - - - - - - - - - - - -#if 0 -static AST* definition(Parser* p) { - AST* expr; - Tok* id = expect_val(p, T_ID); -// if (peek(p)->type == T_LPAR) { -// expr = function(p); -// } else { - type_annotation(p); - expr = expression(p); - expect(p, T_END); -// } - return Def(id, expr); -} - -static AST* expression(Parser* p) { - AST* expr = NULL; - if (accept(p, T_LPAR)) { - expr = expression(p); - expect(p, T_RPAR); - } else if (accept(p, T_IF)) { - expr = if_stmnt(p); - } else if (match(p, T_ID)) { - expr = Ident(expect_val(p,T_ID)); - } else { - expr = literal(p); - } - /* Check if this is a function application */ - if (peek(p)->type == T_LPAR) - expr = func_app(p, expr); - return expr; -} - -/* -static AST* function(Parser* p) { - AST* func = Func(); - expect(p, T_LPAR); - while(peek(p)->type != T_RPAR) { - func_add_arg(func, Ident(expect_val(p,T_ID))); - type_annotation(p); - if(peek(p)->type != T_RPAR) - expect(p, T_COMMA); - } - expect(p, T_RPAR); - type_annotation(p); - func_set_body(func, expr_block(p)); - expect(p, T_END); - return func; -} -*/ - -static AST* expr_block(Parser* p) { - AST* block = NULL; - vec_t exprs; - vec_init(&exprs); - /* Build all expressions into let forms with no bodies */ - do { - if (accept(p, T_LET)) { - AST* def = definition(p); - Tok name = { .value.text = def_name(def) }; - vec_push_back(&exprs, Let(Ident(&name), def_value(def), NULL)); - } else { - vec_push_back(&exprs, Let(TempVar(), expression(p), NULL)); - } - } while(!match(p, T_END) && !match(p, T_ELSE)); - /* Now nest all of the let forms making sure that the last one returns - * it's definition as its body */ - for (int i = vec_size(&exprs); i > 0; i--) { - AST* let = (AST*)vec_at(&exprs,i-1); - let_set_body(let, (block == NULL) ? let_var(let) : block); - block = let; - } - vec_deinit(&exprs); - return block; -} - -static AST* if_stmnt(Parser* p) { - AST* ifexpr = IfExpr(); - ifexpr_set_cond( ifexpr, expression(p) ); - accept(p, T_THEN); - ifexpr_set_then( ifexpr, expr_block(p) ); - if (accept(p, T_ELSE)) - ifexpr_set_else( ifexpr, expr_block(p) ); - expect(p,T_END); - return ifexpr; -} - -static AST* func_app(Parser* p, AST* fn) { - AST* app = FnApp(fn); - expect(p,T_LPAR); - while (peek(p)->type != T_RPAR) { - fnapp_add_arg(app, expression(p)); - if (peek(p)->type != T_RPAR) - expect(p, T_COMMA); - } - expect(p,T_RPAR); - return app; -} -#endif diff --git a/source/sclpl.h b/source/sclpl.h index c72b9fb..9a84205 100644 --- a/source/sclpl.h +++ b/source/sclpl.h @@ -40,9 +40,9 @@ void vec_set(vec_t* vec, size_t index, void* data); /* Token Types *****************************************************************************/ typedef enum { - T_NONE, T_ERROR, T_ID, T_CHAR, T_INT, T_FLOAT, T_BOOL, T_STRING, T_LBRACE, - T_RBRACE, T_LBRACK, T_RBRACK, T_LPAR, T_RPAR, T_COMMA, T_SQUOTE, T_DQUOTE, - T_END, T_COLON, T_AMP, T_LET, T_IF, T_THEN, T_ELSE, T_END_FILE + T_NONE, T_ERROR, T_END_FILE, T_ID, T_CHAR, T_INT, T_FLOAT, T_BOOL, T_STRING, + T_LBRACE, T_RBRACE, T_LBRACK, T_RBRACK, T_LPAR, T_RPAR, T_COMMA, T_SQUOTE, + T_DQUOTE, T_END, T_COLON, T_AMP, T_LET, T_IF, T_THEN, T_ELSE, T_ASSIGN } TokType; typedef struct { -- 2.54.0