removing some left-over alloc checks

diff --git a/ast.c b/ast.c
index 294c13b42dc175f369db95f6101868041b43a670..4eb250fad19c360756aae26a362d5cc063bdbe3f 100644 (file)
--- a/ast.c
+++ b/ast.c
@@ -103,10 +103,6 @@ ast_value* ast_value_copy(const ast_value *self)
     ast_value *cp = ast_value_new(self->expression.node.context, self->name, self->expression.vtype);
     if (self->expression.next) {
         cp->expression.next = ast_type_copy(self->expression.node.context, self->expression.next);
     ast_value *cp = ast_value_new(self->expression.node.context, self->name, self->expression.vtype);
     if (self->expression.next) {
         cp->expression.next = ast_type_copy(self->expression.node.context, self->expression.next);

-        if (!cp->expression.next) {
-            ast_value_delete(cp);
-            return NULL;
-        }

     }
     fromex   = &self->expression;
     selfex = &cp->expression;
     }
     fromex   = &self->expression;
     selfex = &cp->expression;


@@ -114,16 +110,12 @@ ast_value* ast_value_copy(const ast_value *self)
     selfex->flags    = fromex->flags;
     for (i = 0; i < vec_size(fromex->params); ++i) {
         ast_value *v = ast_value_copy(fromex->params[i]);
     selfex->flags    = fromex->flags;
     for (i = 0; i < vec_size(fromex->params); ++i) {
         ast_value *v = ast_value_copy(fromex->params[i]);

-        if (!v) {
-            ast_value_delete(cp);
-            return NULL;
-        }

         vec_push(selfex->params, v);
     }
     return cp;
 }
 
         vec_push(selfex->params, v);
     }
     return cp;
 }
 

-bool ast_type_adopt_impl(ast_expression *self, const ast_expression *other)
+void ast_type_adopt_impl(ast_expression *self, const ast_expression *other)

 {
     size_t i;
     const ast_expression_common *fromex;
 {
     size_t i;
     const ast_expression_common *fromex;


@@ -131,8 +123,6 @@ bool ast_type_adopt_impl(ast_expression *self, const ast_expression *other)
     self->expression.vtype = other->expression.vtype;
     if (other->expression.next) {
         self->expression.next = (ast_expression*)ast_type_copy(ast_ctx(self), other->expression.next);
     self->expression.vtype = other->expression.vtype;
     if (other->expression.next) {
         self->expression.next = (ast_expression*)ast_type_copy(ast_ctx(self), other->expression.next);

-        if (!self->expression.next)
-            return false;

     }
     fromex   = &other->expression;
     selfex = &self->expression;
     }
     fromex   = &other->expression;
     selfex = &self->expression;


@@ -140,11 +130,8 @@ bool ast_type_adopt_impl(ast_expression *self, const ast_expression *other)
     selfex->flags    = fromex->flags;
     for (i = 0; i < vec_size(fromex->params); ++i) {
         ast_value *v = ast_value_copy(fromex->params[i]);
     selfex->flags    = fromex->flags;
     for (i = 0; i < vec_size(fromex->params); ++i) {
         ast_value *v = ast_value_copy(fromex->params[i]);

-        if (!v)
-            return false;

         vec_push(selfex->params, v);
     }
         vec_push(selfex->params, v);
     }

-    return true;

 }
 
 static ast_expression* ast_shallow_type(lex_ctx ctx, int vtype)
 }
 
 static ast_expression* ast_shallow_type(lex_ctx ctx, int vtype)


@@ -178,13 +165,7 @@ ast_expression* ast_type_copy(lex_ctx ctx, const ast_expression *ex)
 
         selfex->vtype = fromex->vtype;
         if (fromex->next)
 
         selfex->vtype = fromex->vtype;
         if (fromex->next)

-        {

             selfex->next = ast_type_copy(ctx, fromex->next);
             selfex->next = ast_type_copy(ctx, fromex->next);

-            if (!selfex->next) {
-                ast_expression_delete_full(self);
-                return NULL;
-            }
-        }

         else
             selfex->next = NULL;
 
         else
             selfex->next = NULL;
 


@@ -192,10 +173,6 @@ ast_expression* ast_type_copy(lex_ctx ctx, const ast_expression *ex)
         selfex->flags    = fromex->flags;
         for (i = 0; i < vec_size(fromex->params); ++i) {
             ast_value *v = ast_value_copy(fromex->params[i]);
         selfex->flags    = fromex->flags;
         for (i = 0; i < vec_size(fromex->params); ++i) {
             ast_value *v = ast_value_copy(fromex->params[i]);

-            if (!v) {
-                ast_expression_delete_full(self);
-                return NULL;
-            }

             vec_push(selfex->params, v);
         }
 
             vec_push(selfex->params, v);
         }
 


@@ -455,11 +432,7 @@ ast_binstore* ast_binstore_new(lex_ctx ctx, int storop, int op,
 
     self->keep_dest = false;
 
 
     self->keep_dest = false;
 

-    if (!ast_type_adopt(self, left)) {
-        ast_delete(self);
-        return NULL;
-    }
-
+    ast_type_adopt(self, left);

     return self;
 }
 
     return self;
 }
 


@@ -545,11 +518,7 @@ ast_entfield* ast_entfield_new_force(lex_ctx ctx, ast_expression *entity, ast_ex
     ast_propagate_effects(self, entity);
     ast_propagate_effects(self, field);
 
     ast_propagate_effects(self, entity);
     ast_propagate_effects(self, field);
 

-    if (!ast_type_adopt(self, outtype)) {
-        ast_entfield_delete(self);
-        return NULL;
-    }
-
+    ast_type_adopt(self, outtype);

     return self;
 }
 
     return self;
 }
 


@@ -641,10 +610,7 @@ ast_array_index* ast_array_index_new(lex_ctx ctx, ast_expression *array, ast_exp
     ast_propagate_effects(self, array);
     ast_propagate_effects(self, index);
 
     ast_propagate_effects(self, array);
     ast_propagate_effects(self, index);
 

-    if (!ast_type_adopt(self, outtype)) {
-        ast_array_index_delete(self);
-        return NULL;
-    }
+    ast_type_adopt(self, outtype);

     if (array->expression.vtype == TYPE_FIELD && outtype->expression.vtype == TYPE_ARRAY) {
         if (self->expression.vtype != TYPE_ARRAY) {
             compile_error(ast_ctx(self), "array_index node on type");
     if (array->expression.vtype == TYPE_FIELD && outtype->expression.vtype == TYPE_ARRAY) {
         if (self->expression.vtype != TYPE_ARRAY) {
             compile_error(ast_ctx(self), "array_index node on type");


@@ -721,10 +687,7 @@ ast_ternary* ast_ternary_new(lex_ctx ctx, ast_expression *cond, ast_expression *
 
     if (ontrue->expression.vtype == TYPE_NIL)
         exprtype = onfalse;
 
     if (ontrue->expression.vtype == TYPE_NIL)
         exprtype = onfalse;

-    if (!ast_type_adopt(self, exprtype)) {
-        ast_ternary_delete(self);
-        return NULL;
-    }
+    ast_type_adopt(self, exprtype);

 
     return self;
 }
 
     return self;
 }


@@ -978,10 +941,7 @@ ast_store* ast_store_new(lex_ctx ctx, int op,
     self->dest = dest;
     self->source = source;
 
     self->dest = dest;
     self->source = source;
 

-    if (!ast_type_adopt(self, dest)) {
-        ast_delete(self);
-        return NULL;
-    }
+    ast_type_adopt(self, dest);

 
     return self;
 }
 
     return self;
 }


@@ -1015,10 +975,7 @@ bool ast_block_add_expr(ast_block *self, ast_expression *e)
         ast_delete(self->expression.next);
         self->expression.next = NULL;
     }
         ast_delete(self->expression.next);
         self->expression.next = NULL;
     }

-    if (!ast_type_adopt(self, e)) {
-        compile_error(ast_ctx(self), "internal error: failed to adopt type");
-        return false;
-    }
+    ast_type_adopt(self, e);

     return true;
 }
 
     return true;
 }
 


@@ -1044,13 +1001,11 @@ void ast_block_delete(ast_block *self)
     mem_d(self);
 }
 
     mem_d(self);
 }
 

-bool ast_block_set_type(ast_block *self, ast_expression *from)
+void ast_block_set_type(ast_block *self, ast_expression *from)

 {
     if (self->expression.next)
         ast_delete(self->expression.next);
 {
     if (self->expression.next)
         ast_delete(self->expression.next);

-    if (!ast_type_adopt(self, from))
-        return false;
-    return true;
+    ast_type_adopt(self, from);

 }
 
 ast_function* ast_function_new(lex_ctx ctx, const char *name, ast_value *vtype)
 }
 
 ast_function* ast_function_new(lex_ctx ctx, const char *name, ast_value *vtype)

diff --git a/ast.h b/ast.h
index 94f388e596a36ee395788a29585799d83a49546d..18f02a8e259f34da73ca4ecebbf94bdd4b1dcb00 100644 (file)
--- a/ast.h
+++ b/ast.h
@@ -215,7 +215,7 @@ void ast_value_params_add(ast_value*, ast_value*);
 bool ast_compare_type(ast_expression *a, ast_expression *b);
 ast_expression* ast_type_copy(lex_ctx ctx, const ast_expression *ex);
 #define ast_type_adopt(a, b) ast_type_adopt_impl((ast_expression*)(a), (ast_expression*)(b))
 bool ast_compare_type(ast_expression *a, ast_expression *b);
 ast_expression* ast_type_copy(lex_ctx ctx, const ast_expression *ex);
 #define ast_type_adopt(a, b) ast_type_adopt_impl((ast_expression*)(a), (ast_expression*)(b))

-bool ast_type_adopt_impl(ast_expression *self, const ast_expression *other);
+void ast_type_adopt_impl(ast_expression *self, const ast_expression *other);

 void ast_type_to_string(ast_expression *e, char *buf, size_t bufsize);
 
 /* Binary
 void ast_type_to_string(ast_expression *e, char *buf, size_t bufsize);
 
 /* Binary


@@ -597,7 +597,7 @@ struct ast_block_s
 };
 ast_block* ast_block_new(lex_ctx ctx);
 void ast_block_delete(ast_block*);
 };
 ast_block* ast_block_new(lex_ctx ctx);
 void ast_block_delete(ast_block*);

-bool ast_block_set_type(ast_block*, ast_expression *from);
+void ast_block_set_type(ast_block*, ast_expression *from);

 
 bool ast_block_codegen(ast_block*, ast_function*, bool lvalue, ir_value**);
 void ast_block_collect(ast_block*, ast_expression*);
 
 bool ast_block_codegen(ast_block*, ast_function*, bool lvalue, ir_value**);
 void ast_block_collect(ast_block*, ast_expression*);

diff --git a/parser.c b/parser.c
index 25c9c8c6fd279a6a40d8df6397c076cafd36f6d2..984668a57895ce1daadf501a9bc29081f2292bc8 100644 (file)
--- a/parser.c
+++ b/parser.c
@@ -671,8 +671,7 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy)
                     return false;
                 }
             }
                     return false;
                 }
             }

-            if (!ast_block_set_type(blocks[0], exprs[1]))
-                return false;
+            ast_block_set_type(blocks[0], exprs[1]);

 
             vec_push(sy->out, syblock(ctx, blocks[0]));
             return true;
 
             vec_push(sy->out, syblock(ctx, blocks[0]));
             return true;


@@ -3856,11 +3855,12 @@ static bool parse_function_body(parser_t *parser, ast_value *var)
             ast_expression *functype = fld_think->expression.next;
 
             thinkfunc = ast_value_new(parser_ctx(parser), parser_tokval(parser), functype->expression.vtype);
             ast_expression *functype = fld_think->expression.next;
 
             thinkfunc = ast_value_new(parser_ctx(parser), parser_tokval(parser), functype->expression.vtype);

-            if (!thinkfunc || !ast_type_adopt(thinkfunc, functype)) {
+            if (!thinkfunc) { /* || !ast_type_adopt(thinkfunc, functype)*/

                 ast_unref(framenum);
                 parseerror(parser, "failed to create implicit prototype for `%s`", parser_tokval(parser));
                 return false;
             }
                 ast_unref(framenum);
                 parseerror(parser, "failed to create implicit prototype for `%s`", parser_tokval(parser));
                 return false;
             }

+            ast_type_adopt(thinkfunc, functype);

 
             if (!parser_next(parser)) {
                 ast_unref(framenum);
 
             if (!parser_next(parser)) {
                 ast_unref(framenum);