new makefile
[xonotic/gmqcc.git] / intrin.cpp
index fd7fa73a22495df304bf73c867749727066421fb..8053b313e28c45193679d3fbbcf635d411302267 100644 (file)
@@ -8,7 +8,7 @@ lex_ctx_t intrin::ctx() const {
     return parser_ctx(m_parser);
 }
 
-ast_function *intrin::value(ast_value **out, const char *name, qcint_t vtype) {
+ast_function *intrin::value(ast_value **out, const char *name, qc_type vtype) {
     ast_value *value = nullptr;
     ast_function *func  = nullptr;
     char buffer[1024];
@@ -17,11 +17,11 @@ ast_function *intrin::value(ast_value **out, const char *name, qcint_t vtype) {
     util_snprintf(buffer, sizeof(buffer), "__builtin_%s", name);
     util_snprintf(stype,  sizeof(stype),   "<%s>",        type_name[vtype]);
 
-    value = ast_value_new(ctx(), buffer, TYPE_FUNCTION);
-    value->intrinsic = true;
-    value->next = (ast_expression*)ast_value_new(ctx(), stype, vtype);
-    func = ast_function_new(ctx(), buffer, value);
-    value->flags |= AST_FLAG_ERASEABLE;
+    value = new ast_value(ctx(), buffer, TYPE_FUNCTION);
+    value->m_intrinsic = true;
+    value->m_next = new ast_value(ctx(), stype, vtype);
+    func = ast_function::make(ctx(), buffer, value);
+    value->m_flags |= AST_FLAG_ERASEABLE;
 
     *out = value;
     return func;
@@ -29,16 +29,14 @@ ast_function *intrin::value(ast_value **out, const char *name, qcint_t vtype) {
 
 void intrin::reg(ast_value *const value, ast_function *const func) {
     m_parser->functions.push_back(func);
-    m_parser->globals.push_back((ast_expression*)value);
+    m_parser->globals.push_back(value);
 }
 
-#define QC_POW_EPSILON 0.00001f
-
 ast_expression *intrin::nullfunc() {
     ast_value *val = nullptr;
     ast_function *func = value(&val, nullptr, TYPE_VOID);
     reg(val, func);
-    return (ast_expression*)val;
+    return val;
 }
 
 ast_expression *intrin::isfinite_() {
@@ -48,42 +46,42 @@ ast_expression *intrin::isfinite_() {
      * }
      */
     ast_value    *val     = nullptr;
-    ast_value    *x         = ast_value_new(ctx(), "x", TYPE_FLOAT);
+    ast_value    *x         = new ast_value(ctx(), "x", TYPE_FLOAT);
     ast_function *func      = value(&val, "isfinite", TYPE_FLOAT);
-    ast_call     *callisnan = ast_call_new(ctx(), func_self("isnan", "isfinite"));
-    ast_call     *callisinf = ast_call_new(ctx(), func_self("isinf", "isfinite"));
-    ast_block    *block     = ast_block_new(ctx());
+    ast_call     *callisnan = ast_call::make(ctx(), func_self("isnan", "isfinite"));
+    ast_call     *callisinf = ast_call::make(ctx(), func_self("isinf", "isfinite"));
+    ast_block    *block     = new ast_block(ctx());
 
     /* float x; */
-    val->type_params.push_back(x);
+    val->m_type_params.emplace_back(x);
 
     /* <callisnan> = isnan(x); */
-    callisnan->params.push_back((ast_expression*)x);
+    callisnan->m_params.push_back(x);
 
     /* <callisinf> = isinf(x); */
-    callisinf->params.push_back((ast_expression*)x);
+    callisinf->m_params.push_back(x);
 
     /* return (!<callisnan> || <callisinf>); */
-    block->exprs.push_back(
-        (ast_expression*)ast_return_new(
+    block->m_exprs.push_back(
+        new ast_return(
             ctx(),
-            (ast_expression*)ast_unary_new(
+            ast_unary::make(
                 ctx(),
                 INSTR_NOT_F,
-                (ast_expression*)ast_binary_new(
+                new ast_binary(
                     ctx(),
                     INSTR_OR,
-                    (ast_expression*)callisnan,
-                    (ast_expression*)callisinf
+                    callisnan,
+                    callisinf
                 )
             )
         )
     );
 
-    func->blocks.push_back(block);
+    func->m_blocks.emplace_back(block);
     reg(val, func);
 
-    return (ast_expression*)val;;
+    return val;;
 }
 
 ast_expression *intrin::isinf_() {
@@ -93,43 +91,43 @@ ast_expression *intrin::isinf_() {
      * }
      */
     ast_value *val = nullptr;
-    ast_value *x = ast_value_new(ctx(), "x", TYPE_FLOAT);
-    ast_block *body = ast_block_new(ctx());
+    ast_value *x = new ast_value(ctx(), "x", TYPE_FLOAT);
+    ast_block *body = new ast_block(ctx());
     ast_function *func = value(&val, "isinf", TYPE_FLOAT);
 
-    body->exprs.push_back(
-        (ast_expression*)ast_return_new(
+    body->m_exprs.push_back(
+        new ast_return(
             ctx(),
-            (ast_expression*)ast_binary_new(
+            new ast_binary(
                 ctx(),
                 INSTR_AND,
-                (ast_expression*)ast_binary_new(
+                new ast_binary(
                     ctx(),
                     INSTR_NE_F,
-                    (ast_expression*)x,
-                    (ast_expression*)m_fold->m_imm_float[0]
+                    x,
+                    m_fold->m_imm_float[0]
                 ),
-                (ast_expression*)ast_binary_new(
+                new ast_binary(
                     ctx(),
                     INSTR_EQ_F,
-                    (ast_expression*)ast_binary_new(
+                    new ast_binary(
                         ctx(),
                         INSTR_ADD_F,
-                        (ast_expression*)x,
-                        (ast_expression*)x
+                        x,
+                        x
                     ),
-                    (ast_expression*)x
+                    x
                 )
             )
         )
     );
 
-    val->type_params.push_back(x);
-    func->blocks.push_back(body);
+    val->m_type_params.emplace_back(x);
+    func->m_blocks.emplace_back(body);
 
     reg(val, func);
 
-    return (ast_expression*)val;
+    return val;
 }
 
 ast_expression *intrin::isnan_() {
@@ -142,39 +140,39 @@ ast_expression *intrin::isnan_() {
      * }
      */
     ast_value *val = nullptr;
-    ast_value *arg1 = ast_value_new(ctx(), "x",TYPE_FLOAT);
-    ast_value *local = ast_value_new(ctx(), "local", TYPE_FLOAT);
-    ast_block *body  = ast_block_new(ctx());
+    ast_value *arg1 = new ast_value(ctx(), "x",TYPE_FLOAT);
+    ast_value *local = new ast_value(ctx(), "local", TYPE_FLOAT);
+    ast_block *body  = new ast_block(ctx());
     ast_function *func = value(&val, "isnan", TYPE_FLOAT);
 
-    body->locals.push_back(local);
-    body->exprs.push_back(
-        (ast_expression*)ast_store_new(
+    body->m_locals.push_back(local);
+    body->m_exprs.push_back(
+        new ast_store(
             ctx(),
             INSTR_STORE_F,
-            (ast_expression*)local,
-            (ast_expression*)arg1
+            local,
+            arg1
         )
     );
 
-    body->exprs.push_back(
-        (ast_expression*)ast_return_new(
+    body->m_exprs.push_back(
+        new ast_return(
             ctx(),
-            (ast_expression*)ast_binary_new(
+            new ast_binary(
                 ctx(),
                 INSTR_NE_F,
-                (ast_expression*)arg1,
-                (ast_expression*)local
+                arg1,
+                local
             )
         )
     );
 
-    val->type_params.push_back(arg1);
-    func->blocks.push_back(body);
+    val->m_type_params.emplace_back(arg1);
+    func->m_blocks.emplace_back(body);
 
     reg(val, func);
 
-    return (ast_expression*)val;
+    return val;
 }
 
 ast_expression *intrin::isnormal_() {
@@ -184,25 +182,25 @@ ast_expression *intrin::isnormal_() {
      * }
      */
     ast_value *val = nullptr;
-    ast_call *callisfinite = ast_call_new(ctx(), func_self("isfinite", "isnormal"));
-    ast_value *x = ast_value_new(ctx(), "x", TYPE_FLOAT);
-    ast_block *body = ast_block_new(ctx());
+    ast_call *callisfinite = ast_call::make(ctx(), func_self("isfinite", "isnormal"));
+    ast_value *x = new ast_value(ctx(), "x", TYPE_FLOAT);
+    ast_block *body = new ast_block(ctx());
     ast_function *func = value(&val, "isnormal", TYPE_FLOAT);
 
-    val->type_params.push_back(x);
-    callisfinite->params.push_back((ast_expression*)x);
+    val->m_type_params.emplace_back(x);
+    callisfinite->m_params.push_back(x);
 
     /* return <callisfinite> */
-    body->exprs.push_back(
-        (ast_expression*)ast_return_new(
+    body->m_exprs.push_back(
+        new ast_return(
             ctx(),
-            (ast_expression*)callisfinite
+            callisfinite
         )
     );
 
-    func->blocks.push_back(body);
+    func->m_blocks.emplace_back(body);
     reg(val, func);
-    return (ast_expression*)val;
+    return val;
 }
 
 ast_expression *intrin::signbit_() {
@@ -212,33 +210,33 @@ ast_expression *intrin::signbit_() {
      * }
      */
     ast_value *val = nullptr;
-    ast_value *x = ast_value_new(ctx(), "x", TYPE_FLOAT);
-    ast_block *body = ast_block_new(ctx());
+    ast_value *x = new ast_value(ctx(), "x", TYPE_FLOAT);
+    ast_block *body = new ast_block(ctx());
     ast_function *func = value(&val, "signbit", TYPE_FLOAT);
 
-    val->type_params.push_back(x);
+    val->m_type_params.emplace_back(x);
 
     /* return (x < 0); */
-    body->exprs.push_back(
-        (ast_expression*)ast_return_new(
+    body->m_exprs.push_back(
+        new ast_return(
             ctx(),
-            (ast_expression*)ast_ternary_new(
+            new ast_ternary(
                 ctx(),
-                (ast_expression*)ast_binary_new(
+                new ast_binary(
                     ctx(),
                     INSTR_LT,
-                    (ast_expression*)x,
-                    (ast_expression*)m_fold->m_imm_float[0]
+                    x,
+                    m_fold->m_imm_float[0]
                 ),
-                (ast_expression*)m_fold->m_imm_float[1],
-                (ast_expression*)m_fold->m_imm_float[0]
+                m_fold->m_imm_float[1],
+                m_fold->m_imm_float[0]
             )
         )
     );
 
-    func->blocks.push_back(body);
+    func->m_blocks.emplace_back(body);
     reg(val, func);
-    return (ast_expression*)val;
+    return val;
 }
 
 ast_expression *intrin::acosh_() {
@@ -248,50 +246,50 @@ ast_expression *intrin::acosh_() {
      * }
      */
     ast_value    *val    = nullptr;
-    ast_value    *x        = ast_value_new(ctx(), "x", TYPE_FLOAT);
-    ast_call     *calllog  = ast_call_new(ctx(), func_self("log", "acosh"));
-    ast_call     *callsqrt = ast_call_new(ctx(), func_self("sqrt", "acosh"));
-    ast_block    *body     = ast_block_new(ctx());
+    ast_value    *x        = new ast_value(ctx(), "x", TYPE_FLOAT);
+    ast_call     *calllog  = ast_call::make(ctx(), func_self("log", "acosh"));
+    ast_call     *callsqrt = ast_call::make(ctx(), func_self("sqrt", "acosh"));
+    ast_block    *body     = new ast_block(ctx());
     ast_function *func     = value(&val, "acosh", TYPE_FLOAT);
 
-    val->type_params.push_back(x);
+    val->m_type_params.emplace_back(x);
 
     /* <callsqrt> = sqrt((x * x) - 1); */
-    callsqrt->params.push_back(
-        (ast_expression*)ast_binary_new(
+    callsqrt->m_params.push_back(
+        new ast_binary(
             ctx(),
             INSTR_SUB_F,
-            (ast_expression*)ast_binary_new(
+            new ast_binary(
                 ctx(),
                 INSTR_MUL_F,
-                (ast_expression*)x,
-                (ast_expression*)x
+                x,
+                x
             ),
-            (ast_expression*)m_fold->m_imm_float[1]
+            m_fold->m_imm_float[1]
         )
     );
 
     /* <calllog> = log(x + <callsqrt>); */
-    calllog->params.push_back(
-        (ast_expression*)ast_binary_new(
+    calllog->m_params.push_back(
+        new ast_binary(
             ctx(),
             INSTR_ADD_F,
-            (ast_expression*)x,
-            (ast_expression*)callsqrt
+            x,
+            callsqrt
         )
     );
 
     /* return <calllog>; */
-    body->exprs.push_back(
-        (ast_expression*)ast_return_new(
+    body->m_exprs.push_back(
+        new ast_return(
             ctx(),
-            (ast_expression*)calllog
+            calllog
         )
     );
 
-    func->blocks.push_back(body);
+    func->m_blocks.emplace_back(body);
     reg(val, func);
-    return (ast_expression*)val;
+    return val;
 }
 
 ast_expression *intrin::asinh_() {
@@ -301,50 +299,50 @@ ast_expression *intrin::asinh_() {
      * }
      */
     ast_value *val = nullptr;
-    ast_value *x = ast_value_new(ctx(), "x", TYPE_FLOAT);
-    ast_call *calllog = ast_call_new(ctx(), func_self("log", "asinh"));
-    ast_call *callsqrt = ast_call_new(ctx(), func_self("sqrt", "asinh"));
-    ast_block *body = ast_block_new(ctx());
+    ast_value *x = new ast_value(ctx(), "x", TYPE_FLOAT);
+    ast_call *calllog = ast_call::make(ctx(), func_self("log", "asinh"));
+    ast_call *callsqrt = ast_call::make(ctx(), func_self("sqrt", "asinh"));
+    ast_block *body = new ast_block(ctx());
     ast_function *func = value(&val, "asinh", TYPE_FLOAT);
 
-    val->type_params.push_back(x);
+    val->m_type_params.emplace_back(x);
 
     /* <callsqrt> = sqrt((x * x) + 1); */
-    callsqrt->params.push_back(
-        (ast_expression*)ast_binary_new(
+    callsqrt->m_params.push_back(
+        new ast_binary(
             ctx(),
             INSTR_ADD_F,
-            (ast_expression*)ast_binary_new(
+            new ast_binary(
                 ctx(),
                 INSTR_MUL_F,
-                (ast_expression*)x,
-                (ast_expression*)x
+                x,
+                x
             ),
-            (ast_expression*)m_fold->m_imm_float[1]
+            m_fold->m_imm_float[1]
         )
     );
 
     /* <calllog> = log(x + <callsqrt>); */
-    calllog->params.push_back(
-        (ast_expression*)ast_binary_new(
+    calllog->m_params.push_back(
+        new ast_binary(
             ctx(),
             INSTR_ADD_F,
-            (ast_expression*)x,
-            (ast_expression*)callsqrt
+            x,
+            callsqrt
         )
     );
 
     /* return <calllog>; */
-    body->exprs.push_back(
-        (ast_expression*)ast_return_new(
+    body->m_exprs.push_back(
+        new ast_return(
             ctx(),
-            (ast_expression*)calllog
+            calllog
         )
     );
 
-    func->blocks.push_back(body);
+    func->m_blocks.emplace_back(body);
     reg(val, func);
-    return (ast_expression*)val;
+    return val;
 }
 
 ast_expression *intrin::atanh_() {
@@ -354,46 +352,46 @@ ast_expression *intrin::atanh_() {
      * }
      */
     ast_value    *val   = nullptr;
-    ast_value    *x       = ast_value_new(ctx(), "x", TYPE_FLOAT);
-    ast_call     *calllog = ast_call_new(ctx(), func_self("log", "atanh"));
-    ast_block    *body    = ast_block_new(ctx());
+    ast_value    *x       = new ast_value(ctx(), "x", TYPE_FLOAT);
+    ast_call     *calllog = ast_call::make(ctx(), func_self("log", "atanh"));
+    ast_block    *body    = new ast_block(ctx());
     ast_function *func    = value(&val, "atanh", TYPE_FLOAT);
 
-    val->type_params.push_back(x);
+    val->m_type_params.emplace_back(x);
 
     /* <callog> = log((1 + x) / (1 - x)); */
-    calllog->params.push_back(
-        (ast_expression*)ast_binary_new(
+    calllog->m_params.push_back(
+        new ast_binary(
             ctx(),
             INSTR_DIV_F,
-            (ast_expression*)ast_binary_new(
+            new ast_binary(
                 ctx(),
                 INSTR_ADD_F,
-                (ast_expression*)m_fold->m_imm_float[1],
-                (ast_expression*)x
+                m_fold->m_imm_float[1],
+                x
             ),
-            (ast_expression*)ast_binary_new(
+            new ast_binary(
                 ctx(),
                 INSTR_SUB_F,
-                (ast_expression*)m_fold->m_imm_float[1],
-                (ast_expression*)x
+                m_fold->m_imm_float[1],
+                x
             )
         )
     );
 
     /* return 0.5 * <calllog>; */
-    body->exprs.push_back(
-        (ast_expression*)ast_binary_new(
+    body->m_exprs.push_back(
+        new ast_binary(
             ctx(),
             INSTR_MUL_F,
-            (ast_expression*)m_fold->constgen_float(0.5, false),
-            (ast_expression*)calllog
+            m_fold->constgen_float(0.5, false),
+            calllog
         )
     );
 
-    func->blocks.push_back(body);
+    func->m_blocks.emplace_back(body);
     reg(val, func);
-    return (ast_expression*)val;
+    return val;
 }
 
 ast_expression *intrin::exp_() {
@@ -409,36 +407,36 @@ ast_expression *intrin::exp_() {
      * }
      */
     ast_value *val = nullptr;
-    ast_value *x = ast_value_new(ctx(), "x", TYPE_FLOAT);
-    ast_value *sum = ast_value_new(ctx(), "sum", TYPE_FLOAT);
-    ast_value *acc = ast_value_new(ctx(), "acc", TYPE_FLOAT);
-    ast_value *i = ast_value_new(ctx(), "i",   TYPE_FLOAT);
-    ast_block *body = ast_block_new(ctx());
+    ast_value *x = new ast_value(ctx(), "x", TYPE_FLOAT);
+    ast_value *sum = new ast_value(ctx(), "sum", TYPE_FLOAT);
+    ast_value *acc = new ast_value(ctx(), "acc", TYPE_FLOAT);
+    ast_value *i = new ast_value(ctx(), "i",   TYPE_FLOAT);
+    ast_block *body = new ast_block(ctx());
     ast_function *func = value(&val, "exp", TYPE_FLOAT);
 
-    val->type_params.push_back(x);
+    val->m_type_params.emplace_back(x);
 
-    body->locals.push_back(sum);
-    body->locals.push_back(acc);
-    body->locals.push_back(i);
+    body->m_locals.push_back(sum);
+    body->m_locals.push_back(acc);
+    body->m_locals.push_back(i);
 
     /* sum = 1.0; */
-    body->exprs.push_back(
-        (ast_expression*)ast_store_new(
+    body->m_exprs.push_back(
+        new ast_store(
             ctx(),
             INSTR_STORE_F,
-            (ast_expression*)sum,
-            (ast_expression*)m_fold->m_imm_float[1]
+            sum,
+            m_fold->m_imm_float[1]
         )
     );
 
     /* acc = 1.0; */
-    body->exprs.push_back(
-        (ast_expression*)ast_store_new(
+    body->m_exprs.push_back(
+        new ast_store(
             ctx(),
             INSTR_STORE_F,
-            (ast_expression*)acc,
-            (ast_expression*)m_fold->m_imm_float[1]
+            acc,
+            m_fold->m_imm_float[1]
         )
     );
 
@@ -446,50 +444,50 @@ ast_expression *intrin::exp_() {
      * for (i = 1; i < 200; ++i)
      *     sum += (acc *= x / i);
      */
-    body->exprs.push_back(
-        (ast_expression*)ast_loop_new(
+    body->m_exprs.push_back(
+        new ast_loop(
             ctx(),
             /* i = 1; */
-            (ast_expression*)ast_store_new(
+            new ast_store(
                 ctx(),
                 INSTR_STORE_F,
-                (ast_expression*)i,
-                (ast_expression*)m_fold->m_imm_float[1]
+                i,
+                m_fold->m_imm_float[1]
             ),
             /* i < 200; */
-            (ast_expression*)ast_binary_new(
+            new ast_binary(
                 ctx(),
                 INSTR_LT,
-                (ast_expression*)i,
-                (ast_expression*)m_fold->constgen_float(200.0f, false)
+                i,
+                m_fold->constgen_float(200.0f, false)
             ),
             false,
             nullptr,
             false,
             /* ++i; */
-            (ast_expression*)ast_binstore_new(
+            new ast_binstore(
                 ctx(),
                 INSTR_STORE_F,
                 INSTR_ADD_F,
-                (ast_expression*)i,
-                (ast_expression*)m_fold->m_imm_float[1]
+                i,
+                m_fold->m_imm_float[1]
             ),
             /* sum += (acc *= (x / i)) */
-            (ast_expression*)ast_binstore_new(
+            new ast_binstore(
                 ctx(),
                 INSTR_STORE_F,
                 INSTR_ADD_F,
-                (ast_expression*)sum,
-                (ast_expression*)ast_binstore_new(
+                sum,
+                new ast_binstore(
                     ctx(),
                     INSTR_STORE_F,
                     INSTR_MUL_F,
-                    (ast_expression*)acc,
-                    (ast_expression*)ast_binary_new(
+                    acc,
+                    new ast_binary(
                         ctx(),
                         INSTR_DIV_F,
-                        (ast_expression*)x,
-                        (ast_expression*)i
+                        x,
+                        i
                     )
                 )
             )
@@ -497,16 +495,16 @@ ast_expression *intrin::exp_() {
     );
 
     /* return sum; */
-    body->exprs.push_back(
-        (ast_expression*)ast_return_new(
+    body->m_exprs.push_back(
+        new ast_return(
             ctx(),
-            (ast_expression*)sum
+            sum
         )
     );
 
-    func->blocks.push_back(body);
+    func->m_blocks.emplace_back(body);
     reg(val, func);
-    return (ast_expression*)val;
+    return val;
 }
 
 ast_expression *intrin::exp2_() {
@@ -516,27 +514,27 @@ ast_expression *intrin::exp2_() {
      * }
      */
     ast_value *val = nullptr;
-    ast_call  *callpow = ast_call_new(ctx(), func_self("pow", "exp2"));
-    ast_value *arg1 = ast_value_new(ctx(), "x", TYPE_FLOAT);
-    ast_block *body = ast_block_new(ctx());
+    ast_call  *callpow = ast_call::make(ctx(), func_self("pow", "exp2"));
+    ast_value *arg1 = new ast_value(ctx(), "x", TYPE_FLOAT);
+    ast_block *body = new ast_block(ctx());
     ast_function *func = value(&val, "exp2", TYPE_FLOAT);
 
-    val->type_params.push_back(arg1);
+    val->m_type_params.emplace_back(arg1);
 
-    callpow->params.push_back((ast_expression*)m_fold->m_imm_float[3]);
-    callpow->params.push_back((ast_expression*)arg1);
+    callpow->m_params.push_back(m_fold->m_imm_float[3]);
+    callpow->m_params.push_back(arg1);
 
     /* return <callpow> */
-    body->exprs.push_back(
-        (ast_expression*)ast_return_new(
+    body->m_exprs.push_back(
+        new ast_return(
             ctx(),
-            (ast_expression*)callpow
+            callpow
         )
     );
 
-    func->blocks.push_back(body);
+    func->m_blocks.emplace_back(body);
     reg(val, func);
-    return (ast_expression*)val;
+    return val;
 }
 
 ast_expression *intrin::expm1_() {
@@ -546,35 +544,37 @@ ast_expression *intrin::expm1_() {
      * }
      */
     ast_value *val = nullptr;
-    ast_call *callexp = ast_call_new(ctx(), func_self("exp", "expm1"));
-    ast_value *x = ast_value_new(ctx(), "x", TYPE_FLOAT);
-    ast_block *body = ast_block_new(ctx());
+    ast_call *callexp = ast_call::make(ctx(), func_self("exp", "expm1"));
+    ast_value *x = new ast_value(ctx(), "x", TYPE_FLOAT);
+    ast_block *body = new ast_block(ctx());
     ast_function *func = value(&val, "expm1", TYPE_FLOAT);
 
-    val->type_params.push_back(x);
+    val->m_type_params.emplace_back(x);
 
     /* <callexp> = exp(x); */
-    callexp->params.push_back((ast_expression*)x);
+    callexp->m_params.push_back(x);
 
     /* return <callexp> - 1; */
-    body->exprs.push_back(
-        (ast_expression*)ast_return_new(
+    body->m_exprs.push_back(
+        new ast_return(
             ctx(),
-            (ast_expression*)ast_binary_new(
+            new ast_binary(
                 ctx(),
                 INSTR_SUB_F,
-                (ast_expression*)callexp,
-                (ast_expression*)m_fold->m_imm_float[1]
+                callexp,
+                m_fold->m_imm_float[1]
             )
         )
     );
 
-    func->blocks.push_back(body);
+    func->m_blocks.emplace_back(body);
     reg(val, func);
-    return (ast_expression*)val;
+    return val;
 }
 
 ast_expression *intrin::pow_() {
+               #define QC_POW_EPSILON 0.00001f
+
     /*
      *
      * float pow(float base, float exp) {
@@ -620,23 +620,23 @@ ast_expression *intrin::pow_() {
     ast_function *func = value(&val, "pow", TYPE_FLOAT);
 
     /* prepare some calls for later */
-    ast_call *callpow1  = ast_call_new(ctx(), (ast_expression*)val);                  /* for pow(base, -exp)    */
-    ast_call *callpow2  = ast_call_new(ctx(), (ast_expression*)val);                  /* for pow(vase, exp / 2) */
-    ast_call *callsqrt1 = ast_call_new(ctx(), func_self("sqrt", "pow")); /* for sqrt(base)         */
-    ast_call *callsqrt2 = ast_call_new(ctx(), func_self("sqrt", "pow")); /* for sqrt(square)       */
-    ast_call *callfabs  = ast_call_new(ctx(), func_self("fabs", "pow")); /* for fabs(mid - exp)    */
+    ast_call *callpow1  = ast_call::make(ctx(), val);                  /* for pow(base, -exp)    */
+    ast_call *callpow2  = ast_call::make(ctx(), val);                  /* for pow(vase, exp / 2) */
+    ast_call *callsqrt1 = ast_call::make(ctx(), func_self("sqrt", "pow")); /* for sqrt(base)         */
+    ast_call *callsqrt2 = ast_call::make(ctx(), func_self("sqrt", "pow")); /* for sqrt(square)       */
+    ast_call *callfabs  = ast_call::make(ctx(), func_self("fabs", "pow")); /* for fabs(mid - exp)    */
 
     /* prepare some blocks for later */
-    ast_block *expgt1       = ast_block_new(ctx());
-    ast_block *midltexp     = ast_block_new(ctx());
-    ast_block *midltexpelse = ast_block_new(ctx());
-    ast_block *whileblock   = ast_block_new(ctx());
+    ast_block *expgt1       = new ast_block(ctx());
+    ast_block *midltexp     = new ast_block(ctx());
+    ast_block *midltexpelse = new ast_block(ctx());
+    ast_block *whileblock   = new ast_block(ctx());
 
     /* float pow(float base, float exp) */
-    ast_value    *base = ast_value_new(ctx(), "base", TYPE_FLOAT);
-    ast_value    *exp  = ast_value_new(ctx(), "exp",  TYPE_FLOAT);
+    ast_value    *base = new ast_value(ctx(), "base", TYPE_FLOAT);
+    ast_value    *exp  = new ast_value(ctx(), "exp",  TYPE_FLOAT);
     /* { */
-    ast_block    *body = ast_block_new(ctx());
+    ast_block    *body = new ast_block(ctx());
 
     /*
      * float result;
@@ -646,38 +646,38 @@ ast_expression *intrin::pow_() {
      * float accumulate;
      * float mid;
      */
-    ast_value *result     = ast_value_new(ctx(), "result",     TYPE_FLOAT);
-    ast_value *low        = ast_value_new(ctx(), "low",        TYPE_FLOAT);
-    ast_value *high       = ast_value_new(ctx(), "high",       TYPE_FLOAT);
-    ast_value *square     = ast_value_new(ctx(), "square",     TYPE_FLOAT);
-    ast_value *accumulate = ast_value_new(ctx(), "accumulate", TYPE_FLOAT);
-    ast_value *mid        = ast_value_new(ctx(), "mid",        TYPE_FLOAT);
-    body->locals.push_back(result);
-    body->locals.push_back(low);
-    body->locals.push_back(high);
-    body->locals.push_back(square);
-    body->locals.push_back(accumulate);
-    body->locals.push_back(mid);
-
-    val->type_params.push_back(base);
-    val->type_params.push_back(exp);
+    ast_value *result     = new ast_value(ctx(), "result",     TYPE_FLOAT);
+    ast_value *low        = new ast_value(ctx(), "low",        TYPE_FLOAT);
+    ast_value *high       = new ast_value(ctx(), "high",       TYPE_FLOAT);
+    ast_value *square     = new ast_value(ctx(), "square",     TYPE_FLOAT);
+    ast_value *accumulate = new ast_value(ctx(), "accumulate", TYPE_FLOAT);
+    ast_value *mid        = new ast_value(ctx(), "mid",        TYPE_FLOAT);
+    body->m_locals.push_back(result);
+    body->m_locals.push_back(low);
+    body->m_locals.push_back(high);
+    body->m_locals.push_back(square);
+    body->m_locals.push_back(accumulate);
+    body->m_locals.push_back(mid);
+
+    val->m_type_params.emplace_back(base);
+    val->m_type_params.emplace_back(exp);
 
     /*
      * if (exp == 0.0)
      *     return 1;
      */
-    body->exprs.push_back(
-        (ast_expression*)ast_ifthen_new(
+    body->m_exprs.push_back(
+        new ast_ifthen(
             ctx(),
-            (ast_expression*)ast_binary_new(
+            new ast_binary(
                 ctx(),
                 INSTR_EQ_F,
-                (ast_expression*)exp,
-                (ast_expression*)m_fold->m_imm_float[0]
+                exp,
+                m_fold->m_imm_float[0]
             ),
-            (ast_expression*)ast_return_new(
+            new ast_return(
                 ctx(),
-                (ast_expression*)m_fold->m_imm_float[1]
+                m_fold->m_imm_float[1]
             ),
             nullptr
         )
@@ -687,30 +687,30 @@ ast_expression *intrin::pow_() {
      * if (exp == 1.0)
      *     return base;
      */
-    body->exprs.push_back(
-        (ast_expression*)ast_ifthen_new(
+    body->m_exprs.push_back(
+        new ast_ifthen(
             ctx(),
-            (ast_expression*)ast_binary_new(
+            new ast_binary(
                 ctx(),
                 INSTR_EQ_F,
-                (ast_expression*)exp,
-                (ast_expression*)m_fold->m_imm_float[1]
+                exp,
+                m_fold->m_imm_float[1]
             ),
-            (ast_expression*)ast_return_new(
+            new ast_return(
                 ctx(),
-                (ast_expression*)base
+                base
             ),
             nullptr
         )
     );
 
     /* <callpow1> = pow(base, -exp) */
-    callpow1->params.push_back((ast_expression*)base);
-    callpow1->params.push_back(
-        (ast_expression*)ast_unary_new(
+    callpow1->m_params.push_back(base);
+    callpow1->m_params.push_back(
+        ast_unary::make(
             ctx(),
             VINSTR_NEG_F,
-            (ast_expression*)exp
+            exp
         )
     );
 
@@ -718,22 +718,22 @@ ast_expression *intrin::pow_() {
      * if (exp < 0)
      *     return 1.0 / <callpow1>;
      */
-    body->exprs.push_back(
-        (ast_expression*)ast_ifthen_new(
+    body->m_exprs.push_back(
+        new ast_ifthen(
             ctx(),
-            (ast_expression*)ast_binary_new(
+            new ast_binary(
                 ctx(),
                 INSTR_LT,
-                (ast_expression*)exp,
-                (ast_expression*)m_fold->m_imm_float[0]
+                exp,
+                m_fold->m_imm_float[0]
             ),
-            (ast_expression*)ast_return_new(
+            new ast_return(
                 ctx(),
-                (ast_expression*)ast_binary_new(
+                new ast_binary(
                     ctx(),
                     INSTR_DIV_F,
-                    (ast_expression*)m_fold->m_imm_float[1],
-                    (ast_expression*)callpow1
+                    m_fold->m_imm_float[1],
+                    callpow1
                 )
             ),
             nullptr
@@ -741,13 +741,13 @@ ast_expression *intrin::pow_() {
     );
 
     /* <callpow2> = pow(base, exp / 2) */
-    callpow2->params.push_back((ast_expression*)base);
-    callpow2->params.push_back(
-        (ast_expression*)ast_binary_new(
+    callpow2->m_params.push_back(base);
+    callpow2->m_params.push_back(
+        new ast_binary(
             ctx(),
             INSTR_DIV_F,
-            (ast_expression*)exp,
-            (ast_expression*)m_fold->m_imm_float[3] /* 2.0f */
+            exp,
+            m_fold->m_imm_float[3] /* 2.0f */
         )
     );
 
@@ -757,22 +757,22 @@ ast_expression *intrin::pow_() {
      *     return result * result;
      * }
      */
-    expgt1->exprs.push_back(
-        (ast_expression*)ast_store_new(
+    expgt1->m_exprs.push_back(
+        new ast_store(
             ctx(),
             INSTR_STORE_F,
-            (ast_expression*)result,
-            (ast_expression*)callpow2
+            result,
+            callpow2
         )
     );
-    expgt1->exprs.push_back(
-        (ast_expression*)ast_return_new(
+    expgt1->m_exprs.push_back(
+        new ast_return(
             ctx(),
-            (ast_expression*)ast_binary_new(
+            new ast_binary(
                 ctx(),
                 INSTR_MUL_F,
-                (ast_expression*)result,
-                (ast_expression*)result
+                result,
+                result
             )
         )
     );
@@ -782,16 +782,16 @@ ast_expression *intrin::pow_() {
      *     <expgt1>
      * }
      */
-    body->exprs.push_back(
-        (ast_expression*)ast_ifthen_new(
+    body->m_exprs.push_back(
+        new ast_ifthen(
             ctx(),
-            (ast_expression*)ast_binary_new(
+            new ast_binary(
                 ctx(),
                 INSTR_GE,
-                (ast_expression*)exp,
-                (ast_expression*)m_fold->m_imm_float[1]
+                exp,
+                m_fold->m_imm_float[1]
             ),
-            (ast_expression*)expgt1,
+            expgt1,
             nullptr
         )
     );
@@ -799,7 +799,7 @@ ast_expression *intrin::pow_() {
     /*
      * <callsqrt1> = sqrt(base)
      */
-    callsqrt1->params.push_back((ast_expression*)base);
+    callsqrt1->m_params.push_back(base);
 
     /*
      * low        = 0.0f;
@@ -808,49 +808,49 @@ ast_expression *intrin::pow_() {
      * accumulate = square;
      * mid        = high / 2.0f;
      */
-    body->exprs.push_back(
-        (ast_expression*)ast_store_new(ctx(),
+    body->m_exprs.push_back(
+        new ast_store(ctx(),
             INSTR_STORE_F,
-            (ast_expression*)low,
-            (ast_expression*)m_fold->m_imm_float[0]
+            low,
+            m_fold->m_imm_float[0]
         )
     );
-    body->exprs.push_back(
-        (ast_expression*)ast_store_new(
+    body->m_exprs.push_back(
+        new ast_store(
             ctx(),
             INSTR_STORE_F,
-            (ast_expression*)high,
-            (ast_expression*)m_fold->m_imm_float[1]
+            high,
+            m_fold->m_imm_float[1]
         )
     );
 
-    body->exprs.push_back(
-        (ast_expression*)ast_store_new(
+    body->m_exprs.push_back(
+        new ast_store(
             ctx(),
             INSTR_STORE_F,
-            (ast_expression*)square,
-            (ast_expression*)callsqrt1
+            square,
+            callsqrt1
         )
     );
 
-    body->exprs.push_back(
-        (ast_expression*)ast_store_new(
+    body->m_exprs.push_back(
+        new ast_store(
             ctx(),
             INSTR_STORE_F,
-            (ast_expression*)accumulate,
-            (ast_expression*)square
+            accumulate,
+            square
         )
     );
-    body->exprs.push_back(
-        (ast_expression*)ast_store_new(
+    body->m_exprs.push_back(
+        new ast_store(
             ctx(),
             INSTR_STORE_F,
-            (ast_expression*)mid,
-            (ast_expression*)ast_binary_new(
+            mid,
+            new ast_binary(
                 ctx(),
                 INSTR_DIV_F,
-                (ast_expression*)high,
-                (ast_expression*)m_fold->m_imm_float[3] /* 2.0f */
+                high,
+                m_fold->m_imm_float[3] /* 2.0f */
             )
         )
     );
@@ -861,21 +861,21 @@ ast_expression *intrin::pow_() {
      *     accumulate *= square;
      * }
      */
-    midltexp->exprs.push_back(
-        (ast_expression*)ast_store_new(
+    midltexp->m_exprs.push_back(
+        new ast_store(
             ctx(),
             INSTR_STORE_F,
-            (ast_expression*)low,
-            (ast_expression*)mid
+            low,
+            mid
         )
     );
-    midltexp->exprs.push_back(
-        (ast_expression*)ast_binstore_new(
+    midltexp->m_exprs.push_back(
+        new ast_binstore(
             ctx(),
             INSTR_STORE_F,
             INSTR_MUL_F,
-            (ast_expression*)accumulate,
-            (ast_expression*)square
+            accumulate,
+            square
         )
     );
 
@@ -885,25 +885,25 @@ ast_expression *intrin::pow_() {
      *     accumulate *= (1.0 / square);
      * }
      */
-    midltexpelse->exprs.push_back(
-        (ast_expression*)ast_store_new(
+    midltexpelse->m_exprs.push_back(
+        new ast_store(
             ctx(),
             INSTR_STORE_F,
-            (ast_expression*)high,
-            (ast_expression*)mid
+            high,
+            mid
         )
     );
-    midltexpelse->exprs.push_back(
-        (ast_expression*)ast_binstore_new(
+    midltexpelse->m_exprs.push_back(
+        new ast_binstore(
             ctx(),
             INSTR_STORE_F,
             INSTR_MUL_F,
-            (ast_expression*)accumulate,
-            (ast_expression*)ast_binary_new(
+            accumulate,
+            new ast_binary(
                 ctx(),
                 INSTR_DIV_F,
-                (ast_expression*)m_fold->m_imm_float[1],
-                (ast_expression*)square
+                m_fold->m_imm_float[1],
+                square
             )
         )
     );
@@ -911,7 +911,7 @@ ast_expression *intrin::pow_() {
     /*
      * <callsqrt2> = sqrt(square)
      */
-    callsqrt2->params.push_back((ast_expression*)square);
+    callsqrt2->m_params.push_back(square);
 
     /*
      * <whileblock> = {
@@ -924,42 +924,42 @@ ast_expression *intrin::pow_() {
      *     mid = (low + high) / 2;
      * }
      */
-    whileblock->exprs.push_back(
-        (ast_expression*)ast_store_new(
+    whileblock->m_exprs.push_back(
+        new ast_store(
             ctx(),
             INSTR_STORE_F,
-            (ast_expression*)square,
-            (ast_expression*)callsqrt2
+            square,
+            callsqrt2
         )
     );
-    whileblock->exprs.push_back(
-        (ast_expression*)ast_ifthen_new(
+    whileblock->m_exprs.push_back(
+        new ast_ifthen(
             ctx(),
-            (ast_expression*)ast_binary_new(
+            new ast_binary(
                 ctx(),
                 INSTR_LT,
-                (ast_expression*)mid,
-                (ast_expression*)exp
+                mid,
+                exp
             ),
-            (ast_expression*)midltexp,
-            (ast_expression*)midltexpelse
+            midltexp,
+            midltexpelse
         )
     );
-    whileblock->exprs.push_back(
-        (ast_expression*)ast_store_new(
+    whileblock->m_exprs.push_back(
+        new ast_store(
             ctx(),
             INSTR_STORE_F,
-            (ast_expression*)mid,
-            (ast_expression*)ast_binary_new(
+            mid,
+            new ast_binary(
                 ctx(),
                 INSTR_DIV_F,
-                (ast_expression*)ast_binary_new(
+                new ast_binary(
                     ctx(),
                     INSTR_ADD_F,
-                    (ast_expression*)low,
-                    (ast_expression*)high
+                    low,
+                    high
                 ),
-                (ast_expression*)m_fold->m_imm_float[3] /* 2.0f */
+                m_fold->m_imm_float[3] /* 2.0f */
             )
         )
     );
@@ -967,12 +967,12 @@ ast_expression *intrin::pow_() {
     /*
      * <callabs> = fabs(mid - exp)
      */
-    callfabs->params.push_back(
-        (ast_expression*)ast_binary_new(
+    callfabs->m_params.push_back(
+        new ast_binary(
             ctx(),
             INSTR_SUB_F,
-            (ast_expression*)mid,
-            (ast_expression*)exp
+            mid,
+            exp
         )
     );
 
@@ -980,17 +980,17 @@ ast_expression *intrin::pow_() {
      * while (<callfabs>  > epsilon)
      *     <whileblock>
      */
-    body->exprs.push_back(
-        (ast_expression*)ast_loop_new(
+    body->m_exprs.push_back(
+        new ast_loop(
             ctx(),
             /* init */
             nullptr,
             /* pre condition */
-            (ast_expression*)ast_binary_new(
+            new ast_binary(
                 ctx(),
                 INSTR_GT,
-                (ast_expression*)callfabs,
-                (ast_expression*)m_fold->constgen_float(QC_POW_EPSILON, false)
+                callfabs,
+                m_fold->constgen_float(QC_POW_EPSILON, false)
             ),
             /* pre not */
             false,
@@ -1001,22 +1001,22 @@ ast_expression *intrin::pow_() {
             /* increment expression */
             nullptr,
             /* code block */
-            (ast_expression*)whileblock
+            whileblock
         )
     );
 
     /* return accumulate */
-    body->exprs.push_back(
-        (ast_expression*)ast_return_new(
+    body->m_exprs.push_back(
+        new ast_return(
             ctx(),
-            (ast_expression*)accumulate
+            accumulate
         )
     );
 
     /* } */
-    func->blocks.push_back(body);
+    func->m_blocks.emplace_back(body);
     reg(val, func);
-    return (ast_expression*)val;
+    return val;
 }
 
 ast_expression *intrin::mod_() {
@@ -1028,91 +1028,91 @@ ast_expression *intrin::mod_() {
      * }
      */
     ast_value    *val = nullptr;
-    ast_call     *call  = ast_call_new(ctx(), func_self("floor", "mod"));
-    ast_value    *a     = ast_value_new(ctx(), "a",    TYPE_FLOAT);
-    ast_value    *b     = ast_value_new(ctx(), "b",    TYPE_FLOAT);
-    ast_value    *div   = ast_value_new(ctx(), "div",  TYPE_FLOAT);
-    ast_value    *sign  = ast_value_new(ctx(), "sign", TYPE_FLOAT);
-    ast_block    *body  = ast_block_new(ctx());
+    ast_call     *call  = ast_call::make(ctx(), func_self("floor", "mod"));
+    ast_value    *a     = new ast_value(ctx(), "a",    TYPE_FLOAT);
+    ast_value    *b     = new ast_value(ctx(), "b",    TYPE_FLOAT);
+    ast_value    *div   = new ast_value(ctx(), "div",  TYPE_FLOAT);
+    ast_value    *sign  = new ast_value(ctx(), "sign", TYPE_FLOAT);
+    ast_block    *body  = new ast_block(ctx());
     ast_function *func  = value(&val, "mod", TYPE_FLOAT);
 
-    val->type_params.push_back(a);
-    val->type_params.push_back(b);
+    val->m_type_params.emplace_back(a);
+    val->m_type_params.emplace_back(b);
 
-    body->locals.push_back(div);
-    body->locals.push_back(sign);
+    body->m_locals.push_back(div);
+    body->m_locals.push_back(sign);
 
     /* div = a / b; */
-    body->exprs.push_back(
-        (ast_expression*)ast_store_new(
+    body->m_exprs.push_back(
+        new ast_store(
             ctx(),
             INSTR_STORE_F,
-            (ast_expression*)div,
-            (ast_expression*)ast_binary_new(
+            div,
+            new ast_binary(
                 ctx(),
                 INSTR_DIV_F,
-                (ast_expression*)a,
-                (ast_expression*)b
+                a,
+                b
             )
         )
     );
 
     /* sign = (div < 0.0f) ? -1 : 1; */
-    body->exprs.push_back(
-        (ast_expression*)ast_store_new(
+    body->m_exprs.push_back(
+        new ast_store(
             ctx(),
             INSTR_STORE_F,
-            (ast_expression*)sign,
-            (ast_expression*)ast_ternary_new(
+            sign,
+            new ast_ternary(
                 ctx(),
-                (ast_expression*)ast_binary_new(
+                new ast_binary(
                     ctx(),
                     INSTR_LT,
-                    (ast_expression*)div,
-                    (ast_expression*)m_fold->m_imm_float[0]
+                    div,
+                    m_fold->m_imm_float[0]
                 ),
-                (ast_expression*)m_fold->m_imm_float[2],
-                (ast_expression*)m_fold->m_imm_float[1]
+                m_fold->m_imm_float[2],
+                m_fold->m_imm_float[1]
             )
         )
     );
 
     /* floor(sign * div) */
-    call->params.push_back(
-        (ast_expression*)ast_binary_new(
+    call->m_params.push_back(
+        new ast_binary(
             ctx(),
             INSTR_MUL_F,
-            (ast_expression*)sign,
-            (ast_expression*)div
+            sign,
+            div
         )
     );
 
     /* return a - b * sign * <call> */
-    body->exprs.push_back(
-        (ast_expression*)ast_return_new(
+    body->m_exprs.push_back(
+        new ast_return(
             ctx(),
-            (ast_expression*)ast_binary_new(
+            new ast_binary(
                 ctx(),
                 INSTR_SUB_F,
-                (ast_expression*)a,
-                (ast_expression*)ast_binary_new(
+                a,
+                new ast_binary(
                     ctx(),
                     INSTR_MUL_F,
-                    (ast_expression*)b,
-                    (ast_expression*)ast_binary_new(
+                    b,
+                    new ast_binary(
                         ctx(),
                         INSTR_MUL_F,
-                        (ast_expression*)sign,
-                        (ast_expression*)call
+                        sign,
+                        call
                     )
                 )
             )
         )
     );
 
-    func->blocks.push_back(body);
+    func->m_blocks.emplace_back(body);
     reg(val, func);
-    return (ast_expression*)val;
+    return val;
 }
 
 ast_expression *intrin::fabs_() {
@@ -1122,36 +1122,36 @@ ast_expression *intrin::fabs_() {
      * }
      */
     ast_value    *val  = nullptr;
-    ast_value    *arg1   = ast_value_new(ctx(), "x", TYPE_FLOAT);
-    ast_block    *body   = ast_block_new(ctx());
+    ast_value    *arg1   = new ast_value(ctx(), "x", TYPE_FLOAT);
+    ast_block    *body   = new ast_block(ctx());
     ast_function *func   = value(&val, "fabs", TYPE_FLOAT);
 
-    body->exprs.push_back(
-        (ast_expression*)ast_return_new(
+    body->m_exprs.push_back(
+        new ast_return(
             ctx(),
-            (ast_expression*)ast_ternary_new(
+            new ast_ternary(
                 ctx(),
-                (ast_expression*)ast_binary_new(
+                new ast_binary(
                     ctx(),
                     INSTR_LE,
-                    (ast_expression*)arg1,
-                    (ast_expression*)m_fold->m_imm_float[0]
+                    arg1,
+                    m_fold->m_imm_float[0]
                 ),
-                (ast_expression*)ast_unary_new(
+                ast_unary::make(
                     ctx(),
                     VINSTR_NEG_F,
-                    (ast_expression*)arg1
+                    arg1
                 ),
-                (ast_expression*)arg1
+                arg1
             )
         )
     );
 
-    val->type_params.push_back(arg1);
+    val->m_type_params.emplace_back(arg1);
 
-    func->blocks.push_back(body);
+    func->m_blocks.emplace_back(body);
     reg(val, func);
-    return (ast_expression*)val;
+    return val;
 }
 
 ast_expression *intrin::epsilon_() {
@@ -1163,67 +1163,67 @@ ast_expression *intrin::epsilon_() {
      * }
      */
     ast_value    *val  = nullptr;
-    ast_value    *eps    = ast_value_new(ctx(), "eps", TYPE_FLOAT);
-    ast_block    *body   = ast_block_new(ctx());
+    ast_value    *eps    = new ast_value(ctx(), "eps", TYPE_FLOAT);
+    ast_block    *body   = new ast_block(ctx());
     ast_function *func   = value(&val, "epsilon", TYPE_FLOAT);
 
-    body->locals.push_back(eps);
+    body->m_locals.push_back(eps);
 
     /* eps = 1.0f; */
-    body->exprs.push_back(
-        (ast_expression*)ast_store_new(
+    body->m_exprs.push_back(
+        new ast_store(
             ctx(),
             INSTR_STORE_F,
-            (ast_expression*)eps,
-            (ast_expression*)m_fold->m_imm_float[0]
+            eps,
+            m_fold->m_imm_float[0]
         )
     );
 
-    body->exprs.push_back(
-        (ast_expression*)ast_loop_new(
+    body->m_exprs.push_back(
+        new ast_loop(
             ctx(),
             nullptr,
             nullptr,
             false,
-            (ast_expression*)ast_binary_new(
+            new ast_binary(
                 ctx(),
                 INSTR_NE_F,
-                (ast_expression*)ast_binary_new(
+                new ast_binary(
                     ctx(),
                     INSTR_ADD_F,
-                    (ast_expression*)m_fold->m_imm_float[1],
-                    (ast_expression*)ast_binary_new(
+                    m_fold->m_imm_float[1],
+                    new ast_binary(
                         ctx(),
                         INSTR_MUL_F,
-                        (ast_expression*)eps,
-                        (ast_expression*)m_fold->m_imm_float[3] /* 2.0f */
+                        eps,
+                        m_fold->m_imm_float[3] /* 2.0f */
                     )
                 ),
-                (ast_expression*)m_fold->m_imm_float[1]
+                m_fold->m_imm_float[1]
             ),
             false,
             nullptr,
-            (ast_expression*)ast_binstore_new(
+            new ast_binstore(
                 ctx(),
                 INSTR_STORE_F,
                 INSTR_DIV_F,
-                (ast_expression*)eps,
-                (ast_expression*)m_fold->m_imm_float[3] /* 2.0f */
+                eps,
+                m_fold->m_imm_float[3] /* 2.0f */
             )
         )
     );
 
     /* return eps; */
-    body->exprs.push_back(
-        (ast_expression*)ast_return_new(
+    body->m_exprs.push_back(
+        new ast_return(
             ctx(),
-            (ast_expression*)eps
+            eps
         )
     );
 
-    func->blocks.push_back(body);
+    func->m_blocks.emplace_back(body);
     reg(val, func);
-    return (ast_expression*)val;
+    return val;
 }
 
 ast_expression *intrin::nan_() {
@@ -1234,36 +1234,36 @@ ast_expression *intrin::nan_() {
      * }
      */
     ast_value    *val  = nullptr;
-    ast_value    *x      = ast_value_new(ctx(), "x", TYPE_FLOAT);
+    ast_value    *x      = new ast_value(ctx(), "x", TYPE_FLOAT);
     ast_function *func   = value(&val, "nan", TYPE_FLOAT);
-    ast_block    *block  = ast_block_new(ctx());
+    ast_block    *block  = new ast_block(ctx());
 
-    block->locals.push_back(x);
+    block->m_locals.push_back(x);
 
-    block->exprs.push_back(
-        (ast_expression*)ast_store_new(
+    block->m_exprs.push_back(
+        new ast_store(
             ctx(),
             INSTR_STORE_F,
-            (ast_expression*)x,
-            (ast_expression*)m_fold->m_imm_float[0]
+            x,
+            m_fold->m_imm_float[0]
         )
     );
 
-    block->exprs.push_back(
-        (ast_expression*)ast_return_new(
+    block->m_exprs.push_back(
+        new ast_return(
             ctx(),
-            (ast_expression*)ast_binary_new(
+            new ast_binary(
                 ctx(),
                 INSTR_DIV_F,
-                (ast_expression*)x,
-                (ast_expression*)x
+                x,
+                x
             )
         )
     );
 
-    func->blocks.push_back(block);
+    func->m_blocks.emplace_back(block);
     reg(val, func);
-    return (ast_expression*)val;
+    return val;
 }
 
 ast_expression *intrin::inf_() {
@@ -1275,42 +1275,42 @@ ast_expression *intrin::inf_() {
      * }
      */
     ast_value    *val  = nullptr;
-    ast_value    *x      = ast_value_new(ctx(), "x", TYPE_FLOAT);
-    ast_value    *y      = ast_value_new(ctx(), "y", TYPE_FLOAT);
+    ast_value    *x      = new ast_value(ctx(), "x", TYPE_FLOAT);
+    ast_value    *y      = new ast_value(ctx(), "y", TYPE_FLOAT);
     ast_function *func   = value(&val, "inf", TYPE_FLOAT);
-    ast_block    *block  = ast_block_new(ctx());
+    ast_block    *block  = new ast_block(ctx());
     size_t        i;
 
-    block->locals.push_back(x);
-    block->locals.push_back(y);
+    block->m_locals.push_back(x);
+    block->m_locals.push_back(y);
 
     /* to keep code size down */
     for (i = 0; i <= 1; i++) {
-        block->exprs.push_back(
-            (ast_expression*)ast_store_new(
+        block->m_exprs.push_back(
+            new ast_store(
                 ctx(),
                 INSTR_STORE_F,
-                (ast_expression*)((i == 0) ? x : y),
-                (ast_expression*)m_fold->m_imm_float[i]
+                ((i == 0) ? x : y),
+                m_fold->m_imm_float[i]
             )
         );
     }
 
-    block->exprs.push_back(
-        (ast_expression*)ast_return_new(
+    block->m_exprs.push_back(
+        new ast_return(
             ctx(),
-            (ast_expression*)ast_binary_new(
+            new ast_binary(
                 ctx(),
                 INSTR_DIV_F,
-                (ast_expression*)x,
-                (ast_expression*)y
+                x,
+                y
             )
         )
     );
 
-    func->blocks.push_back(block);
+    func->m_blocks.emplace_back(block);
     reg(val, func);
-    return (ast_expression*)val;
+    return val;
 }
 
 ast_expression *intrin::ln_() {
@@ -1380,61 +1380,61 @@ ast_expression *intrin::ln_() {
      */
 
     ast_value *val = nullptr;
-    ast_value *power = ast_value_new(ctx(), "power", TYPE_FLOAT);
-    ast_value *base = ast_value_new(ctx(), "base",TYPE_FLOAT);
-    ast_value *whole= ast_value_new(ctx(), "whole", TYPE_FLOAT);
-    ast_value *nth = ast_value_new(ctx(), "nth", TYPE_FLOAT);
-    ast_value *sign = ast_value_new(ctx(), "sign", TYPE_FLOAT);
-    ast_value *A_i = ast_value_new(ctx(), "A_i", TYPE_FLOAT);
-    ast_value *B_i = ast_value_new(ctx(), "B_i", TYPE_FLOAT);
-    ast_value *A_iminus1 = ast_value_new(ctx(), "A_iminus1", TYPE_FLOAT);
-    ast_value *B_iminus1 = ast_value_new(ctx(), "B_iminus1", TYPE_FLOAT);
-    ast_value *b_iplus1 = ast_value_new(ctx(), "b_iplus1", TYPE_FLOAT);
-    ast_value *A_iplus1 = ast_value_new(ctx(), "A_iplus1", TYPE_FLOAT);
-    ast_value *B_iplus1 = ast_value_new(ctx(), "B_iplus1", TYPE_FLOAT);
-    ast_value *eps = ast_value_new(ctx(), "eps", TYPE_FLOAT);
-    ast_value *base2 = ast_value_new(ctx(), "base2", TYPE_FLOAT);
-    ast_value *n2 = ast_value_new(ctx(), "n2",TYPE_FLOAT);
-    ast_value *newbase2 = ast_value_new(ctx(), "newbase2", TYPE_FLOAT);
-    ast_block *block = ast_block_new(ctx());
-    ast_block *plt1orblt1 = ast_block_new(ctx()); // (power <= 1.0f || base <= 1.0f)
-    ast_block *plt1 = ast_block_new(ctx()); // (power < 1.0f)
-    ast_block *blt1 = ast_block_new(ctx()); // (base< 1.0f)
-    ast_block *forloop = ast_block_new(ctx()); // for(;;)
-    ast_block *whileloop = ast_block_new(ctx()); // while (whole >= base)
-    ast_block *nestwhile= ast_block_new(ctx()); // while (whole >= newbase2)
+    ast_value *power = new ast_value(ctx(), "power", TYPE_FLOAT);
+    ast_value *base = new ast_value(ctx(), "base",TYPE_FLOAT);
+    ast_value *whole= new ast_value(ctx(), "whole", TYPE_FLOAT);
+    ast_value *nth = new ast_value(ctx(), "nth", TYPE_FLOAT);
+    ast_value *sign = new ast_value(ctx(), "sign", TYPE_FLOAT);
+    ast_value *A_i = new ast_value(ctx(), "A_i", TYPE_FLOAT);
+    ast_value *B_i = new ast_value(ctx(), "B_i", TYPE_FLOAT);
+    ast_value *A_iminus1 = new ast_value(ctx(), "A_iminus1", TYPE_FLOAT);
+    ast_value *B_iminus1 = new ast_value(ctx(), "B_iminus1", TYPE_FLOAT);
+    ast_value *b_iplus1 = new ast_value(ctx(), "b_iplus1", TYPE_FLOAT);
+    ast_value *A_iplus1 = new ast_value(ctx(), "A_iplus1", TYPE_FLOAT);
+    ast_value *B_iplus1 = new ast_value(ctx(), "B_iplus1", TYPE_FLOAT);
+    ast_value *eps = new ast_value(ctx(), "eps", TYPE_FLOAT);
+    ast_value *base2 = new ast_value(ctx(), "base2", TYPE_FLOAT);
+    ast_value *n2 = new ast_value(ctx(), "n2",TYPE_FLOAT);
+    ast_value *newbase2 = new ast_value(ctx(), "newbase2", TYPE_FLOAT);
+    ast_block *block = new ast_block(ctx());
+    ast_block *plt1orblt1 = new ast_block(ctx()); // (power <= 1.0f || base <= 1.0f)
+    ast_block *plt1 = new ast_block(ctx()); // (power < 1.0f)
+    ast_block *blt1 = new ast_block(ctx()); // (base< 1.0f)
+    ast_block *forloop = new ast_block(ctx()); // for(;;)
+    ast_block *whileloop = new ast_block(ctx()); // while (whole >= base)
+    ast_block *nestwhile= new ast_block(ctx()); // while (whole >= newbase2)
     ast_function *func = value(&val, "ln", TYPE_FLOAT);
     size_t i;
 
-    val->type_params.push_back(power);
-    val->type_params.push_back(base);
+    val->m_type_params.emplace_back(power);
+    val->m_type_params.emplace_back(base);
 
-    block->locals.push_back(whole);
-    block->locals.push_back(nth);
-    block->locals.push_back(sign);
-    block->locals.push_back(eps);
-    block->locals.push_back(A_i);
-    block->locals.push_back(B_i);
-    block->locals.push_back(A_iminus1);
-    block->locals.push_back(B_iminus1);
+    block->m_locals.push_back(whole);
+    block->m_locals.push_back(nth);
+    block->m_locals.push_back(sign);
+    block->m_locals.push_back(eps);
+    block->m_locals.push_back(A_i);
+    block->m_locals.push_back(B_i);
+    block->m_locals.push_back(A_iminus1);
+    block->m_locals.push_back(B_iminus1);
 
     /* sign = 1.0f; */
-    block->exprs.push_back(
-        (ast_expression*)ast_store_new(
+    block->m_exprs.push_back(
+        new ast_store(
             ctx(),
             INSTR_STORE_F,
-            (ast_expression*)sign,
-            (ast_expression*)m_fold->m_imm_float[1]
+            sign,
+            m_fold->m_imm_float[1]
         )
     );
 
     /* eps = __builtin_epsilon(); */
-    block->exprs.push_back(
-        (ast_expression*)ast_store_new(
+    block->m_exprs.push_back(
+        new ast_store(
             ctx(),
             INSTR_STORE_F,
-            (ast_expression*)eps,
-            (ast_expression*)ast_call_new(
+            eps,
+            ast_call::make(
                 ctx(),
                 func_self("__builtin_epsilon", "ln")
             )
@@ -1450,13 +1450,13 @@ ast_expression *intrin::ln_() {
     for (i = 0; i <= 1; i++) {
         int j;
         for (j = 1; j >= 0; j--) {
-            block->exprs.push_back(
-                (ast_expression*)ast_store_new(
+            block->m_exprs.push_back(
+                new ast_store(
                     ctx(),
                     INSTR_STORE_F,
-                    (ast_expression*)((j) ? ((i) ? B_iminus1 : A_i)
+                    ((j) ? ((i) ? B_iminus1 : A_i)
                                           : ((i) ? A_iminus1 : B_i)),
-                    (ast_expression*)m_fold->m_imm_float[j]
+                    m_fold->m_imm_float[j]
                 )
             );
         }
@@ -1473,26 +1473,26 @@ ast_expression *intrin::ln_() {
      * }
      */
     for (i = 0; i <= 1; i++) {
-        ((i) ? blt1 : plt1)->exprs.push_back(
-            (ast_expression*)ast_store_new(
+        ((i) ? blt1 : plt1)->m_exprs.push_back(
+            new ast_store(
                 ctx(),
                 INSTR_STORE_F,
-                (ast_expression*)((i) ? base : power),
-                (ast_expression*)ast_binary_new(
+                ((i) ? base : power),
+                new ast_binary(
                     ctx(),
                     INSTR_DIV_F,
-                    (ast_expression*)m_fold->m_imm_float[1],
-                    (ast_expression*)((i) ? base : power)
+                    m_fold->m_imm_float[1],
+                    ((i) ? base : power)
                 )
             )
         );
-        plt1->exprs.push_back(
-            (ast_expression*)ast_binstore_new(
+        plt1->m_exprs.push_back(
+            new ast_binstore(
                 ctx(),
                 INSTR_STORE_F,
                 INSTR_MUL_F,
-                (ast_expression*)sign,
-                (ast_expression*)m_fold->m_imm_float[2]
+                sign,
+                m_fold->m_imm_float[2]
             )
         );
     }
@@ -1507,28 +1507,28 @@ ast_expression *intrin::ln_() {
      *         <blt1>
      * }
      */
-    plt1orblt1->exprs.push_back(
-        (ast_expression*)ast_ifthen_new(
+    plt1orblt1->m_exprs.push_back(
+        new ast_ifthen(
             ctx(),
-            (ast_expression*)ast_binary_new(
+            new ast_binary(
                 ctx(),
                 INSTR_OR,
-                (ast_expression*)ast_binary_new(
+                new ast_binary(
                     ctx(),
                     INSTR_LE,
-                    (ast_expression*)power,
-                    (ast_expression*)m_fold->m_imm_float[0]
+                    power,
+                    m_fold->m_imm_float[0]
                 ),
-                (ast_expression*)ast_binary_new(
+                new ast_binary(
                     ctx(),
                     INSTR_LE,
-                    (ast_expression*)base,
-                    (ast_expression*)m_fold->m_imm_float[0]
+                    base,
+                    m_fold->m_imm_float[0]
                 )
             ),
-            (ast_expression*)ast_return_new(
+            new ast_return(
                 ctx(),
-                (ast_expression*)ast_call_new(
+                ast_call::make(
                     ctx(),
                     func_self("__builtin_nan", "ln")
                 )
@@ -1538,187 +1538,187 @@ ast_expression *intrin::ln_() {
     );
 
     for (i = 0; i <= 1; i++) {
-        plt1orblt1->exprs.push_back(
-            (ast_expression*)ast_ifthen_new(
+        plt1orblt1->m_exprs.push_back(
+            new ast_ifthen(
                 ctx(),
-                (ast_expression*)ast_binary_new(
+                new ast_binary(
                     ctx(),
                     INSTR_LT,
-                    (ast_expression*)((i) ? base : power),
-                    (ast_expression*)m_fold->m_imm_float[1]
+                    ((i) ? base : power),
+                    m_fold->m_imm_float[1]
                 ),
-                (ast_expression*)((i) ? blt1 : plt1),
+                ((i) ? blt1 : plt1),
                 nullptr
             )
         );
     }
 
-    block->exprs.push_back((ast_expression*)plt1orblt1);
+    block->m_exprs.push_back(plt1orblt1);
 
 
     /* whole = power; */
-    forloop->exprs.push_back(
-        (ast_expression*)ast_store_new(
+    forloop->m_exprs.push_back(
+        new ast_store(
             ctx(),
             INSTR_STORE_F,
-            (ast_expression*)whole,
-            (ast_expression*)power
+            whole,
+            power
         )
     );
 
     /* nth = 0.0f; */
-    forloop->exprs.push_back(
-        (ast_expression*)ast_store_new(
+    forloop->m_exprs.push_back(
+        new ast_store(
             ctx(),
             INSTR_STORE_F,
-            (ast_expression*)nth,
-            (ast_expression*)m_fold->m_imm_float[0]
+            nth,
+            m_fold->m_imm_float[0]
         )
     );
 
     /* base2 = base; */
-    whileloop->exprs.push_back(
-        (ast_expression*)ast_store_new(
+    whileloop->m_exprs.push_back(
+        new ast_store(
             ctx(),
             INSTR_STORE_F,
-            (ast_expression*)base2,
-            (ast_expression*)base
+            base2,
+            base
         )
     );
 
     /* n2 = 1.0f; */
-    whileloop->exprs.push_back(
-        (ast_expression*)ast_store_new(
+    whileloop->m_exprs.push_back(
+        new ast_store(
             ctx(),
             INSTR_STORE_F,
-            (ast_expression*)n2,
-            (ast_expression*)m_fold->m_imm_float[1]
+            n2,
+            m_fold->m_imm_float[1]
         )
     );
 
     /* newbase2 = base2 * base2; */
-    whileloop->exprs.push_back(
-        (ast_expression*)ast_store_new(
+    whileloop->m_exprs.push_back(
+        new ast_store(
             ctx(),
             INSTR_STORE_F,
-            (ast_expression*)newbase2,
-            (ast_expression*)ast_binary_new(
+            newbase2,
+            new ast_binary(
                 ctx(),
                 INSTR_MUL_F,
-                (ast_expression*)base2,
-                (ast_expression*)base2
+                base2,
+                base2
             )
         )
     );
 
     /* while loop locals */
-    whileloop->locals.push_back(base2);
-    whileloop->locals.push_back(n2);
-    whileloop->locals.push_back(newbase2);
+    whileloop->m_locals.push_back(base2);
+    whileloop->m_locals.push_back(n2);
+    whileloop->m_locals.push_back(newbase2);
 
     /* base2 = newbase2; */
-    nestwhile->exprs.push_back(
-        (ast_expression*)ast_store_new(
+    nestwhile->m_exprs.push_back(
+        new ast_store(
             ctx(),
             INSTR_STORE_F,
-            (ast_expression*)base2,
-            (ast_expression*)newbase2
+            base2,
+            newbase2
         )
     );
 
     /* n2 *= 2; */
-    nestwhile->exprs.push_back(
-        (ast_expression*)ast_binstore_new(
+    nestwhile->m_exprs.push_back(
+        new ast_binstore(
             ctx(),
             INSTR_STORE_F,
             INSTR_MUL_F,
-            (ast_expression*)n2,
-            (ast_expression*)m_fold->m_imm_float[3] /* 2.0f */
+            n2,
+            m_fold->m_imm_float[3] /* 2.0f */
         )
     );
 
     /* newbase2 *= newbase2; */
-    nestwhile->exprs.push_back(
-        (ast_expression*)ast_binstore_new(
+    nestwhile->m_exprs.push_back(
+        new ast_binstore(
             ctx(),
             INSTR_STORE_F,
             INSTR_MUL_F,
-            (ast_expression*)newbase2,
-            (ast_expression*)newbase2
+            newbase2,
+            newbase2
         )
     );
 
     /* while (whole >= newbase2) */
-    whileloop->exprs.push_back(
-        (ast_expression*)ast_loop_new(
+    whileloop->m_exprs.push_back(
+        new ast_loop(
             ctx(),
             nullptr,
-            (ast_expression*)ast_binary_new(
+            new ast_binary(
                 ctx(),
                 INSTR_GE,
-                (ast_expression*)whole,
-                (ast_expression*)newbase2
+                whole,
+                newbase2
             ),
             false,
             nullptr,
             false,
             nullptr,
-            (ast_expression*)nestwhile
+            nestwhile
         )
     );
 
     /* whole /= base2; */
-    whileloop->exprs.push_back(
-        (ast_expression*)ast_binstore_new(
+    whileloop->m_exprs.push_back(
+        new ast_binstore(
             ctx(),
             INSTR_STORE_F,
             INSTR_DIV_F,
-            (ast_expression*)whole,
-            (ast_expression*)base2
+            whole,
+            base2
         )
     );
 
     /* nth += n2; */
-    whileloop->exprs.push_back(
-        (ast_expression*)ast_binstore_new(
+    whileloop->m_exprs.push_back(
+        new ast_binstore(
             ctx(),
             INSTR_STORE_F,
             INSTR_ADD_F,
-            (ast_expression*)nth,
-            (ast_expression*)n2
+            nth,
+            n2
         )
     );
 
     /* while (whole >= base) */
-    forloop->exprs.push_back(
-        (ast_expression*)ast_loop_new(
+    forloop->m_exprs.push_back(
+        new ast_loop(
             ctx(),
             nullptr,
-            (ast_expression*)ast_binary_new(
+            new ast_binary(
                 ctx(),
                 INSTR_GE,
-                (ast_expression*)whole,
-                (ast_expression*)base
+                whole,
+                base
             ),
             false,
             nullptr,
             false,
             nullptr,
-            (ast_expression*)whileloop
+            whileloop
         )
     );
 
-    forloop->locals.push_back(b_iplus1);
-    forloop->locals.push_back(A_iplus1);
-    forloop->locals.push_back(B_iplus1);
+    forloop->m_locals.push_back(b_iplus1);
+    forloop->m_locals.push_back(A_iplus1);
+    forloop->m_locals.push_back(B_iplus1);
 
     /* b_iplus1 = nth; */
-    forloop->exprs.push_back(
-        (ast_expression*)ast_store_new(
+    forloop->m_exprs.push_back(
+        new ast_store(
             ctx(),
             INSTR_STORE_F,
-            (ast_expression*)b_iplus1,
-            (ast_expression*)nth
+            b_iplus1,
+            nth
         )
     );
 
@@ -1727,21 +1727,21 @@ ast_expression *intrin::ln_() {
      * B_iplus1 = b_iplus1 * B_i + B_iminus1;
      */
     for (i = 0; i <= 1; i++) {
-        forloop->exprs.push_back(
-            (ast_expression*)ast_store_new(
+        forloop->m_exprs.push_back(
+            new ast_store(
                 ctx(),
                 INSTR_STORE_F,
-                (ast_expression*)((i) ? B_iplus1 : A_iplus1),
-                (ast_expression*)ast_binary_new(
+                ((i) ? B_iplus1 : A_iplus1),
+                new ast_binary(
                     ctx(),
                     INSTR_ADD_F,
-                    (ast_expression*)ast_binary_new(
+                    new ast_binary(
                         ctx(),
                         INSTR_MUL_F,
-                        (ast_expression*)b_iplus1,
-                        (ast_expression*) ((i) ? B_i : A_i)
+                        b_iplus1,
+                         ((i) ? B_i : A_i)
                     ),
-                    (ast_expression*)((i) ? B_iminus1 : A_iminus1)
+                    ((i) ? B_iminus1 : A_iminus1)
                 )
             )
         );
@@ -1752,12 +1752,12 @@ ast_expression *intrin::ln_() {
      * B_iminus1 = B_i;
      */
     for (i = 0; i <= 1; i++) {
-        forloop->exprs.push_back(
-            (ast_expression*)ast_store_new(
+        forloop->m_exprs.push_back(
+            new ast_store(
                 ctx(),
                 INSTR_STORE_F,
-                (ast_expression*)((i) ? B_iminus1 : A_iminus1),
-                (ast_expression*)((i) ? B_i       : A_i)
+                ((i) ? B_iminus1 : A_iminus1),
+                ((i) ? B_i       : A_i)
             )
         );
     }
@@ -1767,12 +1767,12 @@ ast_expression *intrin::ln_() {
      * B_i = B_iplus1;
      */
     for (i = 0; i <= 1; i++) {
-        forloop->exprs.push_back(
-            (ast_expression*)ast_store_new(
+        forloop->m_exprs.push_back(
+            new ast_store(
                 ctx(),
                 INSTR_STORE_F,
-                (ast_expression*)((i) ? B_i      : A_i),
-                (ast_expression*)((i) ? B_iplus1 : A_iplus1)
+                ((i) ? B_i      : A_i),
+                ((i) ? B_iplus1 : A_iplus1)
             )
         );
     }
@@ -1781,21 +1781,21 @@ ast_expression *intrin::ln_() {
      * if (whole <= 1.0f + eps)
      *     break;
      */
-    forloop->exprs.push_back(
-        (ast_expression*)ast_ifthen_new(
+    forloop->m_exprs.push_back(
+        new ast_ifthen(
             ctx(),
-            (ast_expression*)ast_binary_new(
+            new ast_binary(
                 ctx(),
                 INSTR_LE,
-                (ast_expression*)whole,
-                (ast_expression*)ast_binary_new(
+                whole,
+                new ast_binary(
                     ctx(),
                     INSTR_ADD_F,
-                    (ast_expression*)m_fold->m_imm_float[1],
-                    (ast_expression*)eps
+                    m_fold->m_imm_float[1],
+                    eps
                 )
             ),
-            (ast_expression*)ast_breakcont_new(
+            new ast_breakcont(
                 ctx(),
                 false,
                 0
@@ -1809,76 +1809,76 @@ ast_expression *intrin::ln_() {
      * base  = whole;
      */
     for (i = 0; i <= 1; i++) {
-        forloop->exprs.push_back(
-            (ast_expression*)ast_store_new(
+        forloop->m_exprs.push_back(
+            new ast_store(
                 ctx(),
                 INSTR_STORE_F,
-                (ast_expression*)((i) ? base  : power),
-                (ast_expression*)((i) ? whole : base)
+                ((i) ? base  : power),
+                ((i) ? whole : base)
             )
         );
     }
 
     /* add the for loop block */
-    block->exprs.push_back(
-        (ast_expression*)ast_loop_new(
+    block->m_exprs.push_back(
+        new ast_loop(
             ctx(),
             nullptr,
             /* for(; 1; ) ?? (can this be nullptr too?) */
-            (ast_expression*)m_fold->m_imm_float[1],
+            m_fold->m_imm_float[1],
             false,
             nullptr,
             false,
             nullptr,
-            (ast_expression*)forloop
+            forloop
         )
     );
 
     /* return sign * A_i / B_il */
-    block->exprs.push_back(
-        (ast_expression*)ast_return_new(
+    block->m_exprs.push_back(
+        new ast_return(
             ctx(),
-            (ast_expression*)ast_binary_new(
+            new ast_binary(
                 ctx(),
                 INSTR_MUL_F,
-                (ast_expression*)sign,
-                (ast_expression*)ast_binary_new(
+                sign,
+                new ast_binary(
                     ctx(),
                     INSTR_DIV_F,
-                    (ast_expression*)A_i,
-                    (ast_expression*)B_i
+                    A_i,
+                    B_i
                 )
             )
         )
     );
 
-    func->blocks.push_back(block);
+    func->m_blocks.emplace_back(block);
     reg(val, func);
-    return (ast_expression*)val;
+    return val;
 }
 
 ast_expression *intrin::log_variant(const char *name, float base) {
     ast_value *val = nullptr;
-    ast_call *callln = ast_call_new (ctx(), func_self("__builtin_ln", name));
-    ast_value *arg1 = ast_value_new(ctx(), "x", TYPE_FLOAT);
-    ast_block *body = ast_block_new(ctx());
+    ast_call *callln = ast_call::make(ctx(), func_self("__builtin_ln", name));
+    ast_value *arg1 = new ast_value(ctx(), "x", TYPE_FLOAT);
+    ast_block *body = new ast_block(ctx());
     ast_function *func = value(&val, name, TYPE_FLOAT);
 
-    val->type_params.push_back(arg1);
+    val->m_type_params.emplace_back(arg1);
 
-    callln->params.push_back((ast_expression*)arg1);
-    callln->params.push_back((ast_expression*)m_fold->constgen_float(base, false));
+    callln->m_params.push_back(arg1);
+    callln->m_params.push_back(m_fold->constgen_float(base, false));
 
-    body->exprs.push_back(
-        (ast_expression*)ast_return_new(
+    body->m_exprs.push_back(
+        new ast_return(
             ctx(),
-            (ast_expression*)callln
+            callln
         )
     );
 
-    func->blocks.push_back(body);
+    func->m_blocks.emplace_back(body);
     reg(val, func);
-    return (ast_expression*)val;
+    return val;
 }
 
 ast_expression *intrin::log_() {
@@ -1901,41 +1901,41 @@ ast_expression *intrin::shift_variant(const char *name, size_t instr) {
      *   return floor(a [instr] pow(2, b));
      */
     ast_value *val = nullptr;
-    ast_call *callpow = ast_call_new(ctx(), func_self("pow", name));
-    ast_call *callfloor = ast_call_new(ctx(), func_self("floor", name));
-    ast_value *a = ast_value_new(ctx(), "a", TYPE_FLOAT);
-    ast_value *b = ast_value_new(ctx(), "b", TYPE_FLOAT);
-    ast_block *body = ast_block_new(ctx());
+    ast_call *callpow = ast_call::make(ctx(), func_self("pow", name));
+    ast_call *callfloor = ast_call::make(ctx(), func_self("floor", name));
+    ast_value *a = new ast_value(ctx(), "a", TYPE_FLOAT);
+    ast_value *b = new ast_value(ctx(), "b", TYPE_FLOAT);
+    ast_block *body = new ast_block(ctx());
     ast_function *func = value(&val, name, TYPE_FLOAT);
 
-    val->type_params.push_back(a);
-    val->type_params.push_back(b);
+    val->m_type_params.emplace_back(a);
+    val->m_type_params.emplace_back(b);
 
     /* <callpow> = pow(2, b) */
-    callpow->params.push_back((ast_expression*)m_fold->m_imm_float[3]);
-    callpow->params.push_back((ast_expression*)b);
+    callpow->m_params.push_back(m_fold->m_imm_float[3]);
+    callpow->m_params.push_back(b);
 
     /* <callfloor> = floor(a [instr] <callpow>) */
-    callfloor->params.push_back(
-        (ast_expression*)ast_binary_new(
+    callfloor->m_params.push_back(
+        new ast_binary(
             ctx(),
             instr,
-            (ast_expression*)a,
-            (ast_expression*)callpow
+            a,
+            callpow
         )
     );
 
     /* return <callfloor> */
-    body->exprs.push_back(
-        (ast_expression*)ast_return_new(
+    body->m_exprs.push_back(
+        new ast_return(
             ctx(),
-            (ast_expression*)callfloor
+            callfloor
         )
     );
 
-    func->blocks.push_back(body);
+    func->m_blocks.emplace_back(body);
     reg(val, func);
-    return (ast_expression*)val;
+    return val;
 }
 
 ast_expression *intrin::lshift() {
@@ -1998,14 +1998,14 @@ intrin::intrin(parser_t *parser)
 }
 
 ast_expression *intrin::do_fold(ast_value *val, ast_expression **exprs) {
-    if (!val || !val->name)
+    if (!val || !val->m_name.length())
         return nullptr;
     static constexpr size_t kPrefixLength = 10; // "__builtin_"
     for (auto &it : m_intrinsics) {
-        if (!strcmp(val->name, it.name))
+        if (val->m_name == it.name)
             return (vec_size(exprs) != it.args)
                         ? nullptr
-                        : m_fold->intrinsic(val->name + kPrefixLength, exprs);
+                        : m_fold->intrinsic(val->m_name.c_str() + kPrefixLength, it.args, exprs);
     }
     return nullptr;
 }
@@ -2025,9 +2025,9 @@ ast_expression *intrin::func_try(size_t offset, const char *compare) {
 ast_expression *intrin::func_self(const char *name, const char *from) {
     ast_expression *find;
     /* try current first */
-    if ((find = parser_find_global(m_parser, name)) && ((ast_value*)find)->vtype == TYPE_FUNCTION)
+    if ((find = parser_find_global(m_parser, name)) && ((ast_value*)find)->m_vtype == TYPE_FUNCTION)
         for (auto &it : m_parser->functions)
-            if (((ast_value*)find)->name && !strcmp(it->name, ((ast_value*)find)->name) && it->builtin < 0)
+            if (reinterpret_cast<ast_value*>(find)->m_name.length() && it->m_name == reinterpret_cast<ast_value*>(find)->m_name && it->m_builtin < 0)
                 return find;
     /* try name second */
     if ((find = func_try(offsetof(intrin_func_t, name),  name)))