}
static GMQCC_INLINE void intrin_reg(intrin_t *intrin, ast_value *const value, ast_function *const func) {
- vec_push(intrin->parser->functions, func);
- vec_push(intrin->parser->globals, (ast_expression*)value);
+ intrin->parser->functions.push_back(func);
+ intrin->parser->globals.push_back((ast_expression*)value);
}
#define QC_POW_EPSILON 0.00001f
value->expression.params.push_back(x);
/* <callisnan> = isnan(x); */
- vec_push(callisnan->params, (ast_expression*)x);
+ callisnan->params.push_back((ast_expression*)x);
/* <callisinf> = isinf(x); */
- vec_push(callisinf->params, (ast_expression*)x);
+ callisinf->params.push_back((ast_expression*)x);
/* return (!<callisnan> || <callisinf>); */
block->exprs.push_back(
)
);
- vec_push(func->blocks, block);
+ func->blocks.push_back(block);
intrin_reg(intrin, value, func);
return (ast_expression*)value;;
);
value->expression.params.push_back(x);
- vec_push(func->blocks, body);
+ func->blocks.push_back(body);
intrin_reg(intrin, value, func);
);
value->expression.params.push_back(arg1);
- vec_push(func->blocks, body);
+ func->blocks.push_back(body);
intrin_reg(intrin, value, func);
ast_function *func = intrin_value(intrin, &value, "isnormal", TYPE_FLOAT);
value->expression.params.push_back(x);
- vec_push(callisfinite->params, (ast_expression*)x);
+ callisfinite->params.push_back((ast_expression*)x);
/* return <callisfinite> */
body->exprs.push_back(
)
);
- vec_push(func->blocks, body);
+ func->blocks.push_back(body);
intrin_reg(intrin, value, func);
return (ast_expression*)value;
}
)
);
- vec_push(func->blocks, body);
+ func->blocks.push_back(body);
intrin_reg(intrin, value, func);
return (ast_expression*)value;
}
value->expression.params.push_back(x);
/* <callsqrt> = sqrt((x * x) - 1); */
- vec_push(callsqrt->params,
+ callsqrt->params.push_back(
(ast_expression*)ast_binary_new(
intrin_ctx(intrin),
INSTR_SUB_F,
);
/* <calllog> = log(x + <callsqrt>); */
- vec_push(calllog->params,
+ calllog->params.push_back(
(ast_expression*)ast_binary_new(
intrin_ctx(intrin),
INSTR_ADD_F,
)
);
- vec_push(func->blocks, body);
+ func->blocks.push_back(body);
intrin_reg(intrin, value, func);
return (ast_expression*)value;
}
value->expression.params.push_back(x);
/* <callsqrt> = sqrt((x * x) + 1); */
- vec_push(callsqrt->params,
+ callsqrt->params.push_back(
(ast_expression*)ast_binary_new(
intrin_ctx(intrin),
INSTR_ADD_F,
);
/* <calllog> = log(x + <callsqrt>); */
- vec_push(calllog->params,
+ calllog->params.push_back(
(ast_expression*)ast_binary_new(
intrin_ctx(intrin),
INSTR_ADD_F,
)
);
- vec_push(func->blocks, body);
+ func->blocks.push_back(body);
intrin_reg(intrin, value, func);
return (ast_expression*)value;
}
value->expression.params.push_back(x);
/* <callog> = log((1 + x) / (1 - x)); */
- vec_push(calllog->params,
+ calllog->params.push_back(
(ast_expression*)ast_binary_new(
intrin_ctx(intrin),
INSTR_DIV_F,
)
);
- vec_push(func->blocks, body);
+ func->blocks.push_back(body);
intrin_reg(intrin, value, func);
return (ast_expression*)value;
}
)
);
- vec_push(func->blocks, body);
-
+ func->blocks.push_back(body);
intrin_reg(intrin, value, func);
return (ast_expression*)value;
}
value->expression.params.push_back(arg1);
- vec_push(callpow->params, (ast_expression*)intrin->fold->imm_float[3]);
- vec_push(callpow->params, (ast_expression*)arg1);
+ callpow->params.push_back((ast_expression*)intrin->fold->imm_float[3]);
+ callpow->params.push_back((ast_expression*)arg1);
/* return <callpow> */
body->exprs.push_back(
)
);
- vec_push(func->blocks, body);
-
+ func->blocks.push_back(body);
intrin_reg(intrin, value, func);
return (ast_expression*)value;
}
value->expression.params.push_back(x);
/* <callexp> = exp(x); */
- vec_push(callexp->params, (ast_expression*)x);
+ callexp->params.push_back((ast_expression*)x);
/* return <callexp> - 1; */
body->exprs.push_back(
)
);
- vec_push(func->blocks, body);
+ func->blocks.push_back(body);
intrin_reg(intrin, value, func);
return (ast_expression*)value;
}
);
/* <callpow1> = pow(base, -exp) */
- vec_push(callpow1->params, (ast_expression*)base);
- vec_push(callpow1->params,
+ callpow1->params.push_back((ast_expression*)base);
+ callpow1->params.push_back(
(ast_expression*)ast_unary_new(
intrin_ctx(intrin),
VINSTR_NEG_F,
);
/* <callpow2> = pow(base, exp / 2) */
- vec_push(callpow2->params, (ast_expression*)base);
- vec_push(callpow2->params,
+ callpow2->params.push_back((ast_expression*)base);
+ callpow2->params.push_back(
(ast_expression*)ast_binary_new(
intrin_ctx(intrin),
INSTR_DIV_F,
/*
* <callsqrt1> = sqrt(base)
*/
- vec_push(callsqrt1->params, (ast_expression*)base);
+ callsqrt1->params.push_back((ast_expression*)base);
/*
* low = 0.0f;
/*
* <callsqrt2> = sqrt(square)
*/
- vec_push(callsqrt2->params, (ast_expression*)square);
+ callsqrt2->params.push_back((ast_expression*)square);
/*
* <whileblock> = {
/*
* <callabs> = fabs(mid - exp)
*/
- vec_push(callfabs->params,
+ callfabs->params.push_back(
(ast_expression*)ast_binary_new(
intrin_ctx(intrin),
INSTR_SUB_F,
);
/* } */
- vec_push(func->blocks, body);
-
+ func->blocks.push_back(body);
intrin_reg(intrin, value, func);
return (ast_expression*)value;
}
);
/* floor(sign * div) */
- vec_push(call->params,
+ call->params.push_back(
(ast_expression*)ast_binary_new(
intrin_ctx(intrin),
INSTR_MUL_F,
)
);
- vec_push(func->blocks, body);
+ func->blocks.push_back(body);
intrin_reg(intrin, value, func);
-
return (ast_expression*)value;
}
value->expression.params.push_back(arg1);
- vec_push(func->blocks, body);
-
+ func->blocks.push_back(body);
intrin_reg(intrin, value, func);
-
return (ast_expression*)value;
}
)
);
- vec_push(func->blocks, body);
+ func->blocks.push_back(body);
intrin_reg(intrin, value, func);
-
return (ast_expression*)value;
}
)
);
- vec_push(func->blocks, block);
+ func->blocks.push_back(block);
intrin_reg(intrin, value, func);
-
return (ast_expression*)value;
}
)
);
- vec_push(func->blocks, block);
+ func->blocks.push_back(block);
intrin_reg(intrin, value, func);
-
return (ast_expression*)value;
}
)
);
- vec_push(func->blocks, block);
+ func->blocks.push_back(block);
intrin_reg(intrin, value, func);
-
return (ast_expression*)value;
}
value->expression.params.push_back(arg1);
- vec_push(callln->params, (ast_expression*)arg1);
- vec_push(callln->params, (ast_expression*)fold_constgen_float(intrin->fold, base, false));
+ callln->params.push_back((ast_expression*)arg1);
+ callln->params.push_back((ast_expression*)fold_constgen_float(intrin->fold, base, false));
body->exprs.push_back(
(ast_expression*)ast_return_new(
)
);
- vec_push(func->blocks, body);
+ func->blocks.push_back(body);
intrin_reg(intrin, value, func);
return (ast_expression*)value;
}
value->expression.params.push_back(b);
/* <callpow> = pow(2, b) */
- vec_push(callpow->params, (ast_expression*)intrin->fold->imm_float[3]);
- vec_push(callpow->params, (ast_expression*)b);
+ callpow->params.push_back((ast_expression*)intrin->fold->imm_float[3]);
+ callpow->params.push_back((ast_expression*)b);
/* <callfloor> = floor(a [instr] <callpow>) */
- vec_push(
- callfloor->params,
+ callfloor->params.push_back(
(ast_expression*)ast_binary_new(
intrin_ctx(intrin),
instr,
)
);
- vec_push(func->blocks, body);
+ func->blocks.push_back(body);
intrin_reg(intrin, value, func);
return (ast_expression*)value;
}
/* exposed */
intrin_t *intrin_init(parser_t *parser) {
- intrin_t *intrin = (intrin_t*)mem_a(sizeof(intrin_t));
- size_t i;
+ intrin_t *intrin = new intrin_t;
- intrin->parser = parser;
- intrin->fold = parser->fold;
- intrin->intrinsics = NULL;
- intrin->generated = NULL;
+ intrin->parser = parser;
+ intrin->fold = parser->fold;
- vec_append(intrin->intrinsics, GMQCC_ARRAY_COUNT(intrinsics), intrinsics);
-
- /* populate with null pointers for tracking generation */
- for (i = 0; i < GMQCC_ARRAY_COUNT(intrinsics); i++)
- vec_push(intrin->generated, NULL);
+ for (auto &it : intrinsics) {
+ intrin->intrinsics.push_back(it);
+ intrin->generated.push_back(nullptr);
+ }
return intrin;
}
void intrin_cleanup(intrin_t *intrin) {
- vec_free(intrin->intrinsics);
- vec_free(intrin->generated);
- mem_d(intrin);
+ delete intrin;
}
ast_expression *intrin_fold(intrin_t *intrin, ast_value *value, ast_expression **exprs) {
- size_t i;
if (!value || !value->name)
return NULL;
- for (i = 0; i < vec_size(intrin->intrinsics); i++)
- if (!strcmp(value->name, intrin->intrinsics[i].name))
- return (vec_size(exprs) != intrin->intrinsics[i].args)
+ for (auto &it : intrin->intrinsics) {
+ if (!strcmp(value->name, it.name))
+ return (vec_size(exprs) != it.args)
? NULL
: fold_intrin(intrin->fold, value->name + 10, exprs);
+ }
return NULL;
}
static GMQCC_INLINE ast_expression *intrin_func_try(intrin_t *intrin, size_t offset, const char *compare) {
- size_t i;
- for (i = 0; i < vec_size(intrin->intrinsics); i++) {
- if (strcmp(*(char **)((char *)&intrin->intrinsics[i] + offset), compare))
+ for (auto &it : intrin->intrinsics) {
+ const size_t index = &it - &intrin->intrinsics[0];
+ if (strcmp(*(char **)((char *)&it + offset), compare))
continue;
- if (intrin->generated[i])
- return intrin->generated[i];
- return intrin->generated[i] = intrin->intrinsics[i].intrin(intrin);
+ if (intrin->generated[index])
+ return intrin->generated[index];
+ return intrin->generated[index] = it.intrin(intrin);
}
- return NULL;
+ return nullptr;
}
static ast_expression *intrin_func_self(intrin_t *intrin, const char *name, const char *from) {
- size_t i;
- ast_expression *find;
-
+ ast_expression *find;
/* try current first */
if ((find = parser_find_global(intrin->parser, name)) && ((ast_value*)find)->expression.vtype == TYPE_FUNCTION)
- for (i = 0; i < vec_size(intrin->parser->functions); ++i)
- if (((ast_value*)find)->name && !strcmp(intrin->parser->functions[i]->name, ((ast_value*)find)->name) && intrin->parser->functions[i]->builtin < 0)
+ for (auto &it : intrin->parser->functions)
+ if (((ast_value*)find)->name && !strcmp(it->name, ((ast_value*)find)->name) && it->builtin < 0)
return find;
/* try name second */
if ((find = intrin_func_try(intrin, offsetof(intrin_func_t, name), name)))
projects / xonotic / gmqcc.git / blobdiff