Added C99 support, refactored headers

src/cchunk.c

@@ -2,6 +2,7 @@
 #include "cchunk.h"
 #include "cvalue.h"
 #include "cvm.h"
+#include "cobj.h"
 
 CChunk *newChunk(CState* state, size_t startCapacity) {
     CChunk *chunk = cosmoM_xmalloc(state, sizeof(CChunk));

src/cchunk.h

@@ -6,16 +6,14 @@
 #include "coperators.h"
 #include "cvalue.h"
 
-typedef struct CValueArray CValueArray;
-
-typedef struct CChunk {
+struct CChunk {
     size_t capacity; // the amount of space we've allocated for
     size_t count; // the space we're currently using
     INSTRUCTION *buf; // whole chunk
     CValueArray constants; // holds constants
     size_t lineCapacity;
     int *lineInfo;
-} CChunk;
+};
 
 CChunk *newChunk(CState* state, size_t startCapacity);
 void initChunk(CState* state, CChunk *chunk, size_t startCapacity);

src/cobj.h

@@ -22,42 +22,38 @@ typedef enum CObjType {
 #include "cvalue.h"
 #include "ctable.h"
 
-typedef struct CState CState;
-typedef struct CCallFrame CCallFrame;
-typedef uint32_t cosmo_Flag;
-
 #define CommonHeader CObj _obj
 #define readFlag(x, flag)   (x & (1u << flag))
 #define setFlagOn(x, flag)  (x |= (1u << flag))
 
 typedef int (*CosmoCFunction)(CState *state, int argCount, CValue *args);
 
-typedef struct CObj {
+struct CObj {
     struct CObj *next;
     struct CObj *nextRoot; // for the root linked list
     struct CObjObject *proto; // protoobject, describes the behavior of the object
     CObjType type;
     bool isMarked; // for the GC
-} CObj;
+};
 
-typedef struct CObjString {
+struct CObjString {
     CommonHeader; // "is a" CObj
     char *str; // NULL termincated string
     uint32_t hash; // for hashtable lookup
     int length;
     bool isIString;
-} CObjString;
+};
 
-typedef struct CObjError {
+struct CObjError {
     CommonHeader; // "is a" CObj
     CValue err; // error string
     CCallFrame *frames;
     int frameCount;
     int line; // reserved for parser errors
     bool parserError; // if true, cosmoV_printError will format the error to the lexer
-} CObjError;
+};
 
-typedef struct CObjObject {
+struct CObjObject {
     CommonHeader; // "is a" CObj
     CTable tbl;
     cosmo_Flag istringFlags; // enables us to have a much faster lookup for reserved IStrings (like __init, __index, etc.)
@@ -67,14 +63,14 @@ typedef struct CObjObject {
     };
     int userT; // user-defined type (for describing the userdata pointer/integer)
     bool isLocked;
-} CObjObject;
+};
 
-typedef struct CObjTable { // table, a wrapper for CTable
+struct CObjTable { // table, a wrapper for CTable
     CommonHeader; // "is a" CObj
     CTable tbl;
-} CObjTable;
+};
 
-typedef struct CObjFunction {
+struct CObjFunction {
     CommonHeader; // "is a" CObj
     CChunk chunk;
     CObjString *name;
@@ -82,32 +78,32 @@ typedef struct CObjFunction {
     int args;
     int upvals;
     bool variadic;
-} CObjFunction;
+};
 
-typedef struct CObjCFunction {
+struct CObjCFunction {
     CommonHeader; // "is a" CObj
     CosmoCFunction cfunc;
-} CObjCFunction;
+};
 
-typedef struct CObjClosure {
+struct CObjClosure {
     CommonHeader; // "is a" CObj
     CObjFunction *function;
     CObjUpval **upvalues;
     int upvalueCount;
-} CObjClosure;
+};
 
-typedef struct CObjMethod {
+struct CObjMethod {
     CommonHeader; // "is a " CObj
     CValue func;
     CObj *obj; // obj this method is bound too
-} CObjMethod;
+};
 
-typedef struct CObjUpval {
+struct CObjUpval {
     CommonHeader; // "is a" CObj
     CValue closed;
     CValue *val;
     struct CObjUpval *next;
-} CObjUpval;
+};
 
 #undef CommonHeader
 

src/cosmo.h

@@ -20,12 +20,17 @@
 // forward declare *most* stuff so our headers are cleaner
 typedef struct CState CState;
 typedef struct CChunk CChunk;
+typedef struct CCallFrame CCallFrame;
+
 #ifdef NAN_BOXXED
 typedef union CValue CValue;
 #else
 typedef struct CValue CValue;
 #endif
 
+typedef struct CValueArray CValueArray;
+typedef uint32_t cosmo_Flag;
+
 // objs
 typedef struct CObj CObj;
 typedef struct CObjString CObjString;

src/cstate.h

@@ -6,11 +6,11 @@
 #include "cvalue.h"
 #include "ctable.h"
 
-typedef struct CCallFrame {
+struct CCallFrame {
     CObjClosure *closure;
     INSTRUCTION *pc;
     CValue* base;
-} CCallFrame;
+};
 
 typedef enum IStringEnum {
     ISTRING_INIT,       // __init
@@ -33,7 +33,7 @@ typedef struct ArrayCObj {
     int capacity;
 } ArrayCObj;
 
-typedef struct CState {
+struct CState {
     bool panic;
     int freezeGC; // when > 0, GC events will be ignored (for internal use)
     int frameCount;
@@ -54,7 +54,7 @@ typedef struct CState {
     CObjString *iStrings[ISTRING_MAX]; // strings used internally by the VM, eg. __init, __index & friends
     CCallFrame callFrame[FRAME_MAX]; // call frames
     CValue stack[STACK_MAX]; // stack
-} CState;
+};
 
 COSMO_API CState *cosmoV_newState();
 // expects 2*pairs values on the stack, each pair should consist of 1 key and 1 value

src/cvalue.h

@@ -27,10 +27,10 @@ typedef double cosmo_Number;
 
     TL;DR: we can store payloads in the NaN value in the IEEE 754 standard.
 */
-typedef union CValue {
+union CValue {
     uint64_t data;
     cosmo_Number num;
-} CValue;
+};
 
 #define MASK_TYPE       ((uint64_t)0x0007000000000000)
 #define MASK_PAYLOAD    ((uint64_t)0x0000ffffffffffff)
@@ -68,14 +68,14 @@ typedef union CValue {
 /*
     Tagged union, this is the best platform independent solution
 */
-typedef struct CValue {
+struct CValue {
     CosmoType type;
     union {
         cosmo_Number num;
         bool b; // boolean
         CObj *obj;
     } val;
-} CValue;
+};
 
 #define GET_TYPE(x)     ((x).type)
 
@@ -103,11 +103,11 @@ typedef struct CValue {
 
 typedef CValue* StkPtr;
 
-typedef struct CValueArray {
+struct CValueArray {
     size_t capacity;
     size_t count;
     CValue *values;
-} CValueArray;
+};
 
 void initValArray(CState *state, CValueArray *val, size_t startCapacity);
 void cleanValArray(CState *state, CValueArray *array); // cleans array