stripped down parser

diff --git a/source/lexer.l b/source/lexer.l
index 4747beaf828b353def9665aa03fa79df668817f9..89931cb5dde852bfd641adb36aef7a830481479b 100644 (file)
--- a/source/lexer.l
+++ b/source/lexer.l
@@ -32,18 +32,22 @@ NOSPACE [^ \t\r\n]
 
 <<EOF>> { return T_END_FILE; }
 
-"end" { return T_END;    }
-"("   { return T_LPAR;   }
-")"   { return T_RPAR;   }
-"["   { return T_LBRACK; }
-"]"   { return T_RBRACK; }
-"{"   { return T_LBRACE; }
-"}"   { return T_RBRACE; }
-";"   { return T_END;    }
-","   { return T_COMMA;  }
-"'"   { return T_SQUOTE; }
-":"   { return T_COLON;  }
-"&"   { return T_AMP;    }
+"let"  { return T_LET;    }
+"if"   { return T_IF;     }
+"then" { return T_THEN;   }
+"else" { return T_ELSE;   }
+"end"  { return T_END;    }
+"("    { return T_LPAR;   }
+")"    { return T_RPAR;   }
+"["    { return T_LBRACK; }
+"]"    { return T_RBRACK; }
+"{"    { return T_LBRACE; }
+"}"    { return T_RBRACE; }
+";"    { return T_END;    }
+","    { return T_COMMA;  }
+"'"    { return T_SQUOTE; }
+":"    { return T_COLON;  }
+"&"    { return T_AMP;    }
 
 \\.       { Value.character = yytext[1];    return T_CHAR; }
 \\space   { Value.character = ' ';          return T_CHAR; }
@@ -51,7 +55,6 @@ NOSPACE [^ \t\r\n]
 \\return  { Value.character = '\r';         return T_CHAR; }
 \\tab     { Value.character = '\t';         return T_CHAR; }
 \\vtab    { Value.character = '\v';         return T_CHAR; }
-\\[a-z]+  { Value.text = dupstring(yytext); return T_ID;   }
 
 0b[01]+ {
     Value.integer = strtol(&yytext[2], NULL, 2);
@@ -73,11 +76,6 @@ NOSPACE [^ \t\r\n]
     return T_INT;
 }
 
-0[b0dh][0-9a-fA-F]+ {
-    Value.text = dupstring(yytext);
-    return T_ID;
-}
-
 [+-]?[0-9]+ {
     Value.integer = strtol(&yytext[0], NULL, 10);
     return T_INT;
@@ -105,22 +103,12 @@ false {
     return T_BOOL;
 }
 
-"require" { return T_REQUIRE; }
-"let"     { return T_LET;     }
-"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;
 }
 
-[^ \r\t\n\[\]\{\}\(\)'\",;:]+ {
-    Value.text = dupstring(yytext);
-    return T_ID;
-}
+. { return T_ERROR; }
 
 %%
 
@@ -129,8 +117,3 @@ void gettoken(Parser* ctx, Tok* tok) {
     if (tok->type != T_END_FILE)
         memcpy(&(tok->value), &Value, sizeof(Value));
 }
-
-void fetchline(Parser* ctx)
-{
-}
-

diff --git a/source/parser.c b/source/parser.c
index 64705a9203fb84f0ed60cfc93fb6d52f6f1ddc0d..0d13b7a16a67a4d4ec9a9b5b6d0b81bf33e2e723 100644 (file)
--- a/source/parser.c
+++ b/source/parser.c
@@ -75,13 +75,13 @@ AST* toplevel(Parser* p) {
 static AST* const_definition(Parser* p) {
     AST* expr;
     Tok* id = expect_val(p, T_ID);
-    if (peek(p)->type == T_LPAR) {
-        expr = function(p);
-    } else {
+//    if (peek(p)->type == T_LPAR) {
+//        expr = function(p);
+//    } else {
         type_annotation(p);
         expr = const_expression(p);
         expect(p, T_END);
-    }
+//    }
     return Def(id, expr);
 }
 
@@ -90,8 +90,6 @@ static AST* const_expression(Parser* p) {
     if (accept(p, T_LPAR)) {
         expr = const_expression(p);
         expect(p, T_RPAR);
-    } else if (accept(p, T_FN)) {
-        expr = function(p);
     } else if (match(p, T_ID)) {
         expr = Ident(expect_val(p, T_ID));
     } else {
@@ -100,16 +98,59 @@ static AST* const_expression(Parser* p) {
     return expr;
 }
 
+static void type_annotation(Parser* p) {
+    expect(p, T_ID);
+    /* array type */
+    if (accept(p,T_LBRACK)) {
+        accept(p, T_INT);
+        expect(p, T_RBRACK);
+    /* reference type */
+    } else if (accept(p, T_AMP)) {
+        // TODO: implement reference types
+    }
+}
+
+static AST* literal(Parser* p) {
+    AST* ret = NULL;
+    Tok* tok = peek(p);
+    switch (tok->type) {
+        case T_BOOL:
+        case T_CHAR:
+        case T_STRING:
+        case T_INT:
+        case T_FLOAT:
+            ret = token_to_tree(expect_val(p, tok->type));
+            break;
+        default:
+            error(p, "Expected a literal");
+    }
+    return ret;
+}
+
+static AST* token_to_tree(Tok* tok) {
+    switch (tok->type) {
+        case T_BOOL:   return Bool(tok);
+        case T_CHAR:   return Char(tok);
+        case T_STRING: return String(tok);
+        case T_INT:    return Integer(tok);
+        case T_FLOAT:  return Float(tok);
+        case T_ID:     return Ident(tok);
+        default:       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 {
+//    if (peek(p)->type == T_LPAR) {
+//        expr = function(p);
+//    } else {
         type_annotation(p);
         expr = expression(p);
         expect(p, T_END);
-    }
+//    }
     return Def(id, expr);
 }
 
@@ -120,8 +161,6 @@ static AST* expression(Parser* p) {
         expect(p, T_RPAR);
     } else if (accept(p, T_IF)) {
         expr = if_stmnt(p);
-    } else if (accept(p, T_FN)) {
-        expr = function(p);
     } else if (match(p, T_ID)) {
         expr = Ident(expect_val(p,T_ID));
     } else {
@@ -133,6 +172,7 @@ static AST* expression(Parser* p) {
     return expr;
 }
 
+/*
 static AST* function(Parser* p) {
     AST* func = Func();
     expect(p, T_LPAR);
@@ -148,35 +188,7 @@ static AST* function(Parser* p) {
     expect(p, T_END);
     return func;
 }
-
-static void type_annotation(Parser* p) {
-    expect(p, T_ID);
-    /* array type */
-    if (accept(p,T_LBRACK)) {
-        accept(p, T_INT);
-        expect(p, T_RBRACK);
-    /* reference type */
-    } else if (accept(p, T_AMP)) {
-        // TODO: implement reference types
-    }
-}
-
-static AST* literal(Parser* p) {
-    AST* ret = NULL;
-    Tok* tok = peek(p);
-    switch (tok->type) {
-        case T_BOOL:
-        case T_CHAR:
-        case T_STRING:
-        case T_INT:
-        case T_FLOAT:
-            ret = token_to_tree(expect_val(p, tok->type));
-            break;
-        default:
-            error(p, "Expected a literal");
-    }
-    return ret;
-}
+*/
 
 static AST* expr_block(Parser* p) {
     AST* block = NULL;
@@ -203,18 +215,6 @@ static AST* expr_block(Parser* p) {
     return block;
 }
 
-static AST* token_to_tree(Tok* tok) {
-    switch (tok->type) {
-        case T_BOOL:   return Bool(tok);
-        case T_CHAR:   return Char(tok);
-        case T_STRING: return String(tok);
-        case T_INT:    return Integer(tok);
-        case T_FLOAT:  return Float(tok);
-        case T_ID:     return Ident(tok);
-        default:       return NULL;
-    }
-}
-
 static AST* if_stmnt(Parser* p) {
     AST* ifexpr = IfExpr();
     ifexpr_set_cond( ifexpr, expression(p) );
@@ -237,3 +237,4 @@ static AST* func_app(Parser* p, AST* fn) {
     expect(p,T_RPAR);
     return app;
 }
+#endif

diff --git a/source/sclpl.h b/source/sclpl.h
index cfb803c5cee2b0c5bb983efc0ce47e4d22f5fe2c..5335413960c367efe78bb07c8554c00594b071b6 100644 (file)
--- 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_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_REQUIRE, T_LET, T_IF, T_FN, T_THEN, T_ELSE, T_END_FILE
+    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
 } TokType;
 
 typedef struct {