Added tokens to the lexer in order to eliminnate the *_str parser functions

diff --git a/source/lexer.l b/source/lexer.l
index ae0659d579ccd04c7912487896c1fa7606d0fec2..13cc63523e525365ba7efdeeb3d5d6e3fef57bc3 100644 (file)
--- a/source/lexer.l
+++ b/source/lexer.l
@@ -103,6 +103,13 @@ false {
     return T_BOOL;
 }
 
+"require" { return T_REQUIRE; }
+"def"     { return T_DEF;     }
+"if"      { return T_IF;      }
+"fn"      { return T_FN;      }
+"then"    { return T_THEN;    }
+"else"    { return T_ELSE;    }
+
 [a-zA-Z_][a-zA-Z0-9_]* {
     Value.text = dupstring(yytext);
     return T_ID;
@@ -113,6 +120,7 @@ false {
     return T_ID;
 }
 
+
 %%
 
 static void token_free(void* obj)

diff --git a/source/parser.c b/source/parser.c
index 8ba7a8b85d756e18ee131ac4485ef249d6609e5a..1b0840bf2416ad125158f74699a2398487d6878a 100644 (file)
--- a/source/parser.c
+++ b/source/parser.c
@@ -30,11 +30,8 @@ static bool parser_eof(Parser* parser);
 static void parser_resume(Parser* parser);
 static void error(Parser* parser, const char* text);
 static bool match(Parser* parser, TokType type);
-static bool match_str(Parser* parser, TokType type, const char* text);
 static Tok* accept(Parser* parser, TokType type);
-static Tok* accept_str(Parser* parser, TokType type, const char* text);
 static Tok* expect(Parser* parser, TokType type);
-static Tok* expect_str(Parser* parser, TokType type, const char* text);
 
 /* Grammar Definition
  *****************************************************************************/
@@ -42,9 +39,9 @@ AST* toplevel(Parser* p)
 {
     AST* ret = NULL;
     if (!match(p, T_END_FILE)) {
-        if (accept_str(p, T_ID, "require"))
+        if (accept(p, T_REQUIRE))
             ret = require(p);
-        else if (accept_str(p, T_ID, "def"))
+        else if (accept(p, T_DEF))
             ret = definition(p);
         else
             ret = expression(p);
@@ -78,9 +75,9 @@ static AST* expression(Parser* p)
     if (accept(p, T_LPAR)) {
         expr = expression(p);
         expect(p, T_RPAR);
-    } else if (accept_str(p, T_ID, "if")) {
+    } else if (accept(p, T_IF)) {
         expr = if_stmnt(p);
-    } else if (accept_str(p, T_ID, "fn")) {
+    } else if (accept(p, T_FN)) {
         expr = function(p);
     } else if (match(p, T_ID)) {
         expr = Ident(expect(p,T_ID));
@@ -98,9 +95,9 @@ static AST* if_stmnt(Parser* p)
 {
     AST* ifexpr = IfExpr();
     ifexpr_set_cond( ifexpr, expression(p) );
-    accept_str(p, T_ID, "then");
+    accept(p, T_THEN);
     ifexpr_set_then( ifexpr, expr_block(p) );
-    if (accept_str(p, T_ID, "else"))
+    if (accept(p, T_ELSE))
         ifexpr_set_else( ifexpr, expr_block(p) );
     expect(p,T_END);
     return ifexpr;
@@ -146,14 +143,14 @@ static AST* expr_block(Parser* p)
     vec_init(&exprs);
     /* Build all expressions into let forms with no bodies */
     do {
-        if (accept_str(p, T_ID, "def")) {
+        if (accept(p, T_DEF)) {
             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_str(p, T_ID, "else"));
+    } 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--) {
@@ -257,12 +254,6 @@ static bool match(Parser* parser, TokType type)
     return (peek(parser)->type == type);
 }
 
-static bool match_str(Parser* parser, TokType type, const char* text)
-{
-    return (match(parser, type) &&
-            (0 == strcmp((char*)(peek(parser)->value.text), text)));
-}
-
 static Tok* accept(Parser* parser, TokType type)
 {
     Tok* tok = peek(parser);
@@ -273,16 +264,6 @@ static Tok* accept(Parser* parser, TokType type)
     return NULL;
 }
 
-static Tok* accept_str(Parser* parser, TokType type, const char* text)
-{
-    Tok* tok = peek(parser);
-    if ((tok->type == type) && (0 == strcmp((char*)(tok->value.text), text))) {
-        gc_swapref((void**)&(parser->tok), NULL);
-        return tok;
-    }
-    return NULL;
-}
-
 static Tok* expect(Parser* parser, TokType type)
 {
     Tok* tok = accept(parser, type);
@@ -292,12 +273,3 @@ static Tok* expect(Parser* parser, TokType type)
     return tok;
 }
 
-static Tok* expect_str(Parser* parser, TokType type, const char* text)
-{
-    Tok* tok = accept_str(parser, type, text);
-    if (tok == NULL) {
-        error(parser, "Unexpected token");
-    }
-    return tok;
-}
-

diff --git a/source/sclpl.h b/source/sclpl.h
index 730ccafafe4dcfd26548221ccdc825b66def965b..cd6a437d676bfc6538afacf0c298183869e0c680 100644 (file)
--- a/source/sclpl.h
+++ b/source/sclpl.h
@@ -50,10 +50,9 @@ void vec_set(vec_t* vec, size_t index, void* data);
 /* Token Types
  *****************************************************************************/
 typedef enum {
-    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_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_REQUIRE,
+    T_DEF, T_IF, T_FN, T_THEN, T_ELSE, T_END_FILE
 } TokType;
 
 typedef struct {