Added vector implementation in preparation for block AST nodes

diff --git a/source/ast.c b/source/ast.c
index 02edaa11e867f30378f36664f8b152135067925b..822c04293cff5259a9d82e6a7e53bb59ad616116 100644 (file)
--- a/source/ast.c
+++ b/source/ast.c
@@ -181,6 +181,30 @@ AST* def_value(AST* def)
     return def->value.def.value;
 }
 
+AST* Block(void)
+{
+    return NULL;
+}
+
+void block_append(AST* block, AST* expr)
+{
+
+}
+
+size_t block_size(AST* block)
+{
+    return 0;
+}
+
+AST* block_get(size_t index)
+{
+    return NULL;
+}
+
+
+
+
+
 //AST* Ann(char* name, AST* value)
 //{
 //    (void)name;

diff --git a/source/grammar.c b/source/grammar.c
index b9c0326f74bb161fb8260645644073dfd6487ddb..958ab42512c0b1d9749db87290e3014003fa939c 100644 (file)
--- a/source/grammar.c
+++ b/source/grammar.c
@@ -9,7 +9,9 @@
 static AST* require(Parser* p);
 static AST* definition(Parser* p);
 static AST* expression(Parser* p);
+static AST* if_stmnt(Parser* p);
 static AST* literal(Parser* p);
+static AST* expr_block(Parser* p);
 static AST* token_to_tree(Tok* tok);
 
 AST* toplevel(Parser* p)
@@ -28,10 +30,6 @@ AST* toplevel(Parser* p)
     //    return type_definition(p);
     //else if (accept_str(p, T_ID, "ann"))
     //    return type_annotation(p);
-    //else if (accept_str(p, T_ID, "def"))
-    //    return definition(p);
-    //else
-    //    return expression(p);
     return ret;
 }
 
@@ -58,10 +56,12 @@ static AST* require(Parser* p)
 static AST* expression(Parser* p)
 {
     if (peek(p)->type == T_ID) {
-        return Ident(expect(p,T_ID)); //expect_lit(p, T_ID);
+        return Ident(expect(p,T_ID));
         //if (peek(p)->type == T_LPAR) {
         //    arglist(p);
         //}
+    } else if (accept_str(p, T_ID, "if")) {
+        return if_stmnt(p);
     } else {
         return literal(p);
     }
@@ -71,8 +71,6 @@ static AST* expression(Parser* p)
     //    expression(p);
     //    expect(p, T_RPAR);
     //    //reduce(p, mrk);
-    //} else if (accept_str(p, T_ID, "if")) {
-    //    if_stmnt(p);
     //} else if (accept_str(p, T_ID, "fn")) {
     //    fn_stmnt(p);
     //} else if (peek(p)->type == T_ID) {
@@ -80,9 +78,16 @@ static AST* expression(Parser* p)
     //    if (peek(p)->type == T_LPAR) {
     //        arglist(p);
     //    }
-    //} else {
-    //    return literal(p);
-    //}
+}
+
+static AST* if_stmnt(Parser* p)
+{
+    //AST* ifexpr = IfExpr();
+    //ifexpr_set_condition( expression(p) );
+    //ifexpr_set_branch_then( expr_block(p) );
+    //expect(p,T_END);
+    //return ifexpr;
+    return NULL;
 }
 
 static AST* literal(Parser* p)
@@ -103,6 +108,15 @@ static AST* literal(Parser* p)
     return ret;
 }
 
+static AST* expr_block(Parser* p)
+{
+    AST* block = Block();
+    do {
+        block_append(block, expression(p));
+    } while(!accept_str(p, T_ID, "else") && !accept(p, T_END));
+    return block;
+}
+
 static AST* token_to_tree(Tok* tok)
 {
     switch (tok->type) {
@@ -204,18 +218,6 @@ static AST* arglist(Parser* p)
     return NULL;
 }
 
-static AST* if_stmnt(Parser* p)
-{
-    ////size_t mrk = mark(p);
-    //expression(p);
-    //expression(p);
-    //if (accept_str(p, T_ID, "else")) {
-    //    expression(p);
-    //}
-    //expect(p,T_END);
-    ////reduce(p, mrk);
-    return NULL;
-}
 
 static AST* fn_stmnt(Parser* p)
 {

diff --git a/source/sclpl.h b/source/sclpl.h
index 757812dcc84cb265862e81abdab4915d7ce85f21..8982f33eb38255c1e345f7537b45c531738a897b 100644 (file)
--- a/source/sclpl.h
+++ b/source/sclpl.h
@@ -30,6 +30,22 @@ void gc_swapref(void** dest, void* newref);
 // Redfine main
 extern int user_main(int argc, char** argv);
 
+/* Vector Implementation
+ *****************************************************************************/
+typedef struct {
+    size_t count;
+    size_t size;
+    size_t capacity;
+    void** buffer;
+} vec_t;
+
+void vec_init(vec_t* vec);
+void vec_deinit(vec_t* vec);
+void vec_clear(vec_t* vec);
+size_t vec_size(vec_t* vec);
+void* vec_at(vec_t* vec, size_t index);
+void vec_push_back(vec_t* vec, void* data);
+
 /* Token Types
  *****************************************************************************/
 typedef enum {
@@ -138,8 +154,17 @@ AST* Def(Tok* name, AST* value);
 char* def_name(AST* def);
 AST* def_value(AST* def);
 
+/* If Expression */
+AST* IfExpr(AST* cond, AST* bthen, AST* belse);
+AST* ifexpr_condition(AST* ifexpr);
+AST* ifexpr_branch_then(AST* ifexpr);
+AST* ifexpr_branch_else(AST* ifexpr);
 
-
+/* Code Block */
+AST* Block(void);
+void block_append(AST* block, AST* expr);
+size_t block_size(AST* block);
+AST* block_get(size_t index);
 
 
 
@@ -148,22 +173,12 @@ AST* def_value(AST* def);
 //char* ann_name(AST* def);
 //AST* ann_value(AST* def);
 //
-///* If Expression */
-//AST* IfExpr(AST* cond, AST* bthen, AST* belse);
-//AST* ifexpr_condition(AST* ifexpr);
-//AST* ifexpr_branch_then(AST* ifexpr);
-//AST* ifexpr_branch_else(AST* ifexpr);
 //
 ///* Function */
 //AST* Func(AST* args, AST* body);
 //AST* func_args(AST* func);
 //AST* func_body(AST* func);
 //
-///* Code Block */
-//AST* Block(void);
-//void block_append(AST* expr);
-//size_t block_size(AST* block);
-//AST* block_get(size_t index);
 //
 /* Lexer and Parser Types
  *****************************************************************************/

diff --git a/source/vec.c b/source/vec.c
new file mode 100644 (file)
index 0000000..8881267
--- /dev/null
+++ b/source/vec.c
@@ -0,0 +1,85 @@
+/**
+  @file vec.c
+*/
+#include <sclpl.h>
+
+#ifndef DEFAULT_VEC_CAPACITY
+#define DEFAULT_VEC_CAPACITY (size_t)8
+#endif
+
+void vec_init(vec_t* vec)
+{
+    vec->count    = 0;
+    vec->capacity = DEFAULT_VEC_CAPACITY;
+    vec->buffer   = malloc(sizeof(void*) * vec->capacity);
+}
+
+void vec_deinit(vec_t* vec)
+{
+    vec_clear(vec);
+    free(vec->buffer);
+}
+
+size_t vec_size(vec_t* vec)
+{
+    return vec->count;
+}
+
+void* vec_at(vec_t* vec, size_t index)
+{
+    assert(index < vec->count);
+    return vec->buffer[index];
+}
+
+static void vec_reserve(vec_t* vec, size_t size)
+{
+    assert(vec != NULL);
+    vec->buffer = realloc( vec->buffer, sizeof(void*) * size );
+    assert(vec->buffer != NULL);
+    vec->capacity = size;
+}
+
+static size_t vec_next_capacity(size_t req_size)
+{
+    size_t next_power = req_size;
+    size_t num_bits = sizeof(size_t) * 8;
+    size_t bit_n;
+    /* Find the next highest power of 2 */
+    next_power--;
+    for (bit_n = 1; bit_n < num_bits; bit_n = bit_n << 1)
+    {
+        next_power = next_power | (next_power >> bit_n);
+    }
+    next_power++;
+    return next_power;
+}
+
+static void vec_resize(vec_t* vec, size_t count, void* fillval)
+{
+    if (count > vec->count) {
+        vec_reserve(vec, vec_next_capacity(count+1));
+        for (; vec->count < count; vec->count++)
+            vec->buffer[vec->count] = gc_addref(fillval);
+    } else if (count < vec->count) {
+        vec->count = count;
+    }
+}
+
+void vec_push_back(vec_t* vec, void* data)
+{
+    vec_resize(vec, vec->count+1, data);
+}
+
+void vec_set(vec_t* vec, size_t index, void* data)
+{
+    assert(index < vec->count);
+    gc_swapref((void**)&(vec->buffer[index]), data);
+}
+
+void vec_clear(vec_t* vec)
+{
+    for (size_t i = 0; i < vec->count; i++)
+        gc_delref(vec->buffer[i]);
+    vec->count = 0;
+}
+