sketched out parser for new file structure

diff --git a/example.src b/example.src
index 690c1b17c8bfd79750dc804a3689f9e479f71b61..57ee08c08d1a129f68d63953ca783f5d1b38331b 100644 (file)
--- a/example.src
+++ b/example.src
@@ -1,3 +1,15 @@
-def main(args string[]) int
-    0
-end
+package main
+requires ("fmt")
+provides (main)
+
+let const_true bool = true
+let const_false bool = false
+let const_uint int = 123
+let const_string string = ""
+
+var const_true bool = true
+var const_false bool = false
+var const_uint int = 123
+var const_string string = ""
+
+

diff --git a/source/codegen.c b/source/codegen.c
index 563e2a226a6e918b2a57c5a8fedeecaae60140a6..daa1a3b49ca3ed8894ff6c3f186080d457fe83a4 100644 (file)
--- a/source/codegen.c
+++ b/source/codegen.c
@@ -4,14 +4,14 @@ void codegen_init(Parser* p) {
     sym_add(&(p->syms), SF_TYPEDEF, "void",   VoidType());
     sym_add(&(p->syms), SF_TYPEDEF, "bool",   UIntType(1u));
     sym_add(&(p->syms), SF_TYPEDEF, "byte",   UIntType(8u));
-    sym_add(&(p->syms), SF_TYPEDEF, "ushort", UIntType(16u));
-    sym_add(&(p->syms), SF_TYPEDEF, "short",  IntType(16u));
-    sym_add(&(p->syms), SF_TYPEDEF, "uint",   UIntType(32u));
+//    sym_add(&(p->syms), SF_TYPEDEF, "ushort", UIntType(16u));
+//    sym_add(&(p->syms), SF_TYPEDEF, "short",  IntType(16u));
+//    sym_add(&(p->syms), SF_TYPEDEF, "uint",   UIntType(32u));
     sym_add(&(p->syms), SF_TYPEDEF, "int",    IntType(32u));
-    sym_add(&(p->syms), SF_TYPEDEF, "ulong",  UIntType(64u));
-    sym_add(&(p->syms), SF_TYPEDEF, "long",   IntType(64u));
+//    sym_add(&(p->syms), SF_TYPEDEF, "ulong",  UIntType(64u));
+//    sym_add(&(p->syms), SF_TYPEDEF, "long",   IntType(64u));
     sym_add(&(p->syms), SF_TYPEDEF, "float",  FloatType(32u));
-    sym_add(&(p->syms), SF_TYPEDEF, "double", FloatType(64u));
+//    sym_add(&(p->syms), SF_TYPEDEF, "double", FloatType(64u));
     sym_add(&(p->syms), SF_TYPEDEF, "string",
         ArrayOf(sym_get(&(p->syms), "byte")->type, -1));
 }

diff --git a/source/lexer.l b/source/lexer.l
index a34922f7ff8cf28655e387586cf386359951b67d..e48131c0880a07f3b03f7db4764e14f386fcf414 100644 (file)
--- a/source/lexer.l
+++ b/source/lexer.l
@@ -33,8 +33,12 @@ NOSPACE [^ \t\r\n]
 [ \t\r\n] { /* whitespace is insignificant */ }
 <<EOF>>   { return T_END_FILE; }
 
-"let"  { return T_LET;    }
-"var"  { return T_VAR;    }
+"package"  { return T_PACKAGE;  }
+"requires" { return T_REQUIRES; }
+"provides" { return T_PROVIDES; }
+"let"      { return T_LET;      }
+"var"      { return T_VAR;      }
+"fun"      { return T_FUN;      }
 
 "if"   { return T_IF;     }
 "then" { return T_THEN;   }

diff --git a/source/parser.c b/source/parser.c
index 1b36bd716f37f2311b2ee51a2f6e07088cda3a12..1f3cb1f36fdce38e9692819d4cf84f22be779852 100644 (file)
--- a/source/parser.c
+++ b/source/parser.c
@@ -1,7 +1,12 @@
 #include <sclpl.h>
 #include <stdarg.h>
 
+static void require_list(Parser* p);
+static void provide_list(Parser* p);
+static AST* definition_list(Parser* p);
 static AST* const_definition(Parser* p, bool constant);
+static AST* type_definition(Parser* p);
+static AST* func_definition(Parser* p);
 static AST* const_expression(Parser* p);
 static AST* definition(Parser* p);
 static AST* expression(Parser* p);
@@ -66,19 +71,46 @@ static Tok* expect_val(Parser* parser, TokType type) {
 /* Grammar Definition
  *****************************************************************************/
 AST* toplevel(Parser* p) {
-    AST* ret = NULL;
-    if (!match(p, T_END_FILE)) {
+    expect(p, T_PACKAGE);
+    expect(p, T_ID);
+    if (accept(p, T_REQUIRES))
+        require_list(p);
+    if (accept(p, T_PROVIDES))
+        provide_list(p);
+    definition_list(p);
+    return NULL;
+}
+
+static void require_list(Parser* p) {
+    expect(p, T_LPAR);
+    while (peek(p)->type != T_RPAR) {
+        expect(p, T_STRING);
+    }
+    expect(p, T_RPAR);
+}
+
+static void provide_list(Parser* p) {
+    expect(p, T_LPAR);
+    while (peek(p)->type != T_RPAR) {
+        expect(p, T_ID);
+    }
+    expect(p, T_RPAR);
+}
+
+static AST* definition_list(Parser* p) {
+    while (!match(p, T_END_FILE)) {
         TokType type = peek(p)->type;
-        if (accept(p, T_LET) || accept(p, T_VAR))
-            ret = const_definition(p, (type == T_LET));
-//        else if (accept(p, T_TYPE))
-//            ret = type_definition(p);
-//        else if (accept(p, T_FUN))
-//            ret = func_definition(p);
-        else
+        if (accept(p, T_LET) || accept(p, T_VAR)) {
+            const_definition(p, (type == T_LET));
+        } else if (accept(p, T_TYPE)) {
+            type_definition(p);
+        } else if (accept(p, T_FUN)) {
+            func_definition(p);
+        } else {
             error(p, "only definitions are allowed at the toplevel");
+        }
     }
-    return ret;
+    return NULL;
 }
 
 static AST* const_definition(Parser* p, bool constant) {
@@ -92,6 +124,15 @@ static AST* const_definition(Parser* p, bool constant) {
     return Var(id, expr, constant);
 }
 
+static AST* type_definition(Parser* p) {
+    return NULL;
+}
+
+static AST* func_definition(Parser* p) {
+    return NULL;
+
+}
+
 static AST* const_expression(Parser* p) {
     AST* expr = NULL;
     if (accept(p, T_LPAR)) {

diff --git a/source/sclpl.h b/source/sclpl.h
index 74ce1470c7bb5f3c5f1d1aae7efca04fe9980d58..5851cfa5878d2f3846f3961d2776270ba8d1cf4f 100644 (file)
--- a/source/sclpl.h
+++ b/source/sclpl.h
@@ -40,7 +40,8 @@ void vec_set(vec_t* vec, size_t index, void* data);
 /* Token Types
  *****************************************************************************/
 typedef enum {
-    T_NONE, T_ERROR, T_END_FILE, T_LET, T_VAR,
+    T_NONE, T_ERROR, T_END_FILE,
+    T_PACKAGE, T_REQUIRES, T_PROVIDES, T_LET, T_VAR, T_FUN, T_TYPE,
     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_IF, T_THEN, T_ELSE, T_ASSIGN