flush

[m6w6/ext-psi] / src / context.c

diff --git a/src/context.c b/src/context.c
index cbcfbc6b1d6ecd6e32ab0a2a099cf557cad958f1..ac663afa0eaf5b2bfaee6ec05b9c2a8fd4175b50 100644 (file)
--- a/src/context.c
+++ b/src/context.c
@@ -397,7 +397,7 @@ static inline int validate_decl(PSI_Data *data, void *dl, decl *decl) {
        }
        return 1;
 }
-static inline decl_arg *locate_decl_var_arg(decl_var *var, decl_args *args) {
+static inline decl_arg *locate_decl_var_arg(decl_var *var, decl_args *args, decl_arg *func) {
        size_t i;
 
        for (i = 0; i < args->count; ++i) {
@@ -408,16 +408,75 @@ static inline decl_arg *locate_decl_var_arg(decl_var *var, decl_args *args) {
                        return var->arg = arg;
                }
        }
+       if (func && !strcmp(var->name, func->var->name)) {
+               return var->arg = func;
+       }
 
        return NULL;
 }
 static inline decl_arg *locate_struct_member(decl_struct *s, decl_var *var) {
        if (s->args) {
-               return locate_decl_var_arg(var, s->args);
+               return locate_decl_var_arg(var, s->args, NULL);
+       }
+
+       return NULL;
+}
+static inline constant *locate_num_exp_constant(num_exp *exp, constants *consts) {
+       size_t i;
+
+       for (i = 0; i < consts->count; ++i) {
+               constant *cnst = consts->list[i];
+
+               if (!strcmp(cnst->name, exp->u.numb)) {
+                       free(exp->u.numb);
+                       return exp->u.cnst = cnst;
+               }
        }
 
        return NULL;
 }
+static inline int validate_num_exp(PSI_Data *data, decl_args *dargs, decl_arg *func, num_exp *exp) {
+       if (exp->operand) {
+               switch (exp->operator) {
+               case PSI_T_PLUS:
+                       exp->calculator = psi_calc_add;
+                       break;
+               case PSI_T_MINUS:
+                       exp->calculator = psi_calc_sub;
+                       break;
+               case PSI_T_ASTERISK:
+                       exp->calculator = psi_calc_mul;
+                       break;
+               case PSI_T_SLASH:
+                       exp->calculator = psi_calc_div;
+                       break;
+               EMPTY_SWITCH_DEFAULT_CASE();
+               }
+               if (!validate_num_exp(data, dargs, func, exp->operand)) {
+                       return 0;
+               }
+       }
+       switch (exp->t) {
+       case PSI_T_NAME:
+               if (!locate_decl_var_arg(exp->u.dvar, dargs, func)) {
+                       data->error(PSI_WARNING, "Unknown variable '%s' in numeric expression",
+                                       exp->u.dvar->name);
+                       return 0;
+               }
+               return 1;
+       case PSI_T_NSNAME:
+               if (!locate_num_exp_constant(exp, data->consts)) {
+                       data->error(PSI_WARNING, "Unknown constant '%s' in numeric expression",
+                                       exp->u.numb);
+                       return 0;
+               }
+               return 1;
+       case PSI_T_NUMBER:
+               return 1;
+       default:
+               return 0;
+       }
+}
 static inline int validate_set_value(PSI_Data *data, set_value *set, decl_arg *ref, decl_args *ref_list) {
        size_t i;
        decl_type *ref_type = real_decl_type(ref->type);
@@ -439,11 +498,17 @@ static inline int validate_set_value(PSI_Data *data, set_value *set, decl_arg *r
        case PSI_T_TO_ARRAY:
                set->func->handler = psi_to_array;
                break;
+       case PSI_T_TO_OBJECT:
+               set->func->handler = psi_to_object;
+               break;
+       case PSI_T_VOID:
+               set->func->handler = psi_to_void;
+               break;
        EMPTY_SWITCH_DEFAULT_CASE();
        }
 
        for (i = 1; i < set->vars->count; ++i) {
-               if (!locate_decl_var_arg(set->vars->vars[i], ref_list)) {
+               if (!locate_decl_var_arg(set->vars->vars[i], ref_list, ref)) {
                        return 0;
                }
        }
@@ -459,6 +524,11 @@ static inline int validate_set_value(PSI_Data *data, set_value *set, decl_arg *r
                        return 0;
                }
        }
+       if (set->num) {
+               if (!validate_num_exp(data, ref_list, ref, set->num)) {
+                       return 0;
+               }
+       }
 
        if (ref_type->type == PSI_T_STRUCT) {
                /* to_array(struct, to_...) */
@@ -476,7 +546,7 @@ static inline int validate_set_value(PSI_Data *data, set_value *set, decl_arg *r
        } else if (set->count == 1) {
                /* to_array(ptr, to_string(*ptr)) */
                decl_var *sub_var = set->inner[0]->vars->vars[0];
-               decl_arg *sub_ref = locate_decl_var_arg(sub_var, ref_list);
+               decl_arg *sub_ref = locate_decl_var_arg(sub_var, ref_list, ref);
 
                set->inner[0]->outer.set = set;
                if (sub_ref) {
@@ -542,6 +612,7 @@ static inline int validate_impl_ret_stmt(PSI_Data *data, impl *impl) {
 
        return 1;
 }
+
 static inline int validate_impl_let_stmts(PSI_Data *data, impl *impl) {
        size_t i, j;
        /* we can have multiple let stmts */
@@ -573,9 +644,10 @@ static inline int validate_impl_let_stmts(PSI_Data *data, impl *impl) {
                int check = 0;
 
                if (let->val && let->val->func && let->val->func->alloc) {
-                       if (!validate_decl_type(data, let->val->func->alloc->type)) {
-                               data->error(PSI_WARNING, "Cannot use '%s' as type for calloc in `let` statement",
-                                       let->val->func->alloc->type->name);
+                       if (!validate_num_exp(data, impl->decl->args, impl->decl->func, let->val->func->alloc->nmemb)) {
+                               return 0;
+                       }
+                       if (!validate_num_exp(data, impl->decl->args, impl->decl->func, let->val->func->alloc->size)) {
                                return 0;
                        }
                }
@@ -1029,6 +1101,7 @@ zend_function_entry *PSI_ContextCompile(PSI_Context *C)
 
 void PSI_ContextCall(PSI_Context *C, impl_val *ret_val, decl *decl)
 {
+       errno = 0;
        C->ops->call(C, ret_val, decl);
 }
 
@@ -1088,6 +1161,20 @@ static inline void dump_impl_set_value(int fd, set_value *set, unsigned level) {
                dprintf(fd, ");\n");
        }
 }
+static inline void dump_num_exp(int fd, num_exp *exp) {
+       switch (exp->t) {
+       case PSI_T_NUMBER:
+               dprintf(fd, "%s", exp->u.numb);
+               break;
+       case PSI_T_NAME:
+               dump_decl_var(fd, exp->u.dvar);
+               break;
+       case PSI_T_NSNAME:
+               dprintf(fd, "%s", exp->u.cnst->name);
+               break;
+       EMPTY_SWITCH_DEFAULT_CASE();
+       }
+}
 void PSI_ContextDump(PSI_Context *C, int fd)
 {
        size_t i, j, k, l;
@@ -1191,8 +1278,9 @@ void PSI_ContextDump(PSI_Context *C, int fd)
                                                if (let->val->func) {
                                                        dprintf(fd, "%s(", let->val->func->name);
                                                        if (let->val->func->alloc) {
-                                                               dprintf(fd, "%zu, ", let->val->func->alloc->n);
-                                                               dump_decl_type(fd, let->val->func->alloc->type);
+                                                               dump_num_exp(fd, let->val->func->alloc->nmemb);
+                                                               dprintf(fd, ", ");
+                                                               dump_num_exp(fd, let->val->func->alloc->size);
                                                        } else {
                                                                dprintf(fd, "$%s", let->val->var->name);
                                                        }