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];
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->expression.next = (ast_expression*)ast_value_new(ctx(), stype, vtype);
- func = ast_function_new(ctx(), buffer, value);
- value->expression.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;
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_() {
* }
*/
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->expression.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_() {
* }
*/
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->expression.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_() {
* }
*/
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->expression.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_() {
* }
*/
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->expression.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_() {
* }
*/
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->expression.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_() {
* }
*/
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->expression.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_() {
* }
*/
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->expression.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_() {
* }
*/
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->expression.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_() {
* }
*/
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->expression.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]
)
);
* 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
)
)
)
);
/* 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_() {
* }
*/
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->expression.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_() {
* }
*/
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->expression.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) {
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;
* 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->expression.type_params.push_back(base);
- val->expression.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
)
* 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
)
);
* 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
);
/* <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 */
)
);
* 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
)
)
);
* <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
)
);
/*
* <callsqrt1> = sqrt(base)
*/
- callsqrt1->params.push_back((ast_expression*)base);
+ callsqrt1->m_params.push_back(base);
/*
* low = 0.0f;
* 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 */
)
)
);
* 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
)
);
* 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
)
)
);
/*
* <callsqrt2> = sqrt(square)
*/
- callsqrt2->params.push_back((ast_expression*)square);
+ callsqrt2->m_params.push_back(square);
/*
* <whileblock> = {
* 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 */
)
)
);
/*
* <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
)
);
* 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,
/* 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_() {
* }
*/
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->expression.type_params.push_back(a);
- val->expression.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_() {
* }
*/
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->expression.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_() {
* }
*/
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_() {
* }
*/
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_() {
* }
*/
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_() {
*/
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->expression.type_params.push_back(power);
- val->expression.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")
)
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]
)
);
}
* }
*/
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]
)
);
}
* <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")
)
);
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
)
);
* 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)
)
)
);
* 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)
)
);
}
* 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)
)
);
}
* 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
* 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->expression.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_() {
* 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->expression.type_params.push_back(a);
- val->expression.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() {
}
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;
}
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)->expression.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)))
projects / xonotic / gmqcc.git / blobdiff