OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*******************************************************************************/
-#include "php_psi_stdinc.h"
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#else
+# include "php_config.h"
+#endif
#include <assert.h>
#include "context.h"
#include "call.h"
#include "calc.h"
+#include "debug.h"
struct psi_num_exp *psi_num_exp_init_ternary(token_t op,
struct psi_num_exp *cond, struct psi_num_exp *truthy,
struct psi_num_exp *falsy)
{
- struct psi_num_exp *exp = calloc(1, sizeof(*exp));
+ struct psi_num_exp *exp = pecalloc(1, sizeof(*exp), 1);
exp->op = op;
exp->data.t.cond = cond;
struct psi_num_exp *psi_num_exp_init_binary(token_t op,
struct psi_num_exp *lhs, struct psi_num_exp *rhs)
{
- struct psi_num_exp *exp = calloc(1, sizeof(*exp));
+ struct psi_num_exp *exp = pecalloc(1, sizeof(*exp), 1);
exp->op = op;
exp->data.b.lhs = lhs;
struct psi_num_exp *psi_num_exp_init_unary(token_t op,
struct psi_num_exp *u)
{
- struct psi_num_exp *exp = calloc(1, sizeof(*exp));
+ struct psi_num_exp *exp = pecalloc(1, sizeof(*exp), 1);
exp->op = op;
exp->data.u = u;
struct psi_num_exp *psi_num_exp_init_num(struct psi_number *n)
{
- struct psi_num_exp *exp = calloc(1, sizeof(*exp));
+ struct psi_num_exp *exp = pecalloc(1, sizeof(*exp), 1);
exp->op = PSI_T_NUMBER;
exp->data.n = n;
struct psi_num_exp *psi_num_exp_init_cast(struct psi_decl_type *typ,
struct psi_num_exp *num)
{
- struct psi_num_exp *exp = calloc(1, sizeof(*exp));
+ struct psi_num_exp *exp = pecalloc(1, sizeof(*exp), 1);
exp->op = PSI_T_CAST;
exp->data.c.typ = typ;
return NULL;
}
- cpy = malloc(sizeof(*cpy));
+ cpy = pemalloc(sizeof(*cpy), 1);
*cpy = *exp;
switch (exp->op) {
return cpy;
}
+void psi_num_exp_copy_ctor(struct psi_num_exp **exp_ptr)
+{
+ *exp_ptr = psi_num_exp_copy(*exp_ptr);
+}
+
void psi_num_exp_free(struct psi_num_exp **c_ptr)
{
if (*c_ptr) {
struct psi_plist *list)
{
struct psi_token *ntoken;
+
if (!list) {
list = psi_plist_init((psi_plist_dtor) psi_token_free);
}
return list;
}
-void psi_num_exp_dump(int fd, struct psi_num_exp *exp)
+void psi_num_exp_dump(struct psi_dump *dump, struct psi_num_exp *exp)
{
switch (exp->op) {
case PSI_T_NUMBER:
- psi_number_dump(fd, exp->data.n);
+ psi_number_dump(dump, exp->data.n);
break;
case PSI_T_CAST:
- dprintf(fd, "(");
- psi_decl_type_dump(1, exp->data.c.typ, 0);
- dprintf(fd, ")");
+ PSI_DUMP(dump, "(");
+ psi_decl_type_dump(dump, exp->data.c.typ, 0);
+ PSI_DUMP(dump, ")");
+ psi_num_exp_dump(dump, exp->data.c.num);
break;
case PSI_T_NOT:
case PSI_T_TILDE:
unary:
- dprintf(fd, "%s", psi_num_exp_op_tok(exp->op));
- psi_num_exp_dump(fd, exp->data.u);
+ PSI_DUMP(dump, "%s", psi_num_exp_op_tok(exp->op));
+ psi_num_exp_dump(dump, exp->data.u);
break;
case PSI_T_LPAREN:
- dprintf(fd, "(");
- psi_num_exp_dump(fd, exp->data.u);
- dprintf(fd, ")");
+ PSI_DUMP(dump, "(");
+ psi_num_exp_dump(dump, exp->data.u);
+ PSI_DUMP(dump, ")");
break;
case PSI_T_PLUS:
case PSI_T_CMP_GE:
case PSI_T_RCHEVR:
case PSI_T_LCHEVR:
- psi_num_exp_dump(fd, exp->data.b.lhs);
- dprintf(fd, " %s ", psi_num_exp_op_tok(exp->op));
- psi_num_exp_dump(fd, exp->data.b.rhs);
+ psi_num_exp_dump(dump, exp->data.b.lhs);
+ PSI_DUMP(dump, " %s ", psi_num_exp_op_tok(exp->op));
+ psi_num_exp_dump(dump, exp->data.b.rhs);
break;
case PSI_T_IIF:
- psi_num_exp_dump(fd, exp->data.t.cond);
- dprintf(fd, " ? ");
- psi_num_exp_dump(fd, exp->data.t.truthy);
- dprintf(fd, " : ");
- psi_num_exp_dump(fd, exp->data.t.falsy);
+ psi_num_exp_dump(dump, exp->data.t.cond);
+ PSI_DUMP(dump, " ? ");
+ psi_num_exp_dump(dump, exp->data.t.truthy);
+ PSI_DUMP(dump, " : ");
+ psi_num_exp_dump(dump, exp->data.t.falsy);
break;
default:
}
static void psi_num_exp_reduce(struct psi_num_exp *exp, struct psi_plist **output_ptr,
- struct psi_plist **input_ptr, struct psi_call_frame *frame, HashTable *defs)
+ struct psi_plist **input_ptr, struct psi_call_frame *frame, struct psi_cpp *cpp)
{
struct psi_plist *output = *output_ptr, *input = *input_ptr;
struct element {
switch (exp->op) {
case PSI_T_NUMBER:
- entry.type = psi_number_eval(exp->data.n, &entry.data.value, frame, defs, exp);
+ entry.type = psi_number_eval(exp->data.n, &entry.data.value, frame, cpp, exp);
output = psi_plist_add(output, &entry);
break;
case PSI_T_LPAREN:
entry.type = exp->op;
input = psi_plist_add(input, &entry);
- psi_num_exp_reduce(exp->data.u, &output, &input, frame, defs);
+ psi_num_exp_reduce(exp->data.u, &output, &input, frame, cpp);
while (psi_plist_pop(input, &entry)) {
if (entry.type == PSI_T_LPAREN) {
break;
entry.type = exp->op;
entry.data.cast = exp->data.c.typ;
input = psi_plist_add(input, &entry);
- psi_num_exp_reduce(exp->data.c.num, &output, &input, frame, defs);
+ psi_num_exp_reduce(exp->data.c.num, &output, &input, frame, cpp);
break;
case PSI_T_NOT:
entry.type = exp->op;
entry.data.calc = exp->calc;
input = psi_plist_add(input, &entry);
- psi_num_exp_reduce(exp->data.u, &output, &input, frame, defs);
+ psi_num_exp_reduce(exp->data.u, &output, &input, frame, cpp);
break;
case PSI_T_IIF:
{
impl_val cond_val = {0};
- token_t cond_typ = psi_num_exp_exec(exp->data.t.cond, &cond_val, frame, defs);
+ token_t cond_typ = psi_num_exp_exec(exp->data.t.cond, &cond_val, frame, cpp);
psi_calc_bool_not(cond_typ, &cond_val, 0, NULL, &cond_val);
if (cond_val.u8) {
- psi_num_exp_reduce(exp->data.t.falsy, &output, &input, frame, defs);
+ psi_num_exp_reduce(exp->data.t.falsy, &output, &input, frame, cpp);
} else {
- psi_num_exp_reduce(exp->data.t.truthy, &output, &input, frame, defs);
+ psi_num_exp_reduce(exp->data.t.truthy, &output, &input, frame, cpp);
}
}
break;
case PSI_T_PLUS:
/* unary */
if (!exp->data.b.rhs) {
- entry.type = psi_num_exp_exec(exp->data.b.lhs, &entry.data.value, frame, defs);
+ entry.type = psi_num_exp_exec(exp->data.b.lhs, &entry.data.value, frame, cpp);
if (exp->calc) {
entry.type = exp->calc(entry.type, &entry.data.value, 0, NULL, &entry.data.value);
}
/* no break */
default:
- psi_num_exp_reduce(exp->data.b.lhs, &output, &input, frame, defs);
+ psi_num_exp_reduce(exp->data.b.lhs, &output, &input, frame, cpp);
while (psi_plist_top(input, &entry)) {
/* bail out if exp->op > entry.type */
if (psi_calc_oper(exp->op, entry.type) == -1) {
entry.type = exp->op;
entry.data.calc = exp->calc;
input = psi_plist_add(input, &entry);
- psi_num_exp_reduce(exp->data.b.rhs, &output, &input, frame, defs);
+ psi_num_exp_reduce(exp->data.b.rhs, &output, &input, frame, cpp);
break;
}
}
token_t psi_num_exp_exec(struct psi_num_exp *exp, impl_val *res,
- struct psi_call_frame *frame, HashTable *defs)
+ struct psi_call_frame *frame, struct psi_cpp *cpp)
{
struct psi_plist *output, *input;
struct element {
output = psi_plist_init_ex(sizeof(entry), NULL);
input = psi_plist_init_ex(sizeof(entry), NULL);
- psi_num_exp_reduce(exp, &output, &input, frame, defs);
+ psi_num_exp_reduce(exp, &output, &input, frame, cpp);
while (psi_plist_pop(input, &entry)) {
if (frame) PSI_DEBUG_PRINT(frame->context, " %s", psi_num_exp_op_tok(entry.type));
projects / m6w6 / ext-psi / blobdiff