tests rewrited for gtest framework & added trick for exporting static functions for testing (see nnc_static.h)

Author: almeswe

.gitignore

@@ -42,12 +42,7 @@ Module.symvers
 Mkfile.old
 dkms.conf
 .vscode
+
 tests/googletest
-tests2/googletest
-
-src/CMakeCache.txt
-src/cmake_install.cmake
-src/Makefile
-src/CMakeFiles
-src/nnc
-src/tests
+tests/build
+src/build

.gitmodules

@@ -1,3 +1,3 @@
 [submodule "src/googletest"]
-	path = tests2/googletest
+	path = tests/googletest
 	url = https://github.com/google/googletest

src/CMakeLists.txt

@@ -2,6 +2,7 @@ CMAKE_MINIMUM_REQUIRED(VERSION 3.10)
 PROJECT(nnc)
 ADD_COMPILE_OPTIONS(-Wall)
 
+SET(CMAKE_BUILD_TYPE Debug)
 FILE(GLOB nnc_star_c ${CMAKE_CURRENT_SOURCE_DIR}/*.c)
 
 ADD_EXECUTABLE(${PROJECT_NAME} ${nnc_star_c})

src/nnc_alloc.h

@@ -6,7 +6,7 @@
 
 #include "nnc_typedefs.h"
 
-#define anew(type)           (type*)nnc_alloc(sizeof(type))
+#define anew(type)          (type*)nnc_alloc(sizeof(type))
 #define cnew(type, size)    (type*)nnc_alloc(sizeof(type) * (size))
 #define rem(ptr)            nnc_dispose(ptr)
 

src/nnc_arena.c

@@ -6,7 +6,7 @@
  * @param ptr Pointer to allocted block.
  * @return Pointer to allocated & initialized arena entry.
  */
-static nnc_arena_entry* nnc_arena_entry_init(nnc_u64 size, nnc_heap_ptr ptr) {
+nnc_static nnc_arena_entry* nnc_arena_entry_init(nnc_u64 size, nnc_heap_ptr ptr) {
     nnc_arena_entry* entry = (nnc_arena_entry*)
         calloc(1, sizeof(nnc_arena_entry));
     if (entry == NULL) {
@@ -21,7 +21,7 @@ static nnc_arena_entry* nnc_arena_entry_init(nnc_u64 size, nnc_heap_ptr ptr) {
  * @brief Finalizes arena entry instance.
  * @param entry Pointer to arena entry to be freed.
  */
-static void nnc_arena_entry_fini(nnc_arena_entry* entry) {
+nnc_static void nnc_arena_entry_fini(nnc_arena_entry* entry) {
     if (entry != NULL) {
         free(entry->hptr);
         entry->hptr = NULL;
@@ -34,7 +34,7 @@ static void nnc_arena_entry_fini(nnc_arena_entry* entry) {
  * @param arena Pointer to arena instance.
  * @return `true` if arena needs compressing, otherwise `false`.
  */
-static nnc_bool nnc_arena_need_zip(nnc_arena* arena) {
+nnc_static nnc_bool nnc_arena_need_zip(nnc_arena* arena) {
     assert(arena->metrics.disposed >= 0);
     if (arena->metrics.disposed == 0) {
         return false;
@@ -49,7 +49,7 @@ static nnc_bool nnc_arena_need_zip(nnc_arena* arena) {
  *  of existing entry pointer array.
  * @param arena Pointer to arena instance.
  */
-static void nnc_arena_zip(nnc_arena* arena) {
+nnc_static void nnc_arena_zip(nnc_arena* arena) {
     nnc_u64 initial = arena->metrics.len;
     // reset len metric, because it will be recalculated.
     arena->metrics.len = 0;
@@ -71,7 +71,7 @@ static void nnc_arena_zip(nnc_arena* arena) {
  * @brief Extends arena's max capacity.
  * @param arena Pointer to arena instance.
  */
-static void nnc_arena_grow(nnc_arena* arena) {
+nnc_static void nnc_arena_grow(nnc_arena* arena) {
     arena->metrics.cap *= 2;
     nnc_u64 size = arena->metrics.cap 
         * sizeof(nnc_arena_entry*);
@@ -88,7 +88,7 @@ static void nnc_arena_grow(nnc_arena* arena) {
  * @param arena Pointer to arena instance.
  * @param entry Pointer to entry that must be pushed.
  */
-static void nnc_arena_push(nnc_arena* arena, nnc_arena_entry* entry) {
+nnc_static void nnc_arena_push(nnc_arena* arena, nnc_arena_entry* entry) {
     if (arena->metrics.cap == arena->metrics.len) {
         if (nnc_arena_need_zip(arena)) {
             nnc_arena_zip(arena);
@@ -106,7 +106,7 @@ static void nnc_arena_push(nnc_arena* arena, nnc_arena_entry* entry) {
  * @param arena Pointer to arena instance.
  * @param index Index of entry at `arena->entries` to be flushed.
  */
-static void nnc_arena_flush(nnc_arena* arena, nnc_u64 index) {
+nnc_static void nnc_arena_flush(nnc_arena* arena, nnc_u64 index) {
     assert(arena->entries[index] != NULL);
     nnc_arena_entry* entry = arena->entries[index];
     // decrease number of allocated bytes

src/nnc_ast_dump.c

@@ -14,11 +14,11 @@ typedef struct _nnc_dump_data {
 
 typedef void (*nnc_dump_fn)(nnc_dump_data);
 
-static void nnc_dump_expr(nnc_dump_data data);
-static void nnc_dump_stmt(nnc_dump_data data);
-static void nnc_dump_compound_stmt(nnc_dump_data data);
+nnc_static void nnc_dump_expr(nnc_dump_data data);
+nnc_static void nnc_dump_stmt(nnc_dump_data data);
+nnc_static void nnc_dump_compound_stmt(nnc_dump_data data);
 
-static nnc_bool nnc_is_escape(nnc_byte code) {
+nnc_static nnc_bool nnc_is_escape(nnc_byte code) {
     switch (code) {
         case '\0': case '\a':
         case '\b': case '\f':
@@ -31,7 +31,7 @@ static nnc_bool nnc_is_escape(nnc_byte code) {
     return false;
 }
 
-static nnc_byte nnc_escape(nnc_byte code) {
+nnc_static nnc_byte nnc_escape(nnc_byte code) {
     switch (code) {
         case '\0': return '0';
         case '\a': return 'a';
@@ -49,13 +49,13 @@ static nnc_byte nnc_escape(nnc_byte code) {
     return '\0';
 }
 
-static void nnc_dump_indent(nnc_i64 indent) {
+nnc_static void nnc_dump_indent(nnc_i64 indent) {
     for (nnc_i64 i = 0; i < indent; i++) {
         fprintf(stderr, "%s", "  ");
     }
 }
 
-static void nnc_dump_type(const nnc_type* type) {
+nnc_static void nnc_dump_type(const nnc_type* type) {
     if (type == NULL) {
         fprintf(stderr, _c(RED, "%s"), "?");
     }
@@ -64,7 +64,7 @@ static void nnc_dump_type(const nnc_type* type) {
     }
 }
 
-static void nnc_dump_chr(nnc_dump_data data) {
+nnc_static void nnc_dump_chr(nnc_dump_data data) {
     const nnc_chr_literal* literal = data.exact;
     nnc_byte c_repr[3] = { 0 };
     c_repr[0] = literal->exact;
@@ -79,7 +79,7 @@ static void nnc_dump_chr(nnc_dump_data data) {
     fprintf(stderr, ">\n");
 }
 
-static void nnc_dump_str(nnc_dump_data data) {
+nnc_static void nnc_dump_str(nnc_dump_data data) {
     const nnc_str_literal* literal = data.exact;
     fprintf(stderr, _c(BYEL, "str") " <val=");
     for (nnc_u64 i = 0; i < literal->length; i++) {
@@ -97,7 +97,7 @@ static void nnc_dump_str(nnc_dump_data data) {
     fprintf(stderr, ">\n");
 }
 
-static void nnc_dump_ident(nnc_dump_data data) {
+nnc_static void nnc_dump_ident(nnc_dump_data data) {
     const nnc_ident* ident = data.exact;
     fprintf(stderr, _c(BCYN, "ident "));
     fprintf(stderr, "<val=\"%s\",", ident->name);
@@ -107,7 +107,7 @@ static void nnc_dump_ident(nnc_dump_data data) {
     fprintf(stderr, ">\n");
 }
 
-static void nnc_dump_int(nnc_dump_data data) {
+nnc_static void nnc_dump_int(nnc_dump_data data) {
     const nnc_int_literal* literal = data.exact;
     fprintf(stderr, _c(BYEL, "int") " <");
     if (literal->is_signed) {
@@ -124,7 +124,7 @@ static void nnc_dump_int(nnc_dump_data data) {
     fprintf(stderr, ">\n");
 }
 
-static void nnc_dump_dbl(nnc_dump_data data) {
+nnc_static void nnc_dump_dbl(nnc_dump_data data) {
     const nnc_dbl_literal* literal = data.exact;
     fprintf(stderr, _c(BYEL, "float "));
     fprintf(stderr, "%f", literal->exact);
@@ -134,7 +134,7 @@ static void nnc_dump_dbl(nnc_dump_data data) {
     fprintf(stderr, ">\n");
 }
 
-static void nnc_dump_unary(nnc_dump_data data) {
+nnc_static void nnc_dump_unary(nnc_dump_data data) {
     const nnc_unary_expression* unary = data.exact;
     static const char* unary_str[] = {
         [UNARY_CAST]          = "cast",
@@ -196,7 +196,7 @@ static void nnc_dump_unary(nnc_dump_data data) {
     }
 }
 
-static void nnc_dump_binary(nnc_dump_data data) {
+nnc_static void nnc_dump_binary(nnc_dump_data data) {
     const nnc_binary_expression* binary = data.exact;
     static const char* binary_str[] = {
         [BINARY_ADD]        = "+",
@@ -230,7 +230,7 @@ static void nnc_dump_binary(nnc_dump_data data) {
     nnc_dump_expr(DUMP_DATA(data.indent + 1, binary->rexpr));
 }
 
-static void nnc_dump_ternary(nnc_dump_data data) {
+nnc_static void nnc_dump_ternary(nnc_dump_data data) {
     const nnc_ternary_expression* ternary = data.exact;
     fprintf(stderr, _c(BGRN, "ternary-expr "));
     fprintf(stderr, "<type=");
@@ -247,7 +247,7 @@ static void nnc_dump_ternary(nnc_dump_data data) {
     nnc_dump_expr(DUMP_DATA(data.indent + 1, ternary->rexpr));
 }
 
-static void nnc_dump_expr(nnc_dump_data data) {
+nnc_static void nnc_dump_expr(nnc_dump_data data) {
     const nnc_expression* expr = data.exact;
     static const nnc_dump_fn dumpers[] = {
         [EXPR_DBL_LITERAL] = nnc_dump_dbl,
@@ -264,7 +264,7 @@ static void nnc_dump_expr(nnc_dump_data data) {
     }
 } 
 
-static void nnc_dump_if_stmt(nnc_dump_data data) {
+nnc_static void nnc_dump_if_stmt(nnc_dump_data data) {
     const nnc_if_stmt* if_stmt = data.exact;
     fprintf(stderr, _c(BMAG, "if-stmt\n"));
     nnc_dump_indent(data.indent + 1);
@@ -292,7 +292,7 @@ static void nnc_dump_if_stmt(nnc_dump_data data) {
     }
 }
 
-static void nnc_dump_do_stmt(nnc_dump_data data) {
+nnc_static void nnc_dump_do_stmt(nnc_dump_data data) {
     const nnc_do_while_stmt* do_stmt = data.exact;
     fprintf(stderr, _c(BMAG, "do-stmt\n"));
     nnc_dump_indent(data.indent + 1);
@@ -303,7 +303,7 @@ static void nnc_dump_do_stmt(nnc_dump_data data) {
     nnc_dump_expr(DUMP_DATA(data.indent+1, do_stmt->cond));
 }
 
-static void nnc_dump_for_stmt(nnc_dump_data data) {
+nnc_static void nnc_dump_for_stmt(nnc_dump_data data) {
     const nnc_for_stmt* for_stmt = data.exact;
     fprintf(stderr, _c(BMAG, "for-stmt\n"));
     nnc_dump_indent(data.indent + 1);
@@ -320,7 +320,7 @@ static void nnc_dump_for_stmt(nnc_dump_data data) {
     nnc_dump_stmt(DUMP_DATA(data.indent+1, for_stmt->body));
 }
 
-static void nnc_dump_let_stmt(nnc_dump_data data) {
+nnc_static void nnc_dump_let_stmt(nnc_dump_data data) {
     const nnc_let_statement* let_stmt = data.exact;
     fprintf(stderr, _c(BMAG, "let-stmt "));
     fprintf(stderr, "<var=%s,", let_stmt->var->name);
@@ -334,14 +334,14 @@ static void nnc_dump_let_stmt(nnc_dump_data data) {
     }
 }
 
-static void nnc_dump_goto_stmt(nnc_dump_data data) {
+nnc_static void nnc_dump_goto_stmt(nnc_dump_data data) {
     const nnc_goto_statement* goto_stmt = data.exact;
     fprintf(stderr, _c(BMAG, "goto-stmt ") "<label=");
     const nnc_expression_statement* body = goto_stmt->body->exact;
     nnc_dump_expr(DUMP_DATA(data.indent+1, body->expr));
 }
 
-static void nnc_dump_type_stmt(nnc_dump_data data) {
+nnc_static void nnc_dump_type_stmt(nnc_dump_data data) {
     const nnc_type_statement* type_stmt = data.exact;
     fprintf(stderr, _c(BMAG, "type-stmt ") "<type=");
     nnc_dump_type(type_stmt->type);
@@ -350,7 +350,7 @@ static void nnc_dump_type_stmt(nnc_dump_data data) {
     fprintf(stderr, ">\n");
 }
 
-static void nnc_dump_while_stmt(nnc_dump_data data) {
+nnc_static void nnc_dump_while_stmt(nnc_dump_data data) {
     const nnc_while_stmt* while_stmt = data.exact;
     fprintf(stderr, _c(BMAG, "while-stmt\n"));
     nnc_dump_indent(data.indent + 1);
@@ -361,31 +361,31 @@ static void nnc_dump_while_stmt(nnc_dump_data data) {
     nnc_dump_stmt(DUMP_DATA(data.indent+1, while_stmt->body));
 }
 
-static void nnc_dump_empty_stmt(nnc_dump_data data) {
+nnc_static void nnc_dump_empty_stmt(nnc_dump_data data) {
     fprintf(stderr, _c(BMAG, "empty-stmt\n"));
 }
 
-static void nnc_dump_break_stmt(nnc_dump_data data) {
+nnc_static void nnc_dump_break_stmt(nnc_dump_data data) {
     fprintf(stderr, _c(BMAG, "break-stmt\n"));
 }
 
-static void nnc_dump_return_stmt(nnc_dump_data data) {
+nnc_static void nnc_dump_return_stmt(nnc_dump_data data) {
     const nnc_return_statement* ret_stmt = data.exact;
     fprintf(stderr, _c(BMAG, "return-stmt\n"));
     nnc_dump_indent(data.indent + 1);
     fprintf(stderr, TREE_BR "what=");
     nnc_dump_stmt(DUMP_DATA(data.indent+1, ret_stmt->body));
 }
 
-static void nnc_dump_expr_stmt(nnc_dump_data data) {
+nnc_static void nnc_dump_expr_stmt(nnc_dump_data data) {
     const nnc_expression_statement* expr_stmt = data.exact;
     fprintf(stderr, _c(BMAG, "expr-stmt\n"));
     nnc_dump_indent(data.indent + 1);
     fprintf(stderr, TREE_BR "expr=");
     nnc_dump_expr(DUMP_DATA(data.indent+1, expr_stmt->expr));
 }
 
-static void nnc_dump_compound_stmt(nnc_dump_data data) {
+nnc_static void nnc_dump_compound_stmt(nnc_dump_data data) {
     const nnc_compound_statement* compound = data.exact;
     fprintf(stderr, _c(BMAG, "compound-stmt"));
     fprintf(stderr, " <stmts=%lu>\n", buf_len(compound->stmts));
@@ -396,11 +396,11 @@ static void nnc_dump_compound_stmt(nnc_dump_data data) {
     }
 }
 
-static void nnc_dump_continue_stmt(nnc_dump_data data) {
+nnc_static void nnc_dump_continue_stmt(nnc_dump_data data) {
     fprintf(stderr, _c(BMAG, "continue-stmt\n"));
 }
 
-static void nnc_dump_namespace_stmt(nnc_dump_data data) {
+nnc_static void nnc_dump_namespace_stmt(nnc_dump_data data) {
     const nnc_namespace_statement* namespace_stmt = data.exact;
     fprintf(stderr, _c(BRED, "namespace-stmt ") "<name=%s>\n", namespace_stmt->var->name);
     nnc_statement** stmts = ((nnc_compound_statement*)(namespace_stmt->body->exact))->stmts;
@@ -411,7 +411,7 @@ static void nnc_dump_namespace_stmt(nnc_dump_data data) {
     }
 }
 
-static void nnc_dump_fn_stmt(nnc_dump_data data) {
+nnc_static void nnc_dump_fn_stmt(nnc_dump_data data) {
     const nnc_fn_statement* fn_stmt = data.exact;
     fprintf(stderr, _c(BRED, "fn-stmt ") "<name=%s, paramc=%lu, proto=",
         fn_stmt->var->name, buf_len(fn_stmt->params));
@@ -432,7 +432,7 @@ static void nnc_dump_fn_stmt(nnc_dump_data data) {
     }
 }
 
-static void nnc_dump_stmt(nnc_dump_data data) {
+nnc_static void nnc_dump_stmt(nnc_dump_data data) {
     const nnc_statement* stmt = data.exact;
     static const nnc_dump_fn dumpers[] = {
         [STMT_IF]        = nnc_dump_if_stmt,

src/nnc_buf.h

@@ -16,7 +16,7 @@ typedef struct _nnc_buf {
 #define nncbuf__len(buf) nncbuf__hdr(buf)->len
 #define nncbuf__cap(buf) nncbuf__hdr(buf)->cap
 
-#define nncbuf__grow(buf) nncbuf_grow(buf, sizeof(*(buf)), NNC_BUF_INICAP)
+#define nncbuf__grow(buf) nncbuf_grow((void*)(buf), sizeof(*(buf)), NNC_BUF_INICAP)
 #define nncbuf__need(buf) ((buf) ? (nncbuf__cap(buf) <= nncbuf__len(buf)) : 1)
 #define nncbuf__fits(buf) ((nncbuf__need(buf)) ? ((buf) = nncbuf__grow(buf)) : 0)
 
@@ -29,7 +29,7 @@ typedef struct _nnc_buf {
 #define buf_len(buf) 		((buf) ? nncbuf__len(buf) : 0)
 #define buf_cap(buf) 		((buf) ? nncbuf__cap(buf) : 0)
 #define buf_add(buf, item) 	(nncbuf__fits(buf), (buf)[nncbuf__len(buf)++] = (item))
-#define buf_free(buf) 		((buf) ? nnc_dispose(nncbuf__hdr(buf)) : 0)
+#define buf_free(buf) 		((buf) ? nnc_dispose(nncbuf__hdr(buf)) : (void)0)
 
 void* nncbuf_grow(void* buf, nnc_u64 type, nnc_u16 inicap);
 

src/nnc_core.h

@@ -1,6 +1,7 @@
 #ifndef _NNC_CORE_H
 #define _NNC_CORE_H
 
+#include "nnc_static.h"
 #include "nnc_buf.h"
 #include "nnc_map.h"