#include <string.h>
+
+#include "ast.h"
+#include "fold.h"
#include "parser.h"
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];
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);
+ value->m_intrinsic = true;
+ value->m_next = (ast_expression*)ast_value_new(ctx(), stype, vtype);
func = ast_function_new(ctx(), buffer, value);
- value->expression.flags |= AST_FLAG_ERASEABLE;
+ value->m_flags |= AST_FLAG_ERASEABLE;
*out = value;
return func;
ast_block *block = ast_block_new(ctx());
/* float x; */
- val->expression.params.push_back(x);
+ val->m_type_params.push_back(x);
/* <callisnan> = isnan(x); */
- callisnan->params.push_back((ast_expression*)x);
+ callisnan->m_params.push_back((ast_expression*)x);
/* <callisinf> = isinf(x); */
- callisinf->params.push_back((ast_expression*)x);
+ callisinf->m_params.push_back((ast_expression*)x);
/* return (!<callisnan> || <callisinf>); */
- block->exprs.push_back(
+ block->m_exprs.push_back(
(ast_expression*)ast_return_new(
ctx(),
(ast_expression*)ast_unary_new(
)
);
- func->blocks.push_back(block);
+ func->m_blocks.emplace_back(block);
reg(val, func);
return (ast_expression*)val;;
ast_block *body = ast_block_new(ctx());
ast_function *func = value(&val, "isinf", TYPE_FLOAT);
- body->exprs.push_back(
+ body->m_exprs.push_back(
(ast_expression*)ast_return_new(
ctx(),
(ast_expression*)ast_binary_new(
ctx(),
INSTR_NE_F,
(ast_expression*)x,
- (ast_expression*)m_fold->imm_float[0]
+ (ast_expression*)m_fold->m_imm_float[0]
),
(ast_expression*)ast_binary_new(
ctx(),
)
);
- val->expression.params.push_back(x);
- func->blocks.push_back(body);
+ val->m_type_params.push_back(x);
+ func->m_blocks.emplace_back(body);
reg(val, func);
ast_block *body = ast_block_new(ctx());
ast_function *func = value(&val, "isnan", TYPE_FLOAT);
- body->locals.push_back(local);
- body->exprs.push_back(
+ body->m_locals.push_back(local);
+ body->m_exprs.push_back(
(ast_expression*)ast_store_new(
ctx(),
INSTR_STORE_F,
)
);
- body->exprs.push_back(
+ body->m_exprs.push_back(
(ast_expression*)ast_return_new(
ctx(),
(ast_expression*)ast_binary_new(
)
);
- val->expression.params.push_back(arg1);
- func->blocks.push_back(body);
+ val->m_type_params.push_back(arg1);
+ func->m_blocks.emplace_back(body);
reg(val, func);
ast_block *body = ast_block_new(ctx());
ast_function *func = value(&val, "isnormal", TYPE_FLOAT);
- val->expression.params.push_back(x);
- callisfinite->params.push_back((ast_expression*)x);
+ val->m_type_params.push_back(x);
+ callisfinite->m_params.push_back((ast_expression*)x);
/* return <callisfinite> */
- body->exprs.push_back(
+ body->m_exprs.push_back(
(ast_expression*)ast_return_new(
ctx(),
(ast_expression*)callisfinite
)
);
- func->blocks.push_back(body);
+ func->m_blocks.emplace_back(body);
reg(val, func);
return (ast_expression*)val;
}
ast_block *body = ast_block_new(ctx());
ast_function *func = value(&val, "signbit", TYPE_FLOAT);
- val->expression.params.push_back(x);
+ val->m_type_params.push_back(x);
/* return (x < 0); */
- body->exprs.push_back(
+ body->m_exprs.push_back(
(ast_expression*)ast_return_new(
ctx(),
(ast_expression*)ast_ternary_new(
ctx(),
INSTR_LT,
(ast_expression*)x,
- (ast_expression*)m_fold->imm_float[0]
+ (ast_expression*)m_fold->m_imm_float[0]
),
- (ast_expression*)m_fold->imm_float[1],
- (ast_expression*)m_fold->imm_float[0]
+ (ast_expression*)m_fold->m_imm_float[1],
+ (ast_expression*)m_fold->m_imm_float[0]
)
)
);
- func->blocks.push_back(body);
+ func->m_blocks.emplace_back(body);
reg(val, func);
return (ast_expression*)val;
}
ast_block *body = ast_block_new(ctx());
ast_function *func = value(&val, "acosh", TYPE_FLOAT);
- val->expression.params.push_back(x);
+ val->m_type_params.push_back(x);
/* <callsqrt> = sqrt((x * x) - 1); */
- callsqrt->params.push_back(
+ callsqrt->m_params.push_back(
(ast_expression*)ast_binary_new(
ctx(),
INSTR_SUB_F,
(ast_expression*)x,
(ast_expression*)x
),
- (ast_expression*)m_fold->imm_float[1]
+ (ast_expression*)m_fold->m_imm_float[1]
)
);
/* <calllog> = log(x + <callsqrt>); */
- calllog->params.push_back(
+ calllog->m_params.push_back(
(ast_expression*)ast_binary_new(
ctx(),
INSTR_ADD_F,
);
/* return <calllog>; */
- body->exprs.push_back(
+ body->m_exprs.push_back(
(ast_expression*)ast_return_new(
ctx(),
(ast_expression*)calllog
)
);
- func->blocks.push_back(body);
+ func->m_blocks.emplace_back(body);
reg(val, func);
return (ast_expression*)val;
}
ast_block *body = ast_block_new(ctx());
ast_function *func = value(&val, "asinh", TYPE_FLOAT);
- val->expression.params.push_back(x);
+ val->m_type_params.push_back(x);
/* <callsqrt> = sqrt((x * x) + 1); */
- callsqrt->params.push_back(
+ callsqrt->m_params.push_back(
(ast_expression*)ast_binary_new(
ctx(),
INSTR_ADD_F,
(ast_expression*)x,
(ast_expression*)x
),
- (ast_expression*)m_fold->imm_float[1]
+ (ast_expression*)m_fold->m_imm_float[1]
)
);
/* <calllog> = log(x + <callsqrt>); */
- calllog->params.push_back(
+ calllog->m_params.push_back(
(ast_expression*)ast_binary_new(
ctx(),
INSTR_ADD_F,
);
/* return <calllog>; */
- body->exprs.push_back(
+ body->m_exprs.push_back(
(ast_expression*)ast_return_new(
ctx(),
(ast_expression*)calllog
)
);
- func->blocks.push_back(body);
+ func->m_blocks.emplace_back(body);
reg(val, func);
return (ast_expression*)val;
}
ast_block *body = ast_block_new(ctx());
ast_function *func = value(&val, "atanh", TYPE_FLOAT);
- val->expression.params.push_back(x);
+ val->m_type_params.push_back(x);
/* <callog> = log((1 + x) / (1 - x)); */
- calllog->params.push_back(
+ calllog->m_params.push_back(
(ast_expression*)ast_binary_new(
ctx(),
INSTR_DIV_F,
(ast_expression*)ast_binary_new(
ctx(),
INSTR_ADD_F,
- (ast_expression*)m_fold->imm_float[1],
+ (ast_expression*)m_fold->m_imm_float[1],
(ast_expression*)x
),
(ast_expression*)ast_binary_new(
ctx(),
INSTR_SUB_F,
- (ast_expression*)m_fold->imm_float[1],
+ (ast_expression*)m_fold->m_imm_float[1],
(ast_expression*)x
)
)
);
/* return 0.5 * <calllog>; */
- body->exprs.push_back(
+ body->m_exprs.push_back(
(ast_expression*)ast_binary_new(
ctx(),
INSTR_MUL_F,
- (ast_expression*)fold_constgen_float(m_fold, 0.5, false),
+ (ast_expression*)m_fold->constgen_float(0.5, false),
(ast_expression*)calllog
)
);
- func->blocks.push_back(body);
+ func->m_blocks.emplace_back(body);
reg(val, func);
return (ast_expression*)val;
}
ast_block *body = ast_block_new(ctx());
ast_function *func = value(&val, "exp", TYPE_FLOAT);
- val->expression.params.push_back(x);
+ val->m_type_params.push_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(
+ body->m_exprs.push_back(
(ast_expression*)ast_store_new(
ctx(),
INSTR_STORE_F,
(ast_expression*)sum,
- (ast_expression*)m_fold->imm_float[1]
+ (ast_expression*)m_fold->m_imm_float[1]
)
);
/* acc = 1.0; */
- body->exprs.push_back(
+ body->m_exprs.push_back(
(ast_expression*)ast_store_new(
ctx(),
INSTR_STORE_F,
(ast_expression*)acc,
- (ast_expression*)m_fold->imm_float[1]
+ (ast_expression*)m_fold->m_imm_float[1]
)
);
* for (i = 1; i < 200; ++i)
* sum += (acc *= x / i);
*/
- body->exprs.push_back(
+ body->m_exprs.push_back(
(ast_expression*)ast_loop_new(
ctx(),
/* i = 1; */
ctx(),
INSTR_STORE_F,
(ast_expression*)i,
- (ast_expression*)m_fold->imm_float[1]
+ (ast_expression*)m_fold->m_imm_float[1]
),
/* i < 200; */
(ast_expression*)ast_binary_new(
ctx(),
INSTR_LT,
(ast_expression*)i,
- (ast_expression*)fold_constgen_float(m_fold, 200.0f, false)
+ (ast_expression*)m_fold->constgen_float(200.0f, false)
),
false,
nullptr,
INSTR_STORE_F,
INSTR_ADD_F,
(ast_expression*)i,
- (ast_expression*)m_fold->imm_float[1]
+ (ast_expression*)m_fold->m_imm_float[1]
),
/* sum += (acc *= (x / i)) */
(ast_expression*)ast_binstore_new(
);
/* return sum; */
- body->exprs.push_back(
+ body->m_exprs.push_back(
(ast_expression*)ast_return_new(
ctx(),
(ast_expression*)sum
)
);
- func->blocks.push_back(body);
+ func->m_blocks.emplace_back(body);
reg(val, func);
return (ast_expression*)val;
}
ast_block *body = ast_block_new(ctx());
ast_function *func = value(&val, "exp2", TYPE_FLOAT);
- val->expression.params.push_back(arg1);
+ val->m_type_params.push_back(arg1);
- callpow->params.push_back((ast_expression*)m_fold->imm_float[3]);
- callpow->params.push_back((ast_expression*)arg1);
+ callpow->m_params.push_back((ast_expression*)m_fold->m_imm_float[3]);
+ callpow->m_params.push_back((ast_expression*)arg1);
/* return <callpow> */
- body->exprs.push_back(
+ body->m_exprs.push_back(
(ast_expression*)ast_return_new(
ctx(),
(ast_expression*)callpow
)
);
- func->blocks.push_back(body);
+ func->m_blocks.emplace_back(body);
reg(val, func);
return (ast_expression*)val;
}
ast_block *body = ast_block_new(ctx());
ast_function *func = value(&val, "expm1", TYPE_FLOAT);
- val->expression.params.push_back(x);
+ val->m_type_params.push_back(x);
/* <callexp> = exp(x); */
- callexp->params.push_back((ast_expression*)x);
+ callexp->m_params.push_back((ast_expression*)x);
/* return <callexp> - 1; */
- body->exprs.push_back(
+ body->m_exprs.push_back(
(ast_expression*)ast_return_new(
ctx(),
(ast_expression*)ast_binary_new(
ctx(),
INSTR_SUB_F,
(ast_expression*)callexp,
- (ast_expression*)m_fold->imm_float[1]
+ (ast_expression*)m_fold->m_imm_float[1]
)
)
);
- func->blocks.push_back(body);
+ func->m_blocks.emplace_back(body);
reg(val, func);
return (ast_expression*)val;
}
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);
+ 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->expression.params.push_back(base);
- val->expression.params.push_back(exp);
+ val->m_type_params.push_back(base);
+ val->m_type_params.push_back(exp);
/*
* if (exp == 0.0)
* return 1;
*/
- body->exprs.push_back(
+ body->m_exprs.push_back(
(ast_expression*)ast_ifthen_new(
ctx(),
(ast_expression*)ast_binary_new(
ctx(),
INSTR_EQ_F,
(ast_expression*)exp,
- (ast_expression*)m_fold->imm_float[0]
+ (ast_expression*)m_fold->m_imm_float[0]
),
(ast_expression*)ast_return_new(
ctx(),
- (ast_expression*)m_fold->imm_float[1]
+ (ast_expression*)m_fold->m_imm_float[1]
),
nullptr
)
* if (exp == 1.0)
* return base;
*/
- body->exprs.push_back(
+ body->m_exprs.push_back(
(ast_expression*)ast_ifthen_new(
ctx(),
(ast_expression*)ast_binary_new(
ctx(),
INSTR_EQ_F,
(ast_expression*)exp,
- (ast_expression*)m_fold->imm_float[1]
+ (ast_expression*)m_fold->m_imm_float[1]
),
(ast_expression*)ast_return_new(
ctx(),
);
/* <callpow1> = pow(base, -exp) */
- callpow1->params.push_back((ast_expression*)base);
- callpow1->params.push_back(
+ callpow1->m_params.push_back((ast_expression*)base);
+ callpow1->m_params.push_back(
(ast_expression*)ast_unary_new(
ctx(),
VINSTR_NEG_F,
* if (exp < 0)
* return 1.0 / <callpow1>;
*/
- body->exprs.push_back(
+ body->m_exprs.push_back(
(ast_expression*)ast_ifthen_new(
ctx(),
(ast_expression*)ast_binary_new(
ctx(),
INSTR_LT,
(ast_expression*)exp,
- (ast_expression*)m_fold->imm_float[0]
+ (ast_expression*)m_fold->m_imm_float[0]
),
(ast_expression*)ast_return_new(
ctx(),
(ast_expression*)ast_binary_new(
ctx(),
INSTR_DIV_F,
- (ast_expression*)m_fold->imm_float[1],
+ (ast_expression*)m_fold->m_imm_float[1],
(ast_expression*)callpow1
)
),
);
/* <callpow2> = pow(base, exp / 2) */
- callpow2->params.push_back((ast_expression*)base);
- callpow2->params.push_back(
+ callpow2->m_params.push_back((ast_expression*)base);
+ callpow2->m_params.push_back(
(ast_expression*)ast_binary_new(
ctx(),
INSTR_DIV_F,
(ast_expression*)exp,
- (ast_expression*)m_fold->imm_float[3] /* 2.0f */
+ (ast_expression*)m_fold->m_imm_float[3] /* 2.0f */
)
);
* return result * result;
* }
*/
- expgt1->exprs.push_back(
+ expgt1->m_exprs.push_back(
(ast_expression*)ast_store_new(
ctx(),
INSTR_STORE_F,
(ast_expression*)callpow2
)
);
- expgt1->exprs.push_back(
+ expgt1->m_exprs.push_back(
(ast_expression*)ast_return_new(
ctx(),
(ast_expression*)ast_binary_new(
* <expgt1>
* }
*/
- body->exprs.push_back(
+ body->m_exprs.push_back(
(ast_expression*)ast_ifthen_new(
ctx(),
(ast_expression*)ast_binary_new(
ctx(),
INSTR_GE,
(ast_expression*)exp,
- (ast_expression*)m_fold->imm_float[1]
+ (ast_expression*)m_fold->m_imm_float[1]
),
(ast_expression*)expgt1,
nullptr
/*
* <callsqrt1> = sqrt(base)
*/
- callsqrt1->params.push_back((ast_expression*)base);
+ callsqrt1->m_params.push_back((ast_expression*)base);
/*
* low = 0.0f;
* accumulate = square;
* mid = high / 2.0f;
*/
- body->exprs.push_back(
+ body->m_exprs.push_back(
(ast_expression*)ast_store_new(ctx(),
INSTR_STORE_F,
(ast_expression*)low,
- (ast_expression*)m_fold->imm_float[0]
+ (ast_expression*)m_fold->m_imm_float[0]
)
);
- body->exprs.push_back(
+ body->m_exprs.push_back(
(ast_expression*)ast_store_new(
ctx(),
INSTR_STORE_F,
(ast_expression*)high,
- (ast_expression*)m_fold->imm_float[1]
+ (ast_expression*)m_fold->m_imm_float[1]
)
);
- body->exprs.push_back(
+ body->m_exprs.push_back(
(ast_expression*)ast_store_new(
ctx(),
INSTR_STORE_F,
)
);
- body->exprs.push_back(
+ body->m_exprs.push_back(
(ast_expression*)ast_store_new(
ctx(),
INSTR_STORE_F,
(ast_expression*)square
)
);
- body->exprs.push_back(
+ body->m_exprs.push_back(
(ast_expression*)ast_store_new(
ctx(),
INSTR_STORE_F,
ctx(),
INSTR_DIV_F,
(ast_expression*)high,
- (ast_expression*)m_fold->imm_float[3] /* 2.0f */
+ (ast_expression*)m_fold->m_imm_float[3] /* 2.0f */
)
)
);
* accumulate *= square;
* }
*/
- midltexp->exprs.push_back(
+ midltexp->m_exprs.push_back(
(ast_expression*)ast_store_new(
ctx(),
INSTR_STORE_F,
(ast_expression*)mid
)
);
- midltexp->exprs.push_back(
+ midltexp->m_exprs.push_back(
(ast_expression*)ast_binstore_new(
ctx(),
INSTR_STORE_F,
* accumulate *= (1.0 / square);
* }
*/
- midltexpelse->exprs.push_back(
+ midltexpelse->m_exprs.push_back(
(ast_expression*)ast_store_new(
ctx(),
INSTR_STORE_F,
(ast_expression*)mid
)
);
- midltexpelse->exprs.push_back(
+ midltexpelse->m_exprs.push_back(
(ast_expression*)ast_binstore_new(
ctx(),
INSTR_STORE_F,
(ast_expression*)ast_binary_new(
ctx(),
INSTR_DIV_F,
- (ast_expression*)m_fold->imm_float[1],
+ (ast_expression*)m_fold->m_imm_float[1],
(ast_expression*)square
)
)
/*
* <callsqrt2> = sqrt(square)
*/
- callsqrt2->params.push_back((ast_expression*)square);
+ callsqrt2->m_params.push_back((ast_expression*)square);
/*
* <whileblock> = {
* mid = (low + high) / 2;
* }
*/
- whileblock->exprs.push_back(
+ whileblock->m_exprs.push_back(
(ast_expression*)ast_store_new(
ctx(),
INSTR_STORE_F,
(ast_expression*)callsqrt2
)
);
- whileblock->exprs.push_back(
+ whileblock->m_exprs.push_back(
(ast_expression*)ast_ifthen_new(
ctx(),
(ast_expression*)ast_binary_new(
(ast_expression*)midltexpelse
)
);
- whileblock->exprs.push_back(
+ whileblock->m_exprs.push_back(
(ast_expression*)ast_store_new(
ctx(),
INSTR_STORE_F,
(ast_expression*)low,
(ast_expression*)high
),
- (ast_expression*)m_fold->imm_float[3] /* 2.0f */
+ (ast_expression*)m_fold->m_imm_float[3] /* 2.0f */
)
)
);
/*
* <callabs> = fabs(mid - exp)
*/
- callfabs->params.push_back(
+ callfabs->m_params.push_back(
(ast_expression*)ast_binary_new(
ctx(),
INSTR_SUB_F,
* while (<callfabs> > epsilon)
* <whileblock>
*/
- body->exprs.push_back(
+ body->m_exprs.push_back(
(ast_expression*)ast_loop_new(
ctx(),
/* init */
ctx(),
INSTR_GT,
(ast_expression*)callfabs,
- (ast_expression*)fold_constgen_float(m_fold, QC_POW_EPSILON, false)
+ (ast_expression*)m_fold->constgen_float(QC_POW_EPSILON, false)
),
/* pre not */
false,
);
/* return accumulate */
- body->exprs.push_back(
+ body->m_exprs.push_back(
(ast_expression*)ast_return_new(
ctx(),
(ast_expression*)accumulate
);
/* } */
- func->blocks.push_back(body);
+ func->m_blocks.emplace_back(body);
reg(val, func);
return (ast_expression*)val;
}
ast_block *body = ast_block_new(ctx());
ast_function *func = value(&val, "mod", TYPE_FLOAT);
- val->expression.params.push_back(a);
- val->expression.params.push_back(b);
+ val->m_type_params.push_back(a);
+ val->m_type_params.push_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(
+ body->m_exprs.push_back(
(ast_expression*)ast_store_new(
ctx(),
INSTR_STORE_F,
);
/* sign = (div < 0.0f) ? -1 : 1; */
- body->exprs.push_back(
+ body->m_exprs.push_back(
(ast_expression*)ast_store_new(
ctx(),
INSTR_STORE_F,
ctx(),
INSTR_LT,
(ast_expression*)div,
- (ast_expression*)m_fold->imm_float[0]
+ (ast_expression*)m_fold->m_imm_float[0]
),
- (ast_expression*)m_fold->imm_float[2],
- (ast_expression*)m_fold->imm_float[1]
+ (ast_expression*)m_fold->m_imm_float[2],
+ (ast_expression*)m_fold->m_imm_float[1]
)
)
);
/* floor(sign * div) */
- call->params.push_back(
+ call->m_params.push_back(
(ast_expression*)ast_binary_new(
ctx(),
INSTR_MUL_F,
);
/* return a - b * sign * <call> */
- body->exprs.push_back(
+ body->m_exprs.push_back(
(ast_expression*)ast_return_new(
ctx(),
(ast_expression*)ast_binary_new(
)
);
- func->blocks.push_back(body);
+ func->m_blocks.emplace_back(body);
reg(val, func);
return (ast_expression*)val;
}
ast_block *body = ast_block_new(ctx());
ast_function *func = value(&val, "fabs", TYPE_FLOAT);
- body->exprs.push_back(
+ body->m_exprs.push_back(
(ast_expression*)ast_return_new(
ctx(),
(ast_expression*)ast_ternary_new(
ctx(),
INSTR_LE,
(ast_expression*)arg1,
- (ast_expression*)m_fold->imm_float[0]
+ (ast_expression*)m_fold->m_imm_float[0]
),
(ast_expression*)ast_unary_new(
ctx(),
)
);
- val->expression.params.push_back(arg1);
+ val->m_type_params.push_back(arg1);
- func->blocks.push_back(body);
+ func->m_blocks.emplace_back(body);
reg(val, func);
return (ast_expression*)val;
}
ast_block *body = ast_block_new(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(
+ body->m_exprs.push_back(
(ast_expression*)ast_store_new(
ctx(),
INSTR_STORE_F,
(ast_expression*)eps,
- (ast_expression*)m_fold->imm_float[0]
+ (ast_expression*)m_fold->m_imm_float[0]
)
);
- body->exprs.push_back(
+ body->m_exprs.push_back(
(ast_expression*)ast_loop_new(
ctx(),
nullptr,
(ast_expression*)ast_binary_new(
ctx(),
INSTR_ADD_F,
- (ast_expression*)m_fold->imm_float[1],
+ (ast_expression*)m_fold->m_imm_float[1],
(ast_expression*)ast_binary_new(
ctx(),
INSTR_MUL_F,
(ast_expression*)eps,
- (ast_expression*)m_fold->imm_float[3] /* 2.0f */
+ (ast_expression*)m_fold->m_imm_float[3] /* 2.0f */
)
),
- (ast_expression*)m_fold->imm_float[1]
+ (ast_expression*)m_fold->m_imm_float[1]
),
false,
nullptr,
INSTR_STORE_F,
INSTR_DIV_F,
(ast_expression*)eps,
- (ast_expression*)m_fold->imm_float[3] /* 2.0f */
+ (ast_expression*)m_fold->m_imm_float[3] /* 2.0f */
)
)
);
/* return eps; */
- body->exprs.push_back(
+ body->m_exprs.push_back(
(ast_expression*)ast_return_new(
ctx(),
(ast_expression*)eps
)
);
- func->blocks.push_back(body);
+ func->m_blocks.emplace_back(body);
reg(val, func);
return (ast_expression*)val;
}
ast_function *func = value(&val, "nan", TYPE_FLOAT);
ast_block *block = ast_block_new(ctx());
- block->locals.push_back(x);
+ block->m_locals.push_back(x);
- block->exprs.push_back(
+ block->m_exprs.push_back(
(ast_expression*)ast_store_new(
ctx(),
INSTR_STORE_F,
(ast_expression*)x,
- (ast_expression*)m_fold->imm_float[0]
+ (ast_expression*)m_fold->m_imm_float[0]
)
);
- block->exprs.push_back(
+ block->m_exprs.push_back(
(ast_expression*)ast_return_new(
ctx(),
(ast_expression*)ast_binary_new(
)
);
- func->blocks.push_back(block);
+ func->m_blocks.emplace_back(block);
reg(val, func);
return (ast_expression*)val;
}
ast_block *block = ast_block_new(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(
+ block->m_exprs.push_back(
(ast_expression*)ast_store_new(
ctx(),
INSTR_STORE_F,
(ast_expression*)((i == 0) ? x : y),
- (ast_expression*)m_fold->imm_float[i]
+ (ast_expression*)m_fold->m_imm_float[i]
)
);
}
- block->exprs.push_back(
+ block->m_exprs.push_back(
(ast_expression*)ast_return_new(
ctx(),
(ast_expression*)ast_binary_new(
)
);
- func->blocks.push_back(block);
+ func->m_blocks.emplace_back(block);
reg(val, func);
return (ast_expression*)val;
}
ast_function *func = value(&val, "ln", TYPE_FLOAT);
size_t i;
- val->expression.params.push_back(power);
- val->expression.params.push_back(base);
+ val->m_type_params.push_back(power);
+ val->m_type_params.push_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(
+ block->m_exprs.push_back(
(ast_expression*)ast_store_new(
ctx(),
INSTR_STORE_F,
(ast_expression*)sign,
- (ast_expression*)m_fold->imm_float[1]
+ (ast_expression*)m_fold->m_imm_float[1]
)
);
/* eps = __builtin_epsilon(); */
- block->exprs.push_back(
+ block->m_exprs.push_back(
(ast_expression*)ast_store_new(
ctx(),
INSTR_STORE_F,
for (i = 0; i <= 1; i++) {
int j;
for (j = 1; j >= 0; j--) {
- block->exprs.push_back(
+ block->m_exprs.push_back(
(ast_expression*)ast_store_new(
ctx(),
INSTR_STORE_F,
(ast_expression*)((j) ? ((i) ? B_iminus1 : A_i)
: ((i) ? A_iminus1 : B_i)),
- (ast_expression*)m_fold->imm_float[j]
+ (ast_expression*)m_fold->m_imm_float[j]
)
);
}
* }
*/
for (i = 0; i <= 1; i++) {
- ((i) ? blt1 : plt1)->exprs.push_back(
+ ((i) ? blt1 : plt1)->m_exprs.push_back(
(ast_expression*)ast_store_new(
ctx(),
INSTR_STORE_F,
(ast_expression*)ast_binary_new(
ctx(),
INSTR_DIV_F,
- (ast_expression*)m_fold->imm_float[1],
+ (ast_expression*)m_fold->m_imm_float[1],
(ast_expression*)((i) ? base : power)
)
)
);
- plt1->exprs.push_back(
+ plt1->m_exprs.push_back(
(ast_expression*)ast_binstore_new(
ctx(),
INSTR_STORE_F,
INSTR_MUL_F,
(ast_expression*)sign,
- (ast_expression*)m_fold->imm_float[2]
+ (ast_expression*)m_fold->m_imm_float[2]
)
);
}
* <blt1>
* }
*/
- plt1orblt1->exprs.push_back(
+ plt1orblt1->m_exprs.push_back(
(ast_expression*)ast_ifthen_new(
ctx(),
(ast_expression*)ast_binary_new(
ctx(),
INSTR_LE,
(ast_expression*)power,
- (ast_expression*)m_fold->imm_float[0]
+ (ast_expression*)m_fold->m_imm_float[0]
),
(ast_expression*)ast_binary_new(
ctx(),
INSTR_LE,
(ast_expression*)base,
- (ast_expression*)m_fold->imm_float[0]
+ (ast_expression*)m_fold->m_imm_float[0]
)
),
(ast_expression*)ast_return_new(
);
for (i = 0; i <= 1; i++) {
- plt1orblt1->exprs.push_back(
+ plt1orblt1->m_exprs.push_back(
(ast_expression*)ast_ifthen_new(
ctx(),
(ast_expression*)ast_binary_new(
ctx(),
INSTR_LT,
(ast_expression*)((i) ? base : power),
- (ast_expression*)m_fold->imm_float[1]
+ (ast_expression*)m_fold->m_imm_float[1]
),
(ast_expression*)((i) ? blt1 : plt1),
nullptr
);
}
- block->exprs.push_back((ast_expression*)plt1orblt1);
+ block->m_exprs.push_back((ast_expression*)plt1orblt1);
/* whole = power; */
- forloop->exprs.push_back(
+ forloop->m_exprs.push_back(
(ast_expression*)ast_store_new(
ctx(),
INSTR_STORE_F,
);
/* nth = 0.0f; */
- forloop->exprs.push_back(
+ forloop->m_exprs.push_back(
(ast_expression*)ast_store_new(
ctx(),
INSTR_STORE_F,
(ast_expression*)nth,
- (ast_expression*)m_fold->imm_float[0]
+ (ast_expression*)m_fold->m_imm_float[0]
)
);
/* base2 = base; */
- whileloop->exprs.push_back(
+ whileloop->m_exprs.push_back(
(ast_expression*)ast_store_new(
ctx(),
INSTR_STORE_F,
);
/* n2 = 1.0f; */
- whileloop->exprs.push_back(
+ whileloop->m_exprs.push_back(
(ast_expression*)ast_store_new(
ctx(),
INSTR_STORE_F,
(ast_expression*)n2,
- (ast_expression*)m_fold->imm_float[1]
+ (ast_expression*)m_fold->m_imm_float[1]
)
);
/* newbase2 = base2 * base2; */
- whileloop->exprs.push_back(
+ whileloop->m_exprs.push_back(
(ast_expression*)ast_store_new(
ctx(),
INSTR_STORE_F,
);
/* 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(
+ nestwhile->m_exprs.push_back(
(ast_expression*)ast_store_new(
ctx(),
INSTR_STORE_F,
);
/* n2 *= 2; */
- nestwhile->exprs.push_back(
+ nestwhile->m_exprs.push_back(
(ast_expression*)ast_binstore_new(
ctx(),
INSTR_STORE_F,
INSTR_MUL_F,
(ast_expression*)n2,
- (ast_expression*)m_fold->imm_float[3] /* 2.0f */
+ (ast_expression*)m_fold->m_imm_float[3] /* 2.0f */
)
);
/* newbase2 *= newbase2; */
- nestwhile->exprs.push_back(
+ nestwhile->m_exprs.push_back(
(ast_expression*)ast_binstore_new(
ctx(),
INSTR_STORE_F,
);
/* while (whole >= newbase2) */
- whileloop->exprs.push_back(
+ whileloop->m_exprs.push_back(
(ast_expression*)ast_loop_new(
ctx(),
nullptr,
);
/* whole /= base2; */
- whileloop->exprs.push_back(
+ whileloop->m_exprs.push_back(
(ast_expression*)ast_binstore_new(
ctx(),
INSTR_STORE_F,
);
/* nth += n2; */
- whileloop->exprs.push_back(
+ whileloop->m_exprs.push_back(
(ast_expression*)ast_binstore_new(
ctx(),
INSTR_STORE_F,
);
/* while (whole >= base) */
- forloop->exprs.push_back(
+ forloop->m_exprs.push_back(
(ast_expression*)ast_loop_new(
ctx(),
nullptr,
)
);
- 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(
+ forloop->m_exprs.push_back(
(ast_expression*)ast_store_new(
ctx(),
INSTR_STORE_F,
* B_iplus1 = b_iplus1 * B_i + B_iminus1;
*/
for (i = 0; i <= 1; i++) {
- forloop->exprs.push_back(
+ forloop->m_exprs.push_back(
(ast_expression*)ast_store_new(
ctx(),
INSTR_STORE_F,
* B_iminus1 = B_i;
*/
for (i = 0; i <= 1; i++) {
- forloop->exprs.push_back(
+ forloop->m_exprs.push_back(
(ast_expression*)ast_store_new(
ctx(),
INSTR_STORE_F,
* B_i = B_iplus1;
*/
for (i = 0; i <= 1; i++) {
- forloop->exprs.push_back(
+ forloop->m_exprs.push_back(
(ast_expression*)ast_store_new(
ctx(),
INSTR_STORE_F,
* if (whole <= 1.0f + eps)
* break;
*/
- forloop->exprs.push_back(
+ forloop->m_exprs.push_back(
(ast_expression*)ast_ifthen_new(
ctx(),
(ast_expression*)ast_binary_new(
(ast_expression*)ast_binary_new(
ctx(),
INSTR_ADD_F,
- (ast_expression*)m_fold->imm_float[1],
+ (ast_expression*)m_fold->m_imm_float[1],
(ast_expression*)eps
)
),
* base = whole;
*/
for (i = 0; i <= 1; i++) {
- forloop->exprs.push_back(
+ forloop->m_exprs.push_back(
(ast_expression*)ast_store_new(
ctx(),
INSTR_STORE_F,
}
/* add the for loop block */
- block->exprs.push_back(
+ block->m_exprs.push_back(
(ast_expression*)ast_loop_new(
ctx(),
nullptr,
/* for(; 1; ) ?? (can this be nullptr too?) */
- (ast_expression*)m_fold->imm_float[1],
+ (ast_expression*)m_fold->m_imm_float[1],
false,
nullptr,
false,
);
/* return sign * A_i / B_il */
- block->exprs.push_back(
+ block->m_exprs.push_back(
(ast_expression*)ast_return_new(
ctx(),
(ast_expression*)ast_binary_new(
)
);
- func->blocks.push_back(block);
+ func->m_blocks.emplace_back(block);
reg(val, func);
return (ast_expression*)val;
}
ast_block *body = ast_block_new(ctx());
ast_function *func = value(&val, name, TYPE_FLOAT);
- val->expression.params.push_back(arg1);
+ val->m_type_params.push_back(arg1);
- callln->params.push_back((ast_expression*)arg1);
- callln->params.push_back((ast_expression*)fold_constgen_float(m_fold, base, false));
+ callln->m_params.push_back((ast_expression*)arg1);
+ callln->m_params.push_back((ast_expression*)m_fold->constgen_float(base, false));
- body->exprs.push_back(
+ body->m_exprs.push_back(
(ast_expression*)ast_return_new(
ctx(),
(ast_expression*)callln
)
);
- func->blocks.push_back(body);
+ func->m_blocks.emplace_back(body);
reg(val, func);
return (ast_expression*)val;
}
ast_block *body = ast_block_new(ctx());
ast_function *func = value(&val, name, TYPE_FLOAT);
- val->expression.params.push_back(a);
- val->expression.params.push_back(b);
+ val->m_type_params.push_back(a);
+ val->m_type_params.push_back(b);
/* <callpow> = pow(2, b) */
- callpow->params.push_back((ast_expression*)m_fold->imm_float[3]);
- callpow->params.push_back((ast_expression*)b);
+ callpow->m_params.push_back((ast_expression*)m_fold->m_imm_float[3]);
+ callpow->m_params.push_back((ast_expression*)b);
/* <callfloor> = floor(a [instr] <callpow>) */
- callfloor->params.push_back(
+ callfloor->m_params.push_back(
(ast_expression*)ast_binary_new(
ctx(),
instr,
);
/* return <callfloor> */
- body->exprs.push_back(
+ body->m_exprs.push_back(
(ast_expression*)ast_return_new(
ctx(),
(ast_expression*)callfloor
)
);
- func->blocks.push_back(body);
+ func->m_blocks.emplace_back(body);
reg(val, func);
return (ast_expression*)val;
}
intrin::intrin(parser_t *parser)
: m_parser(parser)
- , m_fold(parser->fold)
+ , m_fold(&parser->m_fold)
{
static const intrin_func_t intrinsics[] = {
{&intrin::isfinite_, "__builtin_isfinite", "isfinite", 1},
}
}
-ast_expression *intrin::fold(ast_value *val, ast_expression **exprs) {
- if (!val || !val->name)
+ast_expression *intrin::do_fold(ast_value *val, ast_expression **exprs) {
+ if (!val || !val->m_name)
return nullptr;
static constexpr size_t kPrefixLength = 10; // "__builtin_"
for (auto &it : m_intrinsics) {
- if (!strcmp(val->name, it.name))
+ if (!strcmp(val->m_name, it.name))
return (vec_size(exprs) != it.args)
? nullptr
- : fold_intrin(m_fold, val->name + kPrefixLength, exprs);
+ : m_fold->intrinsic(val->m_name + kPrefixLength, 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 (((ast_value*)find)->m_name && !strcmp(it->m_name, ((ast_value*)find)->m_name) && it->m_builtin < 0)
return find;
/* try name second */
if ((find = func_try(offsetof(intrin_func_t, name), name)))