Implemented C++ compatability

CausticLang · Jun 5, 2024 · 2152dbe · 2152dbe
1 parent 81941f5
commit 2152dbe
Show file tree

Hide file tree

Showing 6 changed files with 31 additions and 31 deletions.
diff --git a/block.peg b/block.peg
@@ -9,8 +9,8 @@ block_inner <-
     {
         cap_ps_push(auxil);
         auxil->stack->mark = BLOCK;
-        auxil->stack->data = cst_binit_Block(malloc(sizeof(cst_Node)), cst_ninit_Block(malloc(sizeof(cst_nBlock))), $0s, 0, cap_lno(auxil), cap_cno(auxil, $0s));
-        _cap_ADDNODE(auxil->stack->data);
+        auxil->stack->data = cst_binit_Block((cst_Node*)malloc(sizeof(cst_Node)), cst_ninit_Block((cst_nBlock*)malloc(sizeof(cst_nBlock))), $0s, 0, cap_lno(auxil), cap_cno(auxil, $0s));
+        _cap_ADDNODE((cst_Node*)auxil->stack->data);
         $$ = _cap_LASTNODE;
     }
     ( line_inner _ )*

diff --git a/helper.h b/helper.h
@@ -3,19 +3,19 @@
 #define _cap_PCC0e _0e
 
 #define _cap_COPYSTR(frm) \
-    strcpy(malloc(((strlen(frm) + 1) * sizeof(char))), frm)
+    strcpy((char*)malloc(((strlen(frm) + 1) * sizeof(char))), frm)
 #define _cap_ERROR(rname, msg) \
     cap_error(auxil, __pcc_ctx, rname, msg, _cap_PCC0s, _cap_PCC0e)
 
 #define _cap_MKNODE(type) \
     (cst_n##type*)malloc(sizeof(cst_n##type))
 #define _cap_MKINITNODE(type, ...) \
-    cst_binit_##type(malloc(sizeof(cst_Node)), cst_ninit_##type(_cap_MKNODE(type), __VA_ARGS__), _cap_PCC0s, _cap_PCC0e, cap_lno(auxil), cap_cno(auxil, _cap_PCC0s))
+    cst_binit_##type((cst_Node*)malloc(sizeof(cst_Node)), cst_ninit_##type(_cap_MKNODE(type), __VA_ARGS__), _cap_PCC0s, _cap_PCC0e, cap_lno(auxil), cap_cno(auxil, _cap_PCC0s))
 
 #define _cap_ADDPARAM(ptype, type_, name_, val_) \
     do { \
         assert(auxil->stack->mark == PROC_PARAMS); \
-        cst_ProcParam* param = malloc(sizeof(cst_ProcParam)); \
+        cst_ProcParam* param = (cst_ProcParam*)malloc(sizeof(cst_ProcParam)); \
         *param = (cst_ProcParam)CST__PROCEDURES__PROC_PARAM__INIT; \
         param->type = type_; \
         param->name = name_; \

diff --git a/invoke.peg b/invoke.peg
@@ -12,7 +12,7 @@ invoke <-
             assert(auxil->stack != NULL);
             assert(auxil->stack->mark == INVOKE_ARGS);
             cst_NODECAST(node, Invokation)->n_args = auxil->stack->auxcount;
-            cst_NODECAST(node, Invokation)->args = cap_ps_pop(auxil);
+            cst_NODECAST(node, Invokation)->args = (cst_index*)cap_ps_pop(auxil);
         }
         _cap_ADDNODE(node);
         $$ = _cap_LASTNODE;
@@ -34,7 +34,7 @@ invokation_kwarg <-
     k:expression _ '=' _ v:expression ~ { _cap_ERROR("invokation_kwarg", "Expected expression after '='"); } {
         assert(auxil->stack->mark == INVOKE_KWARGS);
         auxil->stack->data = realloc(auxil->stack->data, sizeof(cst_ProcKwarg*) * ++auxil->stack->auxcount);
-        cst_ProcKwarg* kw = malloc(sizeof(cst_ProcKwarg*));
+        cst_ProcKwarg* kw = (cst_ProcKwarg*)malloc(sizeof(cst_ProcKwarg*));
         kw->key = k; kw->val = v;
         ((cst_ProcKwarg**)auxil->stack->data)[auxil->stack->auxcount-1] = kw;
     }
diff --git a/procedure.peg b/procedure.peg
@@ -18,9 +18,9 @@ proc_expr <-
     _ b:body ~ { _cap_ERROR("proc_expr", "Body is required for procedure expressions"); } {
         assert(auxil->stack->mark == PROC_PARAMS);
         unsigned int n_params = auxil->stack->auxcount;
-        cst_ProcParam** params = cap_ps_pop(auxil);
+        cst_ProcParam** params = (cst_ProcParam**)cap_ps_pop(auxil);
         assert(auxil->stack->mark == PROC_EXPR);
-        cst_Node* node = cap_ps_pop(auxil);
+        cst_Node* node = (cst_Node*)cap_ps_pop(auxil);
         cst_NODECAST(node, ProcExpr)->params = params;
         cst_NODECAST(node, ProcExpr)->n_params = n_params;
         cst_NODECAST(node, ProcExpr)->body = b;
@@ -49,9 +49,9 @@ proc_stmt <-
     _ b:body? {
         assert(auxil->stack->mark == PROC_PARAMS);
         unsigned int n_params = auxil->stack->auxcount;
-        cst_ProcParam** params = cap_ps_pop(auxil);
+        cst_ProcParam** params = (cst_ProcParam**)cap_ps_pop(auxil);
         assert(auxil->stack->mark == PROC_STMT);
-        cst_Node* node = cap_ps_pop(auxil);
+        cst_Node* node = (cst_Node*)cap_ps_pop(auxil);
         cst_NODECAST(node, ProcStmt)->params = params;
         cst_NODECAST(node, ProcStmt)->n_params = n_params;
         cst_NODECAST(node, ProcStmt)->body = b;

diff --git a/statements.peg b/statements.peg
@@ -73,7 +73,7 @@ while_cond <-
 
 
 pass_stmt <- PASS_KW {
-    _cap_ADDNODE(cst_binit_Pass(malloc(sizeof(cst_Node)), cst_ninit_Pass(_cap_MKNODE(Pass)), $0s, $0e, cap_lno(auxil), cap_cno(auxil, $0s)));
+    _cap_ADDNODE(cst_binit_Pass((cst_Node*)malloc(sizeof(cst_Node)), cst_ninit_Pass(_cap_MKNODE(Pass)), $0s, $0e, cap_lno(auxil), cap_cno(auxil, $0s)));
     $$ = _cap_LASTNODE;
 }
 

diff --git a/types.peg b/types.peg
@@ -20,7 +20,7 @@ enum <-
     }
     _ ( enum_member _ )*
     _ '}' ~ { _cap_ERROR("enum", "Expected closing '}'"); } {
-        _cap_ADDNODE(cap_ps_pop(auxil));
+        _cap_ADDNODE((cst_Node*)cap_ps_pop(auxil));
         $$ = _cap_LASTNODE;
     }
 enum_member <-
@@ -29,8 +29,8 @@ enum_member <-
     _ EOL ~ { _cap_ERROR("enum_member", "Expected EOL ';' after enum member"); } {
         assert(auxil->stack->mark == ENUM_BODY);
         cst_nEnum* en = cst_NODECAST((cst_Node*)auxil->stack->data, Enum);
-        en->members = realloc(en->members, (++en->n_members) * sizeof(cst_nEnum_Member*));
-        en->members[en->n_members-1] = malloc(sizeof(cst_nEnum_Member));
+        en->members = (cst_nEnum_Member**)realloc(en->members, (++en->n_members) * sizeof(cst_nEnum_Member*));
+        en->members[en->n_members-1] = (cst_nEnum_Member*)malloc(sizeof(cst_nEnum_Member));
         *(en->members[en->n_members-1]) = (cst_nEnum_Member)CST__TYPES__ENUM_MEMBER__INIT;
         en->members[en->n_members-1]->name = n;
         en->members[en->n_members-1]->val = v;
@@ -50,7 +50,7 @@ struct_inner <-
     }
     _ ( struct_member _ )*
     _ '}' ~ { _cap_ERROR("struct_inner", "Expected closing '}'"); } {
-        _cap_ADDNODE(cap_ps_pop(auxil));
+        _cap_ADDNODE((cst_Node*)cap_ps_pop(auxil));
         $$ = _cap_LASTNODE;
     }
 struct_member <-
@@ -60,8 +60,8 @@ struct_member <-
     _ EOL ~ { _cap_ERROR("struct_member", "Expected EOL ';' after struct member"); } {
         assert(auxil->stack->mark == STRUCT_BODY);
         cst_nStruct* st = cst_NODECAST((cst_Node*)auxil->stack->data, Struct);
-        st->members = realloc(st->members, (++st->n_members) * sizeof(cst_nStruct_Member*));
-        st->members[st->n_members-1] = malloc(sizeof(cst_nStruct_Member));
+        st->members = (cst_nStruct_Member**)realloc(st->members, (++st->n_members) * sizeof(cst_nStruct_Member*));
+        st->members[st->n_members-1] = (cst_nStruct_Member*)malloc(sizeof(cst_nStruct_Member));
         *(st->members[st->n_members-1]) = (cst_nStruct_Member)CST__TYPES__STRUCT_MEMBER__INIT;
         st->members[st->n_members-1]->type = t;
         st->members[st->n_members-1]->name = n;
@@ -79,15 +79,15 @@ structenum <-
     _ '{' ~ { _cap_ERROR("structenum", "Expected '{'"); }
     _ ( structenum_member _ )*
     _ '}' ~ { _cap_ERROR("structenum", "Expected closing '}'"); } {
-        _cap_ADDNODE(cap_ps_pop(auxil));
+        _cap_ADDNODE((cst_Node*)cap_ps_pop(auxil));
         $$ = _cap_LASTNODE;
     }
 
 structenum_member <-
     s:struct_inner _ EOL ~ { _cap_ERROR("structenum_member", "Expected EOL ';' after tagged-union member"); } {
         assert(auxil->stack->mark == STRUCTENUM_BODY);
         cst_nStructEnum* es = cst_NODECAST((cst_Node*)auxil->stack->data, StructEnum);
-        es->members = realloc(es->members, (++es->n_members) * sizeof(cst_index));
+        es->members = (cst_index*)realloc(es->members, (++es->n_members) * sizeof(cst_index));
         es->members[es->n_members-1] = s;
     }
 
@@ -102,7 +102,7 @@ class <-
     _ '{' ~ { _cap_ERROR("class", "Expected '{'"); }
     _ ( class_member _ )*
     _ '}' ~ { _cap_ERROR("class", "Expected closing '}'"); } {
-        _cap_ADDNODE(cap_ps_pop(auxil));
+        _cap_ADDNODE((cst_Node*)cap_ps_pop(auxil));
         $$ = _cap_LASTNODE;
     }
 
@@ -120,12 +120,12 @@ class_instance_member <-
     _ EOL ~ { _cap_ERROR("class_instance_member", "Expected EOL ';' after class member"); } {
         assert(auxil->stack->mark == CLASS_BODY);
         cst_nClass* cls = cst_NODECAST((cst_Node*)auxil->stack->data, Class);
-        cls->members = realloc(cls->members, (++cls->n_members) * sizeof(cst_nClass_Member*));
-        cls->members[cls->n_members-1] = malloc(sizeof(cst_nClass_Member));
+        cls->members = (cst_nClass_Member**)realloc(cls->members, (++cls->n_members) * sizeof(cst_nClass_Member*));
+        cls->members[cls->n_members-1] = (cst_nClass_Member*)malloc(sizeof(cst_nClass_Member));
         *(cls->members[cls->n_members-1]) = (cst_nClass_Member)CST__TYPES__CLASS_MEMBER__INIT;
         cls->members[cls->n_members-1]->is_static = false;
         cls->members[cls->n_members-1]->val_case = CST__TYPES__CLASS_MEMBER__VAL_MEMBER;
-        cst_nStruct_Member* sm = cls->members[cls->n_members-1]->member = malloc(sizeof(cst_nStruct_Member));
+        cst_nStruct_Member* sm = cls->members[cls->n_members-1]->member = (cst_nStruct_Member*)malloc(sizeof(cst_nStruct_Member));
         *sm = (cst_nStruct_Member)CST__TYPES__STRUCT_MEMBER__INIT;
         sm->type = t; sm->name = n; sm->val = v;
     }
@@ -135,21 +135,21 @@ class_class_member <-
     _ EOL ~ { _cap_ERROR("class_class_member", "Expected EOL ';' after class member"); } {
         assert(auxil->stack->mark == CLASS_BODY);
         cst_nClass* cls = cst_NODECAST((cst_Node*)auxil->stack->data, Class);
-        cls->members = realloc(cls->members, (++cls->n_members) * sizeof(cst_nClass_Member*));
-        cls->members[cls->n_members-1] = malloc(sizeof(cst_nClass_Member));
+        cls->members = (cst_nClass_Member**)realloc(cls->members, (++cls->n_members) * sizeof(cst_nClass_Member*));
+        cls->members[cls->n_members-1] = (cst_nClass_Member*)malloc(sizeof(cst_nClass_Member));
         *(cls->members[cls->n_members-1]) = (cst_nClass_Member)CST__TYPES__CLASS_MEMBER__INIT;
         cls->members[cls->n_members-1]->is_static = true;
         cls->members[cls->n_members-1]->val_case = CST__TYPES__CLASS_MEMBER__VAL_MEMBER;
-        cst_nStruct_Member* sm = cls->members[cls->n_members-1]->member = malloc(sizeof(cst_nStruct_Member));
+        cst_nStruct_Member* sm = cls->members[cls->n_members-1]->member = (cst_nStruct_Member*)malloc(sizeof(cst_nStruct_Member));
         *sm = (cst_nStruct_Member)CST__TYPES__STRUCT_MEMBER__INIT;
         sm->type = t; sm->name = n; sm->val = v;
     }
 
 class_instance_method <- p:proc_stmt {
     assert(auxil->stack->mark == CLASS_BODY);
     cst_nClass* cls = cst_NODECAST((cst_Node*)auxil->stack->data, Class);
-    cls->members = realloc(cls->members, (++cls->n_members) * sizeof(cst_nClass_Member));
-    cls->members[cls->n_members-1] = malloc(sizeof(cst_nClass_Member));
+    cls->members = (cst_nClass_Member**)realloc(cls->members, (++cls->n_members) * sizeof(cst_nClass_Member));
+    cls->members[cls->n_members-1] = (cst_nClass_Member*)malloc(sizeof(cst_nClass_Member));
     *(cls->members[cls->n_members-1]) = (cst_nClass_Member)CST__TYPES__CLASS_MEMBER__INIT;
     cls->members[cls->n_members-1]->is_static = false;
     cls->members[cls->n_members-1]->val_case = CST__TYPES__CLASS_MEMBER__VAL_METHOD;
@@ -158,8 +158,8 @@ class_instance_method <- p:proc_stmt {
 class_class_method <- p:proc_stmt {
     assert(auxil->stack->mark == CLASS_BODY);
     cst_nClass* cls = cst_NODECAST((cst_Node*)auxil->stack->data, Class);
-    cls->members = realloc(cls->members, (++cls->n_members) * sizeof(cst_nClass_Member));
-    cls->members[cls->n_members-1] = malloc(sizeof(cst_nClass_Member));
+    cls->members = (cst_nClass_Member**)realloc(cls->members, (++cls->n_members) * sizeof(cst_nClass_Member));
+    cls->members[cls->n_members-1] = (cst_nClass_Member*)malloc(sizeof(cst_nClass_Member));
     *(cls->members[cls->n_members-1]) = (cst_nClass_Member)CST__TYPES__CLASS_MEMBER__INIT;
     cls->members[cls->n_members-1]->is_static = true;
     cls->members[cls->n_members-1]->val_case = CST__TYPES__CLASS_MEMBER__VAL_METHOD;